/* This file generated automatically using
 * @Id: skel2c,v 1.4 2016/06/07 00:26:09 tom Exp @
 */

/* @Id: btyaccpar.skel,v 1.12 2021/06/19 20:46:31 tom Exp @ */

#include "defs.h"

/*  If the skeleton is changed, the banner should be changed so that	*/
/*  the altered version can be easily distinguished from the original.	*/
/*									*/
/*  The #defines included with the banner are there because they are	*/
/*  useful in subsequent code.  The macros #defined in the header or	*/
/*  the body either are not useful outside of semantic actions or	*/
/*  are conditional.							*/

const char *const banner[] =
{
    "/* original parser id follows */",
    "/* yysccsid[] = \"@(#)yaccpar	1.9 (Berkeley) 02/21/93\" */",
    "/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */",
    "",
    "#define YYBYACC 1",
    CONCAT1("#define YYMAJOR ", YYMAJOR),
    CONCAT1("#define YYMINOR ", YYMINOR),
#ifdef YYPATCH
    CONCAT1("#define YYPATCH ", YYPATCH),
#endif
    "",
    "#define YYEMPTY        (-1)",
    "#define yyclearin      (yychar = YYEMPTY)",
    "#define yyerrok        (yyerrflag = 0)",
    "#define YYRECOVERING() (yyerrflag != 0)",
    "#define YYENOMEM       (-2)",
    "#define YYEOF          0",
    0
};

const char *const xdecls[] =
{
    "",
    "extern int YYPARSE_DECL();",
    0
};

const char *const tables[] =
{
    "extern const YYINT yylhs[];",
    "extern const YYINT yylen[];",
    "extern const YYINT yydefred[];",
    "extern const YYINT yystos[];",
    "extern const YYINT yydgoto[];",
    "extern const YYINT yysindex[];",
    "extern const YYINT yyrindex[];",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "extern const YYINT yycindex[];",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "extern const YYINT yygindex[];",
    "extern const YYINT yytable[];",
    "extern const YYINT yycheck[];",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "extern const YYINT yyctable[];",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "",
    "#if YYDEBUG || defined(yytname)",
    "extern const char *const yyname[];",
    "#endif",
    "#if YYDEBUG",
    "extern const char *const yyrule[];",
    "#endif",
    0
};

const char *const global_vars[] =
{
    "",
    "#if YYDEBUG",
    "int      yydebug;",
    "#endif",
    0
};

const char *const impure_vars[] =
{
    "",
    "int      yyerrflag;",
    "int      yychar;",
    "YYSTYPE  yyval;",
    "YYSTYPE  yylval;",
    "int      yynerrs;",
    "",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "YYLTYPE  yyloc; /* position returned by actions */",
    "YYLTYPE  yylloc; /* position from the lexer */",
    "#endif",
    0
};

const char *const hdr_defs[] =
{
    "",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "#ifndef YYLLOC_DEFAULT",
    "#define YYLLOC_DEFAULT(loc, rhs, n) \\",
    "do \\",
    "{ \\",
    "    if (n == 0) \\",
    "    { \\",
    "        (loc).first_line   = YYRHSLOC(rhs, 0).last_line; \\",
    "        (loc).first_column = YYRHSLOC(rhs, 0).last_column; \\",
    "        (loc).last_line    = YYRHSLOC(rhs, 0).last_line; \\",
    "        (loc).last_column  = YYRHSLOC(rhs, 0).last_column; \\",
    "    } \\",
    "    else \\",
    "    { \\",
    "        (loc).first_line   = YYRHSLOC(rhs, 1).first_line; \\",
    "        (loc).first_column = YYRHSLOC(rhs, 1).first_column; \\",
    "        (loc).last_line    = YYRHSLOC(rhs, n).last_line; \\",
    "        (loc).last_column  = YYRHSLOC(rhs, n).last_column; \\",
    "    } \\",
    "} while (0)",
    "#endif /* YYLLOC_DEFAULT */",
    "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "",
    "#ifndef YYLVQUEUEGROWTH",
    "#define YYLVQUEUEGROWTH 32",
    "#endif",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "",
    "/* define the initial stack-sizes */",
    "#ifdef YYSTACKSIZE",
    "#undef YYMAXDEPTH",
    "#define YYMAXDEPTH  YYSTACKSIZE",
    "#else",
    "#ifdef YYMAXDEPTH",
    "#define YYSTACKSIZE YYMAXDEPTH",
    "#else",
    "#define YYSTACKSIZE 10000",
    "#define YYMAXDEPTH  10000",
    "#endif",
    "#endif",
    "",
    "#ifndef YYINITSTACKSIZE",
    "#define YYINITSTACKSIZE 200",
    "#endif",
    "",
    "typedef struct {",
    "    unsigned stacksize;",
    "    YYINT    *s_base;",
    "    YYINT    *s_mark;",
    "    YYINT    *s_last;",
    "    YYSTYPE  *l_base;",
    "    YYSTYPE  *l_mark;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "    YYLTYPE  *p_base;",
    "    YYLTYPE  *p_mark;",
    "#endif",
    "} YYSTACKDATA;",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "",
    "struct YYParseState_s",
    "{",
    "    struct YYParseState_s *save;    /* Previously saved parser state */",
    "    YYSTACKDATA            yystack; /* saved parser stack */",
    "    int                    state;   /* saved parser state */",
    "    int                    errflag; /* saved error recovery status */",
    "    int                    lexeme;  /* saved index of the conflict lexeme in the lexical queue */",
    "    YYINT                  ctry;    /* saved index in yyctable[] for this conflict */",
    "};",
    "typedef struct YYParseState_s YYParseState;",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    0
};

