#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#ifdef MEMDEBUG
#include <mnemosyn.h>
#endif
#define  TRUE (0==0)
#define  FALSE (0!=0)
#include "regexp.h"
#include "imp2c.h"
#ifdef NO_MAIN

extern char **argv;
extern int argc;


extern FILE *yyin;
#else

char **argv = (char **)NULL;
int argc = 0;


FILE *yyin = NULL;
#endif /* MAIN */
#include "taccutil.h"


/* Main cheats - it invokes the parsing routines explicitly,
   in order to reduce the size of the parse tree for a whole
   file.  Also allows recovery of errors at useful boundaries */

 
  
int main_1(YYTYPE *__arg)
{
int __debug = SEEN_main_1 = debug_execute_enter("Executing procedure main_1 -- arg at %p", __arg);

    YYTYPE *subroot;
    void *stacktop;
    int i;

    if (strcmp(argv[argc-1], "-v") == 0) {
      argc -= 1;
      verbose = TRUE;
    }
    if (strcmp(argv[argc-1], "-d") == 0) {
      argc -= 1;
      _debug = TRUE;
    }
    if (strcmp(argv[argc-1], "-vd") == 0) {
      argc -= 1;
      _debug = TRUE;
      verbose = TRUE;
    }


    if (argc == 1) {
       yyin = fopen("test.ii", "r");
    } else if (argc != 2) {
       fprintf(stderr, "syntax: imp infile.ii\n");
       /* Let's just resume for now... */
       // yyin = fopen(argv[1], "r");
       exit(0);
    } else {
       if (
           (strcmp(argv[1]+strlen(argv[1])-4, ".imp") == 0) ||
           (strcmp(argv[1]+strlen(argv[1])-2, ".i") == 0)
          ) {
         char command[1024];
         sprintf(command, "/home/gtoal/src/new-gt-imp/filter < %s > /tmp/imptmp.ii", argv[1]);
         system(command);
         yyin = fopen("/tmp/imptmp.ii", "r"); // cannot use popen, parser requires ability to fseek.
       } else if (strcmp(argv[1]+strlen(argv[1])-3, ".ii") == 0) {
         yyin = fopen(argv[1], "r");
       } else {
         fprintf(stderr, "imp2c: file '%s' must end in .i or .imp (or be pre-processed in .ii)\n", argv[1]);
         exit(1);
       }
    }
    if (yyin == NULL) {
       fprintf(stderr, "imp: cannot open input\n");
       exit(EXIT_FAILURE);
    }

    fprintf(stderr, "%s: processing %s\n", argv[0], argv[1] == NULL ? "test.ii" : argv[1]);

    if (verbose) fprintf(stderr, "Starting\n");
    fprintf(stdout,"#include \"i2clib.h\"\n");
    fprintf(stdout,"#define DEBUGITEM(x) (x)\n");
    for (;;) {
      stacktop = stackmark();
      if (SS_parse(&subroot)) {
          execute_parsetree(subroot);
      } else {
          /* TEMP HACK: does this on failed parse */
          fprintf(stdout, "-----------------------------------------------------------------\n");
          codegen(entrypoint, MULTIPLE_STATEMENTS);
          fprintf(stderr, "imp2c parse failure, partial results generated\n");
          return(FALSE);
      }
      stackrelease(stacktop);
      if (exit_flag) return(TRUE);
      /* printf("\n"); */
      ilev += delayed_ilev; delayed_ilev = 0;
    }
  
if (!_optimise) debug_execute_exit("main_1");
return(TRUE);
}


         
int OPERAND_1(YYTYPE *__arg)
{
int __debug = SEEN_OPERAND_1 = debug_execute_enter("Executing procedure OPERAND_1 -- arg at %p", __arg);
 /* Done */
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *) (int)(__arg->execute.arg[1]->execute.user_value);

if (!_optimise) debug_execute_exit("OPERAND_1");
return(TRUE);
} 
                 
int OPERAND_2(YYTYPE *__arg)
{
int __debug = SEEN_OPERAND_2 = debug_execute_enter("Executing procedure OPERAND_2 -- arg at %p", __arg);

                  /* If <APP> is present, this is an array or a map/fn call */
		  /* If RECORDFIELD is present, <NAME><APP> is a record type (array or map) */
                  /* Plain <NAME> is either a simple variable/constant or a function call */

                  /* To work it out properly we do need to implement a symbol table */

                  int left;
		  if (((int)(__arg->execute.arg[2]->execute.user_value) == 0) && ((int)(__arg->execute.arg[3]->execute.user_value) == 0)) {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(VAR_OR_FNCALL, (int)(__arg->execute.arg[1]->execute.user_value));
                  } else {
                    if ((int)(__arg->execute.arg[2]->execute.user_value) == 0) left = (int)(__arg->execute.arg[1]->execute.user_value); else left = maketuple(ARRAY_OR_FNMAP, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value));
                    if ((int)(__arg->execute.arg[3]->execute.user_value) != 0) {
                      assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)] == RECORDFIELD);
                      //assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)+1] == HOLE);
//fprintf(stdout, " /* sub sub field broken (1) */\n");
                      AST[(int)(__arg->execute.arg[3]->execute.user_value)+1] = left; // THIS NEEDS REVIEW - RECORD SUBFIELDS: "." or "->"?
                      __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[3]->execute.user_value);
                    } else __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  left;
                  }

if (!_optimise) debug_execute_exit("OPERAND_2");
return(TRUE);
} 
                 
int OPERAND_3(YYTYPE *__arg)
{
int __debug = SEEN_OPERAND_3 = debug_execute_enter("Executing procedure OPERAND_3 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *) maketuple(MONOP, UOP_ABS, (int)(__arg->execute.arg[2]->execute.user_value)); /* Added by GT for imp77 */

if (!_optimise) debug_execute_exit("OPERAND_3");
return(TRUE);
} 
                 
int OPERAND_4(YYTYPE *__arg)
{
int __debug = SEEN_OPERAND_4 = debug_execute_enter("Executing procedure OPERAND_4 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *) maketuple(BRACKET, (int)(__arg->execute.arg[2]->execute.user_value)); /* Done */

if (!_optimise) debug_execute_exit("OPERAND_4");
return(TRUE);
}

        
int COPERAND_1(YYTYPE *__arg)
{
int __debug = SEEN_COPERAND_1 = debug_execute_enter("Executing procedure COPERAND_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) (int)(__arg->execute.arg[1]->execute.user_value); /* Only if name is a constant! */ 
if (!_optimise) debug_execute_exit("COPERAND_1");
return(TRUE);
} 
                 
int COPERAND_2(YYTYPE *__arg)
{
int __debug = SEEN_COPERAND_2 = debug_execute_enter("Executing procedure COPERAND_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) (int)(__arg->execute.arg[1]->execute.user_value); 
if (!_optimise) debug_execute_exit("COPERAND_2");
return(TRUE);
} 
                 
int COPERAND_3(YYTYPE *__arg)
{
int __debug = SEEN_COPERAND_3 = debug_execute_enter("Executing procedure COPERAND_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) maketuple(MONOP, UOP_ABS, (int)(__arg->execute.arg[2]->execute.user_value)); /* Added by GT for imp77 */
if (!_optimise) debug_execute_exit("COPERAND_3");
return(TRUE);
} 
                 
int COPERAND_4(YYTYPE *__arg)
{
int __debug = SEEN_COPERAND_4 = debug_execute_enter("Executing procedure COPERAND_4 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) maketuple(BRACKET, (int)(__arg->execute.arg[2]->execute.user_value)); 
if (!_optimise) debug_execute_exit("COPERAND_4");
return(TRUE);
}

/* Just a check to see if comments are allowed between procedures */

           
int CEXPR_1(YYTYPE *__arg)
{
int __debug = SEEN_CEXPR_1 = debug_execute_enter("Executing procedure CEXPR_1 -- arg at %p", __arg);

		  if ((int)(__arg->execute.arg[3]->execute.user_value) != NONE) {
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)] == BINOP);
                    AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] = (int)(__arg->execute.arg[2]->execute.user_value);
                    if ((int)(__arg->execute.arg[1]->execute.user_value) == 0) __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[3]->execute.user_value); else __arg->execute.arg[0]->execute.user_value = (USERTYPE *) maketuple(MONOP, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value));
                  } else {
                    if ((int)(__arg->execute.arg[1]->execute.user_value) == 0) __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[2]->execute.user_value); else __arg->execute.arg[0]->execute.user_value = (USERTYPE *) maketuple(MONOP, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value));
	          }

if (!_optimise) debug_execute_exit("CEXPR_1");
return(TRUE);
}

      
int STAROREXPR_1(YYTYPE *__arg)
{
int __debug = SEEN_STAROREXPR_1 = debug_execute_enter("Executing procedure STAROREXPR_1 -- arg at %p", __arg);

		  if ((int)(__arg->execute.arg[3]->execute.user_value) != NONE) {
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)] == BINOP);
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] == HOLE);
                    AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] = (int)(__arg->execute.arg[2]->execute.user_value);
                    if ((int)(__arg->execute.arg[1]->execute.user_value) == 0) __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[3]->execute.user_value); else __arg->execute.arg[0]->execute.user_value = (USERTYPE *) maketuple(MONOP, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value));
		  } else {
                    if ((int)(__arg->execute.arg[1]->execute.user_value) == 0) __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[2]->execute.user_value); else __arg->execute.arg[0]->execute.user_value = (USERTYPE *) maketuple(MONOP, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value));
		  }

if (!_optimise) debug_execute_exit("STAROREXPR_1");
return(TRUE);
} 
                 
int STAROREXPR_2(YYTYPE *__arg)
{
int __debug = SEEN_STAROREXPR_2 = debug_execute_enter("Executing procedure STAROREXPR_2 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0;

if (!_optimise) debug_execute_exit("STAROREXPR_2");
return(TRUE);
}

            
int EXPR_1(YYTYPE *__arg)
{
int __debug = SEEN_EXPR_1 = debug_execute_enter("Executing procedure EXPR_1 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[3]->execute.user_value) != NONE) {
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)] == BINOP);
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] == HOLE);
                    AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] = (int)(__arg->execute.arg[2]->execute.user_value);
                    if ((int)(__arg->execute.arg[1]->execute.user_value) != NONE) {
                      __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(MONOP, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value)); /* Precedence with all of these may be wrong for monop */
                    } else __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[3]->execute.user_value);
		  } else {
		    if ((int)(__arg->execute.arg[1]->execute.user_value) != NONE) {
                      __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(MONOP, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value));
		    } else {
                      __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[2]->execute.user_value);
		    }
		  }

if (!_optimise) debug_execute_exit("EXPR_1");
return(TRUE);
}

      
int RESTOFEXPR_1(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFEXPR_1 = debug_execute_enter("Executing procedure RESTOFEXPR_1 -- arg at %p", __arg);

		  if ((int)(__arg->execute.arg[3]->execute.user_value) != NONE) {
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)] == BINOP);
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] == HOLE);
                    AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] = (int)(__arg->execute.arg[2]->execute.user_value);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, (int)(__arg->execute.arg[1]->execute.user_value), /*hole*/0, (int)(__arg->execute.arg[3]->execute.user_value));
		  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, (int)(__arg->execute.arg[1]->execute.user_value), /*hole*/0, (int)(__arg->execute.arg[2]->execute.user_value));
		  }

if (!_optimise) debug_execute_exit("RESTOFEXPR_1");
return(TRUE);
} 
                 
int RESTOFEXPR_2(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFEXPR_2 = debug_execute_enter("Executing procedure RESTOFEXPR_2 -- arg at %p", __arg);

                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  NONE;

if (!_optimise) debug_execute_exit("RESTOFEXPR_2");
return(TRUE);
}

     
int RESTOFCEXPR_1(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFCEXPR_1 = debug_execute_enter("Executing procedure RESTOFCEXPR_1 -- arg at %p", __arg);

		  if ((int)(__arg->execute.arg[3]->execute.user_value) != NONE) {
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)] == BINOP);
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] == HOLE);
                    AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] = (int)(__arg->execute.arg[2]->execute.user_value);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, (int)(__arg->execute.arg[1]->execute.user_value), /*hole*/0, (int)(__arg->execute.arg[3]->execute.user_value));
		  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, (int)(__arg->execute.arg[1]->execute.user_value), /*hole*/0, (int)(__arg->execute.arg[2]->execute.user_value));
		  }

if (!_optimise) debug_execute_exit("RESTOFCEXPR_1");
return(TRUE);
} 
                 
int RESTOFCEXPR_2(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFCEXPR_2 = debug_execute_enter("Executing procedure RESTOFCEXPR_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("RESTOFCEXPR_2");
return(TRUE);
}

             
int APP_1(YYTYPE *__arg)
{
int __debug = SEEN_APP_1 = debug_execute_enter("Executing procedure APP_1 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[3]->execute.user_value) != NONE) {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(MULTI, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value));
                  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[2]->execute.user_value);
                  }

if (!_optimise) debug_execute_exit("APP_1");
return(TRUE);
} 
                 
int APP_2(YYTYPE *__arg)
{
int __debug = SEEN_APP_2 = debug_execute_enter("Executing procedure APP_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("APP_2");
return(TRUE);
}

       
int RESTOFAPP_1(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFAPP_1 = debug_execute_enter("Executing procedure RESTOFAPP_1 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[3]->execute.user_value) != NONE) {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(MULTI, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value));
                  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[2]->execute.user_value);
                  }

if (!_optimise) debug_execute_exit("RESTOFAPP_1");
return(TRUE);
} 
                 