const char *const hdr_vars[] =
{
    "/* variables for the parser stack */",
    "static YYSTACKDATA yystack;",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "",
    "/* Current parser state */",
    "static YYParseState *yyps = 0;",
    "",
    "/* yypath != NULL: do the full parse, starting at *yypath parser state. */",
    "static YYParseState *yypath = 0;",
    "",
    "/* Base of the lexical value queue */",
    "static YYSTYPE *yylvals = 0;",
    "",
    "/* Current position at lexical value queue */",
    "static YYSTYPE *yylvp = 0;",
    "",
    "/* End position of lexical value queue */",
    "static YYSTYPE *yylve = 0;",
    "",
    "/* The last allocated position at the lexical value queue */",
    "static YYSTYPE *yylvlim = 0;",
    "",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "/* Base of the lexical position queue */",
    "static YYLTYPE *yylpsns = 0;",
    "",
    "/* Current position at lexical position queue */",
    "static YYLTYPE *yylpp = 0;",
    "",
    "/* End position of lexical position queue */",
    "static YYLTYPE *yylpe = 0;",
    "",
    "/* The last allocated position at the lexical position queue */",
    "static YYLTYPE *yylplim = 0;",
    "#endif",
    "",
    "/* Current position at lexical token queue */",
    "static YYINT  *yylexp = 0;",
    "",
    "static YYINT  *yylexemes = 0;",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    0
};

const char *const body_vars[] =
{
    "    int      yyerrflag;",
    "    int      yychar;",
    "    YYSTYPE  yyval;",
    "    YYSTYPE  yylval;",
    "    int      yynerrs;",
    "",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "    YYLTYPE  yyloc; /* position returned by actions */",
    "    YYLTYPE  yylloc; /* position from the lexer */",
    "#endif",
    "",
    "    /* variables for the parser stack */",
    "    YYSTACKDATA yystack;",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "",
    "    /* Current parser state */",
    "    static YYParseState *yyps = 0;",
    "",
    "    /* yypath != NULL: do the full parse, starting at *yypath parser state. */",
    "    static YYParseState *yypath = 0;",
    "",
    "    /* Base of the lexical value queue */",
    "    static YYSTYPE *yylvals = 0;",
    "",
    "    /* Current position at lexical value queue */",
    "    static YYSTYPE *yylvp = 0;",
    "",
    "    /* End position of lexical value queue */",
    "    static YYSTYPE *yylve = 0;",
    "",
    "    /* The last allocated position at the lexical value queue */",
    "    static YYSTYPE *yylvlim = 0;",
    "",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "    /* Base of the lexical position queue */",
    "    static YYLTYPE *yylpsns = 0;",
    "",
    "    /* Current position at lexical position queue */",
    "    static YYLTYPE *yylpp = 0;",
    "",
    "    /* End position of lexical position queue */",
    "    static YYLTYPE *yylpe = 0;",
    "",
    "    /* The last allocated position at the lexical position queue */",
    "    static YYLTYPE *yylplim = 0;",
    "#endif",
    "",
    "    /* Current position at lexical token queue */",
    "    static YYINT  *yylexp = 0;",
    "",
    "    static YYINT  *yylexemes = 0;",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    0
};