int RESTOFAPP_2(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFAPP_2 = debug_execute_enter("Executing procedure RESTOFAPP_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("RESTOFAPP_2");
return(TRUE);
}

       
int PercentIU_1(YYTYPE *__arg)
{
int __debug = SEEN_PercentIU_1 = debug_execute_enter("Executing procedure PercentIU_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  OP_IF; 
if (!_optimise) debug_execute_exit("PercentIU_1");
return(TRUE);
} 
                 
int PercentIU_2(YYTYPE *__arg)
{
int __debug = SEEN_PercentIU_2 = debug_execute_enter("Executing procedure PercentIU_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  OP_UNLESS; 
if (!_optimise) debug_execute_exit("PercentIU_2");
return(TRUE);
}

       
int PercentWU_1(YYTYPE *__arg)
{
int __debug = SEEN_PercentWU_1 = debug_execute_enter("Executing procedure PercentWU_1 -- arg at %p", __arg);

                  int cond;
                  if ((int)(__arg->execute.arg[3]->execute.user_value)) {
                    cond = (int)(__arg->execute.arg[3]->execute.user_value);
                    assert(AST[cond] == BINOP);
                    assert(AST[cond+2] == HOLE);
                    AST[cond+2] = (int)(__arg->execute.arg[2]->execute.user_value);
                  } else cond = (int)(__arg->execute.arg[2]->execute.user_value);
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(WHILE, cond, HOLE);

if (!_optimise) debug_execute_exit("PercentWU_1");
return(TRUE);
} 
                 
int PercentWU_2(YYTYPE *__arg)
{
int __debug = SEEN_PercentWU_2 = debug_execute_enter("Executing procedure PercentWU_2 -- arg at %p", __arg);
 
                  int cond;
                  if ((int)(__arg->execute.arg[3]->execute.user_value)) {
                    cond = (int)(__arg->execute.arg[3]->execute.user_value);
                    assert(AST[cond] == BINOP);
                    assert(AST[cond+2] == HOLE);
                    AST[cond+2] = (int)(__arg->execute.arg[2]->execute.user_value);
                  } else cond = (int)(__arg->execute.arg[2]->execute.user_value);
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(UNTIL, cond, HOLE);

if (!_optimise) debug_execute_exit("PercentWU_2");
return(TRUE);
} 
                 
int PercentWU_3(YYTYPE *__arg)
{
int __debug = SEEN_PercentWU_3 = debug_execute_enter("Executing procedure PercentWU_3 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[2]->execute.user_value);

if (!_optimise) debug_execute_exit("PercentWU_3");
return(TRUE);
}

      
int ALIASquote_1(YYTYPE *__arg)
{
int __debug = SEEN_ALIASquote_1 = debug_execute_enter("Executing procedure ALIASquote_1 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(ALIAS, (int)(__arg->execute.arg[2]->execute.user_value)); 

if (!_optimise) debug_execute_exit("ALIASquote_1");
return(TRUE);
} 
                 
int ALIASquote_2(YYTYPE *__arg)
{
int __debug = SEEN_ALIASquote_2 = debug_execute_enter("Executing procedure ALIASquote_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("ALIASquote_2");
return(TRUE);
}

      
int NLISTquote_1(YYTYPE *__arg)
{
int __debug = SEEN_NLISTquote_1 = debug_execute_enter("Executing procedure NLISTquote_1 -- arg at %p", __arg);

		  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(MULTI, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value));

if (!_optimise) debug_execute_exit("NLISTquote_1");
return(TRUE);
} 
                 
int NLISTquote_2(YYTYPE *__arg)
{
int __debug = SEEN_NLISTquote_2 = debug_execute_enter("Executing procedure NLISTquote_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("NLISTquote_2");
return(TRUE);
}

            
int TYPE_1(YYTYPE *__arg)
{
int __debug = SEEN_TYPE_1 = debug_execute_enter("Executing procedure TYPE_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_BYTEINTEGER); 
if (!_optimise) debug_execute_exit("TYPE_1");
return(TRUE);
} 
                 
int TYPE_2(YYTYPE *__arg)
{
int __debug = SEEN_TYPE_2 = debug_execute_enter("Executing procedure TYPE_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_INTEGER); 
if (!_optimise) debug_execute_exit("TYPE_2");
return(TRUE);
} 
                 
int TYPE_3(YYTYPE *__arg)
{
int __debug = SEEN_TYPE_3 = debug_execute_enter("Executing procedure TYPE_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_LONG); 
if (!_optimise) debug_execute_exit("TYPE_3");
return(TRUE);
} 
                 
int TYPE_4(YYTYPE *__arg)
{
int __debug = SEEN_TYPE_4 = debug_execute_enter("Executing procedure TYPE_4 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_REAL); 
if (!_optimise) debug_execute_exit("TYPE_4");
return(TRUE);
} 
                 
int TYPE_5(YYTYPE *__arg)
{
int __debug = SEEN_TYPE_5 = debug_execute_enter("Executing procedure TYPE_5 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_LONGLONGREAL); 
if (!_optimise) debug_execute_exit("TYPE_5");
return(TRUE);
} 
                 
int TYPE_6(YYTYPE *__arg)
{
int __debug = SEEN_TYPE_6 = debug_execute_enter("Executing procedure TYPE_6 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_LONGREAL); 
if (!_optimise) debug_execute_exit("TYPE_6");
return(TRUE);
} 
                 
int TYPE_7(YYTYPE *__arg)
{
int __debug = SEEN_TYPE_7 = debug_execute_enter("Executing procedure TYPE_7 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_LONG, (int)(__arg->execute.arg[2]->execute.user_value)); 
if (!_optimise) debug_execute_exit("TYPE_7");
return(TRUE);
} 
                 
int TYPE_8(YYTYPE *__arg)
{
int __debug = SEEN_TYPE_8 = debug_execute_enter("Executing procedure TYPE_8 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_BYTEINTEGER); 
if (!_optimise) debug_execute_exit("TYPE_8");
return(TRUE);
} 
                 
int TYPE_9(YYTYPE *__arg)
{
int __debug = SEEN_TYPE_9 = debug_execute_enter("Executing procedure TYPE_9 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_BYTEINTEGER); 
if (!_optimise) debug_execute_exit("TYPE_9");
return(TRUE);
} 
                 
int TYPE_10(YYTYPE *__arg)
{
int __debug = SEEN_TYPE_10 = debug_execute_enter("Executing procedure TYPE_10 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_STRING, (int)(__arg->execute.arg[2]->execute.user_value)); 
if (!_optimise) debug_execute_exit("TYPE_10");
return(TRUE);
} 
                 
int TYPE_11(YYTYPE *__arg)
{
int __debug = SEEN_TYPE_11 = debug_execute_enter("Executing procedure TYPE_11 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_HALFINTEGER); 
if (!_optimise) debug_execute_exit("TYPE_11");
return(TRUE);
} 
                 
int TYPE_12(YYTYPE *__arg)
{
int __debug = SEEN_TYPE_12 = debug_execute_enter("Executing procedure TYPE_12 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_HALFINTEGER); 
if (!_optimise) debug_execute_exit("TYPE_12");
return(TRUE);
} 
		 
int TYPE_13(YYTYPE *__arg)
{
int __debug = SEEN_TYPE_13 = debug_execute_enter("Executing procedure TYPE_13 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_SHORTINTEGER); 
if (!_optimise) debug_execute_exit("TYPE_13");
return(TRUE);
} 
                 
int TYPE_14(YYTYPE *__arg)
{
int __debug = SEEN_TYPE_14 = debug_execute_enter("Executing procedure TYPE_14 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_SHORTINTEGER); 
if (!_optimise) debug_execute_exit("TYPE_14");
return(TRUE);
} 
                 
int TYPE_15(YYTYPE *__arg)
{
int __debug = SEEN_TYPE_15 = debug_execute_enter("Executing procedure TYPE_15 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_RECORD, 0); /* added for Imp77 */ 
if (!_optimise) debug_execute_exit("TYPE_15");
return(TRUE);
} 
                 
int TYPE_16(YYTYPE *__arg)
{
int __debug = SEEN_TYPE_16 = debug_execute_enter("Executing procedure TYPE_16 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_RECORD, (int)(__arg->execute.arg[2]->execute.user_value)); 
if (!_optimise) debug_execute_exit("TYPE_16");
return(TRUE);
} 
                 
int TYPE_17(YYTYPE *__arg)
{
int __debug = SEEN_TYPE_17 = debug_execute_enter("Executing procedure TYPE_17 -- arg at %p", __arg);
 /* added for pre-imp80 EMAS imp */
                  // REQUIRES RECORD TYPE TO COME AFTER DECLARATION OF NAME
                  // eg %rrecordformat recfm(%iinteger i)
                  //    %rrecord r(recfm)
                  // Not sure if any of these are allowed:
                  //    %rrecord r,s,t(recfm)
                  //    %rrecord r(recfm), s(sfm), t(tfm)
                  //    %rrecord r(recfm), s,t(tfm)
                  // so until I hit one, I'll keep it at a single declaration
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_RECORD, 0);

if (!_optimise) debug_execute_exit("TYPE_17");
return(TRUE);
}

              
int FN_1(YYTYPE *__arg)
{
int __debug = SEEN_FN_1 = debug_execute_enter("Executing procedure FN_1 -- arg at %p", __arg);
 
if (!_optimise) debug_execute_exit("FN_1");
return(TRUE);
}   
int FN_2(YYTYPE *__arg)
{
int __debug = SEEN_FN_2 = debug_execute_enter("Executing procedure FN_2 -- arg at %p", __arg);
 
if (!_optimise) debug_execute_exit("FN_2");
return(TRUE);
}

              
int RT_1(YYTYPE *__arg)
{
int __debug = SEEN_RT_1 = debug_execute_enter("Executing procedure RT_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(ROUTINE, HOLE /* args */); 
if (!_optimise) debug_execute_exit("RT_1");
return(TRUE);
} 
                 
int RT_2(YYTYPE *__arg)
{
int __debug = SEEN_RT_2 = debug_execute_enter("Executing procedure RT_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(PREDICATE, HOLE /* args */); /* Added for Imp77 */ 
if (!_optimise) debug_execute_exit("RT_2");
return(TRUE);
} 
                 
int RT_3(YYTYPE *__arg)
{
int __debug = SEEN_RT_3 = debug_execute_enter("Executing procedure RT_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(FUNCTION, HOLE /* args */, (int)(__arg->execute.arg[1]->execute.user_value) /* type */, HOLE /* result */); 
if (!_optimise) debug_execute_exit("RT_3");
return(TRUE);
} 
                 
int RT_4(YYTYPE *__arg)
{
int __debug = SEEN_RT_4 = debug_execute_enter("Executing procedure RT_4 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(MAP, HOLE /* args */, (int)(__arg->execute.arg[1]->execute.user_value), HOLE /* result */); 
if (!_optimise) debug_execute_exit("RT_4");
return(TRUE);
}

           
int FPDEL_1(YYTYPE *__arg)
{
int __debug = SEEN_FPDEL_1 = debug_execute_enter("Executing procedure FPDEL_1 -- arg at %p", __arg);

                                        /* use multi for (NAME, NLISTquote) */
		  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(FORMALPARAMETER, (int)(__arg->execute.arg[1]->execute.user_value)/* basic type */, (int)(__arg->execute.arg[2]->execute.user_value)/*type-name or type_arrayname */, maketuple(MULTI, (int)(__arg->execute.arg[3]->execute.user_value), (int)(__arg->execute.arg[4]->execute.user_value)));

if (!_optimise) debug_execute_exit("FPDEL_1");
return(TRUE);
} 
                 
int FPDEL_2(YYTYPE *__arg)
{
int __debug = SEEN_FPDEL_2 = debug_execute_enter("Executing procedure FPDEL_2 -- arg at %p", __arg);

                  int call;
                  call = (int)(__arg->execute.arg[1]->execute.user_value);
                  assert(AST[(int)(__arg->execute.arg[1]->execute.user_value)] == ROUTINE || AST[(int)(__arg->execute.arg[1]->execute.user_value)] == PREDICATE ||
                         AST[(int)(__arg->execute.arg[1]->execute.user_value)] == FUNCTION || AST[(int)(__arg->execute.arg[1]->execute.user_value)] == MAP);
                  if ((int)(__arg->execute.arg[2]->execute.user_value) != 0) {
                    if (AST[(int)(__arg->execute.arg[1]->execute.user_value)] == ROUTINE) AST[(int)(__arg->execute.arg[1]->execute.user_value)] == ROUTINENAME;
                    if (AST[(int)(__arg->execute.arg[1]->execute.user_value)] == PREDICATE) AST[(int)(__arg->execute.arg[1]->execute.user_value)] == PREDICATENAME;
                    if (AST[(int)(__arg->execute.arg[1]->execute.user_value)] == FUNCTION) AST[(int)(__arg->execute.arg[1]->execute.user_value)] == FUNCTIONNAME;
                    if (AST[(int)(__arg->execute.arg[1]->execute.user_value)] == MAP) AST[(int)(__arg->execute.arg[1]->execute.user_value)] == MAPNAME;
                  }
                  AST[call+1] = (int)(__arg->execute.arg[5]->execute.user_value); /* Parameters */
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(FUNCTION_PARAMETER, call, maketuple(MULTI, (int)(__arg->execute.arg[3]->execute.user_value), (int)(__arg->execute.arg[4]->execute.user_value)));
                        /* Again, need to turn MULTI's inside-out ... */

if (!_optimise) debug_execute_exit("FPDEL_2");
return(TRUE);
} 
                 
int FPDEL_3(YYTYPE *__arg)
{
int __debug = SEEN_FPDEL_3 = debug_execute_enter("Executing procedure FPDEL_3 -- arg at %p", __arg);
 /* Generic %nname variable (untyped pointer) */
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_GENERICNAME, maketuple(MULTI, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value))); 

if (!_optimise) debug_execute_exit("FPDEL_3");
return(TRUE);
}

     
int PercentNAMEquote_1(YYTYPE *__arg)
{
int __debug = SEEN_PercentNAMEquote_1 = debug_execute_enter("Executing procedure PercentNAMEquote_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_NAME); 
if (!_optimise) debug_execute_exit("PercentNAMEquote_1");
return(TRUE);
} 
                 
int PercentNAMEquote_2(YYTYPE *__arg)
{
int __debug = SEEN_PercentNAMEquote_2 = debug_execute_enter("Executing procedure PercentNAMEquote_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("PercentNAMEquote_2");
return(TRUE);
}

     
int PercentQNAMEquote_1(YYTYPE *__arg)
{
int __debug = SEEN_PercentQNAMEquote_1 = debug_execute_enter("Executing procedure PercentQNAMEquote_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_ARRAYNAME); 
if (!_optimise) debug_execute_exit("PercentQNAMEquote_1");
return(TRUE);
} 
                 
int PercentQNAMEquote_2(YYTYPE *__arg)
{
int __debug = SEEN_PercentQNAMEquote_2 = debug_execute_enter("Executing procedure PercentQNAMEquote_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_NAME); 
if (!_optimise) debug_execute_exit("PercentQNAMEquote_2");
return(TRUE);
} 
                 
int PercentQNAMEquote_3(YYTYPE *__arg)
{
int __debug = SEEN_PercentQNAMEquote_3 = debug_execute_enter("Executing procedure PercentQNAMEquote_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("PercentQNAMEquote_3");
return(TRUE);
}

             
int FPP_1(YYTYPE *__arg)
{
int __debug = SEEN_FPP_1 = debug_execute_enter("Executing procedure FPP_1 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(PARAMLIST, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value)); 

if (!_optimise) debug_execute_exit("FPP_1");
return(TRUE);
} 
                 
int FPP_2(YYTYPE *__arg)
{
int __debug = SEEN_FPP_2 = debug_execute_enter("Executing procedure FPP_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0;

if (!_optimise) debug_execute_exit("FPP_2");
return(TRUE);
}

    
int RESTOFFPLIST_1(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFFPLIST_1 = debug_execute_enter("Executing procedure RESTOFFPLIST_1 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[1]->execute.user_value) != NONE) {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(PARAMLIST, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value)); 
		  } else __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  0;

if (!_optimise) debug_execute_exit("RESTOFFPLIST_1");
return(TRUE);
} 
                 
int RESTOFFPLIST_2(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFFPLIST_2 = debug_execute_enter("Executing procedure RESTOFFPLIST_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0;

if (!_optimise) debug_execute_exit("RESTOFFPLIST_2");
return(TRUE);
}

     
int PercentFORMATquote_1(YYTYPE *__arg)
{
int __debug = SEEN_PercentFORMATquote_1 = debug_execute_enter("Executing procedure PercentFORMATquote_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_FORMAT); 
if (!_optimise) debug_execute_exit("PercentFORMATquote_1");
return(TRUE);
} 
                 
int PercentFORMATquote_2(YYTYPE *__arg)
{
int __debug = SEEN_PercentFORMATquote_2 = debug_execute_enter("Executing procedure PercentFORMATquote_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("PercentFORMATquote_2");
return(TRUE);
}

              
int SC_1(YYTYPE *__arg)
{
int __debug = SEEN_SC_1 = debug_execute_enter("Executing procedure SC_1 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[4]->execute.user_value) != NONE) {
                    int left = maketuple(BINOP, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value));
                    int right = maketuple(BINOP, AST[(int)(__arg->execute.arg[4]->execute.user_value)+1], (int)(__arg->execute.arg[3]->execute.user_value), AST[(int)(__arg->execute.arg[4]->execute.user_value)+3]);
                    /* TO DO: $0 = maketuple(DOUBLE_SIDED, $1, $2, $3, AST[$4+1], AST[$4+3]); */
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, OP_AND, left, right);
                  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value));
                  }

if (!_optimise) debug_execute_exit("SC_1");
return(TRUE);
} 
                 
int SC_2(YYTYPE *__arg)
{
int __debug = SEEN_SC_2 = debug_execute_enter("Executing procedure SC_2 -- arg at %p", __arg);
  /* predicate for imp77 - maybe not the best way to do this */
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[1]->execute.user_value); /* TO DO - mark as predicate */ 

if (!_optimise) debug_execute_exit("SC_2");
return(TRUE);
} 
                 
int SC_3(YYTYPE *__arg)
{
int __debug = SEEN_SC_3 = debug_execute_enter("Executing procedure SC_3 -- arg at %p", __arg);

                  int cond = (int)(__arg->execute.arg[3]->execute.user_value);
                  if (cond != 0) {
                      assert(AST[cond] == BINOP);
                      assert(AST[cond+2] == HOLE);
                      AST[cond+2]=(int)(__arg->execute.arg[2]->execute.user_value);
                  } else {
                    cond = (int)(__arg->execute.arg[2]->execute.user_value);
                  }
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  cond;

if (!_optimise) debug_execute_exit("SC_3");
return(TRUE);
} 
                 
int SC_4(YYTYPE *__arg)
{
int __debug = SEEN_SC_4 = debug_execute_enter("Executing procedure SC_4 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(MONOP, UOP_LOGNOT, (int)(__arg->execute.arg[2]->execute.user_value)); 
if (!_optimise) debug_execute_exit("SC_4");
return(TRUE);
}

        
int RESTOFSC_1(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFSC_1 = debug_execute_enter("Executing procedure RESTOFSC_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, (int)(__arg->execute.arg[1]->execute.user_value), HOLE, (int)(__arg->execute.arg[2]->execute.user_value)); 
if (!_optimise) debug_execute_exit("RESTOFSC_1");
return(TRUE);
} 
                 
int RESTOFSC_2(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFSC_2 = debug_execute_enter("Executing procedure RESTOFSC_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("RESTOFSC_2");
return(TRUE);
}

      
int RESTOFCOND_1(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFCOND_1 = debug_execute_enter("Executing procedure RESTOFCOND_1 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[3]->execute.user_value) != NONE) {
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)] == BINOP);
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] == HOLE);
                    AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] = (int)(__arg->execute.arg[2]->execute.user_value);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, OP_AND, HOLE, (int)(__arg->execute.arg[3]->execute.user_value)); 
                  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, OP_AND, HOLE, (int)(__arg->execute.arg[2]->execute.user_value)); 
                  }

if (!_optimise) debug_execute_exit("RESTOFCOND_1");
return(TRUE);
} 
                 
int RESTOFCOND_2(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFCOND_2 = debug_execute_enter("Executing procedure RESTOFCOND_2 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[3]->execute.user_value) != NONE) {
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)] == BINOP);
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] == HOLE);
                    AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] = (int)(__arg->execute.arg[2]->execute.user_value);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, OP_OR, HOLE, (int)(__arg->execute.arg[3]->execute.user_value)); 
                  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, OP_OR, HOLE, (int)(__arg->execute.arg[2]->execute.user_value)); 
                  }

if (!_optimise) debug_execute_exit("RESTOFCOND_2");
return(TRUE);
} 
                 
int RESTOFCOND_3(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFCOND_3 = debug_execute_enter("Executing procedure RESTOFCOND_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("RESTOFCOND_3");
return(TRUE);
}

      
int RESTOFANDC_1(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFANDC_1 = debug_execute_enter("Executing procedure RESTOFANDC_1 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[3]->execute.user_value) != NONE) {
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)] == BINOP);
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] == HOLE);
                    AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] = (int)(__arg->execute.arg[2]->execute.user_value);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, OP_AND, HOLE, (int)(__arg->execute.arg[3]->execute.user_value)); 
                  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, OP_AND, HOLE, (int)(__arg->execute.arg[2]->execute.user_value)); 
                  }

if (!_optimise) debug_execute_exit("RESTOFANDC_1");
return(TRUE);
} 
                 
int RESTOFANDC_2(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFANDC_2 = debug_execute_enter("Executing procedure RESTOFANDC_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("RESTOFANDC_2");
return(TRUE);
}

       
int RESTOFORC_1(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFORC_1 = debug_execute_enter("Executing procedure RESTOFORC_1 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[3]->execute.user_value) != NONE) {
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)] == BINOP);
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] == HOLE);
                    AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] = (int)(__arg->execute.arg[2]->execute.user_value);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, OP_OR, HOLE, (int)(__arg->execute.arg[3]->execute.user_value)); 
                  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, OP_OR, HOLE, (int)(__arg->execute.arg[2]->execute.user_value)); 
                  }

if (!_optimise) debug_execute_exit("RESTOFORC_1");
return(TRUE);
} 
                 
int RESTOFORC_2(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFORC_2 = debug_execute_enter("Executing procedure RESTOFORC_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("RESTOFORC_2");
return(TRUE);
}

     
int PercentSPECquote_1(YYTYPE *__arg)
{
int __debug = SEEN_PercentSPECquote_1 = debug_execute_enter("Executing procedure PercentSPECquote_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  SPEC; 
if (!_optimise) debug_execute_exit("PercentSPECquote_1");
return(TRUE);
} 
                 
int PercentSPECquote_2(YYTYPE *__arg)
{
int __debug = SEEN_PercentSPECquote_2 = debug_execute_enter("Executing procedure PercentSPECquote_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) NONE; 
if (!_optimise) debug_execute_exit("PercentSPECquote_2");
return(TRUE);
}

     
int VSPECquote_1(YYTYPE *__arg)
{
int __debug = SEEN_VSPECquote_1 = debug_execute_enter("Executing procedure VSPECquote_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  SPEC; 
if (!_optimise) debug_execute_exit("VSPECquote_1");
return(TRUE);
} 
                 
int VSPECquote_2(YYTYPE *__arg)
{
int __debug = SEEN_VSPECquote_2 = debug_execute_enter("Executing procedure VSPECquote_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) NONE; 
if (!_optimise) debug_execute_exit("VSPECquote_2");
return(TRUE);
}

    
int RESTOFBPLIST_1(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFBPLIST_1 = debug_execute_enter("Executing procedure RESTOFBPLIST_1 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(MULTI, maketuple(BOUND_PAIR, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[4]->execute.user_value)), (int)(__arg->execute.arg[5]->execute.user_value));

if (!_optimise) debug_execute_exit("RESTOFBPLIST_1");
return(TRUE);
} 
                 
int RESTOFBPLIST_2(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFBPLIST_2 = debug_execute_enter("Executing procedure RESTOFBPLIST_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("RESTOFBPLIST_2");
return(TRUE);
}

     
int OLDRECquote_1(YYTYPE *__arg)
{
int __debug = SEEN_OLDRECquote_1 = debug_execute_enter("Executing procedure OLDRECquote_1 -- arg at %p", __arg);
 // GT addition.  Not yet confirmed.
                  // OLD-STYLE record declaration  %rrecord fred,jim,joe(fredfm)
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_RECORD, (int)(__arg->execute.arg[2]->execute.user_value));

if (!_optimise) debug_execute_exit("OLDRECquote_1");
return(TRUE);
} 
                 
int OLDRECquote_2(YYTYPE *__arg)
{
int __debug = SEEN_OLDRECquote_2 = debug_execute_enter("Executing procedure OLDRECquote_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("OLDRECquote_2");
return(TRUE);
}


           
int DECLN_1(YYTYPE *__arg)
{
int __debug = SEEN_DECLN_1 = debug_execute_enter("Executing procedure DECLN_1 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(DECLARATION, (int)(__arg->execute.arg[4]->execute.user_value) /* For type */, (int)(__arg->execute.arg[1]->execute.user_value) /* TYPE_NAME/TYPE_ARRAYNAME/0 */, maketuple(MULTI, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value)));

if (!_optimise) debug_execute_exit("DECLN_1");
return(TRUE);
} 
                 
int DECLN_2(YYTYPE *__arg)
{
int __debug = SEEN_DECLN_2 = debug_execute_enter("Executing procedure DECLN_2 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[2]->execute.user_value) != 0) {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(ARRAYFORMATDECLARATION, HOLE, (int)(__arg->execute.arg[2]->execute.user_value)); // NEED TO ADD HOLES HERE TOO!
                  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(ARRAYDECLARATION, HOLE, (int)(__arg->execute.arg[3]->execute.user_value)); // NEED TO ADD HOLES HERE TOO!
                  }

if (!_optimise) debug_execute_exit("DECLN_2");
return(TRUE);
}

          
int ADECLN_1(YYTYPE *__arg)
{
int __debug = SEEN_ADECLN_1 = debug_execute_enter("Executing procedure ADECLN_1 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(MULTI /* TO DO - FIX!!! (like SWITCHDECL) */, maketuple(DECLARE_ARRAY, maketuple(MULTI, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value)), (int)(__arg->execute.arg[3]->execute.user_value)), (int)(__arg->execute.arg[4]->execute.user_value)); 

if (!_optimise) debug_execute_exit("ADECLN_1");
return(TRUE);
}

    
int RESTOFARLIST_1(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFARLIST_1 = debug_execute_enter("Executing procedure RESTOFARLIST_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[2]->execute.user_value); 
if (!_optimise) debug_execute_exit("RESTOFARLIST_1");
return(TRUE);
} 
                 
int RESTOFARLIST_2(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFARLIST_2 = debug_execute_enter("Executing procedure RESTOFARLIST_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("RESTOFARLIST_2");
return(TRUE);
}

        
int WHATEVER_1(YYTYPE *__arg)
{
int __debug = SEEN_WHATEVER_1 = debug_execute_enter("Executing procedure WHATEVER_1 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(WHATEVER, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value), (int)(__arg->execute.arg[4]->execute.user_value)); 

if (!_optimise) debug_execute_exit("WHATEVER_1");
return(TRUE);
}

         
                   
int OWNDEC_1(YYTYPE *__arg)
{
int __debug = SEEN_OWNDEC_1 = debug_execute_enter("Executing procedure OWNDEC_1 -- arg at %p", __arg);
 /* I.e. initialised decln */
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(OWNSCALARDEC, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value));  /* not good enough. assemble parts and DECLARE */

if (!_optimise) debug_execute_exit("OWNDEC_1");
return(TRUE);
} 
                 
int OWNDEC_2(YYTYPE *__arg)
{
int __debug = SEEN_OWNDEC_2 = debug_execute_enter("Executing procedure OWNDEC_2 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(OWNARRAYDEC, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value), (int)(__arg->execute.arg[4]->execute.user_value), (int)(__arg->execute.arg[5]->execute.user_value), (int)(__arg->execute.arg[6]->execute.user_value), (int)(__arg->execute.arg[7]->execute.user_value)); 

if (!_optimise) debug_execute_exit("OWNDEC_2");
return(TRUE);
}

    
int RESTOFOWNDEC_1(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFOWNDEC_1 = debug_execute_enter("Executing procedure RESTOFOWNDEC_1 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[2]->execute.user_value);

if (!_optimise) debug_execute_exit("RESTOFOWNDEC_1");
return(TRUE);
} 
                 
int RESTOFOWNDEC_2(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFOWNDEC_2 = debug_execute_enter("Executing procedure RESTOFOWNDEC_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("RESTOFOWNDEC_2");
return(TRUE);
}

            
int XOWN_1(YYTYPE *__arg)
{
int __debug = SEEN_XOWN_1 = debug_execute_enter("Executing procedure XOWN_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_OWN); 
if (!_optimise) debug_execute_exit("XOWN_1");
return(TRUE);
} 
                 
int XOWN_2(YYTYPE *__arg)
{
int __debug = SEEN_XOWN_2 = debug_execute_enter("Executing procedure XOWN_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_EXTERN); 
if (!_optimise) debug_execute_exit("XOWN_2");
return(TRUE);
} 
                 
int XOWN_3(YYTYPE *__arg)
{
int __debug = SEEN_XOWN_3 = debug_execute_enter("Executing procedure XOWN_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_EXTERN); 
if (!_optimise) debug_execute_exit("XOWN_3");
return(TRUE);
} 
                 
int XOWN_4(YYTYPE *__arg)
{
int __debug = SEEN_XOWN_4 = debug_execute_enter("Executing procedure XOWN_4 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_CONST); 
if (!_optimise) debug_execute_exit("XOWN_4");
return(TRUE);
} 
                 
int XOWN_5(YYTYPE *__arg)
{
int __debug = SEEN_XOWN_5 = debug_execute_enter("Executing procedure XOWN_5 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_CONST); 
if (!_optimise) debug_execute_exit("XOWN_5");
return(TRUE);
} 
                 
int XOWN_6(YYTYPE *__arg)
{
int __debug = SEEN_XOWN_6 = debug_execute_enter("Executing procedure XOWN_6 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_AUTO); /* Added initialised auto variables for Imp77 */ 
if (!_optimise) debug_execute_exit("XOWN_6");
return(TRUE);
}

       
int CONSTLIST_1(YYTYPE *__arg)
{
int __debug = SEEN_CONSTLIST_1 = debug_execute_enter("Executing procedure CONSTLIST_1 -- arg at %p", __arg);

		  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[2]->execute.user_value);

if (!_optimise) debug_execute_exit("CONSTLIST_1");
return(TRUE);
} 
                 
int CONSTLIST_2(YYTYPE *__arg)
{
int __debug = SEEN_CONSTLIST_2 = debug_execute_enter("Executing procedure CONSTLIST_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("CONSTLIST_2");
return(TRUE);
}

      
int CONSTITEMS_1(YYTYPE *__arg)
{
int __debug = SEEN_CONSTITEMS_1 = debug_execute_enter("Executing procedure CONSTITEMS_1 -- arg at %p", __arg);

                  int con /* need to fold const expr */, rest;
                  if ((int)(__arg->execute.arg[2]->execute.user_value) != 0) con = maketuple(MONOP, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value)); else con = (int)(__arg->execute.arg[3]->execute.user_value);
                  if ((int)(__arg->execute.arg[4]->execute.user_value) != 0) {
                    assert(AST[(int)(__arg->execute.arg[4]->execute.user_value)] == BINOP);
                    assert(AST[(int)(__arg->execute.arg[4]->execute.user_value)+2] == HOLE);
                    AST[(int)(__arg->execute.arg[4]->execute.user_value)+2] = con; con = (int)(__arg->execute.arg[4]->execute.user_value);
                  }
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(INITCONSTARRAY, con, (int)(__arg->execute.arg[5]->execute.user_value), (int)(__arg->execute.arg[6]->execute.user_value)); /* move 'rest' into a while loop */

if (!_optimise) debug_execute_exit("CONSTITEMS_1");
return(TRUE);
}

            
int ROCL_1(YYTYPE *__arg)
{
int __debug = SEEN_ROCL_1 = debug_execute_enter("Executing procedure ROCL_1 -- arg at %p", __arg);

		  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[2]->execute.user_value);

if (!_optimise) debug_execute_exit("ROCL_1");
return(TRUE);
} 
                 
int ROCL_2(YYTYPE *__arg)
{
int __debug = SEEN_ROCL_2 = debug_execute_enter("Executing procedure ROCL_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("ROCL_2");
return(TRUE);
}

         
int REPFACT_1(YYTYPE *__arg)
{
int __debug = SEEN_REPFACT_1 = debug_execute_enter("Executing procedure REPFACT_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[2]->execute.user_value); 
if (!_optimise) debug_execute_exit("REPFACT_1");
return(TRUE);
} 
                 
int REPFACT_2(YYTYPE *__arg)
{
int __debug = SEEN_REPFACT_2 = debug_execute_enter("Executing procedure REPFACT_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("REPFACT_2");
return(TRUE);
}

     
int RESTOFELIST_1(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFELIST_1 = debug_execute_enter("Executing procedure RESTOFELIST_1 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(MULTI, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value)); 

if (!_optimise) debug_execute_exit("RESTOFELIST_1");
return(TRUE);
} 
                 
int RESTOFELIST_2(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFELIST_2 = debug_execute_enter("Executing procedure RESTOFELIST_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("RESTOFELIST_2");
return(TRUE);
}

     
int PercentEVENTquote_1(YYTYPE *__arg)
{
int __debug = SEEN_PercentEVENTquote_1 = debug_execute_enter("Executing procedure PercentEVENTquote_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 1; 
if (!_optimise) debug_execute_exit("PercentEVENTquote_1");
return(TRUE);
} 
                 
int PercentEVENTquote_2(YYTYPE *__arg)
{
int __debug = SEEN_PercentEVENTquote_2 = debug_execute_enter("Executing procedure PercentEVENTquote_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("PercentEVENTquote_2");
return(TRUE);
}

          
int OPEXPR_1(YYTYPE *__arg)
{
int __debug = SEEN_OPEXPR_1 = debug_execute_enter("Executing procedure OPEXPR_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[2]->execute.user_value); 
if (!_optimise) debug_execute_exit("OPEXPR_1");
return(TRUE);
} 
                 
int OPEXPR_2(YYTYPE *__arg)
{
int __debug = SEEN_OPEXPR_2 = debug_execute_enter("Executing procedure OPEXPR_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("OPEXPR_2");
return(TRUE);
}

    
int RESTOFREPEAT_1(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFREPEAT_1 = debug_execute_enter("Executing procedure RESTOFREPEAT_1 -- arg at %p", __arg);

		  if ((int)(__arg->execute.arg[3]->execute.user_value) != NONE) {
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)] == BINOP);
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] == NONE);
                    AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] = (int)(__arg->execute.arg[2]->execute.user_value);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(REPEATUNTIL, (int)(__arg->execute.arg[3]->execute.user_value));
		  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(REPEATUNTIL, (int)(__arg->execute.arg[2]->execute.user_value));
		  }

if (!_optimise) debug_execute_exit("RESTOFREPEAT_1");
return(TRUE);
} 
                 
int RESTOFREPEAT_2(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFREPEAT_2 = debug_execute_enter("Executing procedure RESTOFREPEAT_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("RESTOFREPEAT_2");
return(TRUE);
}

        
int RESTOFSS_1(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFSS_1 = debug_execute_enter("Executing procedure RESTOFSS_1 -- arg at %p", __arg);

                  printf("{debug: label = TRUE}"); label = TRUE; __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[1]->execute.user_value);

if (!_optimise) debug_execute_exit("RESTOFSS_1");
return(TRUE);
} 
                 
int RESTOFSS_2(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFSS_2 = debug_execute_enter("Executing procedure RESTOFSS_2 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  0;

if (!_optimise) debug_execute_exit("RESTOFSS_2");
return(TRUE);
} 
                 
int RESTOFSS_3(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFSS_3 = debug_execute_enter("Executing procedure RESTOFSS_3 -- arg at %p", __arg);

		  if ((int)(__arg->execute.arg[3]->execute.user_value) != NONE) {
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)] == BINOP);
                    assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] == NONE);
                    AST[(int)(__arg->execute.arg[3]->execute.user_value)+2] = (int)(__arg->execute.arg[1]->execute.user_value);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(CONDITIONAL, (int)(__arg->execute.arg[1]->execute.user_value) /* IF or UNLESS */, (int)(__arg->execute.arg[3]->execute.user_value), HOLE /* for body */);
		  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(CONDITIONAL, (int)(__arg->execute.arg[1]->execute.user_value) /* IF or UNLESS */, (int)(__arg->execute.arg[2]->execute.user_value), HOLE /* for body */);
		  }

if (!_optimise) debug_execute_exit("RESTOFSS_3");
return(TRUE);
} 
                 
int RESTOFSS_4(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFSS_4 = debug_execute_enter("Executing procedure RESTOFSS_4 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[1]->execute.user_value); /* Need mechanism to hook up preceding UIs in PercentWU HOLE */

if (!_optimise) debug_execute_exit("RESTOFSS_4");
return(TRUE);
}

      
int UIRESTOFSS_1(YYTYPE *__arg)
{
int __debug = SEEN_UIRESTOFSS_1 = debug_execute_enter("Executing procedure UIRESTOFSS_1 -- arg at %p", __arg);

		  if ((int)(__arg->execute.arg[4]->execute.user_value) != NONE) {
                    assert(AST[(int)(__arg->execute.arg[4]->execute.user_value)] == BINOP);
                    assert(AST[(int)(__arg->execute.arg[4]->execute.user_value)+2] == NONE);
                    AST[(int)(__arg->execute.arg[4]->execute.user_value)+2] = (int)(__arg->execute.arg[3]->execute.user_value);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(CONDITIONAL, (int)(__arg->execute.arg[2]->execute.user_value) /* IF or UNLESS */, (int)(__arg->execute.arg[4]->execute.user_value), (int)(__arg->execute.arg[1]->execute.user_value));
		  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(CONDITIONAL, (int)(__arg->execute.arg[2]->execute.user_value) /* IF or UNLESS */, (int)(__arg->execute.arg[3]->execute.user_value), (int)(__arg->execute.arg[1]->execute.user_value));
		  }

if (!_optimise) debug_execute_exit("UIRESTOFSS_1");
return(TRUE);
} 
                 
int UIRESTOFSS_2(YYTYPE *__arg)
{
int __debug = SEEN_UIRESTOFSS_2 = debug_execute_enter("Executing procedure UIRESTOFSS_2 -- arg at %p", __arg);

                  assert(AST[(int)(__arg->execute.arg[2]->execute.user_value)+2] == HOLE);
                  AST[(int)(__arg->execute.arg[2]->execute.user_value)+2] = (int)(__arg->execute.arg[1]->execute.user_value);
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[2]->execute.user_value);

if (!_optimise) debug_execute_exit("UIRESTOFSS_2");
return(TRUE);
}

        
int RESTOFIU_1(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFIU_1 = debug_execute_enter("Executing procedure RESTOFIU_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  0; 
if (!_optimise) debug_execute_exit("RESTOFIU_1");
return(TRUE);
} 
                 
int RESTOFIU_2(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFIU_2 = debug_execute_enter("Executing procedure RESTOFIU_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  0; 
if (!_optimise) debug_execute_exit("RESTOFIU_2");
return(TRUE);
} 
                 
int RESTOFIU_3(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFIU_3 = debug_execute_enter("Executing procedure RESTOFIU_3 -- arg at %p", __arg);
 /* ELSE Needs special handling TODO */
                  if ((int)(__arg->execute.arg[3]->execute.user_value) != NONE) {
                    // (int)(__arg->execute.arg[3]->execute.user_value) = 0, or ELSESTART, ELSEIFORUNLESSSTART, ELSEIFORUNLESS, ELSE
		    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(THENELSE, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value));
		  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[2]->execute.user_value);
		  }

if (!_optimise) debug_execute_exit("RESTOFIU_3");
return(TRUE);
}

      
int ELSEquote_1(YYTYPE *__arg)
{
int __debug = SEEN_ELSEquote_1 = debug_execute_enter("Executing procedure ELSEquote_1 -- arg at %p", __arg);

                 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(ELSESTART);

if (!_optimise) debug_execute_exit("ELSEquote_1");
return(TRUE);
} 
                 
int ELSEquote_2(YYTYPE *__arg)
{
int __debug = SEEN_ELSEquote_2 = debug_execute_enter("Executing procedure ELSEquote_2 -- arg at %p", __arg);

                  int cond;
		  if ((int)(__arg->execute.arg[4]->execute.user_value) != NONE) {
                    assert(AST[(int)(__arg->execute.arg[4]->execute.user_value)] == BINOP);
                    assert(AST[(int)(__arg->execute.arg[4]->execute.user_value)+2] == NONE);
                    AST[(int)(__arg->execute.arg[4]->execute.user_value)+2] = (int)(__arg->execute.arg[3]->execute.user_value);
                    cond = (int)(__arg->execute.arg[4]->execute.user_value);
		  } else {
                    cond = (int)(__arg->execute.arg[3]->execute.user_value);
		  }
                  if ((int)(__arg->execute.arg[5]->execute.user_value) == 0) {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(ELSEIFORUNLESSSTART, (int)(__arg->execute.arg[2]->execute.user_value), cond);
                  } else {
                    // (int)(__arg->execute.arg[5]->execute.user_value) = tuple(THENELSE,
                    //  (ELSESTART, ELSEIFORUNLESSSTART, ELSEIFORUNLESS, ELSE))
                    // ... *or* an arbitrary <UI> ???

//                    assert(AST[(int)(__arg->execute.arg[5]->execute.user_value)] == THENELSE);
                    if (AST[(int)(__arg->execute.arg[5]->execute.user_value)] != THENELSE) {
                      // looks like it is a SUBSEQUENCE
//                      fprintf(stdout, "*** Assertion failed: AST[%d] = %d\n", (int)(__arg->execute.arg[5]->execute.user_value), AST[(int)(__arg->execute.arg[5]->execute.user_value)]);
//                      exit(1);
                    }

// fails on: %ffinish %eelse %iif I=1 %aand a=b %tthen a=' ' %aand b='%'' %aand i=i+2

                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(ELSEIFORUNLESS, (int)(__arg->execute.arg[2]->execute.user_value), cond, (int)(__arg->execute.arg[5]->execute.user_value));
                  }

if (!_optimise) debug_execute_exit("ELSEquote_2");
return(TRUE);
} 
                 
int ELSEquote_3(YYTYPE *__arg)
{
int __debug = SEEN_ELSEquote_3 = debug_execute_enter("Executing procedure ELSEquote_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(ELSE, (int)(__arg->execute.arg[2]->execute.user_value));

if (!_optimise) debug_execute_exit("ELSEquote_3");
return(TRUE);
} 
                 
int ELSEquote_4(YYTYPE *__arg)
{
int __debug = SEEN_ELSEquote_4 = debug_execute_enter("Executing procedure ELSEquote_4 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("ELSEquote_4");
return(TRUE);
}

           
int BPAIR_1(YYTYPE *__arg)
{
int __debug = SEEN_BPAIR_1 = debug_execute_enter("Executing procedure BPAIR_1 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(MULTI, maketuple(BOUND_PAIR, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[4]->execute.user_value)), (int)(__arg->execute.arg[5]->execute.user_value));

if (!_optimise) debug_execute_exit("BPAIR_1");
return(TRUE);
}

     
int CONSTquote_1(YYTYPE *__arg)
{
int __debug = SEEN_CONSTquote_1 = debug_execute_enter("Executing procedure CONSTquote_1 -- arg at %p", __arg);



                int con; /* need to fold const expr */
                if ((int)(__arg->execute.arg[2]->execute.user_value) != 0) con = maketuple(MONOP, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value)); else con = (int)(__arg->execute.arg[3]->execute.user_value);
                if ((int)(__arg->execute.arg[4]->execute.user_value) != 0) {
                  assert(AST[(int)(__arg->execute.arg[4]->execute.user_value)] == BINOP);
                  assert(AST[(int)(__arg->execute.arg[4]->execute.user_value)+2] == HOLE);
                  AST[(int)(__arg->execute.arg[4]->execute.user_value)+2] = con; con = (int)(__arg->execute.arg[4]->execute.user_value);
                }
                __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(INITCONST, con);

if (!_optimise) debug_execute_exit("CONSTquote_1");
return(TRUE);
} 
                 
int CONSTquote_2(YYTYPE *__arg)
{
int __debug = SEEN_CONSTquote_2 = debug_execute_enter("Executing procedure CONSTquote_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("CONSTquote_2");
return(TRUE);
}

      
int PercentSEX_1(YYTYPE *__arg)
{
int __debug = SEEN_PercentSEX_1 = debug_execute_enter("Executing procedure PercentSEX_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_SYSTEM); 
if (!_optimise) debug_execute_exit("PercentSEX_1");
return(TRUE);
} 
                 
int PercentSEX_2(YYTYPE *__arg)
{
int __debug = SEEN_PercentSEX_2 = debug_execute_enter("Executing procedure PercentSEX_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_EXTERNAL); 
if (!_optimise) debug_execute_exit("PercentSEX_2");
return(TRUE);
} 
                 
int PercentSEX_3(YYTYPE *__arg)
{
int __debug = SEEN_PercentSEX_3 = debug_execute_enter("Executing procedure PercentSEX_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_DYNAMIC); 
if (!_optimise) debug_execute_exit("PercentSEX_3");
return(TRUE);
} 
                 
int PercentSEX_4(YYTYPE *__arg)
{
int __debug = SEEN_PercentSEX_4 = debug_execute_enter("Executing procedure PercentSEX_4 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(TYPE_PRIM); /* Added for Imp77 */ 
if (!_optimise) debug_execute_exit("PercentSEX_4");
return(TRUE);
} 
                 
int PercentSEX_5(YYTYPE *__arg)
{
int __debug = SEEN_PercentSEX_5 = debug_execute_enter("Executing procedure PercentSEX_5 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("PercentSEX_5");
return(TRUE);
}

         
int CYCPARM_1(YYTYPE *__arg)
{
int __debug = SEEN_CYCPARM_1 = debug_execute_enter("Executing procedure CYCPARM_1 -- arg at %p", __arg);

		  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(FORLOOP, (int)(__arg->execute.arg[1]->execute.user_value), HOLE, (int)(__arg->execute.arg[3]->execute.user_value), (int)(__arg->execute.arg[5]->execute.user_value), (int)(__arg->execute.arg[7]->execute.user_value));
                  /* Hole is for body of loop AND MUST BE IN AST[2] for while/until compat */

if (!_optimise) debug_execute_exit("CYCPARM_1");
return(TRUE);
} 
                 
int CYCPARM_2(YYTYPE *__arg)
{
int __debug = SEEN_CYCPARM_2 = debug_execute_enter("Executing procedure CYCPARM_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("CYCPARM_2");
return(TRUE);
}

     
int RESTOFRFDEC_1(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFRFDEC_1 = debug_execute_enter("Executing procedure RESTOFRFDEC_1 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(MULTI, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value)); 

if (!_optimise) debug_execute_exit("RESTOFRFDEC_1");
return(TRUE);
} 
                 
int RESTOFRFDEC_2(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFRFDEC_2 = debug_execute_enter("Executing procedure RESTOFRFDEC_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("RESTOFRFDEC_2");
return(TRUE);
}

         
int RFSTMNT_1(YYTYPE *__arg)
{
int __debug = SEEN_RFSTMNT_1 = debug_execute_enter("Executing procedure RFSTMNT_1 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(RECORDFORMATSPEC, (int)(__arg->execute.arg[2]->execute.user_value));

if (!_optimise) debug_execute_exit("RFSTMNT_1");
return(TRUE);
} 
                 
int RFSTMNT_2(YYTYPE *__arg)
{
int __debug = SEEN_RFSTMNT_2 = debug_execute_enter("Executing procedure RFSTMNT_2 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[5]->execute.user_value) != NONE) {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(VARIANTRECORDFORMAT, (int)(__arg->execute.arg[1]->execute.user_value), maketuple(MULTI, (int)(__arg->execute.arg[3]->execute.user_value), (int)(__arg->execute.arg[4]->execute.user_value)), (int)(__arg->execute.arg[5]->execute.user_value));
                  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(RECORDFORMAT, (int)(__arg->execute.arg[1]->execute.user_value), maketuple(MULTI, (int)(__arg->execute.arg[3]->execute.user_value), (int)(__arg->execute.arg[4]->execute.user_value)));
		  }

if (!_optimise) debug_execute_exit("RFSTMNT_2");
return(TRUE);
}

           
int RFREF_1(YYTYPE *__arg)
{
int __debug = SEEN_RFREF_1 = debug_execute_enter("Executing procedure RFREF_1 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[1]->execute.user_value);

if (!_optimise) debug_execute_exit("RFREF_1");
return(TRUE);
} 
                 
int RFREF_2(YYTYPE *__arg)
{
int __debug = SEEN_RFREF_2 = debug_execute_enter("Executing procedure RFREF_2 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[3]->execute.user_value) != NONE) {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(VARIANTRECORDFORMAT, (int)(__arg->execute.arg[1]->execute.user_value), maketuple(MULTI, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value)), (int)(__arg->execute.arg[3]->execute.user_value));
                  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(RECORDFORMAT, HOLE, maketuple(MULTI, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value)));
		  }

if (!_optimise) debug_execute_exit("RFREF_2");
return(TRUE);
}

           
int RFDEC_1(YYTYPE *__arg)
{
int __debug = SEEN_RFDEC_1 = debug_execute_enter("Executing procedure RFDEC_1 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(RECORDFORMATDECLARATION, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value)); 

if (!_optimise) debug_execute_exit("RFDEC_1");
return(TRUE);
} 
                 
int RFDEC_2(YYTYPE *__arg)
{
int __debug = SEEN_RFDEC_2 = debug_execute_enter("Executing procedure RFDEC_2 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[4]->execute.user_value) != NONE) {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(VARIANTRECORDFORMAT, maketuple(MULTI, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value)), (int)(__arg->execute.arg[4]->execute.user_value));
                  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(RECORDFORMAT /* WRONG TAG! */, NONE, maketuple(MULTI, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value)));
		  }

if (!_optimise) debug_execute_exit("RFDEC_2");
return(TRUE);
}

         
int RFELMNT_1(YYTYPE *__arg)
{
int __debug = SEEN_RFELMNT_1 = debug_execute_enter("Executing procedure RFELMNT_1 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(RECORDFORMATELEMENT, (int)(__arg->execute.arg[1]->execute.user_value) /* name or arrayname */, maketuple(MULTI, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value)));

if (!_optimise) debug_execute_exit("RFELMNT_1");
return(TRUE);
} 
                 
int RFELMNT_2(YYTYPE *__arg)
{
int __debug = SEEN_RFELMNT_2 = debug_execute_enter("Executing procedure RFELMNT_2 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[2]->execute.user_value); /* is this sufficient? */

if (!_optimise) debug_execute_exit("RFELMNT_2");
return(TRUE);
}

        
int ALTRFDEC_1(YYTYPE *__arg)
{
int __debug = SEEN_ALTRFDEC_1 = debug_execute_enter("Executing procedure ALTRFDEC_1 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[4]->execute.user_value) != NONE) {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(VARIANTRECORDFORMAT, maketuple(MULTI, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value)), (int)(__arg->execute.arg[4]->execute.user_value));
                  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(RECORDFORMAT /* WRONG TAG! */, NONE, maketuple(MULTI, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value)));
		  }

if (!_optimise) debug_execute_exit("ALTRFDEC_1");
return(TRUE);
} 
                 
int ALTRFDEC_2(YYTYPE *__arg)
{
int __debug = SEEN_ALTRFDEC_2 = debug_execute_enter("Executing procedure ALTRFDEC_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("ALTRFDEC_2");
return(TRUE);
}

          
int OPTINC_1(YYTYPE *__arg)
{
int __debug = SEEN_OPTINC_1 = debug_execute_enter("Executing procedure OPTINC_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  formatf("+%s", (int)(__arg->execute.arg[2]->execute.user_value)); 
if (!_optimise) debug_execute_exit("OPTINC_1");
return(TRUE);
} 
                 
int OPTINC_2(YYTYPE *__arg)
{
int __debug = SEEN_OPTINC_2 = debug_execute_enter("Executing procedure OPTINC_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  formatf("-%s", (int)(__arg->execute.arg[2]->execute.user_value)); 
if (!_optimise) debug_execute_exit("OPTINC_2");
return(TRUE);
} 
                 
int OPTINC_3(YYTYPE *__arg)
{
int __debug = SEEN_OPTINC_3 = debug_execute_enter("Executing procedure OPTINC_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("OPTINC_3");
return(TRUE);
}

        
int ATquote_1(YYTYPE *__arg)
{
int __debug = SEEN_ATquote_1 = debug_execute_enter("Executing procedure ATquote_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  formatf("%s", __arg->execute.arg[1]->execute.text); 
if (!_optimise) debug_execute_exit("ATquote_1");
return(TRUE);
} 
                 
int ATquote_2(YYTYPE *__arg)
{
int __debug = SEEN_ATquote_2 = debug_execute_enter("Executing procedure ATquote_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  formatf("%s", __arg->execute.arg[1]->execute.text); 
if (!_optimise) debug_execute_exit("ATquote_2");
return(TRUE);
} 
                 
int ATquote_3(YYTYPE *__arg)
{
int __debug = SEEN_ATquote_3 = debug_execute_enter("Executing procedure ATquote_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("ATquote_3");
return(TRUE);
}

             
int XAPP_1(YYTYPE *__arg)
{
int __debug = SEEN_XAPP_1 = debug_execute_enter("Executing procedure XAPP_1 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(MULTI, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value));

if (!_optimise) debug_execute_exit("XAPP_1");
return(TRUE);
}

     
int RECORDFIELD_1(YYTYPE *__arg)
{
int __debug = SEEN_RECORDFIELD_1 = debug_execute_enter("Executing procedure RECORDFIELD_1 -- arg at %p", __arg);

                  int field;
                  if ((int)(__arg->execute.arg[3]->execute.user_value) != 0) {
                    field =  maketuple(ARRAYINDEX, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value));
                  } else {
                    field = (int)(__arg->execute.arg[2]->execute.user_value);
                  }
                  if ((int)(__arg->execute.arg[4]->execute.user_value) != 0) {
                    int node = (int)(__arg->execute.arg[4]->execute.user_value);
                    assert(AST[node+1] == HOLE);
                    AST[node+1] = maketuple(RECORDFIELD, HOLE, field);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  node;
                  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(RECORDFIELD, HOLE, field);
                  }

if (!_optimise) debug_execute_exit("RECORDFIELD_1");
return(TRUE);
} 
                 
int RECORDFIELD_2(YYTYPE *__arg)
{
int __debug = SEEN_RECORDFIELD_2 = debug_execute_enter("Executing procedure RECORDFIELD_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("RECORDFIELD_2");
return(TRUE);
}


     
int XRECORDFIELD_1(YYTYPE *__arg)
{
int __debug = SEEN_XRECORDFIELD_1 = debug_execute_enter("Executing procedure XRECORDFIELD_1 -- arg at %p", __arg);

                  int field;
                  if ((int)(__arg->execute.arg[3]->execute.user_value) != 0) {
                    field =  maketuple(ARRAYINDEX, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value));
                  } else {
                    field = (int)(__arg->execute.arg[2]->execute.user_value);
                  }
                  if ((int)(__arg->execute.arg[4]->execute.user_value) != 0) {
                    int node = (int)(__arg->execute.arg[4]->execute.user_value);
                    assert(AST[node+1] == HOLE);
                    AST[node+1] = maketuple(RECORDFIELD, HOLE, field);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  node;
                  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(RECORDFIELD, HOLE, field);
                  }

if (!_optimise) debug_execute_exit("XRECORDFIELD_1");
return(TRUE);
}

         
int NAMEAPP_1(YYTYPE *__arg)
{
int __debug = SEEN_NAMEAPP_1 = debug_execute_enter("Executing procedure NAMEAPP_1 -- arg at %p", __arg);
 /* NOTE: MAY BE AN ARRAY ACCESS */
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(PROCCALL_OR_ARRAY_OR_MAP, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value));

if (!_optimise) debug_execute_exit("NAMEAPP_1");
return(TRUE);
}               
int NAMEAPP_2(YYTYPE *__arg)
{
int __debug = SEEN_NAMEAPP_2 = debug_execute_enter("Executing procedure NAMEAPP_2 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(PROCCALL, (int)(__arg->execute.arg[1]->execute.user_value), 0);

if (!_optimise) debug_execute_exit("NAMEAPP_2");
return(TRUE);
}



                 
int BASIC_1(YYTYPE *__arg)
{
int __debug = SEEN_BASIC_1 = debug_execute_enter("Executing procedure BASIC_1 -- arg at %p", __arg);

                  /* record array element with subfield assignment */
/* TODO  fred(1)_jim = 3  may be a map to a record */
                int lhs = maketuple(ARRAYINDEX, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value));
                assert(AST[(int)(__arg->execute.arg[3]->execute.user_value)+1] == HOLE);
                AST[(int)(__arg->execute.arg[3]->execute.user_value)+1] = lhs;
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, (int)(__arg->execute.arg[4]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value), (int)(__arg->execute.arg[5]->execute.user_value)); 

if (!_optimise) debug_execute_exit("BASIC_1");
return(TRUE);
} 
                 
int BASIC_2(YYTYPE *__arg)
{
int __debug = SEEN_BASIC_2 = debug_execute_enter("Executing procedure BASIC_2 -- arg at %p", __arg);

                  /* record with subfield assignment */
                  //assert(AST[(int)(__arg->execute.arg[2]->execute.user_value)+1] == HOLE);
//fprintf(stdout, " /* sub sub field bug to be fixed (2) */\n");
                  AST[(int)(__arg->execute.arg[2]->execute.user_value)+1] = (int)(__arg->execute.arg[1]->execute.user_value); // AGAIN, "." vs "->"??
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, (int)(__arg->execute.arg[3]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[4]->execute.user_value)); 

if (!_optimise) debug_execute_exit("BASIC_2");
return(TRUE);
} 
                 
int BASIC_3(YYTYPE *__arg)
{
int __debug = SEEN_BASIC_3 = debug_execute_enter("Executing procedure BASIC_3 -- arg at %p", __arg);

                  /* array element assignment */
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, (int)(__arg->execute.arg[3]->execute.user_value), maketuple(PROCCALL_OR_ARRAY_OR_MAP, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value)), (int)(__arg->execute.arg[4]->execute.user_value)); 

if (!_optimise) debug_execute_exit("BASIC_3");
return(TRUE);
} 
                 
int BASIC_4(YYTYPE *__arg)
{
int __debug = SEEN_BASIC_4 = debug_execute_enter("Executing procedure BASIC_4 -- arg at %p", __arg);

                  /* variable or map assignment */
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BINOP, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value)); 

if (!_optimise) debug_execute_exit("BASIC_4");
return(TRUE);
} 
                 
int BASIC_5(YYTYPE *__arg)
{
int __debug = SEEN_BASIC_5 = debug_execute_enter("Executing procedure BASIC_5 -- arg at %p", __arg);

                  /* Switch label.  possibly regular label if APP is null??? */
		  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(SWITCHLABEL, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value));

if (!_optimise) debug_execute_exit("BASIC_5");
return(TRUE);
} 
                 
int BASIC_6(YYTYPE *__arg)
{
int __debug = SEEN_BASIC_6 = debug_execute_enter("Executing procedure BASIC_6 -- arg at %p", __arg);

		  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(LABEL, (int)(__arg->execute.arg[1]->execute.user_value));

if (!_optimise) debug_execute_exit("BASIC_6");
return(TRUE);
} 
                 
int BASIC_7(YYTYPE *__arg)
{
int __debug = SEEN_BASIC_7 = debug_execute_enter("Executing procedure BASIC_7 -- arg at %p", __arg);

                  /* procedure call with params. */
		  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(PROCCALL, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value));

if (!_optimise) debug_execute_exit("BASIC_7");
return(TRUE);
} 
                 
int BASIC_8(YYTYPE *__arg)
{
int __debug = SEEN_BASIC_8 = debug_execute_enter("Executing procedure BASIC_8 -- arg at %p", __arg);

                  /* procedure call, no params. */
		  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(PROCCALL, (int)(__arg->execute.arg[1]->execute.user_value), 0);

if (!_optimise) debug_execute_exit("BASIC_8");
return(TRUE);
}

/* NOTE: imp80 does not allow  %iif a=b %tthen x=y %aand %sstart */

             
int AUI_1(YYTYPE *__arg)
{
int __debug = SEEN_AUI_1 = debug_execute_enter("Executing procedure AUI_1 -- arg at %p", __arg);

                  if (AST[(int)(__arg->execute.arg[2]->execute.user_value)] == SUBSEQUENCE) {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(SUBSEQUENCE, HOLE, (int)(__arg->execute.arg[2]->execute.user_value));
                  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(SUBSEQUENCE, HOLE, maketuple(SUBSEQUENCE, (int)(__arg->execute.arg[2]->execute.user_value), 0));
                  }

if (!_optimise) debug_execute_exit("AUI_1");
return(TRUE);
} 
                 
int AUI_2(YYTYPE *__arg)
{
int __debug = SEEN_AUI_2 = debug_execute_enter("Executing procedure AUI_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("AUI_2");
return(TRUE);
}

              
int UI_1(YYTYPE *__arg)
{
int __debug = SEEN_UI_1 = debug_execute_enter("Executing procedure UI_1 -- arg at %p", __arg);

                  if (AST[(int)(__arg->execute.arg[3]->execute.user_value)] != SUBSEQUENCE) {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(SUBSEQUENCE, (int)(__arg->execute.arg[1]->execute.user_value), maketuple(SUBSEQUENCE, (int)(__arg->execute.arg[3]->execute.user_value), 0));
                  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(SUBSEQUENCE, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value));
                  }
                  /* Much worse parsing performance, easier to handle however */

if (!_optimise) debug_execute_exit("UI_1");
return(TRUE);
}               
int UI_2(YYTYPE *__arg)
{
int __debug = SEEN_UI_2 = debug_execute_enter("Executing procedure UI_2 -- arg at %p", __arg);

		    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[1]->execute.user_value);
                    /* Much worse parsing performance, easier to handle however */

if (!_optimise) debug_execute_exit("UI_2");
return(TRUE);
} 
                  
int UI_3(YYTYPE *__arg)
{
int __debug = SEEN_UI_3 = debug_execute_enter("Executing procedure UI_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(GOTO_LABEL,
                         sformatf("L_%s", __arg->execute.arg[2]->execute.text)); /* Added for Imp15 */
if (!_optimise) debug_execute_exit("UI_3");
return(TRUE);
} 
                 
int UI_4(YYTYPE *__arg)
{
int __debug = SEEN_UI_4 = debug_execute_enter("Executing procedure UI_4 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[3]->execute.user_value) != NONE) {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(GOTO_SWITCH, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value));
                  } else {
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(GOTO_LABEL, (int)(__arg->execute.arg[2]->execute.user_value));
                  }

if (!_optimise) debug_execute_exit("UI_4");
return(TRUE);
} 
                 
int UI_5(YYTYPE *__arg)
{
int __debug = SEEN_UI_5 = debug_execute_enter("Executing procedure UI_5 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(RETURN); 
if (!_optimise) debug_execute_exit("UI_5");
return(TRUE);
} 
                 
int UI_6(YYTYPE *__arg)
{
int __debug = SEEN_UI_6 = debug_execute_enter("Executing procedure UI_6 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(RETURN_TRUE); 
if (!_optimise) debug_execute_exit("UI_6");
return(TRUE);
} 
                 
int UI_7(YYTYPE *__arg)
{
int __debug = SEEN_UI_7 = debug_execute_enter("Executing procedure UI_7 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(RETURN_FALSE); 
if (!_optimise) debug_execute_exit("UI_7");
return(TRUE);
} 
                 
int UI_8(YYTYPE *__arg)
{
int __debug = SEEN_UI_8 = debug_execute_enter("Executing procedure UI_8 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(RESULT, (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value)); 
if (!_optimise) debug_execute_exit("UI_8");
return(TRUE);
} 
                 
int UI_9(YYTYPE *__arg)
{
int __debug = SEEN_UI_9 = debug_execute_enter("Executing procedure UI_9 -- arg at %p", __arg);

                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(SUBSEQUENCE,
                                          maketuple(MONITOR),
                                          maketuple(SUBSEQUENCE,
                                                    maketuple(STOP),
                                                    0));

if (!_optimise) debug_execute_exit("UI_9");
return(TRUE);
} 
                 
int UI_10(YYTYPE *__arg)
{
int __debug = SEEN_UI_10 = debug_execute_enter("Executing procedure UI_10 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[2]->execute.user_value) != NONE) {  /* %mmonitor, followed by UI. */
                    assert(AST[(int)(__arg->execute.arg[2]->execute.user_value)] == SUBSEQUENCE);
                    assert(AST[(int)(__arg->execute.arg[2]->execute.user_value)+1] == HOLE);
                    assert((AST[(int)(__arg->execute.arg[2]->execute.user_value)+2] == 0) || (AST[AST[(int)(__arg->execute.arg[2]->execute.user_value)+2]] == SUBSEQUENCE));
                    AST[(int)(__arg->execute.arg[2]->execute.user_value)+1] = maketuple(MONITOR);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[2]->execute.user_value);
		  } else {
		    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(MONITOR);
		  }

if (!_optimise) debug_execute_exit("UI_10");
return(TRUE);
} 
                 
int UI_11(YYTYPE *__arg)
{
int __debug = SEEN_UI_11 = debug_execute_enter("Executing procedure UI_11 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(STOP); 
if (!_optimise) debug_execute_exit("UI_11");
return(TRUE);
} 
                 
int UI_12(YYTYPE *__arg)
{
int __debug = SEEN_UI_12 = debug_execute_enter("Executing procedure UI_12 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(SIGNAL, (int)(__arg->execute.arg[3]->execute.user_value), (int)(__arg->execute.arg[4]->execute.user_value), (int)(__arg->execute.arg[5]->execute.user_value)); /* should make into a signal bitmask */

if (!_optimise) debug_execute_exit("UI_12");
return(TRUE);
} 
                 
int UI_13(YYTYPE *__arg)
{
int __debug = SEEN_UI_13 = debug_execute_enter("Executing procedure UI_13 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(BREAK, HOLE /* destination */); 
if (!_optimise) debug_execute_exit("UI_13");
return(TRUE);
} 
                 
int UI_14(YYTYPE *__arg)
{
int __debug = SEEN_UI_14 = debug_execute_enter("Executing procedure UI_14 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(CONTINUE, HOLE /* destination */); 
if (!_optimise) debug_execute_exit("UI_14");
return(TRUE);
}

       
int SWITCHDEC_1(YYTYPE *__arg)
{
int __debug = SEEN_SWITCHDEC_1 = debug_execute_enter("Executing procedure SWITCHDEC_1 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  maketuple(SWITCHDECL, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[4]->execute.user_value), (int)(__arg->execute.arg[6]->execute.user_value), (int)(__arg->execute.arg[8]->execute.user_value));

if (!_optimise) debug_execute_exit("SWITCHDEC_1");
return(TRUE);
}

    
int RESTOFSWLIST_1(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFSWLIST_1 = debug_execute_enter("Executing procedure RESTOFSWLIST_1 -- arg at %p", __arg);

                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  (int)(__arg->execute.arg[2]->execute.user_value);

if (!_optimise) debug_execute_exit("RESTOFSWLIST_1");
return(TRUE);
} 
                 
int RESTOFSWLIST_2(YYTYPE *__arg)
{
int __debug = SEEN_RESTOFSWLIST_2 = debug_execute_enter("Executing procedure RESTOFSWLIST_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("RESTOFSWLIST_2");
return(TRUE);
}

           
int SS_1(YYTYPE *__arg)
{
int __debug = SEEN_SS_1 = debug_execute_enter("Executing procedure SS_1 -- arg at %p", __arg);
 /* always fails - hack to save text of every line!*/

if (!_optimise) debug_execute_exit("SS_1");
return(TRUE);
} 

              
int SS_2(YYTYPE *__arg)
{
int __debug = SEEN_SS_2 = debug_execute_enter("Executing procedure SS_2 -- arg at %p", __arg);
 exit_flag = TRUE; 
                  /* Successful parse: generate the C code now. */
		  entrypoint = reverse_list(entrypoint);
		  //fixup_scopes(entrypoint, 0);
                  printf("//============================================================================\n");
		  codegen(entrypoint, 0);

if (!_optimise) debug_execute_exit("SS_2");
return(TRUE);
} 
                 
int SS_3(YYTYPE *__arg)
{
int __debug = SEEN_SS_3 = debug_execute_enter("Executing procedure SS_3 -- arg at %p", __arg);

                  label = FALSE;
                  entrypoint = maketuple(SEQUENCE, (int)(__arg->execute.arg[1]->execute.user_value), entrypoint);
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;

if (!_optimise) debug_execute_exit("SS_3");
return(TRUE);
} 
                 
int SS_4(YYTYPE *__arg)
{
int __debug = SEEN_SS_4 = debug_execute_enter("Executing procedure SS_4 -- arg at %p", __arg);

                  label = FALSE;
		  if ((int)(__arg->execute.arg[2]->execute.user_value) == NONE) {
                    entrypoint = maketuple(SEQUENCE, (int)(__arg->execute.arg[1]->execute.user_value), entrypoint);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                  } else {
                    entrypoint = maketuple(SEQUENCE, maketuple(SEQUENCE, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value)), entrypoint);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
		  }

if (!_optimise) debug_execute_exit("SS_4");
return(TRUE);
} 
                   
int SS_5(YYTYPE *__arg)
{
int __debug = SEEN_SS_5 = debug_execute_enter("Executing procedure SS_5 -- arg at %p", __arg);
 /* Added for Imp15 */
                   label = FALSE;
                   entrypoint = maketuple(SEQUENCE, maketuple(NUMERICLABEL, (int)sformatf("%s", __arg->execute.arg[1]->execute.text)), entrypoint);
                   __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;

if (!_optimise) debug_execute_exit("SS_5");
return(TRUE);
} 
                  
int SS_6(YYTYPE *__arg)
{
int __debug = SEEN_SS_6 = debug_execute_enter("Executing procedure SS_6 -- arg at %p", __arg);

                    entrypoint = maketuple(SEQUENCE, maketuple(COMMENT, (int)(__arg->execute.arg[1]->execute.user_value)), entrypoint);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;

if (!_optimise) debug_execute_exit("SS_6");
return(TRUE);
} 
                 
int SS_7(YYTYPE *__arg)
{
int __debug = SEEN_SS_7 = debug_execute_enter("Executing procedure SS_7 -- arg at %p", __arg);

                  int cond, hack;
                  if ((int)(__arg->execute.arg[3]->execute.user_value) != NONE) {
                    cond = (int)(__arg->execute.arg[3]->execute.user_value);
                    assert(AST[cond] == BINOP);
                    assert(AST[cond+2] == HOLE);
                    AST[cond+2] = (int)(__arg->execute.arg[2]->execute.user_value);
                  } else cond = (int)(__arg->execute.arg[2]->execute.user_value);
                  // if <(int)(__arg->execute.arg[4]->execute.user_value)/RESTOFIU> is 0, it's a "start"...
                  if ((int)(__arg->execute.arg[4]->execute.user_value) == 0) {
                    entrypoint = maketuple(SEQUENCE, 
                                           maketuple(IFORUNLESSSTART, (int)(__arg->execute.arg[1]->execute.user_value), cond), entrypoint);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                  } else {
// PROBLEM CASE: fixed in fixup_...
// %iif j=k %tthen j=j %eelse %iif k=j %tthen k=k %eelse %sstart
                    entrypoint = maketuple(SEQUENCE,
                                           maketuple(CONDITIONAL, (int)(__arg->execute.arg[1]->execute.user_value), cond, (int)(__arg->execute.arg[4]->execute.user_value)), entrypoint);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                  }

if (!_optimise) debug_execute_exit("SS_7");
return(TRUE);
} 
                 
int SS_8(YYTYPE *__arg)
{
int __debug = SEEN_SS_8 = debug_execute_enter("Executing procedure SS_8 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[2]->execute.user_value) != NONE) {
                    int stmnt = 0;
                    // (int)(__arg->execute.arg[2]->execute.user_value) = ELSESTART, ELSEIFORUNLESSSTART, ELSEIFORUNLESS, ELSE
                    if (AST[(int)(__arg->execute.arg[2]->execute.user_value)] == ELSESTART) stmnt = FINISHELSESTART;
                    if (AST[(int)(__arg->execute.arg[2]->execute.user_value)] == ELSEIFORUNLESSSTART) stmnt = FINISHELSEIFORUNLESSSTART;
                    if (AST[(int)(__arg->execute.arg[2]->execute.user_value)] == ELSEIFORUNLESS) stmnt = FINISHELSEIFORUNLESS;
                    if (AST[(int)(__arg->execute.arg[2]->execute.user_value)] == ELSE) stmnt = FINISHELSE;
                    if (stmnt == 0) {
                      fprintf(stderr, "finish<ELSEquote><S> -> $2=%d", (int)(__arg->execute.arg[2]->execute.user_value));
                      fprintf(stdout, "finish<ELSEquote><S> -> $2=%d", (int)(__arg->execute.arg[2]->execute.user_value));
                      exit(1);
                    }
                    AST[(int)(__arg->execute.arg[2]->execute.user_value)] = stmnt;
		    entrypoint = maketuple(SEQUENCE, (int)(__arg->execute.arg[2]->execute.user_value), entrypoint);
                    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                    /* FLOW CONTROL NEEDS TO BE PATCHED UP IN THE AST! */
                  } else {
		    entrypoint = maketuple(SEQUENCE, maketuple(FINISH), entrypoint);
		    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                  }
                  

if (!_optimise) debug_execute_exit("SS_8");
return(TRUE);
} 
                 
int SS_9(YYTYPE *__arg)
{
int __debug = SEEN_SS_9 = debug_execute_enter("Executing procedure SS_9 -- arg at %p", __arg);

                  if ((int)(__arg->execute.arg[2]->execute.user_value) != NONE) {
		    entrypoint = maketuple(SEQUENCE, (int)(__arg->execute.arg[2]->execute.user_value), entrypoint); /* CYCPARM passes up FORLOOP TODO */
		    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                  } else {
		    entrypoint = maketuple(SEQUENCE, maketuple(LOOP), entrypoint);
		    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                  }
                  

if (!_optimise) debug_execute_exit("SS_9");
return(TRUE);
} 
                 
int SS_10(YYTYPE *__arg)
{
int __debug = SEEN_SS_10 = debug_execute_enter("Executing procedure SS_10 -- arg at %p", __arg);

                  /* Should link these up with starting FORLOOP/LOOP */
                  if ((int)(__arg->execute.arg[2]->execute.user_value) != NONE) {
		    entrypoint = maketuple(SEQUENCE, (int)(__arg->execute.arg[2]->execute.user_value), entrypoint); /* RESTOFREPEAT passes up REPEATUNTIL TODO */
		    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                  } else {
		    entrypoint = maketuple(SEQUENCE, maketuple(ENDLOOP), entrypoint);
		    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                  }
                  

if (!_optimise) debug_execute_exit("SS_10");
return(TRUE);
} 
                 
int SS_11(YYTYPE *__arg)
{
int __debug = SEEN_SS_11 = debug_execute_enter("Executing procedure SS_11 -- arg at %p", __arg);

                  /* while/until/for - but not "" */
                  entrypoint = maketuple(SEQUENCE, (int)(__arg->execute.arg[1]->execute.user_value), entrypoint); /* PercentWU passes up WHILELOOP, UNTILLOOP, or FORLOOP */
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;

if (!_optimise) debug_execute_exit("SS_11");
return(TRUE);
} 
                 
int SS_12(YYTYPE *__arg)
{
int __debug = SEEN_SS_12 = debug_execute_enter("Executing procedure SS_12 -- arg at %p", __arg);

                  int decln = (int)(__arg->execute.arg[2]->execute.user_value);
                  assert(AST[decln+1] == HOLE || (AST[(int)(__arg->execute.arg[1]->execute.user_value)] == TYPE_RECORD)); // HOLE is first param for all 3 DECLN types now
                  if (AST[decln+1] == HOLE) AST[decln+1] = (int)(__arg->execute.arg[1]->execute.user_value);
debug_ast(decln); // with plugged hole

                  if ((AST[(int)(__arg->execute.arg[1]->execute.user_value)] == TYPE_RECORD) && (AST[(int)(__arg->execute.arg[1]->execute.user_value)+1] == HOLE)) {
                    // need to do a bit of fixup here for record declarations in the old form of %rrecord r(rfm)
                    // but be careful because "%record (*) r" also comes through here...
fprintf(stdout, "// UNKNOWN RECORD TYPE\n");
                  }

                  entrypoint = maketuple(SEQUENCE, (int)(__arg->execute.arg[2]->execute.user_value), entrypoint);
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                  

if (!_optimise) debug_execute_exit("SS_12");
return(TRUE);
}                
int SS_13(YYTYPE *__arg)
{
int __debug = SEEN_SS_13 = debug_execute_enter("Executing procedure SS_13 -- arg at %p", __arg);

                    reals_long = TRUE;  /* probably not appropriate to put this in the parser but it works */

if (!_optimise) debug_execute_exit("SS_13");
return(TRUE);
}                
int SS_14(YYTYPE *__arg)
{
int __debug = SEEN_SS_14 = debug_execute_enter("Executing procedure SS_14 -- arg at %p", __arg);

                    reals_long = FALSE;

if (!_optimise) debug_execute_exit("SS_14");
return(TRUE);
}               
int SS_15(YYTYPE *__arg)
{
int __debug = SEEN_SS_15 = debug_execute_enter("Executing procedure SS_15 -- arg at %p", __arg);

		    entrypoint = maketuple(SEQUENCE, maketuple(ENDPROG), entrypoint);
		    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;

if (!_optimise) debug_execute_exit("SS_15");
return(TRUE);
}               
int SS_16(YYTYPE *__arg)
{
int __debug = SEEN_SS_16 = debug_execute_enter("Executing procedure SS_16 -- arg at %p", __arg);

		    entrypoint = maketuple(SEQUENCE, maketuple(ENDPROG), entrypoint);
		    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;

if (!_optimise) debug_execute_exit("SS_16");
return(TRUE);
}               
int SS_17(YYTYPE *__arg)
{
int __debug = SEEN_SS_17 = debug_execute_enter("Executing procedure SS_17 -- arg at %p", __arg);

		    entrypoint = maketuple(SEQUENCE, maketuple(ENDFILE), entrypoint);
		    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;

if (!_optimise) debug_execute_exit("SS_17");
return(TRUE);
}               
int SS_18(YYTYPE *__arg)
{
int __debug = SEEN_SS_18 = debug_execute_enter("Executing procedure SS_18 -- arg at %p", __arg);

		    entrypoint = maketuple(SEQUENCE, maketuple(ENDPERM), entrypoint);
		    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;

if (!_optimise) debug_execute_exit("SS_18");
return(TRUE);
}               
int SS_19(YYTYPE *__arg)
{
int __debug = SEEN_SS_19 = debug_execute_enter("Executing procedure SS_19 -- arg at %p", __arg);

		    entrypoint = maketuple(SEQUENCE, maketuple(ENDLIST), entrypoint);
		    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;

if (!_optimise) debug_execute_exit("SS_19");
return(TRUE);
}               
int SS_20(YYTYPE *__arg)
{
int __debug = SEEN_SS_20 = debug_execute_enter("Executing procedure SS_20 -- arg at %p", __arg);

		    entrypoint = maketuple(SEQUENCE, maketuple(ENDBLOCKPROCFN), entrypoint); /* end of scope for symtab */
		    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                  

if (!_optimise) debug_execute_exit("SS_20");
return(TRUE);
} 
                 
int SS_21(YYTYPE *__arg)
{
int __debug = SEEN_SS_21 = debug_execute_enter("Executing procedure SS_21 -- arg at %p", __arg);

		    entrypoint = maketuple(SEQUENCE, (int)(__arg->execute.arg[2]->execute.user_value), entrypoint);
		    __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;

if (!_optimise) debug_execute_exit("SS_21");
return(TRUE);
} 
                 
int SS_22(YYTYPE *__arg)
{
int __debug = SEEN_SS_22 = debug_execute_enter("Executing procedure SS_22 -- arg at %p", __arg);

                  entrypoint = maketuple(SEQUENCE, maketuple(PROCDEF, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value), (int)(__arg->execute.arg[4]->execute.user_value), (int)(__arg->execute.arg[5]->execute.user_value), (int)(__arg->execute.arg[6]->execute.user_value)), entrypoint);
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                  

if (!_optimise) debug_execute_exit("SS_22");
return(TRUE);
}               
int SS_23(YYTYPE *__arg)
{
int __debug = SEEN_SS_23 = debug_execute_enter("Executing procedure SS_23 -- arg at %p", __arg);
 
                  entrypoint = maketuple(SEQUENCE, maketuple(OWNDEC, (int)(__arg->execute.arg[1]->execute.user_value), (int)(__arg->execute.arg[2]->execute.user_value), (int)(__arg->execute.arg[3]->execute.user_value)), entrypoint); 
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                

if (!_optimise) debug_execute_exit("SS_23");
return(TRUE);
} 
                 
int SS_24(YYTYPE *__arg)
{
int __debug = SEEN_SS_24 = debug_execute_enter("Executing procedure SS_24 -- arg at %p", __arg);
 /* No <S>? */
                  entrypoint = maketuple(SEQUENCE, maketuple(INCLUDE, (int)(__arg->execute.arg[2]->execute.user_value)), entrypoint);
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                  

if (!_optimise) debug_execute_exit("SS_24");
return(TRUE);
} 
                 
int SS_25(YYTYPE *__arg)
{
int __debug = SEEN_SS_25 = debug_execute_enter("Executing procedure SS_25 -- arg at %p", __arg);

                  entrypoint = maketuple(SEQUENCE, maketuple(BEGINBLOCK, HOLE), entrypoint);
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                  

if (!_optimise) debug_execute_exit("SS_25");
return(TRUE);
} 
                 
int SS_26(YYTYPE *__arg)
{
int __debug = SEEN_SS_26 = debug_execute_enter("Executing procedure SS_26 -- arg at %p", __arg);

                  entrypoint = maketuple(SEQUENCE, maketuple(ONEVENT, (int)(__arg->execute.arg[3]->execute.user_value), (int)(__arg->execute.arg[4]->execute.user_value), HOLE), entrypoint); /*NOTESTART*/
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                  

if (!_optimise) debug_execute_exit("SS_26");
return(TRUE);
} 
                 
int SS_27(YYTYPE *__arg)
{
int __debug = SEEN_SS_27 = debug_execute_enter("Executing procedure SS_27 -- arg at %p", __arg);

                  entrypoint = maketuple(SEQUENCE, (int)(__arg->execute.arg[2]->execute.user_value), entrypoint);
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;

if (!_optimise) debug_execute_exit("SS_27");
return(TRUE);
} 
                 
int SS_28(YYTYPE *__arg)
{
int __debug = SEEN_SS_28 = debug_execute_enter("Executing procedure SS_28 -- arg at %p", __arg);
 

if (!_optimise) debug_execute_exit("SS_28");
return(TRUE);
} 
                 
int SS_29(YYTYPE *__arg)
{
int __debug = SEEN_SS_29 = debug_execute_enter("Executing procedure SS_29 -- arg at %p", __arg);

                  entrypoint = maketuple(SEQUENCE, maketuple(FINISHELSESTART), entrypoint);
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;

if (!_optimise) debug_execute_exit("SS_29");
return(TRUE);
} 
		 
int SS_30(YYTYPE *__arg)
{
int __debug = SEEN_SS_30 = debug_execute_enter("Executing procedure SS_30 -- arg at %p", __arg);
  /* else if for imp77 */
                  int cond;
                  if ((int)(__arg->execute.arg[4]->execute.user_value) != NONE) {
                    cond = (int)(__arg->execute.arg[4]->execute.user_value);
                    assert(AST[cond] == BINOP);
                    AST[cond+2] = (int)(__arg->execute.arg[3]->execute.user_value);
                  } else cond = (int)(__arg->execute.arg[3]->execute.user_value);
                  entrypoint = maketuple(SEQUENCE, maketuple(FINISHELSEIFSTART, (int)(__arg->execute.arg[2]->execute.user_value), cond), entrypoint); /* CONDITIONAL?? */
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                  /* $0 = formatf("ELSE: if/unless=%dd sc=%dd restofcond=%dd\n", $2, $3, $4); */

if (!_optimise) debug_execute_exit("SS_30");
return(TRUE);
} 
                 
int SS_31(YYTYPE *__arg)
{
int __debug = SEEN_SS_31 = debug_execute_enter("Executing procedure SS_31 -- arg at %p", __arg);

                  entrypoint = maketuple(SEQUENCE, maketuple(ASM, (int)(__arg->execute.arg[2]->execute.user_value)), entrypoint);
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                  

if (!_optimise) debug_execute_exit("SS_31");
return(TRUE);
} 
                 
int SS_32(YYTYPE *__arg)
{
int __debug = SEEN_SS_32 = debug_execute_enter("Executing procedure SS_32 -- arg at %p", __arg);
 

if (!_optimise) debug_execute_exit("SS_32");
return(TRUE);
} 
                 
int SS_33(YYTYPE *__arg)
{
int __debug = SEEN_SS_33 = debug_execute_enter("Executing procedure SS_33 -- arg at %p", __arg);
 

if (!_optimise) debug_execute_exit("SS_33");
return(TRUE);
} 
                 
int SS_34(YYTYPE *__arg)
{
int __debug = SEEN_SS_34 = debug_execute_enter("Executing procedure SS_34 -- arg at %p", __arg);
 

if (!_optimise) debug_execute_exit("SS_34");
return(TRUE);
} 
                 
int SS_35(YYTYPE *__arg)
{
int __debug = SEEN_SS_35 = debug_execute_enter("Executing procedure SS_35 -- arg at %p", __arg);
 

if (!_optimise) debug_execute_exit("SS_35");
return(TRUE);
} 
                 
int SS_36(YYTYPE *__arg)
{
int __debug = SEEN_SS_36 = debug_execute_enter("Executing procedure SS_36 -- arg at %p", __arg);

                  entrypoint = maketuple(SEQUENCE, maketuple(PROCCALL, "printstring", (int)(__arg->execute.arg[2]->execute.user_value)), entrypoint);
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;

if (!_optimise) debug_execute_exit("SS_36");
return(TRUE);
} 
                 
int SS_37(YYTYPE *__arg)
{
int __debug = SEEN_SS_37 = debug_execute_enter("Executing procedure SS_37 -- arg at %p", __arg);

                  /* default case statement.  Ought to have been picked up in BASIC */
                  entrypoint = maketuple(SEQUENCE, maketuple(DEFAULTCASE, (int)(__arg->execute.arg[1]->execute.user_value)), entrypoint);
                  __arg->execute.arg[0]->execute.user_value = (USERTYPE *)  entrypoint;
                  

if (!_optimise) debug_execute_exit("SS_37");
return(TRUE);
} 
                 
int SS_38(YYTYPE *__arg)
{
int __debug = SEEN_SS_38 = debug_execute_enter("Executing procedure SS_38 -- arg at %p", __arg);
 
if (!_optimise) debug_execute_exit("SS_38");
return(TRUE);
}

  
int ASSOP_1(YYTYPE *__arg)
{
int __debug = SEEN_ASSOP_1 = debug_execute_enter("Executing procedure ASSOP_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_PTRASSIGN; 
if (!_optimise) debug_execute_exit("ASSOP_1");
return(TRUE);
} 
        
int ASSOP_2(YYTYPE *__arg)
{
int __debug = SEEN_ASSOP_2 = debug_execute_enter("Executing procedure ASSOP_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_ASSIGN; 
if (!_optimise) debug_execute_exit("ASSOP_2");
return(TRUE);
} 
        
int ASSOP_3(YYTYPE *__arg)
{
int __debug = SEEN_ASSOP_3 = debug_execute_enter("Executing procedure ASSOP_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_JAMTRANSFER; 
if (!_optimise) debug_execute_exit("ASSOP_3");
return(TRUE);
} 
        
int ASSOP_4(YYTYPE *__arg)
{
int __debug = SEEN_ASSOP_4 = debug_execute_enter("Executing procedure ASSOP_4 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_STRINGRESOLVE; 
if (!_optimise) debug_execute_exit("ASSOP_4");
return(TRUE);
}

  
int COLON_1(YYTYPE *__arg)
{
int __debug = SEEN_COLON_1 = debug_execute_enter("Executing procedure COLON_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) formatf("%s", __arg->execute.arg[1]->execute.text); 
if (!_optimise) debug_execute_exit("COLON_1");
return(TRUE);
}

  
int COMP_1(YYTYPE *__arg)
{
int __debug = SEEN_COMP_1 = debug_execute_enter("Executing procedure COMP_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_PTREQ; 
if (!_optimise) debug_execute_exit("COMP_1");
return(TRUE);
} 
       
int COMP_2(YYTYPE *__arg)
{
int __debug = SEEN_COMP_2 = debug_execute_enter("Executing procedure COMP_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_LE; 
if (!_optimise) debug_execute_exit("COMP_2");
return(TRUE);
} 
       
int COMP_3(YYTYPE *__arg)
{
int __debug = SEEN_COMP_3 = debug_execute_enter("Executing procedure COMP_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_GE; 
if (!_optimise) debug_execute_exit("COMP_3");
return(TRUE);
} 
       
int COMP_4(YYTYPE *__arg)
{
int __debug = SEEN_COMP_4 = debug_execute_enter("Executing procedure COMP_4 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_GT; 
if (!_optimise) debug_execute_exit("COMP_4");
return(TRUE);
} 
       
int COMP_5(YYTYPE *__arg)
{
int __debug = SEEN_COMP_5 = debug_execute_enter("Executing procedure COMP_5 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_TESTRESOLVE; 
if (!_optimise) debug_execute_exit("COMP_5");
return(TRUE);
} 
       
int COMP_6(YYTYPE *__arg)
{
int __debug = SEEN_COMP_6 = debug_execute_enter("Executing procedure COMP_6 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_EQ; 
if (!_optimise) debug_execute_exit("COMP_6");
return(TRUE);
} 
       
int COMP_7(YYTYPE *__arg)
{
int __debug = SEEN_COMP_7 = debug_execute_enter("Executing procedure COMP_7 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) (int)(__arg->execute.arg[1]->execute.user_value); 
if (!_optimise) debug_execute_exit("COMP_7");
return(TRUE);
}   
int COMP_8(YYTYPE *__arg)
{
int __debug = SEEN_COMP_8 = debug_execute_enter("Executing procedure COMP_8 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) (int)(__arg->execute.arg[1]->execute.user_value); 
if (!_optimise) debug_execute_exit("COMP_8");
return(TRUE);
} 
       
int COMP_9(YYTYPE *__arg)
{
int __debug = SEEN_COMP_9 = debug_execute_enter("Executing procedure COMP_9 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_LT; 
if (!_optimise) debug_execute_exit("COMP_9");
return(TRUE);
}

  
int notcomp_1(YYTYPE *__arg)
{
int __debug = SEEN_notcomp_1 = debug_execute_enter("Executing procedure notcomp_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_NE; 
if (!_optimise) debug_execute_exit("notcomp_1");
return(TRUE);
} 
          
int notcomp_2(YYTYPE *__arg)
{
int __debug = SEEN_notcomp_2 = debug_execute_enter("Executing procedure notcomp_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_NE; 
if (!_optimise) debug_execute_exit("notcomp_2");
return(TRUE);
} 
          
int notcomp_3(YYTYPE *__arg)
{
int __debug = SEEN_notcomp_3 = debug_execute_enter("Executing procedure notcomp_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_NE; 
if (!_optimise) debug_execute_exit("notcomp_3");
return(TRUE);
}

  
int notequivcomp_1(YYTYPE *__arg)
{
int __debug = SEEN_notequivcomp_1 = debug_execute_enter("Executing procedure notequivcomp_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_PTRNE; 
if (!_optimise) debug_execute_exit("notequivcomp_1");
return(TRUE);
} 
               
int notequivcomp_2(YYTYPE *__arg)
{
int __debug = SEEN_notequivcomp_2 = debug_execute_enter("Executing procedure notequivcomp_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_PTRNE; 
if (!_optimise) debug_execute_exit("notequivcomp_2");
return(TRUE);
}


       
int COMPtwo_1(YYTYPE *__arg)
{
int __debug = SEEN_COMPtwo_1 = debug_execute_enter("Executing procedure COMPtwo_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_PTREQ; 
if (!_optimise) debug_execute_exit("COMPtwo_1");
return(TRUE);
} 
       
int COMPtwo_2(YYTYPE *__arg)
{
int __debug = SEEN_COMPtwo_2 = debug_execute_enter("Executing procedure COMPtwo_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_LE; 
if (!_optimise) debug_execute_exit("COMPtwo_2");
return(TRUE);
} 
       
int COMPtwo_3(YYTYPE *__arg)
{
int __debug = SEEN_COMPtwo_3 = debug_execute_enter("Executing procedure COMPtwo_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_GE; 
if (!_optimise) debug_execute_exit("COMPtwo_3");
return(TRUE);
} 
       
int COMPtwo_4(YYTYPE *__arg)
{
int __debug = SEEN_COMPtwo_4 = debug_execute_enter("Executing procedure COMPtwo_4 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_GT; 
if (!_optimise) debug_execute_exit("COMPtwo_4");
return(TRUE);
} 
       
int COMPtwo_5(YYTYPE *__arg)
{
int __debug = SEEN_COMPtwo_5 = debug_execute_enter("Executing procedure COMPtwo_5 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_TESTRESOLVE; /* SOME OF THESE ARE INVALID IN A DOUBLE-SIDED */
if (!_optimise) debug_execute_exit("COMPtwo_5");
return(TRUE);
} 
       
int COMPtwo_6(YYTYPE *__arg)
{
int __debug = SEEN_COMPtwo_6 = debug_execute_enter("Executing procedure COMPtwo_6 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_EQ; 
if (!_optimise) debug_execute_exit("COMPtwo_6");
return(TRUE);
} 
       
int COMPtwo_7(YYTYPE *__arg)
{
int __debug = SEEN_COMPtwo_7 = debug_execute_enter("Executing procedure COMPtwo_7 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) (int)(__arg->execute.arg[1]->execute.user_value); 
if (!_optimise) debug_execute_exit("COMPtwo_7");
return(TRUE);
}   
int COMPtwo_8(YYTYPE *__arg)
{
int __debug = SEEN_COMPtwo_8 = debug_execute_enter("Executing procedure COMPtwo_8 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) (int)(__arg->execute.arg[1]->execute.user_value); 
if (!_optimise) debug_execute_exit("COMPtwo_8");
return(TRUE);
} 
       
int COMPtwo_9(YYTYPE *__arg)
{
int __debug = SEEN_COMPtwo_9 = debug_execute_enter("Executing procedure COMPtwo_9 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_LT; 
if (!_optimise) debug_execute_exit("COMPtwo_9");
return(TRUE);
}

  
int CONST_1(YYTYPE *__arg)
{
int __debug = SEEN_CONST_1 = debug_execute_enter("Executing procedure CONST_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) maketuple(CONST, REAL, (int)(__arg->execute.arg[1]->execute.user_value)); 
if (!_optimise) debug_execute_exit("CONST_1");
return(TRUE);
} 
        
int CONST_2(YYTYPE *__arg)
{
int __debug = SEEN_CONST_2 = debug_execute_enter("Executing procedure CONST_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) maketuple(CONST, INTEGER, (int)(__arg->execute.arg[1]->execute.user_value)); 
if (!_optimise) debug_execute_exit("CONST_2");
return(TRUE);
} 
        
int CONST_3(YYTYPE *__arg)
{
int __debug = SEEN_CONST_3 = debug_execute_enter("Executing procedure CONST_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) maketuple(CONST, INTEGER, (int)(__arg->execute.arg[1]->execute.user_value)); 
if (!_optimise) debug_execute_exit("CONST_3");
return(TRUE);
} 
        
int CONST_4(YYTYPE *__arg)
{
int __debug = SEEN_CONST_4 = debug_execute_enter("Executing procedure CONST_4 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) maketuple(CONST, STRING, (int)(__arg->execute.arg[1]->execute.user_value)); 
if (!_optimise) debug_execute_exit("CONST_4");
return(TRUE);
} 
        
int CONST_5(YYTYPE *__arg)
{
int __debug = SEEN_CONST_5 = debug_execute_enter("Executing procedure CONST_5 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) (int)(__arg->execute.arg[1]->execute.user_value); 
if (!_optimise) debug_execute_exit("CONST_5");
return(TRUE);
}

  
int realconst_1(YYTYPE *__arg)
{
int __debug = SEEN_realconst_1 = debug_execute_enter("Executing procedure realconst_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", __arg->execute.arg[1]->execute.text); 
if (!_optimise) debug_execute_exit("realconst_1");
return(TRUE);
} 
            
int realconst_2(YYTYPE *__arg)
{
int __debug = SEEN_realconst_2 = debug_execute_enter("Executing procedure realconst_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", __arg->execute.arg[1]->execute.text); 
if (!_optimise) debug_execute_exit("realconst_2");
return(TRUE);
} 
            
int realconst_3(YYTYPE *__arg)
{
int __debug = SEEN_realconst_3 = debug_execute_enter("Executing procedure realconst_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", __arg->execute.arg[1]->execute.text); 
if (!_optimise) debug_execute_exit("realconst_3");
return(TRUE);
}

  
int basedconst_1(YYTYPE *__arg)
{
int __debug = SEEN_basedconst_1 = debug_execute_enter("Executing procedure basedconst_1 -- arg at %p", __arg);

              if (strncmp(__arg->execute.arg[1]->execute.text, "16_", 3) == 0) {
                __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("0x%s", __arg->execute.arg[1]->execute.text+3);
              } else if (strncmp(__arg->execute.arg[1]->execute.text, "2_", 2) == 0) {
                __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("0b%s", __arg->execute.arg[1]->execute.text+2);
              } else {
                __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", __arg->execute.arg[1]->execute.text); // needs work
              }

if (!_optimise) debug_execute_exit("basedconst_1");
return(TRUE);
}

  
int intconst_1(YYTYPE *__arg)
{
int __debug = SEEN_intconst_1 = debug_execute_enter("Executing procedure intconst_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", __arg->execute.arg[1]->execute.text); 
if (!_optimise) debug_execute_exit("intconst_1");
return(TRUE);
}

  
int stringconst_1(YYTYPE *__arg)
{
int __debug = SEEN_stringconst_1 = debug_execute_enter("Executing procedure stringconst_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) (int)(__arg->execute.arg[1]->execute.user_value); 
if (!_optimise) debug_execute_exit("stringconst_1");
return(TRUE);
} 
               
int stringconst_2(YYTYPE *__arg)
{
int __debug = SEEN_stringconst_2 = debug_execute_enter("Executing procedure stringconst_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("E%s", str((int)(__arg->execute.arg[2]->execute.user_value))); /* EBCDIC string */ 
if (!_optimise) debug_execute_exit("stringconst_2");
return(TRUE);
}

    
int lettercharconst_1(YYTYPE *__arg)
{
int __debug = SEEN_lettercharconst_1 = debug_execute_enter("Executing procedure lettercharconst_1 -- arg at %p", __arg);
                   /* These need some work for type determination */
                   __arg->execute.arg[0]->execute.user_value = (USERTYPE *) maketuple(LETTERCHARCONST, str(ccharconst('c', str((int)(__arg->execute.arg[2]->execute.user_value))))); 

if (!_optimise) debug_execute_exit("lettercharconst_1");
return(TRUE);
} 
                     
int lettercharconst_2(YYTYPE *__arg)
{
int __debug = SEEN_lettercharconst_2 = debug_execute_enter("Executing procedure lettercharconst_2 -- arg at %p", __arg);

                   __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", str(ccharconst(*__arg->execute.arg[1]->execute.text, str((int)(__arg->execute.arg[3]->execute.user_value))))); 

if (!_optimise) debug_execute_exit("lettercharconst_2");
return(TRUE);
} 
                     
int lettercharconst_3(YYTYPE *__arg)
{
int __debug = SEEN_lettercharconst_3 = debug_execute_enter("Executing procedure lettercharconst_3 -- arg at %p", __arg);

                   char *s = str((int)(__arg->execute.arg[3]->execute.user_value));
                   int c = *__arg->execute.arg[1]->execute.text;
                   char *t = ccharconst('B', s);
                   assert(c == 'B');
                   assert(t != NULL);
                   __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", str(t)); 

if (!_optimise) debug_execute_exit("lettercharconst_3");
return(TRUE);
} 
                     
int lettercharconst_4(YYTYPE *__arg)
{
int __debug = SEEN_lettercharconst_4 = debug_execute_enter("Executing procedure lettercharconst_4 -- arg at %p", __arg);

                   __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", str(ccharconst(*__arg->execute.arg[1]->execute.text, str((int)(__arg->execute.arg[3]->execute.user_value))))); 

if (!_optimise) debug_execute_exit("lettercharconst_4");
return(TRUE);
} 
                     
int lettercharconst_5(YYTYPE *__arg)
{
int __debug = SEEN_lettercharconst_5 = debug_execute_enter("Executing procedure lettercharconst_5 -- arg at %p", __arg);

                   /* I'm not sure what the syntax of D'...' is */
                   /* so I'll allow anything, for now           */
// M'''' causes crash ...
                   __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", str(ccharconst(*__arg->execute.arg[1]->execute.text, str((int)(__arg->execute.arg[3]->execute.user_value))))); 

if (!_optimise) debug_execute_exit("lettercharconst_5");
return(TRUE);
}

  
int squote_1(YYTYPE *__arg)
{
int __debug = SEEN_squote_1 = debug_execute_enter("Executing procedure squote_1 -- arg at %p", __arg);
 
if (!_optimise) debug_execute_exit("squote_1");
return(TRUE);
}

  
int mchar_1(YYTYPE *__arg)
{
int __debug = SEEN_mchar_1 = debug_execute_enter("Executing procedure mchar_1 -- arg at %p", __arg);

         __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%c", SQUOTE); // fixed for M''''

if (!_optimise) debug_execute_exit("mchar_1");
return(TRUE);
} 
         
int mchar_2(YYTYPE *__arg)
{
int __debug = SEEN_mchar_2 = debug_execute_enter("Executing procedure mchar_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", __arg->execute.arg[2]->execute.text); 
if (!_optimise) debug_execute_exit("mchar_2");
return(TRUE);
}

  
int schar_1(YYTYPE *__arg)
{
int __debug = SEEN_schar_1 = debug_execute_enter("Executing procedure schar_1 -- arg at %p", __arg);

         __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%c%c", BSLASH, SQUOTE);

if (!_optimise) debug_execute_exit("schar_1");
return(TRUE);
} 
         
int schar_2(YYTYPE *__arg)
{
int __debug = SEEN_schar_2 = debug_execute_enter("Executing procedure schar_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", __arg->execute.arg[2]->execute.text); 
if (!_optimise) debug_execute_exit("schar_2");
return(TRUE);
}

   
int schars_1(YYTYPE *__arg)
{
int __debug = SEEN_schars_1 = debug_execute_enter("Executing procedure schars_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s%s", str((int)(__arg->execute.arg[1]->execute.user_value)), str((int)(__arg->execute.arg[2]->execute.user_value))); 
if (!_optimise) debug_execute_exit("schars_1");
return(TRUE);
} 
         
int schars_2(YYTYPE *__arg)
{
int __debug = SEEN_schars_2 = debug_execute_enter("Executing procedure schars_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf(""); 
if (!_optimise) debug_execute_exit("schars_2");
return(TRUE);
}

   
int mchars_1(YYTYPE *__arg)
{
int __debug = SEEN_mchars_1 = debug_execute_enter("Executing procedure mchars_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s%s", str((int)(__arg->execute.arg[1]->execute.user_value)), str((int)(__arg->execute.arg[2]->execute.user_value))); 
if (!_optimise) debug_execute_exit("mchars_1");
return(TRUE);
} 
         
int mchars_2(YYTYPE *__arg)
{
int __debug = SEEN_mchars_2 = debug_execute_enter("Executing procedure mchars_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf(""); 
if (!_optimise) debug_execute_exit("mchars_2");
return(TRUE);
}

  
int hexchars_1(YYTYPE *__arg)
{
int __debug = SEEN_hexchars_1 = debug_execute_enter("Executing procedure hexchars_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", __arg->execute.arg[1]->execute.text); 
if (!_optimise) debug_execute_exit("hexchars_1");
return(TRUE);
}

  
int octchars_1(YYTYPE *__arg)
{
int __debug = SEEN_octchars_1 = debug_execute_enter("Executing procedure octchars_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", __arg->execute.arg[1]->execute.text); 
if (!_optimise) debug_execute_exit("octchars_1");
return(TRUE);
}

  
int binchars_1(YYTYPE *__arg)
{
int __debug = SEEN_binchars_1 = debug_execute_enter("Executing procedure binchars_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", __arg->execute.arg[1]->execute.text); 
if (!_optimise) debug_execute_exit("binchars_1");
return(TRUE);
}

  
int DOWN_1(YYTYPE *__arg)
{
int __debug = SEEN_DOWN_1 = debug_execute_enter("Executing procedure DOWN_1 -- arg at %p", __arg);
 /* Internal routine to push a level */ 
if (!_optimise) debug_execute_exit("DOWN_1");
return(TRUE);
}

  
int DUMMYSTART_1(YYTYPE *__arg)
{
int __debug = SEEN_DUMMYSTART_1 = debug_execute_enter("Executing procedure DUMMYSTART_1 -- arg at %p", __arg);
 
if (!_optimise) debug_execute_exit("DUMMYSTART_1");
return(TRUE);
}

  
int HOLE_1(YYTYPE *__arg)
{
int __debug = SEEN_HOLE_1 = debug_execute_enter("Executing procedure HOLE_1 -- arg at %p", __arg);
 
if (!_optimise) debug_execute_exit("HOLE_1");
return(TRUE);
}

  
int ICONST_1(YYTYPE *__arg)
{
int __debug = SEEN_ICONST_1 = debug_execute_enter("Executing procedure ICONST_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", __arg->execute.arg[1]->execute.text); 
if (!_optimise) debug_execute_exit("ICONST_1");
return(TRUE);
}

  
int LISTOFF_1(YYTYPE *__arg)
{
int __debug = SEEN_LISTOFF_1 = debug_execute_enter("Executing procedure LISTOFF_1 -- arg at %p", __arg);
 
if (!_optimise) debug_execute_exit("LISTOFF_1");
return(TRUE);
}

  
int LISTON_1(YYTYPE *__arg)
{
int __debug = SEEN_LISTON_1 = debug_execute_enter("Executing procedure LISTON_1 -- arg at %p", __arg);
 
if (!_optimise) debug_execute_exit("LISTON_1");
return(TRUE);
}

  
int MARK_1(YYTYPE *__arg)
{
int __debug = SEEN_MARK_1 = debug_execute_enter("Executing procedure MARK_1 -- arg at %p", __arg);
 
if (!_optimise) debug_execute_exit("MARK_1");
return(TRUE);
}

   
int NAME_1(YYTYPE *__arg)
{
int __debug = SEEN_NAME_1 = debug_execute_enter("Executing procedure NAME_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", strlwr(__arg->execute.arg[1]->execute.text)); 
if (!_optimise) debug_execute_exit("NAME_1");
return(TRUE);
}

  
int eitherquote_1(YYTYPE *__arg)
{
int __debug = SEEN_eitherquote_1 = debug_execute_enter("Executing procedure eitherquote_1 -- arg at %p", __arg);
 /* Protects M'fred' or E"string" from being seen as 
                          simple names M or E */ 
if (!_optimise) debug_execute_exit("eitherquote_1");
return(TRUE);
}

  
int NOTECYCLE_1(YYTYPE *__arg)
{
int __debug = SEEN_NOTECYCLE_1 = debug_execute_enter("Executing procedure NOTECYCLE_1 -- arg at %p", __arg);
 
if (!_optimise) debug_execute_exit("NOTECYCLE_1");
return(TRUE);
}

  
int NOTEFINISH_1(YYTYPE *__arg)
{
int __debug = SEEN_NOTEFINISH_1 = debug_execute_enter("Executing procedure NOTEFINISH_1 -- arg at %p", __arg);
 
if (!_optimise) debug_execute_exit("NOTEFINISH_1");
return(TRUE);
}

  
int NOTEREPEAT_1(YYTYPE *__arg)
{
int __debug = SEEN_NOTEREPEAT_1 = debug_execute_enter("Executing procedure NOTEREPEAT_1 -- arg at %p", __arg);
 
if (!_optimise) debug_execute_exit("NOTEREPEAT_1");
return(TRUE);
}

  
int NOTESTART_1(YYTYPE *__arg)
{
int __debug = SEEN_NOTESTART_1 = debug_execute_enter("Executing procedure NOTESTART_1 -- arg at %p", __arg);
 
if (!_optimise) debug_execute_exit("NOTESTART_1");
return(TRUE);
}

  
int N_1(YYTYPE *__arg)
{
int __debug = SEEN_N_1 = debug_execute_enter("Executing procedure N_1 -- arg at %p", __arg);
 /* 16-bit */ __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", __arg->execute.arg[1]->execute.text); 
if (!_optimise) debug_execute_exit("N_1");
return(TRUE);
}

  
int Nbyte_1(YYTYPE *__arg)
{
int __debug = SEEN_Nbyte_1 = debug_execute_enter("Executing procedure Nbyte_1 -- arg at %p", __arg);
 /* between 0 and 255 */ __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", __arg->execute.arg[1]->execute.text); 
if (!_optimise) debug_execute_exit("Nbyte_1");
return(TRUE);
}

  
int OP_1(YYTYPE *__arg)
{
int __debug = SEEN_OP_1 = debug_execute_enter("Executing procedure OP_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_ADD; 
if (!_optimise) debug_execute_exit("OP_1");
return(TRUE);
} 
     
int OP_2(YYTYPE *__arg)
{
int __debug = SEEN_OP_2 = debug_execute_enter("Executing procedure OP_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_SUB; 
if (!_optimise) debug_execute_exit("OP_2");
return(TRUE);
} 
     
int OP_3(YYTYPE *__arg)
{
int __debug = SEEN_OP_3 = debug_execute_enter("Executing procedure OP_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_BITAND; 
if (!_optimise) debug_execute_exit("OP_3");
return(TRUE);
} 
     
int OP_4(YYTYPE *__arg)
{
int __debug = SEEN_OP_4 = debug_execute_enter("Executing procedure OP_4 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_IEXP; 
if (!_optimise) debug_execute_exit("OP_4");
return(TRUE);
} 
     
int OP_5(YYTYPE *__arg)
{
int __debug = SEEN_OP_5 = debug_execute_enter("Executing procedure OP_5 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_EXP; 
if (!_optimise) debug_execute_exit("OP_5");
return(TRUE);
} 
     
int OP_6(YYTYPE *__arg)
{
int __debug = SEEN_OP_6 = debug_execute_enter("Executing procedure OP_6 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_MUL; 
if (!_optimise) debug_execute_exit("OP_6");
return(TRUE);
} 
     
int OP_7(YYTYPE *__arg)
{
int __debug = SEEN_OP_7 = debug_execute_enter("Executing procedure OP_7 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_EOR; 
if (!_optimise) debug_execute_exit("OP_7");
return(TRUE);
} 
     
int OP_8(YYTYPE *__arg)
{
int __debug = SEEN_OP_8 = debug_execute_enter("Executing procedure OP_8 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_IOR; 
if (!_optimise) debug_execute_exit("OP_8");
return(TRUE);
} 
     
int OP_9(YYTYPE *__arg)
{
int __debug = SEEN_OP_9 = debug_execute_enter("Executing procedure OP_9 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_IDIV; 
if (!_optimise) debug_execute_exit("OP_9");
return(TRUE);
} 
     
int OP_10(YYTYPE *__arg)
{
int __debug = SEEN_OP_10 = debug_execute_enter("Executing procedure OP_10 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_RDIV; 
if (!_optimise) debug_execute_exit("OP_10");
return(TRUE);
}  
     
int OP_11(YYTYPE *__arg)
{
int __debug = SEEN_OP_11 = debug_execute_enter("Executing procedure OP_11 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_SHR; 
if (!_optimise) debug_execute_exit("OP_11");
return(TRUE);
} 
     
int OP_12(YYTYPE *__arg)
{
int __debug = SEEN_OP_12 = debug_execute_enter("Executing procedure OP_12 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_SHL; 
if (!_optimise) debug_execute_exit("OP_12");
return(TRUE);
} 
     
int OP_13(YYTYPE *__arg)
{
int __debug = SEEN_OP_13 = debug_execute_enter("Executing procedure OP_13 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_CONCAT; 
if (!_optimise) debug_execute_exit("OP_13");
return(TRUE);
} 
     
int OP_14(YYTYPE *__arg)
{
int __debug = SEEN_OP_14 = debug_execute_enter("Executing procedure OP_14 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_IEXP; /* WHAT IS THIS OPERATOR??? Emas integer exponentiation?*/ 
if (!_optimise) debug_execute_exit("OP_14");
return(TRUE);
} 
     
int OP_15(YYTYPE *__arg)
{
int __debug = SEEN_OP_15 = debug_execute_enter("Executing procedure OP_15 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_EXP; /* Imp77-only */ 
if (!_optimise) debug_execute_exit("OP_15");
return(TRUE);
} 
     
int OP_16(YYTYPE *__arg)
{
int __debug = SEEN_OP_16 = debug_execute_enter("Executing procedure OP_16 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) OP_EXP; 
if (!_optimise) debug_execute_exit("OP_16");
return(TRUE);
}

  
int READLINEquery_1(YYTYPE *__arg)
{
int __debug = SEEN_READLINEquery_1 = debug_execute_enter("Executing procedure READLINEquery_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) formatf("%s", "\n"); 
if (!_optimise) debug_execute_exit("READLINEquery_1");
return(TRUE);
} 
                
int READLINEquery_2(YYTYPE *__arg)
{
int __debug = SEEN_READLINEquery_2 = debug_execute_enter("Executing procedure READLINEquery_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("READLINEquery_2");
return(TRUE);
}

   
int SETNEM_1(YYTYPE *__arg)
{
int __debug = SEEN_SETNEM_1 = debug_execute_enter("Executing procedure SETNEM_1 -- arg at %p", __arg);
 /* Set Mnemonic */ __arg->execute.arg[0]->execute.user_value = (USERTYPE *) formatf("%s_", __arg->execute.arg[1]->execute.text); 
if (!_optimise) debug_execute_exit("SETNEM_1");
return(TRUE);
}

  
int optsub_1(YYTYPE *__arg)
{
int __debug = SEEN_optsub_1 = debug_execute_enter("Executing procedure optsub_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", __arg->execute.arg[1]->execute.text); 
if (!_optimise) debug_execute_exit("optsub_1");
return(TRUE);
} 
         
int optsub_2(YYTYPE *__arg)
{
int __debug = SEEN_optsub_2 = debug_execute_enter("Executing procedure optsub_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("optsub_2");
return(TRUE);
}

  
int S_1(YYTYPE *__arg)
{
int __debug = SEEN_S_1 = debug_execute_enter("Executing procedure S_1 -- arg at %p", __arg);
 /* also ';', but we convert earlier */ 
if (!_optimise) debug_execute_exit("S_1");
return(TRUE);
} 
    
int S_2(YYTYPE *__arg)
{
int __debug = SEEN_S_2 = debug_execute_enter("Executing procedure S_2 -- arg at %p", __arg);
 
if (!_optimise) debug_execute_exit("S_2");
return(TRUE);
}

    
int OLDSTRING_1(YYTYPE *__arg)
{
int __debug = SEEN_OLDSTRING_1 = debug_execute_enter("Executing procedure OLDSTRING_1 -- arg at %p", __arg);

            __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%c%s%c", DQUOTE, str((int)(__arg->execute.arg[2]->execute.user_value)), DQUOTE);

if (!_optimise) debug_execute_exit("OLDSTRING_1");
return(TRUE);
}
   
int oldstringchars_1(YYTYPE *__arg)
{
int __debug = SEEN_oldstringchars_1 = debug_execute_enter("Executing procedure oldstringchars_1 -- arg at %p", __arg);

               __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%c%s", SQUOTE, str((int)(__arg->execute.arg[3]->execute.user_value)));

if (!_optimise) debug_execute_exit("oldstringchars_1");
return(TRUE);
} 
                
int oldstringchars_2(YYTYPE *__arg)
{
int __debug = SEEN_oldstringchars_2 = debug_execute_enter("Executing procedure oldstringchars_2 -- arg at %p", __arg);

               __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s%s", __arg->execute.arg[2]->execute.text, str((int)(__arg->execute.arg[3]->execute.user_value)));

if (!_optimise) debug_execute_exit("oldstringchars_2");
return(TRUE);
} 
               
int oldstringchars_3(YYTYPE *__arg)
{
int __debug = SEEN_oldstringchars_3 = debug_execute_enter("Executing procedure oldstringchars_3 -- arg at %p", __arg);

               __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%cn%s", BSLASH, str((int)(__arg->execute.arg[2]->execute.user_value)));

if (!_optimise) debug_execute_exit("oldstringchars_3");
return(TRUE);
} 
              
int oldstringchars_4(YYTYPE *__arg)
{
int __debug = SEEN_oldstringchars_4 = debug_execute_enter("Executing procedure oldstringchars_4 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf(""); 
if (!_optimise) debug_execute_exit("oldstringchars_4");
return(TRUE);
}


    
int TEXTTEXT_1(YYTYPE *__arg)
{
int __debug = SEEN_TEXTTEXT_1 = debug_execute_enter("Executing procedure TEXTTEXT_1 -- arg at %p", __arg);

            __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", str((int)(__arg->execute.arg[2]->execute.user_value)));
/*            $0=sformatf("%cc%ss%cc", DQUOTE, str($2), DQUOTE);*/

if (!_optimise) debug_execute_exit("TEXTTEXT_1");
return(TRUE);
}

  
int quote_1(YYTYPE *__arg)
{
int __debug = SEEN_quote_1 = debug_execute_enter("Executing procedure quote_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 1; 
if (!_optimise) debug_execute_exit("quote_1");
return(TRUE);
}

   
int stringchars_1(YYTYPE *__arg)
{
int __debug = SEEN_stringchars_1 = debug_execute_enter("Executing procedure stringchars_1 -- arg at %p", __arg);

               __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%c%c%s", BSLASH, DQUOTE, str((int)(__arg->execute.arg[3]->execute.user_value)));

if (!_optimise) debug_execute_exit("stringchars_1");
return(TRUE);
} 
                
int stringchars_2(YYTYPE *__arg)
{
int __debug = SEEN_stringchars_2 = debug_execute_enter("Executing procedure stringchars_2 -- arg at %p", __arg);

               __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s%s", __arg->execute.arg[2]->execute.text, str((int)(__arg->execute.arg[3]->execute.user_value)));

if (!_optimise) debug_execute_exit("stringchars_2");
return(TRUE);
} 
               
int stringchars_3(YYTYPE *__arg)
{
int __debug = SEEN_stringchars_3 = debug_execute_enter("Executing procedure stringchars_3 -- arg at %p", __arg);

               __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%cn%s", BSLASH, str((int)(__arg->execute.arg[2]->execute.user_value)));

if (!_optimise) debug_execute_exit("stringchars_3");
return(TRUE);
} 
              
int stringchars_4(YYTYPE *__arg)
{
int __debug = SEEN_stringchars_4 = debug_execute_enter("Executing procedure stringchars_4 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf(""); 
if (!_optimise) debug_execute_exit("stringchars_4");
return(TRUE);
}

  
int TEXT_1(YYTYPE *__arg)
{
int __debug = SEEN_TEXT_1 = debug_execute_enter("Executing procedure TEXT_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", __arg->execute.arg[1]->execute.text); 
if (!_optimise) debug_execute_exit("TEXT_1");
return(TRUE);
} 
       
int TEXT_2(YYTYPE *__arg)
{
int __debug = SEEN_TEXT_2 = debug_execute_enter("Executing procedure TEXT_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", (__arg->execute.arg[1]->execute.text)+1); 
if (!_optimise) debug_execute_exit("TEXT_2");
return(TRUE);
} 
       
int TEXT_3(YYTYPE *__arg)
{
int __debug = SEEN_TEXT_3 = debug_execute_enter("Executing procedure TEXT_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", (__arg->execute.arg[1]->execute.text)+7); 
if (!_optimise) debug_execute_exit("TEXT_3");
return(TRUE);
}

  
int UCI_1(YYTYPE *__arg)
{
int __debug = SEEN_UCI_1 = debug_execute_enter("Executing procedure UCI_1 -- arg at %p", __arg);

           /* unparsed m/c code */
           __arg->execute.arg[0]->execute.user_value = (USERTYPE *) sformatf("%s", __arg->execute.arg[1]->execute.text); 

if (!_optimise) debug_execute_exit("UCI_1");
return(TRUE);
}

  
int commaquote_1(YYTYPE *__arg)
{
int __debug = SEEN_commaquote_1 = debug_execute_enter("Executing procedure commaquote_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 1; 
if (!_optimise) debug_execute_exit("commaquote_1");
return(TRUE);
} 
              
int commaquote_2(YYTYPE *__arg)
{
int __debug = SEEN_commaquote_2 = debug_execute_enter("Executing procedure commaquote_2 -- arg at %p", __arg);
 /* fast error recovery */ __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("commaquote_2");
return(TRUE);
}

  
int rparen_1(YYTYPE *__arg)
{
int __debug = SEEN_rparen_1 = debug_execute_enter("Executing procedure rparen_1 -- arg at %p", __arg);
 
if (!_optimise) debug_execute_exit("rparen_1");
return(TRUE);
}

  
int UNARY_1(YYTYPE *__arg)
{
int __debug = SEEN_UNARY_1 = debug_execute_enter("Executing procedure UNARY_1 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) UOP_POS; 
if (!_optimise) debug_execute_exit("UNARY_1");
return(TRUE);
} 
        
int UNARY_2(YYTYPE *__arg)
{
int __debug = SEEN_UNARY_2 = debug_execute_enter("Executing procedure UNARY_2 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) UOP_NEG; 
if (!_optimise) debug_execute_exit("UNARY_2");
return(TRUE);
} 
        
int UNARY_3(YYTYPE *__arg)
{
int __debug = SEEN_UNARY_3 = debug_execute_enter("Executing procedure UNARY_3 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) UOP_BITNOT; 
if (!_optimise) debug_execute_exit("UNARY_3");
return(TRUE);
} 
        
int UNARY_4(YYTYPE *__arg)
{
int __debug = SEEN_UNARY_4 = debug_execute_enter("Executing procedure UNARY_4 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) UOP_BITNOT; 
if (!_optimise) debug_execute_exit("UNARY_4");
return(TRUE);
} 
        
int UNARY_5(YYTYPE *__arg)
{
int __debug = SEEN_UNARY_5 = debug_execute_enter("Executing procedure UNARY_5 -- arg at %p", __arg);
 __arg->execute.arg[0]->execute.user_value = (USERTYPE *) 0; 
if (!_optimise) debug_execute_exit("UNARY_5");
return(TRUE);
}



int main_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("main_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 0, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("main_parse found option 1 -- \"\" ");
      *__arg = makeparsetree(__temp, main_1, 1, "main", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("main_parse failed");
   return(FALSE);
}

int OPERAND_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("OPERAND_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& CONST_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OPERAND_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, OPERAND_1, 1, "OPERAND", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OPERAND_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
&& APP_parse(&__temp.execute.arg[2])
&& RECORDFIELD_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("OPERAND_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, OPERAND_2, 3, "OPERAND", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OPERAND_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 1, &__temp.execute.arg[1])
&& EXPR_parse(&__temp.execute.arg[2])
&& _regexp_parse(savepat, 2, &__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("OPERAND_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, OPERAND_3, 3, "OPERAND", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OPERAND_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 3, &__temp.execute.arg[1])
&& EXPR_parse(&__temp.execute.arg[2])
&& _regexp_parse(savepat, 4, &__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("OPERAND_parse found option 4 -- \"\\(\" <EXPR> \"\\)\" ");
      *__arg = makeparsetree(__temp, OPERAND_4, 3, "OPERAND", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("OPERAND_parse failed");
   return(FALSE);
}

int COPERAND_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("COPERAND_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COPERAND_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, COPERAND_1, 1, "COPERAND", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COPERAND_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& CONST_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COPERAND_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, COPERAND_2, 1, "COPERAND", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COPERAND_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 5, &__temp.execute.arg[1])
&& CEXPR_parse(&__temp.execute.arg[2])
&& _regexp_parse(savepat, 6, &__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("COPERAND_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, COPERAND_3, 3, "COPERAND", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COPERAND_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 7, &__temp.execute.arg[1])
&& CEXPR_parse(&__temp.execute.arg[2])
&& _regexp_parse(savepat, 8, &__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("COPERAND_parse found option 4 -- \"\\(\" <CEXPR> \"\\)\" ");
      *__arg = makeparsetree(__temp, COPERAND_4, 3, "COPERAND", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("COPERAND_parse failed");
   return(FALSE);
}

int CEXPR_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("CEXPR_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& UNARY_parse(&__temp.execute.arg[1])
&& COPERAND_parse(&__temp.execute.arg[2])
&& RESTOFCEXPR_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("CEXPR_parse found option 1 -- <UNARY> <COPERAND> <RESTOFCEXPR> ");
      *__arg = makeparsetree(__temp, CEXPR_1, 3, "CEXPR", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("CEXPR_parse failed");
   return(FALSE);
}

int STAROREXPR_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("STAROREXPR_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& UNARY_parse(&__temp.execute.arg[1])
&& COPERAND_parse(&__temp.execute.arg[2])
&& RESTOFCEXPR_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("STAROREXPR_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, STAROREXPR_1, 3, "STAROREXPR", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("STAROREXPR_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 9, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("STAROREXPR_parse found option 2 -- \"\\*\" ");
      *__arg = makeparsetree(__temp, STAROREXPR_2, 1, "STAROREXPR", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("STAROREXPR_parse failed");
   return(FALSE);
}

int EXPR_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("EXPR_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& UNARY_parse(&__temp.execute.arg[1])
&& OPERAND_parse(&__temp.execute.arg[2])
&& RESTOFEXPR_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("EXPR_parse found option 1 -- <UNARY> <OPERAND> <RESTOFEXPR> ");
      *__arg = makeparsetree(__temp, EXPR_1, 3, "EXPR", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("EXPR_parse failed");
   return(FALSE);
}

int RESTOFEXPR_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RESTOFEXPR_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& OP_parse(&__temp.execute.arg[1])
&& OPERAND_parse(&__temp.execute.arg[2])
&& RESTOFEXPR_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("RESTOFEXPR_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RESTOFEXPR_1, 3, "RESTOFEXPR", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFEXPR_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 10, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFEXPR_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, RESTOFEXPR_2, 1, "RESTOFEXPR", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RESTOFEXPR_parse failed");
   return(FALSE);
}

int RESTOFCEXPR_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RESTOFCEXPR_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& OP_parse(&__temp.execute.arg[1])
&& COPERAND_parse(&__temp.execute.arg[2])
&& RESTOFCEXPR_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("RESTOFCEXPR_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RESTOFCEXPR_1, 3, "RESTOFCEXPR", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFCEXPR_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 11, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFCEXPR_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, RESTOFCEXPR_2, 1, "RESTOFCEXPR", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RESTOFCEXPR_parse failed");
   return(FALSE);
}

int APP_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("APP_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 12, &__temp.execute.arg[1])
&& EXPR_parse(&__temp.execute.arg[2])
&& RESTOFAPP_parse(&__temp.execute.arg[3])
&& _regexp_parse(savepat, 13, &__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("APP_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, APP_1, 4, "APP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("APP_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 14, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("APP_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, APP_2, 1, "APP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("APP_parse failed");
   return(FALSE);
}

int RESTOFAPP_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RESTOFAPP_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 15, &__temp.execute.arg[1])
&& EXPR_parse(&__temp.execute.arg[2])
&& RESTOFAPP_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("RESTOFAPP_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RESTOFAPP_1, 3, "RESTOFAPP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFAPP_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 16, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFAPP_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, RESTOFAPP_2, 1, "RESTOFAPP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RESTOFAPP_parse failed");
   return(FALSE);
}

int PercentIU_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("PercentIU_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 17, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentIU_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, PercentIU_1, 1, "PercentIU", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("PercentIU_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 18, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentIU_parse found option 2 -- \"unless\" ");
      *__arg = makeparsetree(__temp, PercentIU_2, 1, "PercentIU", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("PercentIU_parse failed");
   return(FALSE);
}

int PercentWU_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("PercentWU_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 19, &__temp.execute.arg[1])
&& SC_parse(&__temp.execute.arg[2])
&& RESTOFCOND_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("PercentWU_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, PercentWU_1, 3, "PercentWU", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("PercentWU_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 20, &__temp.execute.arg[1])
&& SC_parse(&__temp.execute.arg[2])
&& RESTOFCOND_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("PercentWU_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, PercentWU_2, 3, "PercentWU", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("PercentWU_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 21, &__temp.execute.arg[1])
&& CYCPARM_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("PercentWU_parse found option 3 -- \"for\" <CYCPARM> ");
      *__arg = makeparsetree(__temp, PercentWU_3, 2, "PercentWU", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("PercentWU_parse failed");
   return(FALSE);
}

int ALIASquote_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("ALIASquote_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 22, &__temp.execute.arg[1])
&& TEXTTEXT_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("ALIASquote_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, ALIASquote_1, 2, "ALIASquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("ALIASquote_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 23, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("ALIASquote_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, ALIASquote_2, 1, "ALIASquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("ALIASquote_parse failed");
   return(FALSE);
}

int NLISTquote_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("NLISTquote_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 24, &__temp.execute.arg[1])
&& NAME_parse(&__temp.execute.arg[2])
&& NLISTquote_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("NLISTquote_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, NLISTquote_1, 3, "NLISTquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("NLISTquote_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 25, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("NLISTquote_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, NLISTquote_2, 1, "NLISTquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("NLISTquote_parse failed");
   return(FALSE);
}

int TYPE_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("TYPE_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 26, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TYPE_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, TYPE_1, 1, "TYPE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TYPE_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 27, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TYPE_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, TYPE_2, 1, "TYPE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TYPE_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 28, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TYPE_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, TYPE_3, 1, "TYPE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TYPE_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 29, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TYPE_parse found option 4 -- ");
      *__arg = makeparsetree(__temp, TYPE_4, 1, "TYPE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TYPE_parse - trying option 5"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 30, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TYPE_parse found option 5 -- ");
      *__arg = makeparsetree(__temp, TYPE_5, 1, "TYPE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TYPE_parse - trying option 6"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 31, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TYPE_parse found option 6 -- ");
      *__arg = makeparsetree(__temp, TYPE_6, 1, "TYPE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TYPE_parse - trying option 7"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 32, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TYPE_parse found option 7 -- ");
      *__arg = makeparsetree(__temp, TYPE_7, 1, "TYPE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TYPE_parse - trying option 8"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 33, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TYPE_parse found option 8 -- ");
      *__arg = makeparsetree(__temp, TYPE_8, 1, "TYPE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TYPE_parse - trying option 9"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 34, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TYPE_parse found option 9 -- ");
      *__arg = makeparsetree(__temp, TYPE_9, 1, "TYPE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TYPE_parse - trying option 10"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 35, &__temp.execute.arg[1])
&& REPFACT_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("TYPE_parse found option 10 -- ");
      *__arg = makeparsetree(__temp, TYPE_10, 2, "TYPE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TYPE_parse - trying option 11"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 36, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TYPE_parse found option 11 -- ");
      *__arg = makeparsetree(__temp, TYPE_11, 1, "TYPE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TYPE_parse - trying option 12"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 37, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TYPE_parse found option 12 -- ");
      *__arg = makeparsetree(__temp, TYPE_12, 1, "TYPE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TYPE_parse - trying option 13"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 38, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TYPE_parse found option 13 -- ");
      *__arg = makeparsetree(__temp, TYPE_13, 1, "TYPE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TYPE_parse - trying option 14"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 39, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TYPE_parse found option 14 -- ");
      *__arg = makeparsetree(__temp, TYPE_14, 1, "TYPE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TYPE_parse - trying option 15"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 40, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TYPE_parse found option 15 -- ");
      *__arg = makeparsetree(__temp, TYPE_15, 1, "TYPE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TYPE_parse - trying option 16"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 41, &__temp.execute.arg[1])
&& RFREF_parse(&__temp.execute.arg[2])
&& _regexp_parse(savepat, 42, &__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("TYPE_parse found option 16 -- ");
      *__arg = makeparsetree(__temp, TYPE_16, 3, "TYPE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TYPE_parse - trying option 17"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 43, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TYPE_parse found option 17 -- \"record\" ");
      *__arg = makeparsetree(__temp, TYPE_17, 1, "TYPE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("TYPE_parse failed");
   return(FALSE);
}

int FN_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("FN_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 44, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("FN_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, FN_1, 1, "FN", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("FN_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 45, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("FN_parse found option 2 -- \"function\" ");
      *__arg = makeparsetree(__temp, FN_2, 1, "FN", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("FN_parse failed");
   return(FALSE);
}

int RT_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RT_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 46, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RT_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RT_1, 1, "RT", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RT_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 47, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RT_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, RT_2, 1, "RT", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RT_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& TYPE_parse(&__temp.execute.arg[1])
&& FN_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("RT_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, RT_3, 2, "RT", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RT_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& TYPE_parse(&__temp.execute.arg[1])
&& _regexp_parse(savepat, 48, &__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("RT_parse found option 4 -- <TYPE> \"map\" ");
      *__arg = makeparsetree(__temp, RT_4, 2, "RT", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RT_parse failed");
   return(FALSE);
}

int FPDEL_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("FPDEL_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& TYPE_parse(&__temp.execute.arg[1])
&& PercentQNAMEquote_parse(&__temp.execute.arg[2])
&& NAME_parse(&__temp.execute.arg[3])
&& NLISTquote_parse(&__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("FPDEL_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, FPDEL_1, 4, "FPDEL", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("FPDEL_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& RT_parse(&__temp.execute.arg[1])
&& PercentNAMEquote_parse(&__temp.execute.arg[2])
&& NAME_parse(&__temp.execute.arg[3])
&& NLISTquote_parse(&__temp.execute.arg[4])
&& FPP_parse(&__temp.execute.arg[5])
)  {
      if (!_optimise) debug_exit("FPDEL_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, FPDEL_2, 5, "FPDEL", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("FPDEL_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 49, &__temp.execute.arg[1])
&& NAME_parse(&__temp.execute.arg[2])
&& NLISTquote_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("FPDEL_parse found option 3 -- \"name\" <NAME> <NLISTquote> ");
      *__arg = makeparsetree(__temp, FPDEL_3, 3, "FPDEL", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("FPDEL_parse failed");
   return(FALSE);
}

int PercentNAMEquote_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("PercentNAMEquote_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 50, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentNAMEquote_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, PercentNAMEquote_1, 1, "PercentNAMEquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("PercentNAMEquote_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 51, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentNAMEquote_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, PercentNAMEquote_2, 1, "PercentNAMEquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("PercentNAMEquote_parse failed");
   return(FALSE);
}

int PercentQNAMEquote_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("PercentQNAMEquote_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 52, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentQNAMEquote_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, PercentQNAMEquote_1, 1, "PercentQNAMEquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("PercentQNAMEquote_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 53, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentQNAMEquote_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, PercentQNAMEquote_2, 1, "PercentQNAMEquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("PercentQNAMEquote_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 54, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentQNAMEquote_parse found option 3 -- \"\" ");
      *__arg = makeparsetree(__temp, PercentQNAMEquote_3, 1, "PercentQNAMEquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("PercentQNAMEquote_parse failed");
   return(FALSE);
}

int FPP_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("FPP_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 55, &__temp.execute.arg[1])
&& FPDEL_parse(&__temp.execute.arg[2])
&& RESTOFFPLIST_parse(&__temp.execute.arg[3])
&& _regexp_parse(savepat, 56, &__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("FPP_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, FPP_1, 4, "FPP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("FPP_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 57, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("FPP_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, FPP_2, 1, "FPP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("FPP_parse failed");
   return(FALSE);
}

int RESTOFFPLIST_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RESTOFFPLIST_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& commaquote_parse(&__temp.execute.arg[1])
&& FPDEL_parse(&__temp.execute.arg[2])
&& RESTOFFPLIST_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("RESTOFFPLIST_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RESTOFFPLIST_1, 3, "RESTOFFPLIST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFFPLIST_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 58, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFFPLIST_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, RESTOFFPLIST_2, 1, "RESTOFFPLIST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RESTOFFPLIST_parse failed");
   return(FALSE);
}

int PercentFORMATquote_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("PercentFORMATquote_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 59, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentFORMATquote_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, PercentFORMATquote_1, 1, "PercentFORMATquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("PercentFORMATquote_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 60, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentFORMATquote_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, PercentFORMATquote_2, 1, "PercentFORMATquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("PercentFORMATquote_parse failed");
   return(FALSE);
}

int SC_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("SC_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& EXPR_parse(&__temp.execute.arg[1])
&& COMP_parse(&__temp.execute.arg[2])
&& EXPR_parse(&__temp.execute.arg[3])
&& RESTOFSC_parse(&__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("SC_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, SC_1, 4, "SC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SC_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& EXPR_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("SC_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, SC_2, 1, "SC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SC_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 61, &__temp.execute.arg[1])
&& SC_parse(&__temp.execute.arg[2])
&& RESTOFCOND_parse(&__temp.execute.arg[3])
&& _regexp_parse(savepat, 62, &__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("SC_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, SC_3, 4, "SC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SC_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 63, &__temp.execute.arg[1])
&& SC_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SC_parse found option 4 -- \"not\" <SC> ");
      *__arg = makeparsetree(__temp, SC_4, 2, "SC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("SC_parse failed");
   return(FALSE);
}

int RESTOFSC_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RESTOFSC_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& COMPtwo_parse(&__temp.execute.arg[1])
&& EXPR_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("RESTOFSC_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RESTOFSC_1, 2, "RESTOFSC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFSC_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 64, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFSC_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, RESTOFSC_2, 1, "RESTOFSC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RESTOFSC_parse failed");
   return(FALSE);
}

int RESTOFCOND_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RESTOFCOND_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 65, &__temp.execute.arg[1])
&& SC_parse(&__temp.execute.arg[2])
&& RESTOFANDC_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("RESTOFCOND_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RESTOFCOND_1, 3, "RESTOFCOND", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFCOND_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 66, &__temp.execute.arg[1])
&& SC_parse(&__temp.execute.arg[2])
&& RESTOFORC_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("RESTOFCOND_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, RESTOFCOND_2, 3, "RESTOFCOND", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFCOND_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 67, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFCOND_parse found option 3 -- \"\" ");
      *__arg = makeparsetree(__temp, RESTOFCOND_3, 1, "RESTOFCOND", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RESTOFCOND_parse failed");
   return(FALSE);
}

int RESTOFANDC_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RESTOFANDC_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 68, &__temp.execute.arg[1])
&& SC_parse(&__temp.execute.arg[2])
&& RESTOFANDC_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("RESTOFANDC_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RESTOFANDC_1, 3, "RESTOFANDC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFANDC_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 69, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFANDC_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, RESTOFANDC_2, 1, "RESTOFANDC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RESTOFANDC_parse failed");
   return(FALSE);
}

int RESTOFORC_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RESTOFORC_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 70, &__temp.execute.arg[1])
&& SC_parse(&__temp.execute.arg[2])
&& RESTOFORC_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("RESTOFORC_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RESTOFORC_1, 3, "RESTOFORC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFORC_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 71, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFORC_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, RESTOFORC_2, 1, "RESTOFORC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RESTOFORC_parse failed");
   return(FALSE);
}

int PercentSPECquote_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("PercentSPECquote_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 72, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentSPECquote_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, PercentSPECquote_1, 1, "PercentSPECquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("PercentSPECquote_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 73, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentSPECquote_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, PercentSPECquote_2, 1, "PercentSPECquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("PercentSPECquote_parse failed");
   return(FALSE);
}

int VSPECquote_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("VSPECquote_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 74, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("VSPECquote_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, VSPECquote_1, 1, "VSPECquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("VSPECquote_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 75, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("VSPECquote_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, VSPECquote_2, 1, "VSPECquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("VSPECquote_parse failed");
   return(FALSE);
}

int RESTOFBPLIST_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RESTOFBPLIST_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 76, &__temp.execute.arg[1])
&& EXPR_parse(&__temp.execute.arg[2])
&& _regexp_parse(savepat, 77, &__temp.execute.arg[3])
&& EXPR_parse(&__temp.execute.arg[4])
&& RESTOFBPLIST_parse(&__temp.execute.arg[5])
)  {
      if (!_optimise) debug_exit("RESTOFBPLIST_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RESTOFBPLIST_1, 5, "RESTOFBPLIST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFBPLIST_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 78, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFBPLIST_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, RESTOFBPLIST_2, 1, "RESTOFBPLIST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RESTOFBPLIST_parse failed");
   return(FALSE);
}

int OLDRECquote_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("OLDRECquote_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 79, &__temp.execute.arg[1])
&& RFREF_parse(&__temp.execute.arg[2])
&& _regexp_parse(savepat, 80, &__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("OLDRECquote_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, OLDRECquote_1, 3, "OLDRECquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OLDRECquote_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 81, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OLDRECquote_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, OLDRECquote_2, 1, "OLDRECquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("OLDRECquote_parse failed");
   return(FALSE);
}

int DECLN_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("DECLN_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& PercentQNAMEquote_parse(&__temp.execute.arg[1])
&& NAME_parse(&__temp.execute.arg[2])
&& NLISTquote_parse(&__temp.execute.arg[3])
&& OLDRECquote_parse(&__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("DECLN_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, DECLN_1, 4, "DECLN", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("DECLN_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 82, &__temp.execute.arg[1])
&& PercentFORMATquote_parse(&__temp.execute.arg[2])
&& ADECLN_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("DECLN_parse found option 2 -- \"array\" <PercentFORMATquote> <ADECLN> ");
      *__arg = makeparsetree(__temp, DECLN_2, 3, "DECLN", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("DECLN_parse failed");
   return(FALSE);
}

int ADECLN_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("ADECLN_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
&& NLISTquote_parse(&__temp.execute.arg[2])
&& BPAIR_parse(&__temp.execute.arg[3])
&& RESTOFARLIST_parse(&__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("ADECLN_parse found option 1 -- <NAME> <NLISTquote> <BPAIR> <RESTOFARLIST> ");
      *__arg = makeparsetree(__temp, ADECLN_1, 4, "ADECLN", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("ADECLN_parse failed");
   return(FALSE);
}

int RESTOFARLIST_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RESTOFARLIST_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 83, &__temp.execute.arg[1])
&& ADECLN_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("RESTOFARLIST_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RESTOFARLIST_1, 2, "RESTOFARLIST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFARLIST_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 84, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFARLIST_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, RESTOFARLIST_2, 1, "RESTOFARLIST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RESTOFARLIST_parse failed");
   return(FALSE);
}

int WHATEVER_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("WHATEVER_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
&& ALIASquote_parse(&__temp.execute.arg[2])
&& CONSTquote_parse(&__temp.execute.arg[3])
&& RESTOFOWNDEC_parse(&__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("WHATEVER_parse found option 1 -- <NAME> <ALIASquote> <CONSTquote> <RESTOFOWNDEC> ");
      *__arg = makeparsetree(__temp, WHATEVER_1, 4, "WHATEVER", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("WHATEVER_parse failed");
   return(FALSE);
}

int OWNDEC_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("OWNDEC_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& PercentQNAMEquote_parse(&__temp.execute.arg[1])
&& VSPECquote_parse(&__temp.execute.arg[2])
&& WHATEVER_parse(&__temp.execute.arg[3])
&& S_parse(&__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("OWNDEC_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, OWNDEC_1, 4, "OWNDEC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OWNDEC_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 85, &__temp.execute.arg[1])
&& PercentFORMATquote_parse(&__temp.execute.arg[2])
&& VSPECquote_parse(&__temp.execute.arg[3])
&& NAME_parse(&__temp.execute.arg[4])
&& ALIASquote_parse(&__temp.execute.arg[5])
&& BPAIR_parse(&__temp.execute.arg[6])
&& CONSTLIST_parse(&__temp.execute.arg[7])
)  {
      if (!_optimise) debug_exit("OWNDEC_parse found option 2 -- \"array\" <PercentFORMATquote> <VSPECquote> <NAME> <ALIASquote> <BPAIR> <CONSTLIST> ");
      *__arg = makeparsetree(__temp, OWNDEC_2, 7, "OWNDEC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("OWNDEC_parse failed");
   return(FALSE);
}

int RESTOFOWNDEC_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RESTOFOWNDEC_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 86, &__temp.execute.arg[1])
&& WHATEVER_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("RESTOFOWNDEC_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RESTOFOWNDEC_1, 2, "RESTOFOWNDEC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFOWNDEC_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 87, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFOWNDEC_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, RESTOFOWNDEC_2, 1, "RESTOFOWNDEC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RESTOFOWNDEC_parse failed");
   return(FALSE);
}

int XOWN_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("XOWN_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 88, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("XOWN_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, XOWN_1, 1, "XOWN", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("XOWN_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 89, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("XOWN_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, XOWN_2, 1, "XOWN", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("XOWN_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 90, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("XOWN_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, XOWN_3, 1, "XOWN", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("XOWN_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 91, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("XOWN_parse found option 4 -- ");
      *__arg = makeparsetree(__temp, XOWN_4, 1, "XOWN", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("XOWN_parse - trying option 5"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 92, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("XOWN_parse found option 5 -- ");
      *__arg = makeparsetree(__temp, XOWN_5, 1, "XOWN", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("XOWN_parse - trying option 6"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 93, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("XOWN_parse found option 6 -- \"\" ");
      *__arg = makeparsetree(__temp, XOWN_6, 1, "XOWN", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("XOWN_parse failed");
   return(FALSE);
}

int CONSTLIST_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("CONSTLIST_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 94, &__temp.execute.arg[1])
&& CONSTITEMS_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("CONSTLIST_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, CONSTLIST_1, 2, "CONSTLIST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("CONSTLIST_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 95, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("CONSTLIST_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, CONSTLIST_2, 1, "CONSTLIST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("CONSTLIST_parse failed");
   return(FALSE);
}

int CONSTITEMS_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("CONSTITEMS_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& READLINEquery_parse(&__temp.execute.arg[1])
&& UNARY_parse(&__temp.execute.arg[2])
&& COPERAND_parse(&__temp.execute.arg[3])
&& RESTOFCEXPR_parse(&__temp.execute.arg[4])
&& REPFACT_parse(&__temp.execute.arg[5])
&& ROCL_parse(&__temp.execute.arg[6])
)  {
      if (!_optimise) debug_exit("CONSTITEMS_parse found option 1 -- <READLINEquery> <UNARY> <COPERAND> <RESTOFCEXPR> <REPFACT> <ROCL> ");
      *__arg = makeparsetree(__temp, CONSTITEMS_1, 6, "CONSTITEMS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("CONSTITEMS_parse failed");
   return(FALSE);
}

int ROCL_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("ROCL_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 96, &__temp.execute.arg[1])
&& CONSTITEMS_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("ROCL_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, ROCL_1, 2, "ROCL", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("ROCL_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 97, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("ROCL_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, ROCL_2, 1, "ROCL", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("ROCL_parse failed");
   return(FALSE);
}

int REPFACT_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("REPFACT_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 98, &__temp.execute.arg[1])
&& STAROREXPR_parse(&__temp.execute.arg[2])
&& _regexp_parse(savepat, 99, &__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("REPFACT_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, REPFACT_1, 3, "REPFACT", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("REPFACT_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 100, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("REPFACT_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, REPFACT_2, 1, "REPFACT", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("REPFACT_parse failed");
   return(FALSE);
}

int RESTOFELIST_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RESTOFELIST_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 101, &__temp.execute.arg[1])
&& CEXPR_parse(&__temp.execute.arg[2])
&& RESTOFELIST_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("RESTOFELIST_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RESTOFELIST_1, 3, "RESTOFELIST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFELIST_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 102, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFELIST_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, RESTOFELIST_2, 1, "RESTOFELIST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RESTOFELIST_parse failed");
   return(FALSE);
}

int PercentEVENTquote_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("PercentEVENTquote_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 103, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentEVENTquote_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, PercentEVENTquote_1, 1, "PercentEVENTquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("PercentEVENTquote_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 104, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentEVENTquote_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, PercentEVENTquote_2, 1, "PercentEVENTquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("PercentEVENTquote_parse failed");
   return(FALSE);
}

int OPEXPR_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("OPEXPR_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 105, &__temp.execute.arg[1])
&& EXPR_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("OPEXPR_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, OPEXPR_1, 2, "OPEXPR", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OPEXPR_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 106, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OPEXPR_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, OPEXPR_2, 1, "OPEXPR", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("OPEXPR_parse failed");
   return(FALSE);
}

int RESTOFREPEAT_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RESTOFREPEAT_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 107, &__temp.execute.arg[1])
&& SC_parse(&__temp.execute.arg[2])
&& RESTOFCOND_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("RESTOFREPEAT_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RESTOFREPEAT_1, 3, "RESTOFREPEAT", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFREPEAT_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 108, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFREPEAT_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, RESTOFREPEAT_2, 1, "RESTOFREPEAT", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RESTOFREPEAT_parse failed");
   return(FALSE);
}

int RESTOFSS_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RESTOFSS_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& COLON_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFSS_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RESTOFSS_1, 1, "RESTOFSS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFSS_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& S_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFSS_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, RESTOFSS_2, 1, "RESTOFSS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFSS_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& PercentIU_parse(&__temp.execute.arg[1])
&& SC_parse(&__temp.execute.arg[2])
&& RESTOFCOND_parse(&__temp.execute.arg[3])
&& S_parse(&__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("RESTOFSS_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, RESTOFSS_3, 4, "RESTOFSS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFSS_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& PercentWU_parse(&__temp.execute.arg[1])
&& S_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("RESTOFSS_parse found option 4 -- <PercentWU> <S> ");
      *__arg = makeparsetree(__temp, RESTOFSS_4, 2, "RESTOFSS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RESTOFSS_parse failed");
   return(FALSE);
}

int UIRESTOFSS_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("UIRESTOFSS_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& UI_parse(&__temp.execute.arg[1])
&& PercentIU_parse(&__temp.execute.arg[2])
&& SC_parse(&__temp.execute.arg[3])
&& RESTOFCOND_parse(&__temp.execute.arg[4])
&& S_parse(&__temp.execute.arg[5])
)  {
      if (!_optimise) debug_exit("UIRESTOFSS_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, UIRESTOFSS_1, 5, "UIRESTOFSS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UIRESTOFSS_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& UI_parse(&__temp.execute.arg[1])
&& PercentWU_parse(&__temp.execute.arg[2])
&& S_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("UIRESTOFSS_parse found option 2 -- <UI> <PercentWU> <S> ");
      *__arg = makeparsetree(__temp, UIRESTOFSS_2, 3, "UIRESTOFSS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("UIRESTOFSS_parse failed");
   return(FALSE);
}

int RESTOFIU_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RESTOFIU_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 109, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFIU_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RESTOFIU_1, 1, "RESTOFIU", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFIU_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 110, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFIU_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, RESTOFIU_2, 1, "RESTOFIU", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFIU_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 111, &__temp.execute.arg[1])
&& UI_parse(&__temp.execute.arg[2])
&& ELSEquote_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("RESTOFIU_parse found option 3 -- \"then\" <UI> <ELSEquote> ");
      *__arg = makeparsetree(__temp, RESTOFIU_3, 3, "RESTOFIU", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RESTOFIU_parse failed");
   return(FALSE);
}

int ELSEquote_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("ELSEquote_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 112, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("ELSEquote_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, ELSEquote_1, 1, "ELSEquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("ELSEquote_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 113, &__temp.execute.arg[1])
&& PercentIU_parse(&__temp.execute.arg[2])
&& SC_parse(&__temp.execute.arg[3])
&& RESTOFCOND_parse(&__temp.execute.arg[4])
&& RESTOFIU_parse(&__temp.execute.arg[5])
)  {
      if (!_optimise) debug_exit("ELSEquote_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, ELSEquote_2, 5, "ELSEquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("ELSEquote_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 114, &__temp.execute.arg[1])
&& UI_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("ELSEquote_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, ELSEquote_3, 2, "ELSEquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("ELSEquote_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 115, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("ELSEquote_parse found option 4 -- \"\" ");
      *__arg = makeparsetree(__temp, ELSEquote_4, 1, "ELSEquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("ELSEquote_parse failed");
   return(FALSE);
}

int BPAIR_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("BPAIR_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 116, &__temp.execute.arg[1])
&& EXPR_parse(&__temp.execute.arg[2])
&& _regexp_parse(savepat, 117, &__temp.execute.arg[3])
&& EXPR_parse(&__temp.execute.arg[4])
&& RESTOFBPLIST_parse(&__temp.execute.arg[5])
&& _regexp_parse(savepat, 118, &__temp.execute.arg[6])
)  {
      if (!_optimise) debug_exit("BPAIR_parse found option 1 -- \"\\(\" <EXPR> \":\" <EXPR> <RESTOFBPLIST> \"\\)\" ");
      *__arg = makeparsetree(__temp, BPAIR_1, 6, "BPAIR", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("BPAIR_parse failed");
   return(FALSE);
}

int CONSTquote_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("CONSTquote_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 119, &__temp.execute.arg[1])
&& UNARY_parse(&__temp.execute.arg[2])
&& OPERAND_parse(&__temp.execute.arg[3])
&& RESTOFCEXPR_parse(&__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("CONSTquote_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, CONSTquote_1, 4, "CONSTquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("CONSTquote_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 120, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("CONSTquote_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, CONSTquote_2, 1, "CONSTquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("CONSTquote_parse failed");
   return(FALSE);
}

int PercentSEX_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("PercentSEX_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 121, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentSEX_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, PercentSEX_1, 1, "PercentSEX", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("PercentSEX_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 122, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentSEX_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, PercentSEX_2, 1, "PercentSEX", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("PercentSEX_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 123, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentSEX_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, PercentSEX_3, 1, "PercentSEX", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("PercentSEX_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 124, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentSEX_parse found option 4 -- ");
      *__arg = makeparsetree(__temp, PercentSEX_4, 1, "PercentSEX", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("PercentSEX_parse - trying option 5"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 125, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("PercentSEX_parse found option 5 -- \"\" ");
      *__arg = makeparsetree(__temp, PercentSEX_5, 1, "PercentSEX", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("PercentSEX_parse failed");
   return(FALSE);
}

int CYCPARM_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("CYCPARM_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
&& _regexp_parse(savepat, 126, &__temp.execute.arg[2])
&& EXPR_parse(&__temp.execute.arg[3])
&& _regexp_parse(savepat, 127, &__temp.execute.arg[4])
&& EXPR_parse(&__temp.execute.arg[5])
&& _regexp_parse(savepat, 128, &__temp.execute.arg[6])
&& EXPR_parse(&__temp.execute.arg[7])
)  {
      if (!_optimise) debug_exit("CYCPARM_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, CYCPARM_1, 7, "CYCPARM", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("CYCPARM_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 129, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("CYCPARM_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, CYCPARM_2, 1, "CYCPARM", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("CYCPARM_parse failed");
   return(FALSE);
}

int RESTOFRFDEC_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RESTOFRFDEC_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 130, &__temp.execute.arg[1])
&& RFDEC_parse(&__temp.execute.arg[2])
&& RESTOFRFDEC_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("RESTOFRFDEC_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RESTOFRFDEC_1, 3, "RESTOFRFDEC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFRFDEC_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 131, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFRFDEC_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, RESTOFRFDEC_2, 1, "RESTOFRFDEC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RESTOFRFDEC_parse failed");
   return(FALSE);
}

int RFSTMNT_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RFSTMNT_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 132, &__temp.execute.arg[1])
&& NAME_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("RFSTMNT_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RFSTMNT_1, 2, "RFSTMNT", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RFSTMNT_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
&& _regexp_parse(savepat, 133, &__temp.execute.arg[2])
&& RFDEC_parse(&__temp.execute.arg[3])
&& RESTOFRFDEC_parse(&__temp.execute.arg[4])
&& ALTRFDEC_parse(&__temp.execute.arg[5])
&& _regexp_parse(savepat, 134, &__temp.execute.arg[6])
)  {
      if (!_optimise) debug_exit("RFSTMNT_parse found option 2 -- <NAME> \"\\(\" <RFDEC> <RESTOFRFDEC> <ALTRFDEC> \"\\)\" ");
      *__arg = makeparsetree(__temp, RFSTMNT_2, 6, "RFSTMNT", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RFSTMNT_parse failed");
   return(FALSE);
}

int RFREF_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RFREF_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RFREF_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RFREF_1, 1, "RFREF", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RFREF_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& RFDEC_parse(&__temp.execute.arg[1])
&& RESTOFRFDEC_parse(&__temp.execute.arg[2])
&& ALTRFDEC_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("RFREF_parse found option 2 -- <RFDEC> <RESTOFRFDEC> <ALTRFDEC> ");
      *__arg = makeparsetree(__temp, RFREF_2, 3, "RFREF", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RFREF_parse failed");
   return(FALSE);
}

int RFDEC_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RFDEC_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& TYPE_parse(&__temp.execute.arg[1])
&& RFELMNT_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("RFDEC_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RFDEC_1, 2, "RFDEC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RFDEC_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 135, &__temp.execute.arg[1])
&& RFDEC_parse(&__temp.execute.arg[2])
&& RESTOFRFDEC_parse(&__temp.execute.arg[3])
&& ALTRFDEC_parse(&__temp.execute.arg[4])
&& _regexp_parse(savepat, 136, &__temp.execute.arg[5])
)  {
      if (!_optimise) debug_exit("RFDEC_parse found option 2 -- \"\\(\" <RFDEC> <RESTOFRFDEC> <ALTRFDEC> \"\\)\" ");
      *__arg = makeparsetree(__temp, RFDEC_2, 5, "RFDEC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RFDEC_parse failed");
   return(FALSE);
}

int RFELMNT_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RFELMNT_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& PercentQNAMEquote_parse(&__temp.execute.arg[1])
&& NAME_parse(&__temp.execute.arg[2])
&& NLISTquote_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("RFELMNT_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RFELMNT_1, 3, "RFELMNT", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RFELMNT_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 137, &__temp.execute.arg[1])
&& ADECLN_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("RFELMNT_parse found option 2 -- \"array\" <ADECLN> ");
      *__arg = makeparsetree(__temp, RFELMNT_2, 2, "RFELMNT", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RFELMNT_parse failed");
   return(FALSE);
}

int ALTRFDEC_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("ALTRFDEC_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 138, &__temp.execute.arg[1])
&& RFDEC_parse(&__temp.execute.arg[2])
&& RESTOFRFDEC_parse(&__temp.execute.arg[3])
&& ALTRFDEC_parse(&__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("ALTRFDEC_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, ALTRFDEC_1, 4, "ALTRFDEC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("ALTRFDEC_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 139, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("ALTRFDEC_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, ALTRFDEC_2, 1, "ALTRFDEC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("ALTRFDEC_parse failed");
   return(FALSE);
}

int OPTINC_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("OPTINC_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 140, &__temp.execute.arg[1])
&& N_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("OPTINC_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, OPTINC_1, 2, "OPTINC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OPTINC_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 141, &__temp.execute.arg[1])
&& N_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("OPTINC_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, OPTINC_2, 2, "OPTINC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OPTINC_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 142, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OPTINC_parse found option 3 -- \"\" ");
      *__arg = makeparsetree(__temp, OPTINC_3, 1, "OPTINC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("OPTINC_parse failed");
   return(FALSE);
}

int ATquote_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("ATquote_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 143, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("ATquote_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, ATquote_1, 1, "ATquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("ATquote_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 144, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("ATquote_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, ATquote_2, 1, "ATquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("ATquote_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 145, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("ATquote_parse found option 3 -- \"\" ");
      *__arg = makeparsetree(__temp, ATquote_3, 1, "ATquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("ATquote_parse failed");
   return(FALSE);
}

int XAPP_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("XAPP_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 146, &__temp.execute.arg[1])
&& EXPR_parse(&__temp.execute.arg[2])
&& RESTOFAPP_parse(&__temp.execute.arg[3])
&& _regexp_parse(savepat, 147, &__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("XAPP_parse found option 1 -- \"\\(\" <EXPR> <RESTOFAPP> \"\\)\" ");
      *__arg = makeparsetree(__temp, XAPP_1, 4, "XAPP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("XAPP_parse failed");
   return(FALSE);
}

int RECORDFIELD_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RECORDFIELD_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 148, &__temp.execute.arg[1])
&& NAME_parse(&__temp.execute.arg[2])
&& APP_parse(&__temp.execute.arg[3])
&& RECORDFIELD_parse(&__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("RECORDFIELD_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RECORDFIELD_1, 4, "RECORDFIELD", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RECORDFIELD_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 149, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RECORDFIELD_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, RECORDFIELD_2, 1, "RECORDFIELD", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RECORDFIELD_parse failed");
   return(FALSE);
}

int XRECORDFIELD_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("XRECORDFIELD_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 150, &__temp.execute.arg[1])
&& NAME_parse(&__temp.execute.arg[2])
&& APP_parse(&__temp.execute.arg[3])
&& RECORDFIELD_parse(&__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("XRECORDFIELD_parse found option 1 -- \"_\" <NAME> <APP> <RECORDFIELD> ");
      *__arg = makeparsetree(__temp, XRECORDFIELD_1, 4, "XRECORDFIELD", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("XRECORDFIELD_parse failed");
   return(FALSE);
}

int NAMEAPP_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("NAMEAPP_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
&& XAPP_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("NAMEAPP_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, NAMEAPP_1, 2, "NAMEAPP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("NAMEAPP_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("NAMEAPP_parse found option 2 -- <NAME> ");
      *__arg = makeparsetree(__temp, NAMEAPP_2, 1, "NAMEAPP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("NAMEAPP_parse failed");
   return(FALSE);
}

int BASIC_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("BASIC_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
&& XAPP_parse(&__temp.execute.arg[2])
&& XRECORDFIELD_parse(&__temp.execute.arg[3])
&& ASSOP_parse(&__temp.execute.arg[4])
&& EXPR_parse(&__temp.execute.arg[5])
)  {
      if (!_optimise) debug_exit("BASIC_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, BASIC_1, 5, "BASIC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("BASIC_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
&& XRECORDFIELD_parse(&__temp.execute.arg[2])
&& ASSOP_parse(&__temp.execute.arg[3])
&& EXPR_parse(&__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("BASIC_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, BASIC_2, 4, "BASIC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("BASIC_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
&& XAPP_parse(&__temp.execute.arg[2])
&& ASSOP_parse(&__temp.execute.arg[3])
&& EXPR_parse(&__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("BASIC_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, BASIC_3, 4, "BASIC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("BASIC_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
&& ASSOP_parse(&__temp.execute.arg[2])
&& EXPR_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("BASIC_parse found option 4 -- ");
      *__arg = makeparsetree(__temp, BASIC_4, 3, "BASIC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("BASIC_parse - trying option 5"); lev += 1;

if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
&& APP_parse(&__temp.execute.arg[2])
&& _regexp_parse(savepat, 151, &__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("BASIC_parse found option 5 -- ");
      *__arg = makeparsetree(__temp, BASIC_5, 3, "BASIC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("BASIC_parse - trying option 6"); lev += 1;

if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
&& _regexp_parse(savepat, 152, &__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("BASIC_parse found option 6 -- ");
      *__arg = makeparsetree(__temp, BASIC_6, 2, "BASIC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("BASIC_parse - trying option 7"); lev += 1;

if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
&& XAPP_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("BASIC_parse found option 7 -- ");
      *__arg = makeparsetree(__temp, BASIC_7, 2, "BASIC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("BASIC_parse - trying option 8"); lev += 1;

if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("BASIC_parse found option 8 -- <NAME> ");
      *__arg = makeparsetree(__temp, BASIC_8, 1, "BASIC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("BASIC_parse failed");
   return(FALSE);
}

int AUI_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("AUI_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 153, &__temp.execute.arg[1])
&& UI_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("AUI_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, AUI_1, 2, "AUI", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("AUI_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 154, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("AUI_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, AUI_2, 1, "AUI", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("AUI_parse failed");
   return(FALSE);
}

int UI_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("UI_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& BASIC_parse(&__temp.execute.arg[1])
&& _regexp_parse(savepat, 155, &__temp.execute.arg[2])
&& UI_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("UI_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, UI_1, 3, "UI", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UI_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& BASIC_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("UI_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, UI_2, 1, "UI", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UI_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 156, &__temp.execute.arg[1])
&& _regexp_parse(savepat, 157, &__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("UI_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, UI_3, 2, "UI", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UI_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 158, &__temp.execute.arg[1])
&& NAME_parse(&__temp.execute.arg[2])
&& APP_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("UI_parse found option 4 -- ");
      *__arg = makeparsetree(__temp, UI_4, 3, "UI", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UI_parse - trying option 5"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 159, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("UI_parse found option 5 -- ");
      *__arg = makeparsetree(__temp, UI_5, 1, "UI", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UI_parse - trying option 6"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 160, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("UI_parse found option 6 -- ");
      *__arg = makeparsetree(__temp, UI_6, 1, "UI", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UI_parse - trying option 7"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 161, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("UI_parse found option 7 -- ");
      *__arg = makeparsetree(__temp, UI_7, 1, "UI", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UI_parse - trying option 8"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 162, &__temp.execute.arg[1])
&& ASSOP_parse(&__temp.execute.arg[2])
&& EXPR_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("UI_parse found option 8 -- ");
      *__arg = makeparsetree(__temp, UI_8, 3, "UI", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UI_parse - trying option 9"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 163, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("UI_parse found option 9 -- ");
      *__arg = makeparsetree(__temp, UI_9, 1, "UI", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UI_parse - trying option 10"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 164, &__temp.execute.arg[1])
&& AUI_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("UI_parse found option 10 -- ");
      *__arg = makeparsetree(__temp, UI_10, 2, "UI", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UI_parse - trying option 11"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 165, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("UI_parse found option 11 -- ");
      *__arg = makeparsetree(__temp, UI_11, 1, "UI", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UI_parse - trying option 12"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 166, &__temp.execute.arg[1])
&& PercentEVENTquote_parse(&__temp.execute.arg[2])
&& CEXPR_parse(&__temp.execute.arg[3])
&& OPEXPR_parse(&__temp.execute.arg[4])
&& OPEXPR_parse(&__temp.execute.arg[5])
)  {
      if (!_optimise) debug_exit("UI_parse found option 12 -- ");
      *__arg = makeparsetree(__temp, UI_12, 5, "UI", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UI_parse - trying option 13"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 167, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("UI_parse found option 13 -- ");
      *__arg = makeparsetree(__temp, UI_13, 1, "UI", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UI_parse - trying option 14"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 168, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("UI_parse found option 14 -- \"continue\" ");
      *__arg = makeparsetree(__temp, UI_14, 1, "UI", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("UI_parse failed");
   return(FALSE);
}

int SWITCHDEC_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("SWITCHDEC_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
&& NLISTquote_parse(&__temp.execute.arg[2])
&& _regexp_parse(savepat, 169, &__temp.execute.arg[3])
&& EXPR_parse(&__temp.execute.arg[4])
&& _regexp_parse(savepat, 170, &__temp.execute.arg[5])
&& EXPR_parse(&__temp.execute.arg[6])
&& _regexp_parse(savepat, 171, &__temp.execute.arg[7])
&& RESTOFSWLIST_parse(&__temp.execute.arg[8])
)  {
      if (!_optimise) debug_exit("SWITCHDEC_parse found option 1 -- <NAME> <NLISTquote> \"\\(\" <EXPR> \":\" <EXPR> \"\\)\" <RESTOFSWLIST> ");
      *__arg = makeparsetree(__temp, SWITCHDEC_1, 8, "SWITCHDEC", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("SWITCHDEC_parse failed");
   return(FALSE);
}

int RESTOFSWLIST_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("RESTOFSWLIST_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 172, &__temp.execute.arg[1])
&& SWITCHDEC_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("RESTOFSWLIST_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, RESTOFSWLIST_1, 2, "RESTOFSWLIST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("RESTOFSWLIST_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 173, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("RESTOFSWLIST_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, RESTOFSWLIST_2, 1, "RESTOFSWLIST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("RESTOFSWLIST_parse failed");
   return(FALSE);
}

int SS_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("SS_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& lookahead_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("SS_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, SS_1, 1, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& eof_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("SS_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, SS_2, 1, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& UIRESTOFSS_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("SS_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, SS_3, 1, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& UI_parse(&__temp.execute.arg[1])
&& RESTOFSS_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 4 -- ");
      *__arg = makeparsetree(__temp, SS_4, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 5"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 174, &__temp.execute.arg[1])
&& _regexp_parse(savepat, 175, &__temp.execute.arg[2])
&& _regexp_parse(savepat, 176, &__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("SS_parse found option 5 -- ");
      *__arg = makeparsetree(__temp, SS_5, 3, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 6"); lev += 1;

if (note_backtrack(&__pos)
&& TEXT_parse(&__temp.execute.arg[1])
&& _regexp_parse(savepat, 177, &__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 6 -- ");
      *__arg = makeparsetree(__temp, SS_6, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 7"); lev += 1;

if (note_backtrack(&__pos)
&& PercentIU_parse(&__temp.execute.arg[1])
&& SC_parse(&__temp.execute.arg[2])
&& RESTOFCOND_parse(&__temp.execute.arg[3])
&& RESTOFIU_parse(&__temp.execute.arg[4])
&& S_parse(&__temp.execute.arg[5])
)  {
      if (!_optimise) debug_exit("SS_parse found option 7 -- ");
      *__arg = makeparsetree(__temp, SS_7, 5, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 8"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 178, &__temp.execute.arg[1])
&& ELSEquote_parse(&__temp.execute.arg[2])
&& S_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("SS_parse found option 8 -- ");
      *__arg = makeparsetree(__temp, SS_8, 3, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 9"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 179, &__temp.execute.arg[1])
&& CYCPARM_parse(&__temp.execute.arg[2])
&& S_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("SS_parse found option 9 -- ");
      *__arg = makeparsetree(__temp, SS_9, 3, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 10"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 180, &__temp.execute.arg[1])
&& RESTOFREPEAT_parse(&__temp.execute.arg[2])
&& S_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("SS_parse found option 10 -- ");
      *__arg = makeparsetree(__temp, SS_10, 3, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 11"); lev += 1;

if (note_backtrack(&__pos)
&& PercentWU_parse(&__temp.execute.arg[1])
&& _regexp_parse(savepat, 181, &__temp.execute.arg[2])
&& S_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("SS_parse found option 11 -- ");
      *__arg = makeparsetree(__temp, SS_11, 3, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 12"); lev += 1;

if (note_backtrack(&__pos)
&& TYPE_parse(&__temp.execute.arg[1])
&& DECLN_parse(&__temp.execute.arg[2])
&& S_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("SS_parse found option 12 -- ");
      *__arg = makeparsetree(__temp, SS_12, 3, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 13"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 182, &__temp.execute.arg[1])
&& S_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 13 -- ");
      *__arg = makeparsetree(__temp, SS_13, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 14"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 183, &__temp.execute.arg[1])
&& S_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 14 -- ");
      *__arg = makeparsetree(__temp, SS_14, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 15"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 184, &__temp.execute.arg[1])
&& S_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 15 -- ");
      *__arg = makeparsetree(__temp, SS_15, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 16"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 185, &__temp.execute.arg[1])
&& S_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 16 -- ");
      *__arg = makeparsetree(__temp, SS_16, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 17"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 186, &__temp.execute.arg[1])
&& S_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 17 -- ");
      *__arg = makeparsetree(__temp, SS_17, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 18"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 187, &__temp.execute.arg[1])
&& S_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 18 -- ");
      *__arg = makeparsetree(__temp, SS_18, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 19"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 188, &__temp.execute.arg[1])
&& S_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 19 -- ");
      *__arg = makeparsetree(__temp, SS_19, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 20"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 189, &__temp.execute.arg[1])
&& S_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 20 -- ");
      *__arg = makeparsetree(__temp, SS_20, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 21"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 190, &__temp.execute.arg[1])
&& RFSTMNT_parse(&__temp.execute.arg[2])
&& S_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("SS_parse found option 21 -- ");
      *__arg = makeparsetree(__temp, SS_21, 3, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 22"); lev += 1;

if (note_backtrack(&__pos)
&& PercentSEX_parse(&__temp.execute.arg[1])
&& RT_parse(&__temp.execute.arg[2])
&& PercentSPECquote_parse(&__temp.execute.arg[3])
&& NAME_parse(&__temp.execute.arg[4])
&& ALIASquote_parse(&__temp.execute.arg[5])
&& FPP_parse(&__temp.execute.arg[6])
&& S_parse(&__temp.execute.arg[7])
)  {
      if (!_optimise) debug_exit("SS_parse found option 22 -- ");
      *__arg = makeparsetree(__temp, SS_22, 7, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 23"); lev += 1;

if (note_backtrack(&__pos)
&& XOWN_parse(&__temp.execute.arg[1])
&& TYPE_parse(&__temp.execute.arg[2])
&& OWNDEC_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("SS_parse found option 23 -- ");
      *__arg = makeparsetree(__temp, SS_23, 3, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 24"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 191, &__temp.execute.arg[1])
&& CONST_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 24 -- ");
      *__arg = makeparsetree(__temp, SS_24, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 25"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 192, &__temp.execute.arg[1])
&& S_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 25 -- ");
      *__arg = makeparsetree(__temp, SS_25, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 26"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 193, &__temp.execute.arg[1])
&& PercentEVENTquote_parse(&__temp.execute.arg[2])
&& CEXPR_parse(&__temp.execute.arg[3])
&& RESTOFELIST_parse(&__temp.execute.arg[4])
&& _regexp_parse(savepat, 194, &__temp.execute.arg[5])
&& S_parse(&__temp.execute.arg[6])
)  {
      if (!_optimise) debug_exit("SS_parse found option 26 -- ");
      *__arg = makeparsetree(__temp, SS_26, 6, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 27"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 195, &__temp.execute.arg[1])
&& SWITCHDEC_parse(&__temp.execute.arg[2])
&& S_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("SS_parse found option 27 -- ");
      *__arg = makeparsetree(__temp, SS_27, 3, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 28"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 196, &__temp.execute.arg[1])
&& S_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 28 -- ");
      *__arg = makeparsetree(__temp, SS_28, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 29"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 197, &__temp.execute.arg[1])
&& S_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 29 -- ");
      *__arg = makeparsetree(__temp, SS_29, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 30"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 198, &__temp.execute.arg[1])
&& PercentIU_parse(&__temp.execute.arg[2])
&& SC_parse(&__temp.execute.arg[3])
&& RESTOFCOND_parse(&__temp.execute.arg[4])
&& S_parse(&__temp.execute.arg[5])
)  {
      if (!_optimise) debug_exit("SS_parse found option 30 -- ");
      *__arg = makeparsetree(__temp, SS_30, 5, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 31"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 199, &__temp.execute.arg[1])
&& UCI_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 31 -- ");
      *__arg = makeparsetree(__temp, SS_31, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 32"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 200, &__temp.execute.arg[1])
&& S_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 32 -- ");
      *__arg = makeparsetree(__temp, SS_32, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 33"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 201, &__temp.execute.arg[1])
&& NAME_parse(&__temp.execute.arg[2])
&& S_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("SS_parse found option 33 -- ");
      *__arg = makeparsetree(__temp, SS_33, 3, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 34"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 202, &__temp.execute.arg[1])
&& CONST_parse(&__temp.execute.arg[2])
&& S_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("SS_parse found option 34 -- ");
      *__arg = makeparsetree(__temp, SS_34, 3, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 35"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 203, &__temp.execute.arg[1])
&& CONST_parse(&__temp.execute.arg[2])
&& S_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("SS_parse found option 35 -- ");
      *__arg = makeparsetree(__temp, SS_35, 3, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 36"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 204, &__temp.execute.arg[1])
&& OLDSTRING_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 36 -- ");
      *__arg = makeparsetree(__temp, SS_36, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 37"); lev += 1;

if (note_backtrack(&__pos)
&& NAME_parse(&__temp.execute.arg[1])
&& _regexp_parse(savepat, 205, &__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SS_parse found option 37 -- ");
      *__arg = makeparsetree(__temp, SS_37, 2, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("SS_parse - trying option 38"); lev += 1;

if (note_backtrack(&__pos)
&& S_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("SS_parse found option 38 -- <S> ");
      *__arg = makeparsetree(__temp, SS_38, 1, "SS", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("SS_parse failed");
   return(FALSE);
}

int ASSOP_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("ASSOP_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 206, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("ASSOP_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, ASSOP_1, 1, "ASSOP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("ASSOP_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 207, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("ASSOP_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, ASSOP_2, 1, "ASSOP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("ASSOP_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 208, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("ASSOP_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, ASSOP_3, 1, "ASSOP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("ASSOP_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 209, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("ASSOP_parse found option 4 -- \"->\" ");
      *__arg = makeparsetree(__temp, ASSOP_4, 1, "ASSOP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("ASSOP_parse failed");
   return(FALSE);
}

int COLON_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("COLON_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 210, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COLON_parse found option 1 -- \":\" ");
      *__arg = makeparsetree(__temp, COLON_1, 1, "COLON", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("COLON_parse failed");
   return(FALSE);
}

int COMP_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("COMP_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 211, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMP_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, COMP_1, 1, "COMP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COMP_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 212, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMP_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, COMP_2, 1, "COMP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COMP_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 213, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMP_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, COMP_3, 1, "COMP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COMP_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 214, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMP_parse found option 4 -- ");
      *__arg = makeparsetree(__temp, COMP_4, 1, "COMP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COMP_parse - trying option 5"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 215, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMP_parse found option 5 -- ");
      *__arg = makeparsetree(__temp, COMP_5, 1, "COMP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COMP_parse - trying option 6"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 216, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMP_parse found option 6 -- ");
      *__arg = makeparsetree(__temp, COMP_6, 1, "COMP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COMP_parse - trying option 7"); lev += 1;

if (note_backtrack(&__pos)
&& notequivcomp_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMP_parse found option 7 -- ");
      *__arg = makeparsetree(__temp, COMP_7, 1, "COMP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COMP_parse - trying option 8"); lev += 1;

if (note_backtrack(&__pos)
&& notcomp_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMP_parse found option 8 -- ");
      *__arg = makeparsetree(__temp, COMP_8, 1, "COMP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COMP_parse - trying option 9"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 217, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMP_parse found option 9 -- \"<\" ");
      *__arg = makeparsetree(__temp, COMP_9, 1, "COMP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("COMP_parse failed");
   return(FALSE);
}

int notcomp_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("notcomp_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 218, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("notcomp_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, notcomp_1, 1, "notcomp", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("notcomp_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 219, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("notcomp_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, notcomp_2, 1, "notcomp", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("notcomp_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 220, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("notcomp_parse found option 3 -- \"<>\" ");
      *__arg = makeparsetree(__temp, notcomp_3, 1, "notcomp", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("notcomp_parse failed");
   return(FALSE);
}

int notequivcomp_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("notequivcomp_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 221, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("notequivcomp_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, notequivcomp_1, 1, "notequivcomp", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("notequivcomp_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 222, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("notequivcomp_parse found option 2 -- \"\\\\==\" ");
      *__arg = makeparsetree(__temp, notequivcomp_2, 1, "notequivcomp", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("notequivcomp_parse failed");
   return(FALSE);
}

int COMPtwo_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("COMPtwo_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 223, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMPtwo_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, COMPtwo_1, 1, "COMPtwo", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COMPtwo_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 224, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMPtwo_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, COMPtwo_2, 1, "COMPtwo", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COMPtwo_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 225, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMPtwo_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, COMPtwo_3, 1, "COMPtwo", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COMPtwo_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 226, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMPtwo_parse found option 4 -- ");
      *__arg = makeparsetree(__temp, COMPtwo_4, 1, "COMPtwo", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COMPtwo_parse - trying option 5"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 227, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMPtwo_parse found option 5 -- ");
      *__arg = makeparsetree(__temp, COMPtwo_5, 1, "COMPtwo", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COMPtwo_parse - trying option 6"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 228, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMPtwo_parse found option 6 -- ");
      *__arg = makeparsetree(__temp, COMPtwo_6, 1, "COMPtwo", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COMPtwo_parse - trying option 7"); lev += 1;

if (note_backtrack(&__pos)
&& notequivcomp_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMPtwo_parse found option 7 -- ");
      *__arg = makeparsetree(__temp, COMPtwo_7, 1, "COMPtwo", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COMPtwo_parse - trying option 8"); lev += 1;

if (note_backtrack(&__pos)
&& notcomp_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMPtwo_parse found option 8 -- ");
      *__arg = makeparsetree(__temp, COMPtwo_8, 1, "COMPtwo", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("COMPtwo_parse - trying option 9"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 229, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("COMPtwo_parse found option 9 -- \"<\" ");
      *__arg = makeparsetree(__temp, COMPtwo_9, 1, "COMPtwo", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("COMPtwo_parse failed");
   return(FALSE);
}

int CONST_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("CONST_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& realconst_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("CONST_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, CONST_1, 1, "CONST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("CONST_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& basedconst_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("CONST_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, CONST_2, 1, "CONST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("CONST_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& intconst_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("CONST_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, CONST_3, 1, "CONST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("CONST_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& stringconst_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("CONST_parse found option 4 -- ");
      *__arg = makeparsetree(__temp, CONST_4, 1, "CONST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("CONST_parse - trying option 5"); lev += 1;

if (note_backtrack(&__pos)
&& lettercharconst_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("CONST_parse found option 5 -- <lettercharconst> ");
      *__arg = makeparsetree(__temp, CONST_5, 1, "CONST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("CONST_parse failed");
   return(FALSE);
}

int realconst_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("realconst_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 230, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("realconst_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, realconst_1, 1, "realconst", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("realconst_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 231, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("realconst_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, realconst_2, 1, "realconst", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("realconst_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 232, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("realconst_parse found option 3 -- \"[0-9][0-9]*@[0-9][0-9]*\" ");
      *__arg = makeparsetree(__temp, realconst_3, 1, "realconst", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("realconst_parse failed");
   return(FALSE);
}

int basedconst_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("basedconst_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 233, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("basedconst_parse found option 1 -- \"[0-9][0-9]*_[0-9A-Z][0-9A-Z]*\" ");
      *__arg = makeparsetree(__temp, basedconst_1, 1, "basedconst", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("basedconst_parse failed");
   return(FALSE);
}

int intconst_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("intconst_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 234, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("intconst_parse found option 1 -- \"[0-9][0-9]*\" ");
      *__arg = makeparsetree(__temp, intconst_1, 1, "intconst", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("intconst_parse failed");
   return(FALSE);
}

int stringconst_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("stringconst_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& TEXTTEXT_parse(&__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("stringconst_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, stringconst_1, 1, "stringconst", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("stringconst_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 235, &__temp.execute.arg[1])
&& TEXTTEXT_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("stringconst_parse found option 2 -- \"E\" <TEXTTEXT> ");
      *__arg = makeparsetree(__temp, stringconst_2, 2, "stringconst", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("stringconst_parse failed");
   return(FALSE);
}

int lettercharconst_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("lettercharconst_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& squote_parse(&__temp.execute.arg[1])
&& schar_parse(&__temp.execute.arg[2])
&& squote_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("lettercharconst_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, lettercharconst_1, 3, "lettercharconst", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("lettercharconst_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 236, &__temp.execute.arg[1])
&& squote_parse(&__temp.execute.arg[2])
&& hexchars_parse(&__temp.execute.arg[3])
&& squote_parse(&__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("lettercharconst_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, lettercharconst_2, 4, "lettercharconst", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("lettercharconst_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 237, &__temp.execute.arg[1])
&& squote_parse(&__temp.execute.arg[2])
&& binchars_parse(&__temp.execute.arg[3])
&& squote_parse(&__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("lettercharconst_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, lettercharconst_3, 4, "lettercharconst", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("lettercharconst_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 238, &__temp.execute.arg[1])
&& squote_parse(&__temp.execute.arg[2])
&& octchars_parse(&__temp.execute.arg[3])
&& squote_parse(&__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("lettercharconst_parse found option 4 -- ");
      *__arg = makeparsetree(__temp, lettercharconst_4, 4, "lettercharconst", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("lettercharconst_parse - trying option 5"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 239, &__temp.execute.arg[1])
&& squote_parse(&__temp.execute.arg[2])
&& mchars_parse(&__temp.execute.arg[3])
&& squote_parse(&__temp.execute.arg[4])
)  {
      if (!_optimise) debug_exit("lettercharconst_parse found option 5 -- \"[CMD]\" <squote> <mchars> <squote> ");
      *__arg = makeparsetree(__temp, lettercharconst_5, 4, "lettercharconst", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("lettercharconst_parse failed");
   return(FALSE);
}

int squote_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("squote_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 240, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("squote_parse found option 1 -- \"'\" ");
      *__arg = makeparsetree(__temp, squote_1, 1, "squote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("squote_parse failed");
   return(FALSE);
}

int mchar_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("mchar_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& squote_parse(&__temp.execute.arg[1])
&& squote_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("mchar_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, mchar_1, 2, "mchar", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("mchar_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& not(squote_parse,&__temp.execute.arg[1]) /* Lazy eval */
&& _regexp_parse(savepat, 241, &__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("mchar_parse found option 2 -- <!squote> \".\" ");
      *__arg = makeparsetree(__temp, mchar_2, 2, "mchar", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("mchar_parse failed");
   return(FALSE);
}

int schar_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("schar_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& squote_parse(&__temp.execute.arg[1])
&& squote_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("schar_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, schar_1, 2, "schar", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("schar_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& not(squote_parse,&__temp.execute.arg[1]) /* Lazy eval */
&& _regexp_parse(savepat, 242, &__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("schar_parse found option 2 -- <!squote> \".\" ");
      *__arg = makeparsetree(__temp, schar_2, 2, "schar", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("schar_parse failed");
   return(FALSE);
}

int schars_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("schars_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& schar_parse(&__temp.execute.arg[1])
&& schars_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("schars_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, schars_1, 2, "schars", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("schars_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 243, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("schars_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, schars_2, 1, "schars", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("schars_parse failed");
   return(FALSE);
}

int mchars_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("mchars_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& mchar_parse(&__temp.execute.arg[1])
&& mchars_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("mchars_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, mchars_1, 2, "mchars", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("mchars_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 244, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("mchars_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, mchars_2, 1, "mchars", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("mchars_parse failed");
   return(FALSE);
}

int hexchars_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("hexchars_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 245, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("hexchars_parse found option 1 -- \"[0-9A-Fa-f][0-9A-Fa-f]*\" ");
      *__arg = makeparsetree(__temp, hexchars_1, 1, "hexchars", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("hexchars_parse failed");
   return(FALSE);
}

int octchars_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("octchars_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 246, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("octchars_parse found option 1 -- \"[0-7][0-7]*\" ");
      *__arg = makeparsetree(__temp, octchars_1, 1, "octchars", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("octchars_parse failed");
   return(FALSE);
}

int binchars_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("binchars_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 247, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("binchars_parse found option 1 -- \"[01][01]*\" ");
      *__arg = makeparsetree(__temp, binchars_1, 1, "binchars", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("binchars_parse failed");
   return(FALSE);
}

int DOWN_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("DOWN_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 248, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("DOWN_parse found option 1 -- \"\" ");
      *__arg = makeparsetree(__temp, DOWN_1, 1, "DOWN", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("DOWN_parse failed");
   return(FALSE);
}

int DUMMYSTART_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("DUMMYSTART_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 249, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("DUMMYSTART_parse found option 1 -- \"\" ");
      *__arg = makeparsetree(__temp, DUMMYSTART_1, 1, "DUMMYSTART", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("DUMMYSTART_parse failed");
   return(FALSE);
}

int HOLE_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("HOLE_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 250, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("HOLE_parse found option 1 -- \"\" ");
      *__arg = makeparsetree(__temp, HOLE_1, 1, "HOLE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("HOLE_parse failed");
   return(FALSE);
}

int ICONST_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("ICONST_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 251, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("ICONST_parse found option 1 -- \"[0-9][0-9]*\" ");
      *__arg = makeparsetree(__temp, ICONST_1, 1, "ICONST", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("ICONST_parse failed");
   return(FALSE);
}

int LISTOFF_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("LISTOFF_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 252, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("LISTOFF_parse found option 1 -- \"\" ");
      *__arg = makeparsetree(__temp, LISTOFF_1, 1, "LISTOFF", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("LISTOFF_parse failed");
   return(FALSE);
}

int LISTON_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("LISTON_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 253, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("LISTON_parse found option 1 -- \"\" ");
      *__arg = makeparsetree(__temp, LISTON_1, 1, "LISTON", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("LISTON_parse failed");
   return(FALSE);
}

int MARK_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("MARK_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 254, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("MARK_parse found option 1 -- \"\" ");
      *__arg = makeparsetree(__temp, MARK_1, 1, "MARK", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("MARK_parse failed");
   return(FALSE);
}

int NAME_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("NAME_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 255, &__temp.execute.arg[1])
&& not(eitherquote_parse,&__temp.execute.arg[2]) /* Lazy eval */
)  {
      if (!_optimise) debug_exit("NAME_parse found option 1 -- \"[A-Z][A-Z0-9]*\" <!eitherquote> ");
      *__arg = makeparsetree(__temp, NAME_1, 2, "NAME", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("NAME_parse failed");
   return(FALSE);
}

int eitherquote_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("eitherquote_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 256, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("eitherquote_parse found option 1 -- \"['\"]\" ");
      *__arg = makeparsetree(__temp, eitherquote_1, 1, "eitherquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("eitherquote_parse failed");
   return(FALSE);
}

int NOTECYCLE_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("NOTECYCLE_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 257, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("NOTECYCLE_parse found option 1 -- \"\" ");
      *__arg = makeparsetree(__temp, NOTECYCLE_1, 1, "NOTECYCLE", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("NOTECYCLE_parse failed");
   return(FALSE);
}

int NOTEFINISH_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("NOTEFINISH_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 258, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("NOTEFINISH_parse found option 1 -- \"\" ");
      *__arg = makeparsetree(__temp, NOTEFINISH_1, 1, "NOTEFINISH", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("NOTEFINISH_parse failed");
   return(FALSE);
}

int NOTEREPEAT_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("NOTEREPEAT_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 259, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("NOTEREPEAT_parse found option 1 -- \"\" ");
      *__arg = makeparsetree(__temp, NOTEREPEAT_1, 1, "NOTEREPEAT", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("NOTEREPEAT_parse failed");
   return(FALSE);
}

int NOTESTART_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("NOTESTART_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 260, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("NOTESTART_parse found option 1 -- \"\" ");
      *__arg = makeparsetree(__temp, NOTESTART_1, 1, "NOTESTART", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("NOTESTART_parse failed");
   return(FALSE);
}

int N_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("N_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 261, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("N_parse found option 1 -- \"[0-9][0-9]*\" ");
      *__arg = makeparsetree(__temp, N_1, 1, "N", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("N_parse failed");
   return(FALSE);
}

int Nbyte_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("Nbyte_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 262, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("Nbyte_parse found option 1 -- \"[0-9][0-9]*\" ");
      *__arg = makeparsetree(__temp, Nbyte_1, 1, "Nbyte", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("Nbyte_parse failed");
   return(FALSE);
}

int OP_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("OP_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 263, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OP_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, OP_1, 1, "OP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OP_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 264, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OP_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, OP_2, 1, "OP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OP_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 265, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OP_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, OP_3, 1, "OP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OP_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 266, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OP_parse found option 4 -- ");
      *__arg = makeparsetree(__temp, OP_4, 1, "OP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OP_parse - trying option 5"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 267, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OP_parse found option 5 -- ");
      *__arg = makeparsetree(__temp, OP_5, 1, "OP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OP_parse - trying option 6"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 268, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OP_parse found option 6 -- ");
      *__arg = makeparsetree(__temp, OP_6, 1, "OP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OP_parse - trying option 7"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 269, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OP_parse found option 7 -- ");
      *__arg = makeparsetree(__temp, OP_7, 1, "OP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OP_parse - trying option 8"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 270, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OP_parse found option 8 -- ");
      *__arg = makeparsetree(__temp, OP_8, 1, "OP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OP_parse - trying option 9"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 271, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OP_parse found option 9 -- ");
      *__arg = makeparsetree(__temp, OP_9, 1, "OP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OP_parse - trying option 10"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 272, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OP_parse found option 10 -- ");
      *__arg = makeparsetree(__temp, OP_10, 1, "OP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OP_parse - trying option 11"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 273, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OP_parse found option 11 -- ");
      *__arg = makeparsetree(__temp, OP_11, 1, "OP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OP_parse - trying option 12"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 274, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OP_parse found option 12 -- ");
      *__arg = makeparsetree(__temp, OP_12, 1, "OP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OP_parse - trying option 13"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 275, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OP_parse found option 13 -- ");
      *__arg = makeparsetree(__temp, OP_13, 1, "OP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OP_parse - trying option 14"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 276, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OP_parse found option 14 -- ");
      *__arg = makeparsetree(__temp, OP_14, 1, "OP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OP_parse - trying option 15"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 277, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OP_parse found option 15 -- ");
      *__arg = makeparsetree(__temp, OP_15, 1, "OP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("OP_parse - trying option 16"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 278, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("OP_parse found option 16 -- \"\\\\\" ");
      *__arg = makeparsetree(__temp, OP_16, 1, "OP", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("OP_parse failed");
   return(FALSE);
}

int READLINEquery_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("READLINEquery_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 279, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("READLINEquery_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, READLINEquery_1, 1, "READLINEquery", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("READLINEquery_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 280, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("READLINEquery_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, READLINEquery_2, 1, "READLINEquery", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("READLINEquery_parse failed");
   return(FALSE);
}

int SETNEM_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("SETNEM_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 281, &__temp.execute.arg[1])
&& optsub_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("SETNEM_parse found option 1 -- \"[A-Z][A-Z0-9]*\" <optsub> ");
      *__arg = makeparsetree(__temp, SETNEM_1, 2, "SETNEM", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("SETNEM_parse failed");
   return(FALSE);
}

int optsub_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("optsub_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 282, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("optsub_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, optsub_1, 1, "optsub", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("optsub_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 283, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("optsub_parse found option 2 -- \"\" ");
      *__arg = makeparsetree(__temp, optsub_2, 1, "optsub", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("optsub_parse failed");
   return(FALSE);
}

int S_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("S_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 284, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("S_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, S_1, 1, "S", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("S_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 285, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("S_parse found option 2 -- \";\" ");
      *__arg = makeparsetree(__temp, S_2, 1, "S", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("S_parse failed");
   return(FALSE);
}

int OLDSTRING_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("OLDSTRING_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& squote_parse(&__temp.execute.arg[1])
&& oldstringchars_parse(&__temp.execute.arg[2])
&& squote_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("OLDSTRING_parse found option 1 -- <squote> <oldstringchars> <squote> ");
      *__arg = makeparsetree(__temp, OLDSTRING_1, 3, "OLDSTRING", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("OLDSTRING_parse failed");
   return(FALSE);
}

int oldstringchars_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("oldstringchars_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& squote_parse(&__temp.execute.arg[1])
&& squote_parse(&__temp.execute.arg[2])
&& oldstringchars_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("oldstringchars_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, oldstringchars_1, 3, "oldstringchars", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("oldstringchars_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& not(squote_parse,&__temp.execute.arg[1]) /* Lazy eval */
&& _regexp_parse(savepat, 286, &__temp.execute.arg[2])
&& oldstringchars_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("oldstringchars_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, oldstringchars_2, 3, "oldstringchars", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("oldstringchars_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 287, &__temp.execute.arg[1])
&& oldstringchars_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("oldstringchars_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, oldstringchars_3, 2, "oldstringchars", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("oldstringchars_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 288, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("oldstringchars_parse found option 4 -- \"\" ");
      *__arg = makeparsetree(__temp, oldstringchars_4, 1, "oldstringchars", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("oldstringchars_parse failed");
   return(FALSE);
}

int TEXTTEXT_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("TEXTTEXT_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& quote_parse(&__temp.execute.arg[1])
&& stringchars_parse(&__temp.execute.arg[2])
&& quote_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("TEXTTEXT_parse found option 1 -- <quote> <stringchars> <quote> ");
      *__arg = makeparsetree(__temp, TEXTTEXT_1, 3, "TEXTTEXT", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("TEXTTEXT_parse failed");
   return(FALSE);
}

int quote_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("quote_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 289, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("quote_parse found option 1 -- \"\"\" ");
      *__arg = makeparsetree(__temp, quote_1, 1, "quote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("quote_parse failed");
   return(FALSE);
}

int stringchars_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("stringchars_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& quote_parse(&__temp.execute.arg[1])
&& quote_parse(&__temp.execute.arg[2])
&& stringchars_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("stringchars_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, stringchars_1, 3, "stringchars", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("stringchars_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& not(quote_parse,&__temp.execute.arg[1]) /* Lazy eval */
&& _regexp_parse(savepat, 290, &__temp.execute.arg[2])
&& stringchars_parse(&__temp.execute.arg[3])
)  {
      if (!_optimise) debug_exit("stringchars_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, stringchars_2, 3, "stringchars", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("stringchars_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 291, &__temp.execute.arg[1])
&& stringchars_parse(&__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("stringchars_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, stringchars_3, 2, "stringchars", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("stringchars_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 292, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("stringchars_parse found option 4 -- \"\" ");
      *__arg = makeparsetree(__temp, stringchars_4, 1, "stringchars", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("stringchars_parse failed");
   return(FALSE);
}

int TEXT_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("TEXT_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 293, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TEXT_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, TEXT_1, 1, "TEXT", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TEXT_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 294, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TEXT_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, TEXT_2, 1, "TEXT", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("TEXT_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 295, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("TEXT_parse found option 3 -- \"comment.*\" ");
      *__arg = makeparsetree(__temp, TEXT_3, 1, "TEXT", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("TEXT_parse failed");
   return(FALSE);
}

int UCI_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("UCI_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 296, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("UCI_parse found option 1 -- \".*\" ");
      *__arg = makeparsetree(__temp, UCI_1, 1, "UCI", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("UCI_parse failed");
   return(FALSE);
}

int commaquote_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("commaquote_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 297, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("commaquote_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, commaquote_1, 1, "commaquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("commaquote_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& not(rparen_parse,&__temp.execute.arg[1]) /* Lazy eval */
&& _regexp_parse(savepat, 298, &__temp.execute.arg[2])
)  {
      if (!_optimise) debug_exit("commaquote_parse found option 2 -- <!rparen> \"\" ");
      *__arg = makeparsetree(__temp, commaquote_2, 2, "commaquote", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("commaquote_parse failed");
   return(FALSE);
}

int rparen_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("rparen_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 299, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("rparen_parse found option 1 -- \"\\)\" ");
      *__arg = makeparsetree(__temp, rparen_1, 1, "rparen", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("rparen_parse failed");
   return(FALSE);
}

int UNARY_parse(YYTYPE **__arg)
{
YYTYPE __temp;
int i;
long __pos;

void *__stack;

*__arg = NULL; /* Initialise in case of failure */
/*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
if (!_optimise) debug_enter("UNARY_parse - trying option 1");
__stack = stackmark();
if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 300, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("UNARY_parse found option 1 -- ");
      *__arg = makeparsetree(__temp, UNARY_1, 1, "UNARY", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UNARY_parse - trying option 2"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 301, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("UNARY_parse found option 2 -- ");
      *__arg = makeparsetree(__temp, UNARY_2, 1, "UNARY", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UNARY_parse - trying option 3"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 302, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("UNARY_parse found option 3 -- ");
      *__arg = makeparsetree(__temp, UNARY_3, 1, "UNARY", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UNARY_parse - trying option 4"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 303, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("UNARY_parse found option 4 -- ");
      *__arg = makeparsetree(__temp, UNARY_4, 1, "UNARY", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   /*if (!_optimise)*/ for (i = 0; i < MAX_RULES; i++) __temp.execute.arg[i] = NULL;
   if (!_optimise) debug_exit("UNARY_parse - trying option 5"); lev += 1;

if (note_backtrack(&__pos)
&& _regexp_parse(savepat, 304, &__temp.execute.arg[1])
)  {
      if (!_optimise) debug_exit("UNARY_parse found option 5 -- \"\" ");
      *__arg = makeparsetree(__temp, UNARY_5, 1, "UNARY", __LINE__);
      return(TRUE);
   }
   do_backtrack(__pos);
   stackrelease(__stack);
   if (!_optimise) debug_exit("UNARY_parse failed");
   return(FALSE);
}


static int cover_test(void)
{
if ((cover_testing) && (!SEEN_main_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule main not tested\n");
if ((cover_testing) && (!SEEN_OPERAND_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule OPERAND not tested\n");
if ((cover_testing) && (!SEEN_OPERAND_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule OPERAND not tested\n");
if ((cover_testing) && (!SEEN_OPERAND_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule OPERAND not tested\n");
if ((cover_testing) && (!SEEN_OPERAND_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule OPERAND not tested\n");
if ((cover_testing) && (!SEEN_COPERAND_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule COPERAND not tested\n");
if ((cover_testing) && (!SEEN_COPERAND_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule COPERAND not tested\n");
if ((cover_testing) && (!SEEN_COPERAND_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule COPERAND not tested\n");
if ((cover_testing) && (!SEEN_COPERAND_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule COPERAND not tested\n");
if ((cover_testing) && (!SEEN_CEXPR_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule CEXPR not tested\n");
if ((cover_testing) && (!SEEN_STAROREXPR_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule STAROREXPR not tested\n");
if ((cover_testing) && (!SEEN_STAROREXPR_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule STAROREXPR not tested\n");
if ((cover_testing) && (!SEEN_EXPR_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule EXPR not tested\n");
if ((cover_testing) && (!SEEN_RESTOFEXPR_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RESTOFEXPR not tested\n");
if ((cover_testing) && (!SEEN_RESTOFEXPR_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RESTOFEXPR not tested\n");
if ((cover_testing) && (!SEEN_RESTOFCEXPR_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RESTOFCEXPR not tested\n");
if ((cover_testing) && (!SEEN_RESTOFCEXPR_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RESTOFCEXPR not tested\n");
if ((cover_testing) && (!SEEN_APP_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule APP not tested\n");
if ((cover_testing) && (!SEEN_APP_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule APP not tested\n");
if ((cover_testing) && (!SEEN_RESTOFAPP_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RESTOFAPP not tested\n");
if ((cover_testing) && (!SEEN_RESTOFAPP_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RESTOFAPP not tested\n");
if ((cover_testing) && (!SEEN_PercentIU_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule PercentIU not tested\n");
if ((cover_testing) && (!SEEN_PercentIU_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule PercentIU not tested\n");
if ((cover_testing) && (!SEEN_PercentWU_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule PercentWU not tested\n");
if ((cover_testing) && (!SEEN_PercentWU_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule PercentWU not tested\n");
if ((cover_testing) && (!SEEN_PercentWU_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule PercentWU not tested\n");
if ((cover_testing) && (!SEEN_ALIASquote_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule ALIASquote not tested\n");
if ((cover_testing) && (!SEEN_ALIASquote_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule ALIASquote not tested\n");
if ((cover_testing) && (!SEEN_NLISTquote_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule NLISTquote not tested\n");
if ((cover_testing) && (!SEEN_NLISTquote_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule NLISTquote not tested\n");
if ((cover_testing) && (!SEEN_TYPE_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule TYPE not tested\n");
if ((cover_testing) && (!SEEN_TYPE_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule TYPE not tested\n");
if ((cover_testing) && (!SEEN_TYPE_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule TYPE not tested\n");
if ((cover_testing) && (!SEEN_TYPE_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule TYPE not tested\n");
if ((cover_testing) && (!SEEN_TYPE_5)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 5 of rule TYPE not tested\n");
if ((cover_testing) && (!SEEN_TYPE_6)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 6 of rule TYPE not tested\n");
if ((cover_testing) && (!SEEN_TYPE_7)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 7 of rule TYPE not tested\n");
if ((cover_testing) && (!SEEN_TYPE_8)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 8 of rule TYPE not tested\n");
if ((cover_testing) && (!SEEN_TYPE_9)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 9 of rule TYPE not tested\n");
if ((cover_testing) && (!SEEN_TYPE_10)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 10 of rule TYPE not tested\n");
if ((cover_testing) && (!SEEN_TYPE_11)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 11 of rule TYPE not tested\n");
if ((cover_testing) && (!SEEN_TYPE_12)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 12 of rule TYPE not tested\n");
if ((cover_testing) && (!SEEN_TYPE_13)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 13 of rule TYPE not tested\n");
if ((cover_testing) && (!SEEN_TYPE_14)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 14 of rule TYPE not tested\n");
if ((cover_testing) && (!SEEN_TYPE_15)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 15 of rule TYPE not tested\n");
if ((cover_testing) && (!SEEN_TYPE_16)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 16 of rule TYPE not tested\n");
if ((cover_testing) && (!SEEN_TYPE_17)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 17 of rule TYPE not tested\n");
if ((cover_testing) && (!SEEN_FN_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule FN not tested\n");
if ((cover_testing) && (!SEEN_FN_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule FN not tested\n");
if ((cover_testing) && (!SEEN_RT_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RT not tested\n");
if ((cover_testing) && (!SEEN_RT_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RT not tested\n");
if ((cover_testing) && (!SEEN_RT_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule RT not tested\n");
if ((cover_testing) && (!SEEN_RT_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule RT not tested\n");
if ((cover_testing) && (!SEEN_FPDEL_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule FPDEL not tested\n");
if ((cover_testing) && (!SEEN_FPDEL_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule FPDEL not tested\n");
if ((cover_testing) && (!SEEN_FPDEL_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule FPDEL not tested\n");
if ((cover_testing) && (!SEEN_PercentNAMEquote_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule PercentNAMEquote not tested\n");
if ((cover_testing) && (!SEEN_PercentNAMEquote_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule PercentNAMEquote not tested\n");
if ((cover_testing) && (!SEEN_PercentQNAMEquote_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule PercentQNAMEquote not tested\n");
if ((cover_testing) && (!SEEN_PercentQNAMEquote_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule PercentQNAMEquote not tested\n");
if ((cover_testing) && (!SEEN_PercentQNAMEquote_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule PercentQNAMEquote not tested\n");
if ((cover_testing) && (!SEEN_FPP_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule FPP not tested\n");
if ((cover_testing) && (!SEEN_FPP_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule FPP not tested\n");
if ((cover_testing) && (!SEEN_RESTOFFPLIST_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RESTOFFPLIST not tested\n");
if ((cover_testing) && (!SEEN_RESTOFFPLIST_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RESTOFFPLIST not tested\n");
if ((cover_testing) && (!SEEN_PercentFORMATquote_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule PercentFORMATquote not tested\n");
if ((cover_testing) && (!SEEN_PercentFORMATquote_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule PercentFORMATquote not tested\n");
if ((cover_testing) && (!SEEN_SC_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule SC not tested\n");
if ((cover_testing) && (!SEEN_SC_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule SC not tested\n");
if ((cover_testing) && (!SEEN_SC_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule SC not tested\n");
if ((cover_testing) && (!SEEN_SC_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule SC not tested\n");
if ((cover_testing) && (!SEEN_RESTOFSC_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RESTOFSC not tested\n");
if ((cover_testing) && (!SEEN_RESTOFSC_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RESTOFSC not tested\n");
if ((cover_testing) && (!SEEN_RESTOFCOND_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RESTOFCOND not tested\n");
if ((cover_testing) && (!SEEN_RESTOFCOND_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RESTOFCOND not tested\n");
if ((cover_testing) && (!SEEN_RESTOFCOND_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule RESTOFCOND not tested\n");
if ((cover_testing) && (!SEEN_RESTOFANDC_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RESTOFANDC not tested\n");
if ((cover_testing) && (!SEEN_RESTOFANDC_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RESTOFANDC not tested\n");
if ((cover_testing) && (!SEEN_RESTOFORC_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RESTOFORC not tested\n");
if ((cover_testing) && (!SEEN_RESTOFORC_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RESTOFORC not tested\n");
if ((cover_testing) && (!SEEN_PercentSPECquote_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule PercentSPECquote not tested\n");
if ((cover_testing) && (!SEEN_PercentSPECquote_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule PercentSPECquote not tested\n");
if ((cover_testing) && (!SEEN_VSPECquote_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule VSPECquote not tested\n");
if ((cover_testing) && (!SEEN_VSPECquote_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule VSPECquote not tested\n");
if ((cover_testing) && (!SEEN_RESTOFBPLIST_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RESTOFBPLIST not tested\n");
if ((cover_testing) && (!SEEN_RESTOFBPLIST_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RESTOFBPLIST not tested\n");
if ((cover_testing) && (!SEEN_OLDRECquote_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule OLDRECquote not tested\n");
if ((cover_testing) && (!SEEN_OLDRECquote_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule OLDRECquote not tested\n");
if ((cover_testing) && (!SEEN_DECLN_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule DECLN not tested\n");
if ((cover_testing) && (!SEEN_DECLN_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule DECLN not tested\n");
if ((cover_testing) && (!SEEN_ADECLN_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule ADECLN not tested\n");
if ((cover_testing) && (!SEEN_RESTOFARLIST_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RESTOFARLIST not tested\n");
if ((cover_testing) && (!SEEN_RESTOFARLIST_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RESTOFARLIST not tested\n");
if ((cover_testing) && (!SEEN_WHATEVER_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule WHATEVER not tested\n");
if ((cover_testing) && (!SEEN_OWNDEC_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule OWNDEC not tested\n");
if ((cover_testing) && (!SEEN_OWNDEC_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule OWNDEC not tested\n");
if ((cover_testing) && (!SEEN_RESTOFOWNDEC_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RESTOFOWNDEC not tested\n");
if ((cover_testing) && (!SEEN_RESTOFOWNDEC_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RESTOFOWNDEC not tested\n");
if ((cover_testing) && (!SEEN_XOWN_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule XOWN not tested\n");
if ((cover_testing) && (!SEEN_XOWN_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule XOWN not tested\n");
if ((cover_testing) && (!SEEN_XOWN_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule XOWN not tested\n");
if ((cover_testing) && (!SEEN_XOWN_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule XOWN not tested\n");
if ((cover_testing) && (!SEEN_XOWN_5)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 5 of rule XOWN not tested\n");
if ((cover_testing) && (!SEEN_XOWN_6)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 6 of rule XOWN not tested\n");
if ((cover_testing) && (!SEEN_CONSTLIST_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule CONSTLIST not tested\n");
if ((cover_testing) && (!SEEN_CONSTLIST_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule CONSTLIST not tested\n");
if ((cover_testing) && (!SEEN_CONSTITEMS_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule CONSTITEMS not tested\n");
if ((cover_testing) && (!SEEN_ROCL_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule ROCL not tested\n");
if ((cover_testing) && (!SEEN_ROCL_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule ROCL not tested\n");
if ((cover_testing) && (!SEEN_REPFACT_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule REPFACT not tested\n");
if ((cover_testing) && (!SEEN_REPFACT_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule REPFACT not tested\n");
if ((cover_testing) && (!SEEN_RESTOFELIST_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RESTOFELIST not tested\n");
if ((cover_testing) && (!SEEN_RESTOFELIST_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RESTOFELIST not tested\n");
if ((cover_testing) && (!SEEN_PercentEVENTquote_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule PercentEVENTquote not tested\n");
if ((cover_testing) && (!SEEN_PercentEVENTquote_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule PercentEVENTquote not tested\n");
if ((cover_testing) && (!SEEN_OPEXPR_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule OPEXPR not tested\n");
if ((cover_testing) && (!SEEN_OPEXPR_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule OPEXPR not tested\n");
if ((cover_testing) && (!SEEN_RESTOFREPEAT_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RESTOFREPEAT not tested\n");
if ((cover_testing) && (!SEEN_RESTOFREPEAT_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RESTOFREPEAT not tested\n");
if ((cover_testing) && (!SEEN_RESTOFSS_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RESTOFSS not tested\n");
if ((cover_testing) && (!SEEN_RESTOFSS_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RESTOFSS not tested\n");
if ((cover_testing) && (!SEEN_RESTOFSS_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule RESTOFSS not tested\n");
if ((cover_testing) && (!SEEN_RESTOFSS_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule RESTOFSS not tested\n");
if ((cover_testing) && (!SEEN_UIRESTOFSS_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule UIRESTOFSS not tested\n");
if ((cover_testing) && (!SEEN_UIRESTOFSS_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule UIRESTOFSS not tested\n");
if ((cover_testing) && (!SEEN_RESTOFIU_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RESTOFIU not tested\n");
if ((cover_testing) && (!SEEN_RESTOFIU_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RESTOFIU not tested\n");
if ((cover_testing) && (!SEEN_RESTOFIU_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule RESTOFIU not tested\n");
if ((cover_testing) && (!SEEN_ELSEquote_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule ELSEquote not tested\n");
if ((cover_testing) && (!SEEN_ELSEquote_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule ELSEquote not tested\n");
if ((cover_testing) && (!SEEN_ELSEquote_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule ELSEquote not tested\n");
if ((cover_testing) && (!SEEN_ELSEquote_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule ELSEquote not tested\n");
if ((cover_testing) && (!SEEN_BPAIR_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule BPAIR not tested\n");
if ((cover_testing) && (!SEEN_CONSTquote_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule CONSTquote not tested\n");
if ((cover_testing) && (!SEEN_CONSTquote_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule CONSTquote not tested\n");
if ((cover_testing) && (!SEEN_PercentSEX_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule PercentSEX not tested\n");
if ((cover_testing) && (!SEEN_PercentSEX_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule PercentSEX not tested\n");
if ((cover_testing) && (!SEEN_PercentSEX_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule PercentSEX not tested\n");
if ((cover_testing) && (!SEEN_PercentSEX_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule PercentSEX not tested\n");
if ((cover_testing) && (!SEEN_PercentSEX_5)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 5 of rule PercentSEX not tested\n");
if ((cover_testing) && (!SEEN_CYCPARM_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule CYCPARM not tested\n");
if ((cover_testing) && (!SEEN_CYCPARM_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule CYCPARM not tested\n");
if ((cover_testing) && (!SEEN_RESTOFRFDEC_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RESTOFRFDEC not tested\n");
if ((cover_testing) && (!SEEN_RESTOFRFDEC_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RESTOFRFDEC not tested\n");
if ((cover_testing) && (!SEEN_RFSTMNT_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RFSTMNT not tested\n");
if ((cover_testing) && (!SEEN_RFSTMNT_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RFSTMNT not tested\n");
if ((cover_testing) && (!SEEN_RFREF_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RFREF not tested\n");
if ((cover_testing) && (!SEEN_RFREF_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RFREF not tested\n");
if ((cover_testing) && (!SEEN_RFDEC_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RFDEC not tested\n");
if ((cover_testing) && (!SEEN_RFDEC_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RFDEC not tested\n");
if ((cover_testing) && (!SEEN_RFELMNT_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RFELMNT not tested\n");
if ((cover_testing) && (!SEEN_RFELMNT_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RFELMNT not tested\n");
if ((cover_testing) && (!SEEN_ALTRFDEC_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule ALTRFDEC not tested\n");
if ((cover_testing) && (!SEEN_ALTRFDEC_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule ALTRFDEC not tested\n");
if ((cover_testing) && (!SEEN_OPTINC_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule OPTINC not tested\n");
if ((cover_testing) && (!SEEN_OPTINC_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule OPTINC not tested\n");
if ((cover_testing) && (!SEEN_OPTINC_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule OPTINC not tested\n");
if ((cover_testing) && (!SEEN_ATquote_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule ATquote not tested\n");
if ((cover_testing) && (!SEEN_ATquote_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule ATquote not tested\n");
if ((cover_testing) && (!SEEN_ATquote_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule ATquote not tested\n");
if ((cover_testing) && (!SEEN_XAPP_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule XAPP not tested\n");
if ((cover_testing) && (!SEEN_RECORDFIELD_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RECORDFIELD not tested\n");
if ((cover_testing) && (!SEEN_RECORDFIELD_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RECORDFIELD not tested\n");
if ((cover_testing) && (!SEEN_XRECORDFIELD_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule XRECORDFIELD not tested\n");
if ((cover_testing) && (!SEEN_NAMEAPP_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule NAMEAPP not tested\n");
if ((cover_testing) && (!SEEN_NAMEAPP_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule NAMEAPP not tested\n");
if ((cover_testing) && (!SEEN_BASIC_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule BASIC not tested\n");
if ((cover_testing) && (!SEEN_BASIC_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule BASIC not tested\n");
if ((cover_testing) && (!SEEN_BASIC_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule BASIC not tested\n");
if ((cover_testing) && (!SEEN_BASIC_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule BASIC not tested\n");
if ((cover_testing) && (!SEEN_BASIC_5)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 5 of rule BASIC not tested\n");
if ((cover_testing) && (!SEEN_BASIC_6)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 6 of rule BASIC not tested\n");
if ((cover_testing) && (!SEEN_BASIC_7)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 7 of rule BASIC not tested\n");
if ((cover_testing) && (!SEEN_BASIC_8)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 8 of rule BASIC not tested\n");
if ((cover_testing) && (!SEEN_AUI_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule AUI not tested\n");
if ((cover_testing) && (!SEEN_AUI_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule AUI not tested\n");
if ((cover_testing) && (!SEEN_UI_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule UI not tested\n");
if ((cover_testing) && (!SEEN_UI_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule UI not tested\n");
if ((cover_testing) && (!SEEN_UI_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule UI not tested\n");
if ((cover_testing) && (!SEEN_UI_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule UI not tested\n");
if ((cover_testing) && (!SEEN_UI_5)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 5 of rule UI not tested\n");
if ((cover_testing) && (!SEEN_UI_6)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 6 of rule UI not tested\n");
if ((cover_testing) && (!SEEN_UI_7)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 7 of rule UI not tested\n");
if ((cover_testing) && (!SEEN_UI_8)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 8 of rule UI not tested\n");
if ((cover_testing) && (!SEEN_UI_9)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 9 of rule UI not tested\n");
if ((cover_testing) && (!SEEN_UI_10)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 10 of rule UI not tested\n");
if ((cover_testing) && (!SEEN_UI_11)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 11 of rule UI not tested\n");
if ((cover_testing) && (!SEEN_UI_12)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 12 of rule UI not tested\n");
if ((cover_testing) && (!SEEN_UI_13)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 13 of rule UI not tested\n");
if ((cover_testing) && (!SEEN_UI_14)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 14 of rule UI not tested\n");
if ((cover_testing) && (!SEEN_SWITCHDEC_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule SWITCHDEC not tested\n");
if ((cover_testing) && (!SEEN_RESTOFSWLIST_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule RESTOFSWLIST not tested\n");
if ((cover_testing) && (!SEEN_RESTOFSWLIST_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule RESTOFSWLIST not tested\n");
if ((cover_testing) && (!SEEN_SS_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_5)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 5 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_6)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 6 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_7)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 7 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_8)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 8 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_9)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 9 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_10)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 10 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_11)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 11 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_12)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 12 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_13)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 13 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_14)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 14 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_15)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 15 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_16)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 16 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_17)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 17 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_18)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 18 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_19)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 19 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_20)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 20 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_21)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 21 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_22)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 22 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_23)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 23 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_24)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 24 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_25)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 25 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_26)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 26 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_27)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 27 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_28)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 28 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_29)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 29 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_30)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 30 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_31)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 31 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_32)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 32 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_33)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 33 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_34)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 34 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_35)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 35 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_36)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 36 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_37)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 37 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_SS_38)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 38 of rule SS not tested\n");
if ((cover_testing) && (!SEEN_ASSOP_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule ASSOP not tested\n");
if ((cover_testing) && (!SEEN_ASSOP_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule ASSOP not tested\n");
if ((cover_testing) && (!SEEN_ASSOP_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule ASSOP not tested\n");
if ((cover_testing) && (!SEEN_ASSOP_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule ASSOP not tested\n");
if ((cover_testing) && (!SEEN_COLON_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule COLON not tested\n");
if ((cover_testing) && (!SEEN_COMP_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule COMP not tested\n");
if ((cover_testing) && (!SEEN_COMP_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule COMP not tested\n");
if ((cover_testing) && (!SEEN_COMP_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule COMP not tested\n");
if ((cover_testing) && (!SEEN_COMP_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule COMP not tested\n");
if ((cover_testing) && (!SEEN_COMP_5)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 5 of rule COMP not tested\n");
if ((cover_testing) && (!SEEN_COMP_6)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 6 of rule COMP not tested\n");
if ((cover_testing) && (!SEEN_COMP_7)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 7 of rule COMP not tested\n");
if ((cover_testing) && (!SEEN_COMP_8)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 8 of rule COMP not tested\n");
if ((cover_testing) && (!SEEN_COMP_9)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 9 of rule COMP not tested\n");
if ((cover_testing) && (!SEEN_notcomp_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule notcomp not tested\n");
if ((cover_testing) && (!SEEN_notcomp_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule notcomp not tested\n");
if ((cover_testing) && (!SEEN_notcomp_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule notcomp not tested\n");
if ((cover_testing) && (!SEEN_notequivcomp_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule notequivcomp not tested\n");
if ((cover_testing) && (!SEEN_notequivcomp_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule notequivcomp not tested\n");
if ((cover_testing) && (!SEEN_COMPtwo_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule COMPtwo not tested\n");
if ((cover_testing) && (!SEEN_COMPtwo_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule COMPtwo not tested\n");
if ((cover_testing) && (!SEEN_COMPtwo_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule COMPtwo not tested\n");
if ((cover_testing) && (!SEEN_COMPtwo_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule COMPtwo not tested\n");
if ((cover_testing) && (!SEEN_COMPtwo_5)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 5 of rule COMPtwo not tested\n");
if ((cover_testing) && (!SEEN_COMPtwo_6)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 6 of rule COMPtwo not tested\n");
if ((cover_testing) && (!SEEN_COMPtwo_7)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 7 of rule COMPtwo not tested\n");
if ((cover_testing) && (!SEEN_COMPtwo_8)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 8 of rule COMPtwo not tested\n");
if ((cover_testing) && (!SEEN_COMPtwo_9)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 9 of rule COMPtwo not tested\n");
if ((cover_testing) && (!SEEN_CONST_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule CONST not tested\n");
if ((cover_testing) && (!SEEN_CONST_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule CONST not tested\n");
if ((cover_testing) && (!SEEN_CONST_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule CONST not tested\n");
if ((cover_testing) && (!SEEN_CONST_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule CONST not tested\n");
if ((cover_testing) && (!SEEN_CONST_5)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 5 of rule CONST not tested\n");
if ((cover_testing) && (!SEEN_realconst_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule realconst not tested\n");
if ((cover_testing) && (!SEEN_realconst_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule realconst not tested\n");
if ((cover_testing) && (!SEEN_realconst_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule realconst not tested\n");
if ((cover_testing) && (!SEEN_basedconst_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule basedconst not tested\n");
if ((cover_testing) && (!SEEN_intconst_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule intconst not tested\n");
if ((cover_testing) && (!SEEN_stringconst_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule stringconst not tested\n");
if ((cover_testing) && (!SEEN_stringconst_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule stringconst not tested\n");
if ((cover_testing) && (!SEEN_lettercharconst_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule lettercharconst not tested\n");
if ((cover_testing) && (!SEEN_lettercharconst_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule lettercharconst not tested\n");
if ((cover_testing) && (!SEEN_lettercharconst_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule lettercharconst not tested\n");
if ((cover_testing) && (!SEEN_lettercharconst_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule lettercharconst not tested\n");
if ((cover_testing) && (!SEEN_lettercharconst_5)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 5 of rule lettercharconst not tested\n");
if ((cover_testing) && (!SEEN_squote_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule squote not tested\n");
if ((cover_testing) && (!SEEN_mchar_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule mchar not tested\n");
if ((cover_testing) && (!SEEN_mchar_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule mchar not tested\n");
if ((cover_testing) && (!SEEN_schar_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule schar not tested\n");
if ((cover_testing) && (!SEEN_schar_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule schar not tested\n");
if ((cover_testing) && (!SEEN_schars_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule schars not tested\n");
if ((cover_testing) && (!SEEN_schars_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule schars not tested\n");
if ((cover_testing) && (!SEEN_mchars_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule mchars not tested\n");
if ((cover_testing) && (!SEEN_mchars_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule mchars not tested\n");
if ((cover_testing) && (!SEEN_hexchars_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule hexchars not tested\n");
if ((cover_testing) && (!SEEN_octchars_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule octchars not tested\n");
if ((cover_testing) && (!SEEN_binchars_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule binchars not tested\n");
if ((cover_testing) && (!SEEN_DOWN_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule DOWN not tested\n");
if ((cover_testing) && (!SEEN_DUMMYSTART_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule DUMMYSTART not tested\n");
if ((cover_testing) && (!SEEN_HOLE_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule HOLE not tested\n");
if ((cover_testing) && (!SEEN_ICONST_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule ICONST not tested\n");
if ((cover_testing) && (!SEEN_LISTOFF_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule LISTOFF not tested\n");
if ((cover_testing) && (!SEEN_LISTON_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule LISTON not tested\n");
if ((cover_testing) && (!SEEN_MARK_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule MARK not tested\n");
if ((cover_testing) && (!SEEN_NAME_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule NAME not tested\n");
if ((cover_testing) && (!SEEN_eitherquote_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule eitherquote not tested\n");
if ((cover_testing) && (!SEEN_NOTECYCLE_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule NOTECYCLE not tested\n");
if ((cover_testing) && (!SEEN_NOTEFINISH_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule NOTEFINISH not tested\n");
if ((cover_testing) && (!SEEN_NOTEREPEAT_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule NOTEREPEAT not tested\n");
if ((cover_testing) && (!SEEN_NOTESTART_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule NOTESTART not tested\n");
if ((cover_testing) && (!SEEN_N_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule N not tested\n");
if ((cover_testing) && (!SEEN_Nbyte_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule Nbyte not tested\n");
if ((cover_testing) && (!SEEN_OP_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule OP not tested\n");
if ((cover_testing) && (!SEEN_OP_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule OP not tested\n");
if ((cover_testing) && (!SEEN_OP_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule OP not tested\n");
if ((cover_testing) && (!SEEN_OP_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule OP not tested\n");
if ((cover_testing) && (!SEEN_OP_5)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 5 of rule OP not tested\n");
if ((cover_testing) && (!SEEN_OP_6)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 6 of rule OP not tested\n");
if ((cover_testing) && (!SEEN_OP_7)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 7 of rule OP not tested\n");
if ((cover_testing) && (!SEEN_OP_8)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 8 of rule OP not tested\n");
if ((cover_testing) && (!SEEN_OP_9)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 9 of rule OP not tested\n");
if ((cover_testing) && (!SEEN_OP_10)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 10 of rule OP not tested\n");
if ((cover_testing) && (!SEEN_OP_11)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 11 of rule OP not tested\n");
if ((cover_testing) && (!SEEN_OP_12)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 12 of rule OP not tested\n");
if ((cover_testing) && (!SEEN_OP_13)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 13 of rule OP not tested\n");
if ((cover_testing) && (!SEEN_OP_14)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 14 of rule OP not tested\n");
if ((cover_testing) && (!SEEN_OP_15)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 15 of rule OP not tested\n");
if ((cover_testing) && (!SEEN_OP_16)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 16 of rule OP not tested\n");
if ((cover_testing) && (!SEEN_READLINEquery_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule READLINEquery not tested\n");
if ((cover_testing) && (!SEEN_READLINEquery_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule READLINEquery not tested\n");
if ((cover_testing) && (!SEEN_SETNEM_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule SETNEM not tested\n");
if ((cover_testing) && (!SEEN_optsub_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule optsub not tested\n");
if ((cover_testing) && (!SEEN_optsub_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule optsub not tested\n");
if ((cover_testing) && (!SEEN_S_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule S not tested\n");
if ((cover_testing) && (!SEEN_S_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule S not tested\n");
if ((cover_testing) && (!SEEN_OLDSTRING_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule OLDSTRING not tested\n");
if ((cover_testing) && (!SEEN_oldstringchars_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule oldstringchars not tested\n");
if ((cover_testing) && (!SEEN_oldstringchars_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule oldstringchars not tested\n");
if ((cover_testing) && (!SEEN_oldstringchars_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule oldstringchars not tested\n");
if ((cover_testing) && (!SEEN_oldstringchars_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule oldstringchars not tested\n");
if ((cover_testing) && (!SEEN_TEXTTEXT_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule TEXTTEXT not tested\n");
if ((cover_testing) && (!SEEN_quote_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule quote not tested\n");
if ((cover_testing) && (!SEEN_stringchars_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule stringchars not tested\n");
if ((cover_testing) && (!SEEN_stringchars_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule stringchars not tested\n");
if ((cover_testing) && (!SEEN_stringchars_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule stringchars not tested\n");
if ((cover_testing) && (!SEEN_stringchars_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule stringchars not tested\n");
if ((cover_testing) && (!SEEN_TEXT_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule TEXT not tested\n");
if ((cover_testing) && (!SEEN_TEXT_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule TEXT not tested\n");
if ((cover_testing) && (!SEEN_TEXT_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule TEXT not tested\n");
if ((cover_testing) && (!SEEN_UCI_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule UCI not tested\n");
if ((cover_testing) && (!SEEN_commaquote_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule commaquote not tested\n");
if ((cover_testing) && (!SEEN_commaquote_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule commaquote not tested\n");
if ((cover_testing) && (!SEEN_rparen_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule rparen not tested\n");
if ((cover_testing) && (!SEEN_UNARY_1)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 1 of rule UNARY not tested\n");
if ((cover_testing) && (!SEEN_UNARY_2)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 2 of rule UNARY not tested\n");
if ((cover_testing) && (!SEEN_UNARY_3)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 3 of rule UNARY not tested\n");
if ((cover_testing) && (!SEEN_UNARY_4)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 4 of rule UNARY not tested\n");
if ((cover_testing) && (!SEEN_UNARY_5)) LogWarning(ProgName, "imp2c.e", 0, "Alternative 5 of rule UNARY not tested\n");
}
#ifndef NO_MAIN  /* Get this by default */

int main(int local_argc, char **local_argv)
{
YYTYPE *root; /* Or could be a single YYTYPE, plus an explicit makeparsetree() */
int i;
   argv = local_argv; argc = local_argc;
   /* Should open file yyin here; do it in first entry routine *only* if
   it recognises the null phrase "" */
   if (main_parse(&root)) {
      dump_parsetree(root);
      execute_parsetree(root);
   } else {
      fprintf(stderr, "Parse fail\n");
      for (i = 0; i < 305; i++) if (savepat[i].r != NULL) free(savepat[i].r);
      exit(EXIT_FAILURE);
   }
   /*free_parsetree(root);*/ /*free(root);*/
   cover_test();
   exit(EXIT_SUCCESS);
}
#endif /* not NO_MAIN */

static void _regexp_freeall(void) {
int i;
   for (i = 0; i < 305; i++) if (savepat[i].r != NULL) free(savepat[i].r);
}