const char *const body_1[] =
{
    "",
    "/* For use in generated program */",
    "#define yydepth (int)(yystack.s_mark - yystack.s_base)",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "#define yytrial (yyps->save)",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "",
    "#if YYDEBUG",
    "#include <stdio.h>	/* needed for printf */",
    "#endif",
    "",
    "#include <stdlib.h>	/* needed for malloc, etc */",
    "#include <string.h>	/* needed for memset */",
    "",
    "/* allocate initial stack or double stack size, up to YYMAXDEPTH */",
    "static int yygrowstack(YYSTACKDATA *data)",
    "{",
    "    int i;",
    "    unsigned newsize;",
    "    YYINT *newss;",
    "    YYSTYPE *newvs;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "    YYLTYPE *newps;",
    "#endif",
    "",
    "    if ((newsize = data->stacksize) == 0)",
    "        newsize = YYINITSTACKSIZE;",
    "    else if (newsize >= YYMAXDEPTH)",
    "        return YYENOMEM;",
    "    else if ((newsize *= 2) > YYMAXDEPTH)",
    "        newsize = YYMAXDEPTH;",
    "",
    "    i = (int) (data->s_mark - data->s_base);",
    "    newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));",
    "    if (newss == 0)",
    "        return YYENOMEM;",
    "",
    "    data->s_base = newss;",
    "    data->s_mark = newss + i;",
    "",
    "    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));",
    "    if (newvs == 0)",
    "        return YYENOMEM;",
    "",
    "    data->l_base = newvs;",
    "    data->l_mark = newvs + i;",
    "",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "    newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));",
    "    if (newps == 0)",
    "        return YYENOMEM;",
    "",
    "    data->p_base = newps;",
    "    data->p_mark = newps + i;",
    "#endif",
    "",
    "    data->stacksize = newsize;",
    "    data->s_last = data->s_base + newsize - 1;",
    "",
    "#if YYDEBUG",
    "    if (yydebug)",
    "        fprintf(stderr, \"%sdebug: stack size increased to %d\\n\", YYPREFIX, newsize);",
    "#endif",
    "    return 0;",
    "}",
    "",
    "#if YYPURE || defined(YY_NO_LEAKS)",
    "static void yyfreestack(YYSTACKDATA *data)",
    "{",
    "    free(data->s_base);",
    "    free(data->l_base);",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "    free(data->p_base);",
    "#endif",
    "    memset(data, 0, sizeof(*data));",
    "}",
    "#else",
    "#define yyfreestack(data) /* nothing */",
    "#endif /* YYPURE || defined(YY_NO_LEAKS) */",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "",
    "static YYParseState *",
    "yyNewState(unsigned size)",
    "{",
    "    YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));",
    "    if (p == NULL) return NULL;",
    "",
    "    p->yystack.stacksize = size;",
    "    if (size == 0)",
    "    {",
    "        p->yystack.s_base = NULL;",
    "        p->yystack.l_base = NULL;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "        p->yystack.p_base = NULL;",
    "#endif",
    "        return p;",
    "    }",
    "    p->yystack.s_base    = (YYINT *) malloc(size * sizeof(YYINT));",
    "    if (p->yystack.s_base == NULL) return NULL;",
    "    p->yystack.l_base    = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));",
    "    if (p->yystack.l_base == NULL) return NULL;",
    "    memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "    p->yystack.p_base    = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));",
    "    if (p->yystack.p_base == NULL) return NULL;",
    "    memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));",
    "#endif",
    "",
    "    return p;",
    "}",
    "",
    "static void",
    "yyFreeState(YYParseState *p)",
    "{",
    "    yyfreestack(&p->yystack);",
    "    free(p);",
    "}",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "",
    "#define YYABORT  goto yyabort",
    "#define YYREJECT goto yyabort",
    "#define YYACCEPT goto yyaccept",
    "#define YYERROR  goto yyerrlab",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "#define YYVALID        do { if (yyps->save)            goto yyvalid; } while(0)",
    "#define YYVALID_NESTED do { if (yyps->save && \\",
    "                                yyps->save->save == 0) goto yyvalid; } while(0)",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "",
    "int",
    "YYPARSE_DECL()",
    "{",
    0
};

const char *const body_2[] =
{
    "    int yym, yyn, yystate, yyresult;",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "    int yynewerrflag;",
    "    YYParseState *yyerrctx = NULL;",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "    YYLTYPE  yyerror_loc_range[3]; /* position of error start/end (0 unused) */",
    "#endif",
    "#if YYDEBUG",
    "    const char *yys;",
    "",
    "    if ((yys = getenv(\"YYDEBUG\")) != 0)",
    "    {",
    "        yyn = *yys;",
    "        if (yyn >= '0' && yyn <= '9')",
    "            yydebug = yyn - '0';",
    "    }",
    "    if (yydebug)",
    "        fprintf(stderr, \"%sdebug[<# of symbols on state stack>]\\n\", YYPREFIX);",
    "#endif",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "    memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));",
    "#endif",
    "",
    0
};

const char *const init_vars[] =
{
    "    yyerrflag = 0;",
    "    yychar = 0;",
    "    memset(&yyval,  0, sizeof(yyval));",
    "    memset(&yylval, 0, sizeof(yylval));",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "    memset(&yyloc,  0, sizeof(yyloc));",
    "    memset(&yylloc, 0, sizeof(yylloc));",
    "#endif",
    "",
    0
};

const char *const body_3[] =
{
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "    yyps = yyNewState(0); if (yyps == 0) goto yyenomem;",
    "    yyps->save = 0;",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "    yym = 0;",
    "    /* yyn is set below */",
    "    yynerrs = 0;",
    "    yyerrflag = 0;",
    "    yychar = YYEMPTY;",
    "    yystate = 0;",
    "",
    "#if YYPURE",
    "    memset(&yystack, 0, sizeof(yystack));",
    "#endif",
    "",
    "    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
    "    yystack.s_mark = yystack.s_base;",
    "    yystack.l_mark = yystack.l_base;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "    yystack.p_mark = yystack.p_base;",
    "#endif",
    "    yystate = 0;",
    "    *yystack.s_mark = 0;",
    "",
    "yyloop:",
    "    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;",
    "    if (yychar < 0)",
    "    {",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "        do {",
    "        if (yylvp < yylve)",
    "        {",
    "            /* we're currently re-reading tokens */",
    "            yylval = *yylvp++;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "            yylloc = *yylpp++;",
    "#endif",
    "            yychar = *yylexp++;",
    "            break;",
    "        }",
    "        if (yyps->save)",
    "        {",
    "            /* in trial mode; save scanner results for future parse attempts */",
    "            if (yylvp == yylvlim)",
    "            {   /* Enlarge lexical value queue */",
    "                size_t p = (size_t) (yylvp - yylvals);",
    "                size_t s = (size_t) (yylvlim - yylvals);",
    "",
    "                s += YYLVQUEUEGROWTH;",
    "                if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;",
    "                if ((yylvals   = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "                if ((yylpsns   = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;",
    "#endif",
    "                yylvp   = yylve = yylvals + p;",
    "                yylvlim = yylvals + s;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "                yylpp   = yylpe = yylpsns + p;",
    "                yylplim = yylpsns + s;",
    "#endif",
    "                yylexp  = yylexemes + p;",
    "            }",
    "            *yylexp = (YYINT) YYLEX;",
    "            *yylvp++ = yylval;",
    "            yylve++;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "            *yylpp++ = yylloc;",
    "            yylpe++;",
    "#endif",
    "            yychar = *yylexp++;",
    "            break;",
    "        }",
    "        /* normal operation, no conflict encountered */",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "        yychar = YYLEX;",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "        } while (0);",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "        if (yychar < 0) yychar = YYEOF;",
    "#if YYDEBUG",
    "        if (yydebug)",
    "        {",
    "            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];",
    "            fprintf(stderr, \"%s[%d]: state %d, reading token %d (%s)\",",
    "                            YYDEBUGSTR, yydepth, yystate, yychar, yys);",
    "#ifdef YYSTYPE_TOSTRING",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "            if (!yytrial)",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "                fprintf(stderr, \" <%s>\", YYSTYPE_TOSTRING(yychar, yylval));",
    "#endif",
    "            fputc('\\n', stderr);",
    "        }",
    "#endif",
    "    }",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "",
    "    /* Do we have a conflict? */",
    "    if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&",
    "        yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)",
    "    {",
    "        YYINT ctry;",
    "",
    "        if (yypath)",
    "        {",
    "            YYParseState *save;",
    "#if YYDEBUG",
    "            if (yydebug)",
    "                fprintf(stderr, \"%s[%d]: CONFLICT in state %d: following successful trial parse\\n\",",
    "                                YYDEBUGSTR, yydepth, yystate);",
    "#endif",
    "            /* Switch to the next conflict context */",
    "            save = yypath;",
    "            yypath = save->save;",
    "            save->save = NULL;",
    "            ctry = save->ctry;",
    "            if (save->state != yystate) YYABORT;",
    "            yyFreeState(save);",
    "",
    "        }",
    "        else",
    "        {",
    "",
    "            /* Unresolved conflict - start/continue trial parse */",
    "            YYParseState *save;",
    "#if YYDEBUG",
    "            if (yydebug)",
    "            {",
    "                fprintf(stderr, \"%s[%d]: CONFLICT in state %d. \", YYDEBUGSTR, yydepth, yystate);",
    "                if (yyps->save)",
    "                    fputs(\"ALREADY in conflict, continuing trial parse.\\n\", stderr);",
    "                else",
    "                    fputs(\"Starting trial parse.\\n\", stderr);",
    "            }",
    "#endif",
    "            save                  = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));",
    "            if (save == NULL) goto yyenomem;",
    "            save->save            = yyps->save;",
    "            save->state           = yystate;",
    "            save->errflag         = yyerrflag;",
    "            save->yystack.s_mark  = save->yystack.s_base + (yystack.s_mark - yystack.s_base);",
    "            memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));",
    "            save->yystack.l_mark  = save->yystack.l_base + (yystack.l_mark - yystack.l_base);",
    "            memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "            save->yystack.p_mark  = save->yystack.p_base + (yystack.p_mark - yystack.p_base);",
    "            memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
    "#endif",
    "            ctry                  = yytable[yyn];",
    "            if (yyctable[ctry] == -1)",
    "            {",
    "#if YYDEBUG",
    "                if (yydebug && yychar >= YYEOF)",
    "                    fprintf(stderr, \"%s[%d]: backtracking 1 token\\n\", YYDEBUGSTR, yydepth);",
    "#endif",
    "                ctry++;",
    "            }",
    "            save->ctry = ctry;",
    "            if (yyps->save == NULL)",
    "            {",
    "                /* If this is a first conflict in the stack, start saving lexemes */",
    "                if (!yylexemes)",
    "                {",
    "                    yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));",
    "                    if (yylexemes == NULL) goto yyenomem;",
    "                    yylvals   = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));",
    "                    if (yylvals == NULL) goto yyenomem;",
    "                    yylvlim   = yylvals + YYLVQUEUEGROWTH;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "                    yylpsns   = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));",
    "                    if (yylpsns == NULL) goto yyenomem;",
    "                    yylplim   = yylpsns + YYLVQUEUEGROWTH;",
    "#endif",
    "                }",
    "                if (yylvp == yylve)",
    "                {",
    "                    yylvp  = yylve = yylvals;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "                    yylpp  = yylpe = yylpsns;",
    "#endif",
    "                    yylexp = yylexemes;",
    "                    if (yychar >= YYEOF)",
    "                    {",
    "                        *yylve++ = yylval;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "                        *yylpe++ = yylloc;",
    "#endif",
    "                        *yylexp  = (YYINT) yychar;",
    "                        yychar   = YYEMPTY;",
    "                    }",
    "                }",
    "            }",
    "            if (yychar >= YYEOF)",
    "            {",
    "                yylvp--;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "                yylpp--;",
    "#endif",
    "                yylexp--;",
    "                yychar = YYEMPTY;",
    "            }",
    "            save->lexeme = (int) (yylvp - yylvals);",
    "            yyps->save   = save;",
    "        }",
    "        if (yytable[yyn] == ctry)",
    "        {",
    "#if YYDEBUG",
    "            if (yydebug)",
    "                fprintf(stderr, \"%s[%d]: state %d, shifting to state %d\\n\",",
    "                                YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);",
    "#endif",
    "            if (yychar < 0)",
    "            {",
    "                yylvp++;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "                yylpp++;",
    "#endif",
    "                yylexp++;",
    "            }",
    "            if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)",
    "                goto yyoverflow;",
    "            yystate = yyctable[ctry];",
    "            *++yystack.s_mark = (YYINT) yystate;",
    "            *++yystack.l_mark = yylval;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "            *++yystack.p_mark = yylloc;",
    "#endif",
    "            yychar  = YYEMPTY;",
    "            if (yyerrflag > 0) --yyerrflag;",
    "            goto yyloop;",
    "        }",
    "        else",
    "        {",
    "            yyn = yyctable[ctry];",
    "            goto yyreduce;",
    "        }",
    "    } /* End of code dealing with conflicts */",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "    if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&",
    "            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)",
    "    {",
    "#if YYDEBUG",
    "        if (yydebug)",
    "            fprintf(stderr, \"%s[%d]: state %d, shifting to state %d\\n\",",
    "                            YYDEBUGSTR, yydepth, yystate, yytable[yyn]);",
    "#endif",
    "        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
    "        yystate = yytable[yyn];",
    "        *++yystack.s_mark = yytable[yyn];",
    "        *++yystack.l_mark = yylval;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "        *++yystack.p_mark = yylloc;",
    "#endif",
    "        yychar = YYEMPTY;",
    "        if (yyerrflag > 0)  --yyerrflag;",
    "        goto yyloop;",
    "    }",
    "    if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&",
    "            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)",
    "    {",
    "        yyn = yytable[yyn];",
    "        goto yyreduce;",
    "    }",
    "    if (yyerrflag != 0) goto yyinrecovery;",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "",
    "    yynewerrflag = 1;",
    "    goto yyerrhandler;",
    "    goto yyerrlab; /* redundant goto avoids 'unused label' warning */",
    "",
    "yyerrlab:",
    "    /* explicit YYERROR from an action -- pop the rhs of the rule reduced",
    "     * before looking for error recovery */",
    "    yystack.s_mark -= yym;",
    "    yystate = *yystack.s_mark;",
    "    yystack.l_mark -= yym;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "    yystack.p_mark -= yym;",
    "#endif",
    "",
    "    yynewerrflag = 0;",
    "yyerrhandler:",
    "    while (yyps->save)",
    "    {",
    "        int ctry;",
    "        YYParseState *save = yyps->save;",
    "#if YYDEBUG",
    "        if (yydebug)",
    "            fprintf(stderr, \"%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\\n\",",
    "                            YYDEBUGSTR, yydepth, yystate, yyps->save->state,",
    "                    (int)(yylvp - yylvals - yyps->save->lexeme));",
    "#endif",
    "        /* Memorize most forward-looking error state in case it's really an error. */",
    "        if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)",
    "        {",
    "            /* Free old saved error context state */",
    "            if (yyerrctx) yyFreeState(yyerrctx);",
    "            /* Create and fill out new saved error context state */",
    "            yyerrctx                 = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));",
    "            if (yyerrctx == NULL) goto yyenomem;",
    "            yyerrctx->save           = yyps->save;",
    "            yyerrctx->state          = yystate;",
    "            yyerrctx->errflag        = yyerrflag;",
    "            yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);",
    "            memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));",
    "            yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);",
    "            memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "            yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);",
    "            memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
    "#endif",
    "            yyerrctx->lexeme         = (int) (yylvp - yylvals);",
    "        }",
    "        yylvp          = yylvals   + save->lexeme;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "        yylpp          = yylpsns   + save->lexeme;",
    "#endif",
    "        yylexp         = yylexemes + save->lexeme;",
    "        yychar         = YYEMPTY;",
    "        yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);",
    "        memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));",
    "        yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);",
    "        memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "        yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);",
    "        memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
    "#endif",
    "        ctry           = ++save->ctry;",
    "        yystate        = save->state;",
    "        /* We tried shift, try reduce now */",
    "        if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;",
    "        yyps->save     = save->save;",
    "        save->save     = NULL;",
    "        yyFreeState(save);",
    "",
    "        /* Nothing left on the stack -- error */",
    "        if (!yyps->save)",
    "        {",
    "#if YYDEBUG",
    "            if (yydebug)",
    "                fprintf(stderr, \"%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\\n\",",
    "                                YYPREFIX, yydepth);",
    "#endif",
    "            /* Restore state as it was in the most forward-advanced error */",
    "            yylvp          = yylvals   + yyerrctx->lexeme;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "            yylpp          = yylpsns   + yyerrctx->lexeme;",
    "#endif",
    "            yylexp         = yylexemes + yyerrctx->lexeme;",
    "            yychar         = yylexp[-1];",
    "            yylval         = yylvp[-1];",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "            yylloc         = yylpp[-1];",
    "#endif",
    "            yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);",
    "            memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));",
    "            yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);",
    "            memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "            yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);",
    "            memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
    "#endif",
    "            yystate        = yyerrctx->state;",
    "            yyFreeState(yyerrctx);",
    "            yyerrctx       = NULL;",
    "        }",
    "        yynewerrflag = 1;",
    "    }",
    "    if (yynewerrflag == 0) goto yyinrecovery;",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "",
    "    YYERROR_CALL(\"syntax error\");",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "    yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */",
    "#endif",
    "",
    "#if !YYBTYACC",
    "    goto yyerrlab; /* redundant goto avoids 'unused label' warning */",
    "yyerrlab:",
    "#endif",
    "    ++yynerrs;",
    "",
    "yyinrecovery:",
    "    if (yyerrflag < 3)",
    "    {",
    "        yyerrflag = 3;",
    "        for (;;)",
    "        {",
    "            if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&",
    "                    yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)",
    "            {",
    "#if YYDEBUG",
    "                if (yydebug)",
    "                    fprintf(stderr, \"%s[%d]: state %d, error recovery shifting to state %d\\n\",",
    "                                    YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);",
    "#endif",
    "                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
    "                yystate = yytable[yyn];",
    "                *++yystack.s_mark = yytable[yyn];",
    "                *++yystack.l_mark = yylval;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "                /* lookahead position is error end position */",
    "                yyerror_loc_range[2] = yylloc;",
    "                YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */",
    "                *++yystack.p_mark = yyloc;",
    "#endif",
    "                goto yyloop;",
    "            }",
    "            else",
    "            {",
    "#if YYDEBUG",
    "                if (yydebug)",
    "                    fprintf(stderr, \"%s[%d]: error recovery discarding state %d\\n\",",
    "                                    YYDEBUGSTR, yydepth, *yystack.s_mark);",
    "#endif",
    "                if (yystack.s_mark <= yystack.s_base) goto yyabort;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "                /* the current TOS position is the error start position */",
    "                yyerror_loc_range[1] = *yystack.p_mark;",
    "#endif",
    "#if defined(YYDESTRUCT_CALL)",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "                if (!yytrial)",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "                    YYDESTRUCT_CALL(\"error: discarding state\",",
    "                                    yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);",
    "#else",
    "                    YYDESTRUCT_CALL(\"error: discarding state\",",
    "                                    yystos[*yystack.s_mark], yystack.l_mark);",
    "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
    "#endif /* defined(YYDESTRUCT_CALL) */",
    "                --yystack.s_mark;",
    "                --yystack.l_mark;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "                --yystack.p_mark;",
    "#endif",
    "            }",
    "        }",
    "    }",
    "    else",
    "    {",
    "        if (yychar == YYEOF) goto yyabort;",
    "#if YYDEBUG",
    "        if (yydebug)",
    "        {",
    "            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];",
    "            fprintf(stderr, \"%s[%d]: state %d, error recovery discarding token %d (%s)\\n\",",
    "                            YYDEBUGSTR, yydepth, yystate, yychar, yys);",
    "        }",
    "#endif",
    "#if defined(YYDESTRUCT_CALL)",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "        if (!yytrial)",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "            YYDESTRUCT_CALL(\"error: discarding token\", yychar, &yylval, &yylloc);",
    "#else",
    "            YYDESTRUCT_CALL(\"error: discarding token\", yychar, &yylval);",
    "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
    "#endif /* defined(YYDESTRUCT_CALL) */",
    "        yychar = YYEMPTY;",
    "        goto yyloop;",
    "    }",
    "",
    "yyreduce:",
    "    yym = yylen[yyn];",
    "#if YYDEBUG",
    "    if (yydebug)",
    "    {",
    "        fprintf(stderr, \"%s[%d]: state %d, reducing by rule %d (%s)\",",
    "                        YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);",
    "#ifdef YYSTYPE_TOSTRING",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "        if (!yytrial)",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "            if (yym > 0)",
    "            {",
    "                int i;",
    "                fputc('<', stderr);",
    "                for (i = yym; i > 0; i--)",
    "                {",
    "                    if (i != yym) fputs(\", \", stderr);",
    "                    fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],",
    "                                           yystack.l_mark[1-i]), stderr);",
    "                }",
    "                fputc('>', stderr);",
    "            }",
    "#endif",
    "        fputc('\\n', stderr);",
    "    }",
    "#endif",
    "    if (yym > 0)",
    "        yyval = yystack.l_mark[1-yym];",
    "    else",
    "        memset(&yyval, 0, sizeof yyval);",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "",
    "    /* Perform position reduction */",
    "    memset(&yyloc, 0, sizeof(yyloc));",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "    if (!yytrial)",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "    {",
    "        YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym);",
    "        /* just in case YYERROR is invoked within the action, save",
    "           the start of the rhs as the error start position */",
    "        yyerror_loc_range[1] = yystack.p_mark[1-yym];",
    "    }",
    "#endif",
    "",
    "    switch (yyn)",
    "    {",
    0
};

const char *const trailer[] =
{
    "    default:",
    "        break;",
    "    }",
    "    yystack.s_mark -= yym;",
    "    yystate = *yystack.s_mark;",
    "    yystack.l_mark -= yym;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "    yystack.p_mark -= yym;",
    "#endif",
    "    yym = yylhs[yyn];",
    "    if (yystate == 0 && yym == 0)",
    "    {",
    "#if YYDEBUG",
    "        if (yydebug)",
    "        {",
    "            fprintf(stderr, \"%s[%d]: after reduction, \", YYDEBUGSTR, yydepth);",
    "#ifdef YYSTYPE_TOSTRING",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "            if (!yytrial)",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "                fprintf(stderr, \"result is <%s>, \", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));",
    "#endif",
    "            fprintf(stderr, \"shifting from state 0 to final state %d\\n\", YYFINAL);",
    "        }",
    "#endif",
    "        yystate = YYFINAL;",
    "        *++yystack.s_mark = YYFINAL;",
    "        *++yystack.l_mark = yyval;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "        *++yystack.p_mark = yyloc;",
    "#endif",
    "        if (yychar < 0)",
    "        {",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "            do {",
    "            if (yylvp < yylve)",
    "            {",
    "                /* we're currently re-reading tokens */",
    "                yylval = *yylvp++;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "                yylloc = *yylpp++;",
    "#endif",
    "                yychar = *yylexp++;",
    "                break;",
    "            }",
    "            if (yyps->save)",
    "            {",
    "                /* in trial mode; save scanner results for future parse attempts */",
    "                if (yylvp == yylvlim)",
    "                {   /* Enlarge lexical value queue */",
    "                    size_t p = (size_t) (yylvp - yylvals);",
    "                    size_t s = (size_t) (yylvlim - yylvals);",
    "",
    "                    s += YYLVQUEUEGROWTH;",
    "                    if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL)",
    "                        goto yyenomem;",
    "                    if ((yylvals   = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)",
    "                        goto yyenomem;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "                    if ((yylpsns   = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)",
    "                        goto yyenomem;",
    "#endif",
    "                    yylvp   = yylve = yylvals + p;",
    "                    yylvlim = yylvals + s;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "                    yylpp   = yylpe = yylpsns + p;",
    "                    yylplim = yylpsns + s;",
    "#endif",
    "                    yylexp  = yylexemes + p;",
    "                }",
    "                *yylexp = (YYINT) YYLEX;",
    "                *yylvp++ = yylval;",
    "                yylve++;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "                *yylpp++ = yylloc;",
    "                yylpe++;",
    "#endif",
    "                yychar = *yylexp++;",
    "                break;",
    "            }",
    "            /* normal operation, no conflict encountered */",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "            yychar = YYLEX;",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "            } while (0);",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "            if (yychar < 0) yychar = YYEOF;",
    "#if YYDEBUG",
    "            if (yydebug)",
    "            {",
    "                if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];",
    "                fprintf(stderr, \"%s[%d]: state %d, reading token %d (%s)\\n\",",
    "                                YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);",
    "            }",
    "#endif",
    "        }",
    "        if (yychar == YYEOF) goto yyaccept;",
    "        goto yyloop;",
    "    }",
    "    if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&",
    "            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)",
    "        yystate = yytable[yyn];",
    "    else",
    "        yystate = yydgoto[yym];",
    "#if YYDEBUG",
    "    if (yydebug)",
    "    {",
    "        fprintf(stderr, \"%s[%d]: after reduction, \", YYDEBUGSTR, yydepth);",
    "#ifdef YYSTYPE_TOSTRING",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "        if (!yytrial)",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "            fprintf(stderr, \"result is <%s>, \", YYSTYPE_TOSTRING(yystos[yystate], yyval));",
    "#endif",
    "        fprintf(stderr, \"shifting from state %d to state %d\\n\", *yystack.s_mark, yystate);",
    "    }",
    "#endif",
    "    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;",
    "    *++yystack.s_mark = (YYINT) yystate;",
    "    *++yystack.l_mark = yyval;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "    *++yystack.p_mark = yyloc;",
    "#endif",
    "    goto yyloop;",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "",
    "    /* Reduction declares that this path is valid. Set yypath and do a full parse */",
    "yyvalid:",
    "    if (yypath) YYABORT;",
    "    while (yyps->save)",
    "    {",
    "        YYParseState *save = yyps->save;",
    "        yyps->save = save->save;",
    "        save->save = yypath;",
    "        yypath = save;",
    "    }",
    "#if YYDEBUG",
    "    if (yydebug)",
    "        fprintf(stderr, \"%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\\n\",",
    "                        YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));",
    "#endif",
    "    if (yyerrctx)",
    "    {",
    "        yyFreeState(yyerrctx);",
    "        yyerrctx = NULL;",
    "    }",
    "    yylvp          = yylvals + yypath->lexeme;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "    yylpp          = yylpsns + yypath->lexeme;",
    "#endif",
    "    yylexp         = yylexemes + yypath->lexeme;",
    "    yychar         = YYEMPTY;",
    "    yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);",
    "    memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));",
    "    yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);",
    "    memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "    yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);",
    "    memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));",
    "#endif",
    "    yystate        = yypath->state;",
    "    goto yyloop;",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "",
    "yyoverflow:",
    "    YYERROR_CALL(\"yacc stack overflow\");",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "    goto yyabort_nomem;",
    "yyenomem:",
    "    YYERROR_CALL(\"memory exhausted\");",
    "yyabort_nomem:",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "    yyresult = 2;",
    "    goto yyreturn;",
    "",
    "yyabort:",
    "    yyresult = 1;",
    "    goto yyreturn;",
    "",
    "yyaccept:",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "    if (yyps->save) goto yyvalid;",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "    yyresult = 0;",
    "",
    "yyreturn:",
    "#if defined(YYDESTRUCT_CALL)",
    "    if (yychar != YYEOF && yychar != YYEMPTY)",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "        YYDESTRUCT_CALL(\"cleanup: discarding token\", yychar, &yylval, &yylloc);",
    "#else",
    "        YYDESTRUCT_CALL(\"cleanup: discarding token\", yychar, &yylval);",
    "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
    "",
    "    {",
    "        YYSTYPE *pv;",
    "#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)",
    "        YYLTYPE *pp;",
    "",
    "        for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)",
    "             YYDESTRUCT_CALL(\"cleanup: discarding state\",",
    "                             yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);",
    "#else",
    "        for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)",
    "             YYDESTRUCT_CALL(\"cleanup: discarding state\",",
    "                             yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);",
    "#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */",
    "    }",
    "#endif /* defined(YYDESTRUCT_CALL) */",
    "",
#if defined(YYBTYACC)
    "#if YYBTYACC",
    "    if (yyerrctx)",
    "    {",
    "        yyFreeState(yyerrctx);",
    "        yyerrctx = NULL;",
    "    }",
    "    while (yyps)",
    "    {",
    "        YYParseState *save = yyps;",
    "        yyps = save->save;",
    "        save->save = NULL;",
    "        yyFreeState(save);",
    "    }",
    "    while (yypath)",
    "    {",
    "        YYParseState *save = yypath;",
    "        yypath = save->save;",
    "        save->save = NULL;",
    "        yyFreeState(save);",
    "    }",
    "#endif /* YYBTYACC */",
#endif			/* defined(YYBTYACC) */
    "    yyfreestack(&yystack);",
    "    return (yyresult);",
    "}",
    0
};

void
write_section(FILE * fp, const char *const section[])
{
    int i;
    const char *s;

    for (i = 0; (s = section[i]) != 0; ++i)
    {
	if (fp == code_file)
	    ++outline;
	fprintf(fp, "%s\n", s);
    }
}
