parse.c

/* This file is automatically generated by Lemon from input grammar
** source file "parse.y".
*/
/*
** 2001-09-15
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:
**
**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains SQLite's SQL parser.
**
** The canonical source code to this file ("parse.y") is a Lemon grammar 
** file that specifies the input grammar and actions to take while parsing.
** That input file is processed by Lemon to generate a C-language 
** implementation of a parser for the given grammar.  You might be reading
** this comment as part of the translated C-code.  Edits should be made
** to the original parse.y sources.
*/
#line 64 "parse.y"

#include "sqliteInt.h"

/*
** Verify that the pParse->isCreate field is set
*/
#define ASSERT_IS_CREATE   assert(pParse->isCreate)

/*
** Disable all error recovery processing in the parser push-down
** automaton.
*/
#define YYNOERRORRECOVERY 1

/*
** Make yytestcase() the same as testcase()
*/
#define yytestcase(X) testcase(X)

/*
** Indicate that sqlite3ParserFree() will never be called with a null
** pointer.
*/
#define YYPARSEFREENEVERNULL 1

/*
** In the amalgamation, the parse.c file generated by lemon and the
** tokenize.c file are concatenated.  In that case, sqlite3RunParser()
** has access to the the size of the yyParser object and so the parser
** engine can be allocated from stack.  In that case, only the
** sqlite3ParserInit() and sqlite3ParserFinalize() routines are invoked
** and the sqlite3ParserAlloc() and sqlite3ParserFree() routines can be
** omitted.
*/
#ifdef SQLITE_AMALGAMATION
# define sqlite3Parser_ENGINEALWAYSONSTACK 1
#endif

/*
** Alternative datatype for the argument to the malloc() routine passed
** into sqlite3ParserAlloc().  The default is size_t.
*/
#define YYMALLOCARGTYPE  u64

/*
** An instance of the following structure describes the event of a
** TRIGGER.  "a" is the event type, one of TK_UPDATE, TK_INSERT,
** TK_DELETE, or TK_INSTEAD.  If the event is of the form
**
**      UPDATE ON (a,b,c)
**
** Then the "b" IdList records the list "a,b,c".
*/
struct TrigEvent { int a; IdList * b; };

struct FrameBound     { int eType; Expr *pExpr; };

/*
** Generate a syntax error
*/
static void parserSyntaxError(Parse *pParse, Token *p){
  sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", p);
}

/*
** Disable lookaside memory allocation for objects that might be
** shared across database connections.
*/
static void disableLookaside(Parse *pParse){
  sqlite3 *db = pParse->db;
  pParse->disableLookaside++;
#ifdef SQLITE_DEBUG
  pParse->isCreate = 1;
#endif
  memset(&pParse->u1.cr, 0, sizeof(pParse->u1.cr));
  DisableLookaside;
}

#if !defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) \
 && defined(SQLITE_UDL_CAPABLE_PARSER)
/*
** Issue an error message if an ORDER BY or LIMIT clause occurs on an
** UPDATE or DELETE statement.
*/
static void updateDeleteLimitError(
  Parse *pParse,
  ExprList *pOrderBy,
  Expr *pLimit
){
  if( pOrderBy ){
    sqlite3ErrorMsg(pParse, "syntax error near \"ORDER BY\"");
  }else{
    sqlite3ErrorMsg(pParse, "syntax error near \"LIMIT\"");
  }
  sqlite3ExprListDelete(pParse->db, pOrderBy);
  sqlite3ExprDelete(pParse->db, pLimit);
}
#endif /* SQLITE_ENABLE_UPDATE_DELETE_LIMIT */

#line 537 "parse.y"

  /*
  ** For a compound SELECT statement, make sure p->pPrior->pNext==p for
  ** all elements in the list.  And make sure list length does not exceed
  ** SQLITE_LIMIT_COMPOUND_SELECT.
  */
  static void parserDoubleLinkSelect(Parse *pParse, Select *p){
    assert( p!=0 );
    if( p->pPrior ){
      Select *pNext = 0, *pLoop = p;
      int mxSelect, cnt = 1;
      while(1){
        pLoop->pNext = pNext;
        pLoop->selFlags |= SF_Compound;
        pNext = pLoop;
        pLoop = pLoop->pPrior;
        if( pLoop==0 ) break;
        cnt++;        
        if( pLoop->pOrderBy || pLoop->pLimit ){
          sqlite3ErrorMsg(pParse,"%s clause should come after %s not before",
             pLoop->pOrderBy!=0 ? "ORDER BY" : "LIMIT",
             sqlite3SelectOpName(pNext->op));
          break;
        }
      }
      if( (p->selFlags & (SF_MultiValue|SF_Values))==0
       && (mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0
       && cnt>mxSelect
      ){
        sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
      }
    }
  }

  /* Attach a With object describing the WITH clause to a Select
  ** object describing the query for which the WITH clause is a prefix.
  */
  static Select *attachWithToSelect(Parse *pParse, Select *pSelect, With *pWith){
    if( pSelect ){
      pSelect->pWith = pWith;
      parserDoubleLinkSelect(pParse, pSelect);
    }else{
      sqlite3WithDelete(pParse->db, pWith);
    }
    return pSelect;
  }

  /* Memory allocator for parser stack resizing.  This is a thin wrapper around
  ** sqlite3_realloc() that includes a call to sqlite3FaultSim() to facilitate
  ** testing.
  */
  static void *parserStackRealloc(
    void *pOld,               /* Prior allocation */
    sqlite3_uint64 newSize,   /* Requested new alloation size */
    Parse *pParse             /* Parsing context */
  ){
    void *p = sqlite3FaultSim(700) ? 0 : sqlite3_realloc(pOld, newSize);
    if( p==0 ) sqlite3OomFault(pParse->db);
    return p;
  }
  static void parserStackFree(void *pOld, Parse *pParse){
    (void)pParse;
    sqlite3_free(pOld); 
  }

  /* Return an integer that is the maximum allowed stack size */
  static int parserStackSizeLimit(Parse *pParse){
    return pParse->db->aLimit[SQLITE_LIMIT_PARSER_DEPTH];
  }
#line 1143 "parse.y"


  /* Construct a new Expr object from a single token */
  static Expr *tokenExpr(Parse *pParse, int op, Token t){
    Expr *p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)+t.n+1);
    if( p ){
      /* memset(p, 0, sizeof(Expr)); */
      p->op = (u8)op;
      p->affExpr = 0;
      p->flags = EP_Leaf;
      ExprClearVVAProperties(p);
      /* p->iAgg = -1; // Not required */
      p->pLeft = p->pRight = 0;
      p->pAggInfo = 0;
      memset(&p->x, 0, sizeof(p->x));
      memset(&p->y, 0, sizeof(p->y));
      p->op2 = 0;
      p->iTable = 0;
      p->iColumn = 0;
      p->u.zToken = (char*)&p[1];
      memcpy(p->u.zToken, t.z, t.n);
      p->u.zToken[t.n] = 0;
      p->w.iOfst = (int)(t.z - pParse->zTail);
      if( sqlite3Isquote(p->u.zToken[0]) ){
        sqlite3DequoteExpr(p);
      }
#if SQLITE_MAX_EXPR_DEPTH>0
      p->nHeight = 1;
#endif  
      if( IN_RENAME_OBJECT ){
        return (Expr*)sqlite3RenameTokenMap(pParse, (void*)p, &t);
      }
    }
    return p;
  }

#line 1391 "parse.y"

  /* Create a TK_ISNULL or TK_NOTNULL expression, perhaps optimized to
  ** to TK_TRUEFALSE, if possible */
  static Expr *sqlite3PExprIsNull(
    Parse *pParse,  /* Parsing context */
    int op,         /* TK_ISNULL or TK_NOTNULL */
    Expr *pLeft     /* Operand */
  ){
    Expr *p = pLeft;
    assert( op==TK_ISNULL || op==TK_NOTNULL );
    assert( pLeft!=0 );
    while( p->op==TK_UPLUS || p->op==TK_UMINUS ){
      p = p->pLeft;
      assert( p!=0 );
    }
    switch( p->op ){
      case TK_INTEGER:
      case TK_STRING:
      case TK_FLOAT:
      case TK_BLOB:
        sqlite3ExprDeferredDelete(pParse, pLeft);
        return sqlite3ExprInt32(pParse->db, op==TK_NOTNULL);
      default:
        break;
    }
    return sqlite3PExpr(pParse, op, pLeft, 0);
  }

  /* Create a TK_IS or TK_ISNOT operator, perhaps optimized to
  ** TK_ISNULL or TK_NOTNULL or TK_TRUEFALSE. */
  static Expr *sqlite3PExprIs(
    Parse *pParse,  /* Parsing context */
    int op,         /* TK_IS or TK_ISNOT */
    Expr *pLeft,    /* Left operand */
    Expr *pRight    /* Right operand */
  ){
    if( pRight && pRight->op==TK_NULL ){
      sqlite3ExprDeferredDelete(pParse, pRight);
      return sqlite3PExprIsNull(pParse, op==TK_IS ? TK_ISNULL : TK_NOTNULL, pLeft);
    }
    return sqlite3PExpr(pParse, op, pLeft, pRight);
  }
#line 1667 "parse.y"

  /* Add a single new term to an ExprList that is used to store a
  ** list of identifiers.  Report an error if the ID list contains
  ** a COLLATE clause or an ASC or DESC keyword, except ignore the
  ** error while parsing a legacy schema.
  */
  static ExprList *parserAddExprIdListTerm(
    Parse *pParse,
    ExprList *pPrior,
    Token *pIdToken,
    int hasCollate,
    int sortOrder
  ){
    ExprList *p = sqlite3ExprListAppend(pParse, pPrior, 0);
    if( (hasCollate || sortOrder!=SQLITE_SO_UNDEFINED)
        && pParse->db->init.busy==0
    ){
      sqlite3ErrorMsg(pParse, "syntax error after column name \"%.*s\"",
                         pIdToken->n, pIdToken->z);
    }
    sqlite3ExprListSetName(pParse, p, pIdToken, 1);
    return p;
  }
#line 2161 "parse.y"

#if TK_SPAN>255
# error too many tokens in the grammar
#endif
#line 304 "parse.c"
/**************** End of %include directives **********************************/
/* These constants specify the various numeric values for terminal symbols.
***************** Begin token definitions *************************************/
#ifndef TK_SEMI
#define TK_SEMI                            1
#define TK_EXPLAIN                         2
#define TK_QUERY                           3
#define TK_PLAN                            4
#define TK_BEGIN                           5
#define TK_TRANSACTION                     6
#define TK_DEFERRED                        7
#define TK_IMMEDIATE                       8
#define TK_EXCLUSIVE                       9
#define TK_COMMIT                         10
#define TK_END                            11
#define TK_ROLLBACK                       12
#define TK_SAVEPOINT                      13
#define TK_RELEASE                        14
#define TK_TO                             15
#define TK_TABLE                          16
#define TK_CREATE                         17
#define TK_IF                             18
#define TK_NOT                            19
#define TK_EXISTS                         20
#define TK_TEMP                           21
#define TK_LP                             22
#define TK_RP                             23
#define TK_AS                             24
#define TK_COMMA                          25
#define TK_WITHOUT                        26
#define TK_ABORT                          27
#define TK_ACTION                         28
#define TK_AFTER                          29
#define TK_ANALYZE                        30
#define TK_ASC                            31
#define TK_ATTACH                         32
#define TK_BEFORE                         33
#define TK_BY                             34
#define TK_CASCADE                        35
#define TK_CAST                           36
#define TK_CONFLICT                       37
#define TK_DATABASE                       38
#define TK_DESC                           39
#define TK_DETACH                         40
#define TK_EACH                           41
#define TK_FAIL                           42
#define TK_OR                             43
#define TK_AND                            44
#define TK_IS                             45
#define TK_ISNOT                          46
#define TK_MATCH                          47
#define TK_LIKE_KW                        48
#define TK_BETWEEN                        49
#define TK_IN                             50
#define TK_ISNULL                         51
#define TK_NOTNULL                        52
#define TK_NE                             53
#define TK_EQ                             54
#define TK_GT                             55
#define TK_LE                             56
#define TK_LT                             57
#define TK_GE                             58
#define TK_ESCAPE                         59
#define TK_ID                             60
#define TK_COLUMNKW                       61
#define TK_DO                             62
#define TK_FOR                            63
#define TK_IGNORE                         64
#define TK_INITIALLY                      65
#define TK_INSTEAD                        66
#define TK_NO                             67
#define TK_KEY                            68
#define TK_OF                             69
#define TK_OFFSET                         70
#define TK_PRAGMA                         71
#define TK_RAISE                          72
#define TK_RECURSIVE                      73
#define TK_REPLACE                        74
#define TK_RESTRICT                       75
#define TK_ROW                            76
#define TK_ROWS                           77
#define TK_TRIGGER                        78
#define TK_VACUUM                         79
#define TK_VIEW                           80
#define TK_VIRTUAL                        81
#define TK_WITH                           82
#define TK_NULLS                          83
#define TK_FIRST                          84
#define TK_LAST                           85
#define TK_CURRENT                        86
#define TK_FOLLOWING                      87
#define TK_PARTITION                      88
#define TK_PRECEDING                      89
#define TK_RANGE                          90
#define TK_UNBOUNDED                      91
#define TK_EXCLUDE                        92
#define TK_GROUPS                         93
#define TK_OTHERS                         94
#define TK_TIES                           95
#define TK_GENERATED                      96
#define TK_ALWAYS                         97
#define TK_MATERIALIZED                   98
#define TK_REINDEX                        99
#define TK_RENAME                         100
#define TK_CTIME_KW                       101
#define TK_ANY                            102
#define TK_BITAND                         103
#define TK_BITOR                          104
#define TK_LSHIFT                         105
#define TK_RSHIFT                         106
#define TK_PLUS                           107
#define TK_MINUS                          108
#define TK_STAR                           109
#define TK_SLASH                          110
#define TK_REM                            111
#define TK_CONCAT                         112
#define TK_PTR                            113
#define TK_COLLATE                        114
#define TK_BITNOT                         115
#define TK_ON                             116
#define TK_INDEXED                        117
#define TK_STRING                         118
#define TK_JOIN_KW                        119
#define TK_CONSTRAINT                     120
#define TK_DEFAULT                        121
#define TK_NULL                           122
#define TK_PRIMARY                        123
#define TK_UNIQUE                         124
#define TK_CHECK                          125
#define TK_REFERENCES                     126
#define TK_AUTOINCR                       127
#define TK_INSERT                         128
#define TK_DELETE                         129
#define TK_UPDATE                         130
#define TK_SET                            131
#define TK_DEFERRABLE                     132
#define TK_FOREIGN                        133
#define TK_DROP                           134
#define TK_UNION                          135
#define TK_ALL                            136
#define TK_EXCEPT                         137
#define TK_INTERSECT                      138
#define TK_SELECT                         139
#define TK_VALUES                         140
#define TK_DISTINCT                       141
#define TK_DOT                            142
#define TK_FROM                           143
#define TK_JOIN                           144
#define TK_USING                          145
#define TK_ORDER                          146
#define TK_GROUP                          147
#define TK_HAVING                         148
#define TK_LIMIT                          149
#define TK_WHERE                          150
#define TK_RETURNING                      151
#define TK_INTO                           152
#define TK_NOTHING                        153
#define TK_FLOAT                          154
#define TK_BLOB                           155
#define TK_INTEGER                        156
#define TK_VARIABLE                       157
#define TK_CASE                           158
#define TK_WHEN                           159
#define TK_THEN                           160
#define TK_ELSE                           161
#define TK_INDEX                          162
#define TK_ALTER                          163
#define TK_ADD                            164
#define TK_WINDOW                         165
#define TK_OVER                           166
#define TK_FILTER                         167
#define TK_COLUMN                         168
#define TK_AGG_FUNCTION                   169
#define TK_AGG_COLUMN                     170
#define TK_TRUEFALSE                      171
#define TK_FUNCTION                       172
#define TK_UPLUS                          173
#define TK_UMINUS                         174
#define TK_TRUTH                          175
#define TK_REGISTER                       176
#define TK_VECTOR                         177
#define TK_SELECT_COLUMN                  178
#define TK_IF_NULL_ROW                    179
#define TK_ASTERISK                       180
#define TK_SPAN                           181
#define TK_ERROR                          182
#define TK_QNUMBER                        183
#define TK_SPACE                          184
#define TK_COMMENT                        185
#define TK_ILLEGAL                        186
#endif
/**************** End token definitions ***************************************/

/* The next sections is a series of control #defines.
** various aspects of the generated parser.
**    YYCODETYPE         is the data type used to store the integer codes
**                       that represent terminal and non-terminal symbols.
**                       "unsigned char" is used if there are fewer than
**                       256 symbols.  Larger types otherwise.
**    YYNOCODE           is a number of type YYCODETYPE that is not used for
**                       any terminal or nonterminal symbol.
**    YYFALLBACK         If defined, this indicates that one or more tokens
**                       (also known as: "terminal symbols") have fall-back
**                       values which should be used if the original symbol
**                       would not parse.  This permits keywords to sometimes
**                       be used as identifiers, for example.
**    YYACTIONTYPE       is the data type used for "action codes" - numbers
**                       that indicate what to do in response to the next
**                       token.
**    sqlite3ParserTOKENTYPE     is the data type used for minor type for terminal
**                       symbols.  Background: A "minor type" is a semantic
**                       value associated with a terminal or non-terminal
**                       symbols.  For example, for an "ID" terminal symbol,
**                       the minor type might be the name of the identifier.
**                       Each non-terminal can have a different minor type.
**                       Terminal symbols all have the same minor type, though.
**                       This macros defines the minor type for terminal 
**                       symbols.
**    YYMINORTYPE        is the data type used for all minor types.
**                       This is typically a union of many types, one of
**                       which is sqlite3ParserTOKENTYPE.  The entry in the union
**                       for terminal symbols is called "yy0".
**    YYSTACKDEPTH       is the maximum depth of the parser's stack.  If
**                       zero the stack is dynamically sized using realloc()
**    sqlite3ParserARG_SDECL     A static variable declaration for the %extra_argument
**    sqlite3ParserARG_PDECL     A parameter declaration for the %extra_argument
**    sqlite3ParserARG_PARAM     Code to pass %extra_argument as a subroutine parameter
**    sqlite3ParserARG_STORE     Code to store %extra_argument into yypParser
**    sqlite3ParserARG_FETCH     Code to extract %extra_argument from yypParser
**    sqlite3ParserCTX_*         As sqlite3ParserARG_ except for %extra_context
**    YYREALLOC          Name of the realloc() function to use
**    YYFREE             Name of the free() function to use
**    YYDYNSTACK         True if stack space should be extended on heap
**    YYERRORSYMBOL      is the code number of the error symbol.  If not
**                       defined, then do no error processing.
**    YYNSTATE           the combined number of states.
**    YYNRULE            the number of rules in the grammar
**    YYNTOKEN           Number of terminal symbols
**    YY_MAX_SHIFT       Maximum value for shift actions
**    YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions
**    YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions
**    YY_ERROR_ACTION    The yy_action[] code for syntax error
**    YY_ACCEPT_ACTION   The yy_action[] code for accept
**    YY_NO_ACTION       The yy_action[] code for no-op
**    YY_MIN_REDUCE      Minimum value for reduce actions
**    YY_MAX_REDUCE      Maximum value for reduce actions
**    YY_MIN_DSTRCTR     Minimum symbol value that has a destructor
**    YY_MAX_DSTRCTR     Maximum symbol value that has a destructor
*/
#ifndef INTERFACE
# define INTERFACE 1
#endif
/************* Begin control #defines *****************************************/
#define YYCODETYPE unsigned short int
#define YYNOCODE 322
#define YYACTIONTYPE unsigned short int
#define YYWILDCARD 102
#define sqlite3ParserTOKENTYPE Token
typedef union {
  int yyinit;
  sqlite3ParserTOKENTYPE yy0;
  ExprList* yy14;
  With* yy59;
  Cte* yy67;
  Upsert* yy122;
  IdList* yy132;
  int yy144;
  const char* yy168;
  SrcList* yy203;
  Window* yy211;
  OnOrUsing yy269;
  struct TrigEvent yy286;
  struct {int value; int mask;} yy383;
  u32 yy391;
  TriggerStep* yy427;
  Expr* yy454;
  u8 yy462;
  struct FrameBound yy509;
  Select* yy555;
} YYMINORTYPE;
#ifndef YYSTACKDEPTH
#define YYSTACKDEPTH 50
#endif
#define sqlite3ParserARG_SDECL
#define sqlite3ParserARG_PDECL
#define sqlite3ParserARG_PARAM
#define sqlite3ParserARG_FETCH
#define sqlite3ParserARG_STORE
#undef YYREALLOC
#define YYREALLOC parserStackRealloc
#undef YYFREE
#define YYFREE parserStackFree
#undef YYDYNSTACK
#define YYDYNSTACK 1
#undef YYSIZELIMIT
#define YYSIZELIMIT parserStackSizeLimit
#define sqlite3ParserCTX(P) ((P)->pParse)
#define sqlite3ParserCTX_SDECL Parse *pParse;
#define sqlite3ParserCTX_PDECL ,Parse *pParse
#define sqlite3ParserCTX_PARAM ,pParse
#define sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse;
#define sqlite3ParserCTX_STORE yypParser->pParse=pParse;
#undef YYERRORSYMBOL
#undef YYERRSYMDT
#undef YYFALLBACK
#define YYFALLBACK 1
#define YYNSTATE             600
#define YYNRULE              412
#define YYNRULE_WITH_ACTION  348
#define YYNTOKEN             187
#define YY_MAX_SHIFT         599
#define YY_MIN_SHIFTREDUCE   867
#define YY_MAX_SHIFTREDUCE   1278
#define YY_ERROR_ACTION      1279
#define YY_ACCEPT_ACTION     1280
#define YY_NO_ACTION         1281
#define YY_MIN_REDUCE        1282
#define YY_MAX_REDUCE        1693
#define YY_MIN_DSTRCTR       206
#define YY_MAX_DSTRCTR       319
/************* End control #defines *******************************************/
#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))

/* Define the yytestcase() macro to be a no-op if is not already defined
** otherwise.
**
** Applications can choose to define yytestcase() in the %include section
** to a macro that can assist in verifying code coverage.  For production
** code the yytestcase() macro should be turned off.  But it is useful
** for testing.
*/
#ifndef yytestcase
# define yytestcase(X)
#endif

/* Macro to determine if stack space has the ability to grow using
** heap memory.
*/
#if YYSTACKDEPTH<=0 || YYDYNSTACK
# define YYGROWABLESTACK 1
#else
# define YYGROWABLESTACK 0
#endif

/* Guarantee a minimum number of initial stack slots.
*/
#if YYSTACKDEPTH<=0
# undef YYSTACKDEPTH
# define YYSTACKDEPTH 2  /* Need a minimum stack size */
#endif


/* Next are the tables used to determine what action to take based on the
** current state and lookahead token.  These tables are used to implement
** functions that take a state number and lookahead value and return an
** action integer.  
**
** Suppose the action integer is N.  Then the action is determined as
** follows
**
**   0 <= N <= YY_MAX_SHIFT             Shift N.  That is, push the lookahead
**                                      token onto the stack and goto state N.
**
**   N between YY_MIN_SHIFTREDUCE       Shift to an arbitrary state then
**     and YY_MAX_SHIFTREDUCE           reduce by rule N-YY_MIN_SHIFTREDUCE.
**
**   N == YY_ERROR_ACTION               A syntax error has occurred.
**
**   N == YY_ACCEPT_ACTION              The parser accepts its input.
**
**   N == YY_NO_ACTION                  No such action.  Denotes unused
**                                      slots in the yy_action[] table.
**
**   N between YY_MIN_REDUCE            Reduce by rule N-YY_MIN_REDUCE
**     and YY_MAX_REDUCE
**
** The action table is constructed as a single large table named yy_action[].
** Given state S and lookahead X, the action is computed as either:
**
**    (A)   N = yy_action[ yy_shift_ofst[S] + X ]
**    (B)   N = yy_default[S]
**
** The (A) formula is preferred.  The B formula is used instead if
** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X.
**
** The formulas above are for computing the action when the lookahead is
** a terminal symbol.  If the lookahead is a non-terminal (as occurs after
** a reduce action) then the yy_reduce_ofst[] array is used in place of
** the yy_shift_ofst[] array.
**
** The following are the tables generated in this section:
**
**  yy_action[]        A single table containing all actions.
**  yy_lookahead[]     A table containing the lookahead for each entry in
**                     yy_action.  Used to detect hash collisions.
**  yy_shift_ofst[]    For each state, the offset into yy_action for
**                     shifting terminals.
**  yy_reduce_ofst[]   For each state, the offset into yy_action for
**                     shifting non-terminals after a reduce.
**  yy_default[]       Default action for each state.
**
*********** Begin parsing tables **********************************************/
#define YY_ACTTAB_COUNT (2379)
static const YYACTIONTYPE yy_action[] = {
 /*     0 */   134,  131,  238,  290,  290, 1353,  593, 1332,  478, 1606,
 /*    10 */   593, 1315,  593,    7,  593, 1353,  590,  593,  579,  424,
 /*    20 */  1566,  134,  131,  238, 1318,  541,  478,  477,  575,   84,
 /*    30 */    84, 1005,  303,   84,   84,   51,   51,   63,   63, 1006,
 /*    40 */    84,   84,  498,  141,  142,   93,  442, 1254, 1254, 1085,
 /*    50 */  1088, 1075, 1075,  139,  139,  140,  140,  140,  140,  424,
 /*    60 */   296,  296,  498,  296,  296,  567,  553,  296,  296, 1306,
 /*    70 */   574, 1358, 1358,  590,  542,  579,  590,  574,  579,  548,
 /*    80 */   590, 1304,  579,  141,  142,   93,  576, 1254, 1254, 1085,
 /*    90 */  1088, 1075, 1075,  139,  139,  140,  140,  140,  140,  399,
 /*   100 */   478,  395,    6,  138,  138,  138,  138,  137,  137,  136,
 /*   110 */   136,  136,  135,  132,  463,   44,  342,  593,  305, 1127,
 /*   120 */  1280,    1,    1,  599,    2, 1284,  598, 1200, 1284, 1200,
 /*   130 */   330,  424,  158,  330, 1613,  158,  390,  116,  308, 1366,
 /*   140 */    51,   51, 1366,  138,  138,  138,  138,  137,  137,  136,
 /*   150 */   136,  136,  135,  132,  463,  141,  142,   93,  515, 1254,
 /*   160 */  1254, 1085, 1088, 1075, 1075,  139,  139,  140,  140,  140,
 /*   170 */   140, 1230,  329,  584,  296,  296,  212,  296,  296,  568,
 /*   180 */   568,  488,  143, 1072, 1072, 1086, 1089,  590, 1195,  579,
 /*   190 */   590,  340,  579,  140,  140,  140,  140,  133,  392,  564,
 /*   200 */   536, 1195,  250,  425, 1195,  250,  137,  137,  136,  136,
 /*   210 */   136,  135,  132,  463,  291,  138,  138,  138,  138,  137,
 /*   220 */   137,  136,  136,  136,  135,  132,  463,  966, 1230, 1231,
 /*   230 */  1230,  412,  965,  467,  412,  424,  467,  489,  357, 1611,
 /*   240 */   391,  138,  138,  138,  138,  137,  137,  136,  136,  136,
 /*   250 */   135,  132,  463,  463,  134,  131,  238,  555, 1076,  141,
 /*   260 */   142,   93,  593, 1254, 1254, 1085, 1088, 1075, 1075,  139,
 /*   270 */   139,  140,  140,  140,  140, 1317,  134,  131,  238,  424,
 /*   280 */   549, 1597, 1531,  333,   97,   83,   83,  140,  140,  140,
 /*   290 */   140,  138,  138,  138,  138,  137,  137,  136,  136,  136,
 /*   300 */   135,  132,  463,  141,  142,   93, 1657, 1254, 1254, 1085,
 /*   310 */  1088, 1075, 1075,  139,  139,  140,  140,  140,  140,  138,
 /*   320 */   138,  138,  138,  137,  137,  136,  136,  136,  135,  132,
 /*   330 */   463,  591, 1230,  958,  958,  138,  138,  138,  138,  137,
 /*   340 */   137,  136,  136,  136,  135,  132,  463,   44,  398,  547,
 /*   350 */  1306,  136,  136,  136,  135,  132,  463,  386,  593,  442,
 /*   360 */   595,  145,  595,  138,  138,  138,  138,  137,  137,  136,
 /*   370 */   136,  136,  135,  132,  463,  500, 1230,  112,  550,  460,
 /*   380 */   459,   51,   51,  424,  296,  296,  479,  334, 1259, 1230,
 /*   390 */  1231, 1230, 1599, 1261,  388,  312,  444,  590,  246,  579,
 /*   400 */   546, 1260,  271,  235,  329,  584,  551,  141,  142,   93,
 /*   410 */   429, 1254, 1254, 1085, 1088, 1075, 1075,  139,  139,  140,
 /*   420 */   140,  140,  140,   22,   22, 1230, 1262,  424, 1262,  216,
 /*   430 */   296,  296,   98, 1230, 1231, 1230,  264,  884,   45,  528,
 /*   440 */   525,  524, 1041,  590, 1269,  579,  421,  420,  393,  523,
 /*   450 */    44,  141,  142,   93,  498, 1254, 1254, 1085, 1088, 1075,
 /*   460 */  1075,  139,  139,  140,  140,  140,  140,  138,  138,  138,
 /*   470 */   138,  137,  137,  136,  136,  136,  135,  132,  463,  593,
 /*   480 */  1611,  561, 1230, 1231, 1230,   23,  264,  515,  200,  528,
 /*   490 */   525,  524,  127,  585,  509,    4,  355,  487,  506,  523,
 /*   500 */   593,  498,   84,   84,  134,  131,  238,  329,  584,  588,
 /*   510 */  1627,  138,  138,  138,  138,  137,  137,  136,  136,  136,
 /*   520 */   135,  132,  463,   19,   19,  435, 1230, 1460,  297,  297,
 /*   530 */   311,  424, 1565,  464, 1631,  599,    2, 1284,  437,  574,
 /*   540 */  1107,  590,  330,  579,  158,  582,  489,  357,  573,  593,
 /*   550 */   592, 1366,  409, 1274, 1230,  141,  142,   93, 1364, 1254,
 /*   560 */  1254, 1085, 1088, 1075, 1075,  139,  139,  140,  140,  140,
 /*   570 */   140,  389,   84,   84, 1062,  567, 1230,  313, 1523,  593,
 /*   580 */   125,  125,  970, 1230, 1231, 1230,  296,  296,  126,   46,
 /*   590 */   464,  594,  464,  296,  296, 1050, 1230,  218,  439,  590,
 /*   600 */  1604,  579,   84,   84,    7,  403,  590,  515,  579,  325,
 /*   610 */   417, 1230, 1231, 1230,  250,  138,  138,  138,  138,  137,
 /*   620 */   137,  136,  136,  136,  135,  132,  463, 1050, 1050, 1052,
 /*   630 */  1053,   35, 1275, 1230, 1231, 1230,  424, 1370,  993,  574,
 /*   640 */   371,  414,  274,  412, 1597,  467, 1302,  552,  451,  590,
 /*   650 */   543,  579, 1530, 1230, 1231, 1230, 1214,  201,  409, 1174,
 /*   660 */   141,  142,   93,  223, 1254, 1254, 1085, 1088, 1075, 1075,
 /*   670 */   139,  139,  140,  140,  140,  140,  296,  296, 1250,  593,
 /*   680 */   424,  296,  296,  236,  529,  296,  296,  515,  100,  590,
 /*   690 */  1600,  579,   48, 1605,  590, 1230,  579,    7,  590,  577,
 /*   700 */   579,  904,   84,   84,  141,  142,   93,  496, 1254, 1254,
 /*   710 */  1085, 1088, 1075, 1075,  139,  139,  140,  140,  140,  140,
 /*   720 */   138,  138,  138,  138,  137,  137,  136,  136,  136,  135,
 /*   730 */   132,  463, 1365, 1230,  296,  296, 1250,  115, 1275,  326,
 /*   740 */   233,  539, 1062,   40,  282,  127,  585,  590,    4,  579,
 /*   750 */   329,  584, 1230, 1231, 1230, 1598,  593,  388,  904, 1051,
 /*   760 */  1356, 1356,  588, 1050,  138,  138,  138,  138,  137,  137,
 /*   770 */   136,  136,  136,  135,  132,  463,  185,  593, 1230,   19,
 /*   780 */    19, 1230,  971, 1597,  424, 1651,  464,  129,  908, 1195,
 /*   790 */  1230, 1231, 1230, 1325,  443, 1050, 1050, 1052,  582, 1603,
 /*   800 */   149,  149, 1195,    7,    5, 1195, 1687,  410,  141,  142,
 /*   810 */    93, 1536, 1254, 1254, 1085, 1088, 1075, 1075,  139,  139,
 /*   820 */   140,  140,  140,  140, 1214,  397,  593, 1062,  424, 1536,
 /*   830 */  1538,   50,  901,  125,  125, 1230, 1231, 1230, 1230, 1231,
 /*   840 */  1230,  126, 1230,  464,  594,  464,  515, 1230, 1050,   84,
 /*   850 */    84,    3,  141,  142,   93,  924, 1254, 1254, 1085, 1088,
 /*   860 */  1075, 1075,  139,  139,  140,  140,  140,  140,  138,  138,
 /*   870 */   138,  138,  137,  137,  136,  136,  136,  135,  132,  463,
 /*   880 */  1050, 1050, 1052, 1053,   35,  442,  457,  532,  433, 1230,
 /*   890 */  1062, 1361,  540,  540, 1598,  925,  388,    7, 1129, 1230,
 /*   900 */  1231, 1230, 1129, 1536, 1230, 1231, 1230, 1051,  570, 1214,
 /*   910 */   593, 1050,  138,  138,  138,  138,  137,  137,  136,  136,
 /*   920 */   136,  135,  132,  463,    6,  185, 1195, 1230,  231,  593,
 /*   930 */   382,  992,  424,  151,  151,  510, 1213,  557,  482, 1195,
 /*   940 */   381,  160, 1195, 1050, 1050, 1052, 1230, 1231, 1230,  422,
 /*   950 */   593,  447,   84,   84,  593,  217,  141,  142,   93,  593,
 /*   960 */  1254, 1254, 1085, 1088, 1075, 1075,  139,  139,  140,  140,
 /*   970 */   140,  140, 1214,   19,   19,  593,  424,   19,   19,  442,
 /*   980 */  1063,  442,   19,   19, 1230, 1231, 1230,  515,  445,  458,
 /*   990 */  1597,  386,  315, 1175, 1685,  556, 1685,  450,   84,   84,
 /*  1000 */   141,  142,   93,  505, 1254, 1254, 1085, 1088, 1075, 1075,
 /*  1010 */   139,  139,  140,  140,  140,  140,  138,  138,  138,  138,
 /*  1020 */   137,  137,  136,  136,  136,  135,  132,  463,  442, 1147,
 /*  1030 */   454, 1597,  362, 1041,  593,  462, 1460, 1233,   47, 1393,
 /*  1040 */   324,  565,  565,  115, 1148,  449,    7,  460,  459,  307,
 /*  1050 */   375,  354,  593,  113,  593,  329,  584,   19,   19, 1149,
 /*  1060 */   138,  138,  138,  138,  137,  137,  136,  136,  136,  135,
 /*  1070 */   132,  463,  209, 1173,  563,   19,   19,   19,   19,   49,
 /*  1080 */   424,  944, 1175, 1686, 1046, 1686,  218,  355,  484,  343,
 /*  1090 */   210,  945,  569,  562, 1262, 1233, 1262,  490,  314,  423,
 /*  1100 */   424, 1598, 1206,  388,  141,  142,   93,  440, 1254, 1254,
 /*  1110 */  1085, 1088, 1075, 1075,  139,  139,  140,  140,  140,  140,
 /*  1120 */   352,  316,  531,  316,  141,  142,   93,  549, 1254, 1254,
 /*  1130 */  1085, 1088, 1075, 1075,  139,  139,  140,  140,  140,  140,
 /*  1140 */   446,   10, 1598,  274,  388,  915,  281,  299,  383,  534,
 /*  1150 */   378,  533,  269,  593, 1206,  587,  587,  587,  374,  293,
 /*  1160 */  1579,  991, 1173,  302,  138,  138,  138,  138,  137,  137,
 /*  1170 */   136,  136,  136,  135,  132,  463,   53,   53,  520, 1250,
 /*  1180 */   593, 1147, 1576,  431,  138,  138,  138,  138,  137,  137,
 /*  1190 */   136,  136,  136,  135,  132,  463, 1148,  301,  593, 1577,
 /*  1200 */   593, 1307,  431,   54,   54,  593,  268,  593,  461,  461,
 /*  1210 */   461, 1149,  347,  492,  424,  135,  132,  463, 1146, 1195,
 /*  1220 */   474,   68,   68,   69,   69,  550,  332,  287,   21,   21,
 /*  1230 */    55,   55, 1195,  581,  424, 1195,  309, 1250,  141,  142,
 /*  1240 */    93,  119, 1254, 1254, 1085, 1088, 1075, 1075,  139,  139,
 /*  1250 */   140,  140,  140,  140,  593,  237,  480, 1476,  141,  142,
 /*  1260 */    93,  593, 1254, 1254, 1085, 1088, 1075, 1075,  139,  139,
 /*  1270 */   140,  140,  140,  140,  344,  430,  346,   70,   70,  494,
 /*  1280 */   991, 1132, 1132,  512,   56,   56, 1269,  593,  268,  593,
 /*  1290 */   369,  374,  593,  481,  215,  384, 1624,  481,  138,  138,
 /*  1300 */   138,  138,  137,  137,  136,  136,  136,  135,  132,  463,
 /*  1310 */    71,   71,   72,   72,  225,   73,   73,  593,  138,  138,
 /*  1320 */   138,  138,  137,  137,  136,  136,  136,  135,  132,  463,
 /*  1330 */   586,  431,  593,  872,  873,  874,  593,  911,  593, 1602,
 /*  1340 */    74,   74,  593,    7, 1460,  242,  593,  306,  424, 1578,
 /*  1350 */   472,  306,  364,  219,  367,   75,   75,  430,  345,   57,
 /*  1360 */    57,   58,   58,  432,  187,   59,   59,  593,  424,   61,
 /*  1370 */    61, 1475,  141,  142,   93,  123, 1254, 1254, 1085, 1088,
 /*  1380 */  1075, 1075,  139,  139,  140,  140,  140,  140,  424,  570,
 /*  1390 */    62,   62,  141,  142,   93,  911, 1254, 1254, 1085, 1088,
 /*  1400 */  1075, 1075,  139,  139,  140,  140,  140,  140,  161,  384,
 /*  1410 */  1624, 1474,  141,  130,   93,  441, 1254, 1254, 1085, 1088,
 /*  1420 */  1075, 1075,  139,  139,  140,  140,  140,  140,  267,  266,
 /*  1430 */   265, 1460,  138,  138,  138,  138,  137,  137,  136,  136,
 /*  1440 */   136,  135,  132,  463,  593, 1336,  593, 1269, 1460,  384,
 /*  1450 */  1624,  231,  138,  138,  138,  138,  137,  137,  136,  136,
 /*  1460 */   136,  135,  132,  463,  593,  163,  593,   76,   76,   77,
 /*  1470 */    77,  593,  138,  138,  138,  138,  137,  137,  136,  136,
 /*  1480 */   136,  135,  132,  463,  475,  593,  483,   78,   78,   20,
 /*  1490 */    20, 1249,  424,  491,   79,   79,  495,  422,  295,  235,
 /*  1500 */  1574,   38,  511,  896,  422,  335,  240,  422,  147,  147,
 /*  1510 */   112,  593,  424,  593,  101,  222,  991,  142,   93,  455,
 /*  1520 */  1254, 1254, 1085, 1088, 1075, 1075,  139,  139,  140,  140,
 /*  1530 */   140,  140,  593,   39,  148,  148,   80,   80,   93,  551,
 /*  1540 */  1254, 1254, 1085, 1088, 1075, 1075,  139,  139,  140,  140,
 /*  1550 */   140,  140,  328,  923,  922,   64,   64,  502, 1656, 1005,
 /*  1560 */   933,  896,  124,  422,  121,  254,  593, 1006,  593,  226,
 /*  1570 */   593,  127,  585,  164,    4,   16,  138,  138,  138,  138,
 /*  1580 */   137,  137,  136,  136,  136,  135,  132,  463,  588,   81,
 /*  1590 */    81,   65,   65,   82,   82,  593,  138,  138,  138,  138,
 /*  1600 */   137,  137,  136,  136,  136,  135,  132,  463,  593,  226,
 /*  1610 */   237,  966,  464,  593,  298,  593,  965,  593,   66,   66,
 /*  1620 */   593, 1170,  593,  411,  582,  353,  469,  115,  593,  471,
 /*  1630 */   169,  173,  173,  593,   44,  991,  174,  174,   89,   89,
 /*  1640 */    67,   67,  593,   85,   85,  150,  150, 1114, 1043,  593,
 /*  1650 */   273,   86,   86, 1062,  593,  503,  171,  171,  593,  125,
 /*  1660 */   125,  497,  593,  273,  336,  152,  152,  126, 1335,  464,
 /*  1670 */   594,  464,  146,  146, 1050,  593,  545,  172,  172,  593,
 /*  1680 */  1054,  165,  165,  256,  339,  156,  156,  127,  585, 1586,
 /*  1690 */     4,  329,  584,  499,  358,  273,  115,  348,  155,  155,
 /*  1700 */   930,  931,  153,  153,  588, 1114, 1050, 1050, 1052, 1053,
 /*  1710 */    35, 1554,  521,  593,  270, 1008, 1009,    9,  593,  372,
 /*  1720 */   593,  115,  593,  168,  593,  115,  593, 1110,  464,  270,
 /*  1730 */   996,  964,  273,  129, 1645, 1214,  154,  154, 1054, 1404,
 /*  1740 */   582,   88,   88,   90,   90,   87,   87,   52,   52,   60,
 /*  1750 */    60, 1405,  504,  537,  559, 1179,  961,  507,  129,  558,
 /*  1760 */   127,  585, 1126,    4, 1126, 1125,  894, 1125,  162, 1062,
 /*  1770 */   963,  359,  129, 1401,  363,  125,  125,  588,  366,  368,
 /*  1780 */   370, 1349, 1334,  126, 1333,  464,  594,  464,  377,  387,
 /*  1790 */  1050, 1391, 1414, 1618, 1459, 1387, 1399,  208,  580, 1464,
 /*  1800 */  1314,  464,  243,  516, 1305, 1293, 1384, 1292, 1294, 1638,
 /*  1810 */   288,  170,  228,  582,   12,  408,  321,  322,  241,  323,
 /*  1820 */   245, 1446, 1050, 1050, 1052, 1053,   35,  559,  304,  350,
 /*  1830 */   351,  501,  560,  127,  585, 1441,    4, 1451, 1434,  310,
 /*  1840 */  1450,  526, 1062, 1332,  415,  380,  232, 1527,  125,  125,
 /*  1850 */   588, 1214, 1396,  356, 1526,  583,  126, 1397,  464,  594,
 /*  1860 */   464, 1641,  535, 1050, 1581, 1395, 1269, 1583, 1582,  213,
 /*  1870 */   402,  277,  214,  227,  464, 1573,  239, 1571, 1266, 1394,
 /*  1880 */   434,  198,  100,  224,   96,  183,  582,  191,  485,  193,
 /*  1890 */   486,  194,  195,  196,  519, 1050, 1050, 1052, 1053,   35,
 /*  1900 */   559,  113,  252,  413, 1447,  558,  493,   13, 1455,  416,
 /*  1910 */  1453, 1452,   14,  202, 1521, 1062, 1532,  508,  258,  106,
 /*  1920 */   514,  125,  125,   99, 1214, 1543,  289,  260,  206,  126,
 /*  1930 */   365,  464,  594,  464,  361,  517, 1050,  261,  448, 1295,
 /*  1940 */   262,  418, 1352, 1351,  108, 1350, 1655, 1654, 1343,  915,
 /*  1950 */   419, 1322,  233,  452,  319,  379, 1321,  453, 1623,  320,
 /*  1960 */  1320,  275, 1653,  544,  276, 1609, 1608, 1342, 1050, 1050,
 /*  1970 */  1052, 1053,   35, 1630, 1218,  466,  385,  456,  300, 1419,
 /*  1980 */   144, 1418,  570,  407,  407,  406,  284,  404,   11, 1508,
 /*  1990 */   881,  396,  120,  127,  585,  394,    4, 1214,  327,  114,
 /*  2000 */  1375, 1374,  220,  247,  400,  338,  401,  554,   42, 1224,
 /*  2010 */   588,  596,  283,  337,  285,  286,  188,  597, 1290, 1285,
 /*  2020 */   175, 1558,  176, 1559, 1557, 1556,  159,  317,  229,  177,
 /*  2030 */   868,  230,   91,  465,  464,  221,  331,  468, 1165,  470,
 /*  2040 */   473,   94,  244,   95,  249,  189,  582, 1124, 1122,  341,
 /*  2050 */   427,  190,  178, 1249,  179,   43,  192,  947,  349,  428,
 /*  2060 */  1138,  197,  251,  180,  181,  436,  102,  182,  438,  103,
 /*  2070 */   104,  199,  248, 1140,  253, 1062,  105,  255, 1137,  166,
 /*  2080 */    24,  125,  125,  257, 1264,  273,  360,  513,  259,  126,
 /*  2090 */    15,  464,  594,  464,  204,  883, 1050,  518,  263,  373,
 /*  2100 */   381,   92,  585, 1130,    4,  203,  205,  426,  107,  522,
 /*  2110 */    25,   26,  329,  584,  913,  572,  527,  376,  588,  926,
 /*  2120 */   530,  109,  184,  318,  167,  110,   27,  538, 1050, 1050,
 /*  2130 */  1052, 1053,   35, 1211, 1091,   17,  476,  111, 1181,  234,
 /*  2140 */   292, 1180,  464,  294,  207,  994,  129, 1201,  272, 1000,
 /*  2150 */    28, 1197,   29,   30,  582, 1199, 1205, 1214,   31, 1204,
 /*  2160 */    32, 1186,   41,  566,   33, 1105,  211,    8,  115, 1092,
 /*  2170 */  1090, 1094,   34,  278,  578, 1095,  117,  122,  118, 1145,
 /*  2180 */    36,   18,  128, 1062, 1055,  895,  957,   37,  589,  125,
 /*  2190 */   125,  279,  186,  280, 1646,  157,  405,  126, 1220,  464,
 /*  2200 */   594,  464, 1218,  466, 1050, 1219,  300, 1281, 1281, 1281,
 /*  2210 */  1281,  407,  407,  406,  284,  404, 1281, 1281,  881, 1281,
 /*  2220 */   300, 1281, 1281,  571, 1281,  407,  407,  406,  284,  404,
 /*  2230 */  1281,  247,  881,  338, 1281, 1281, 1050, 1050, 1052, 1053,
 /*  2240 */    35,  337, 1281, 1281, 1281,  247, 1281,  338, 1281, 1281,
 /*  2250 */  1281, 1281, 1281, 1281, 1281,  337, 1281, 1281, 1281, 1281,
 /*  2260 */  1281, 1281, 1281, 1281, 1281, 1214, 1281, 1281, 1281, 1281,
 /*  2270 */  1281, 1281,  249, 1281, 1281, 1281, 1281, 1281, 1281, 1281,
 /*  2280 */   178, 1281, 1281,   43, 1281, 1281,  249, 1281, 1281, 1281,
 /*  2290 */  1281, 1281, 1281, 1281,  178, 1281, 1281,   43, 1281, 1281,
 /*  2300 */   248, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281,
 /*  2310 */  1281, 1281, 1281, 1281,  248, 1281, 1281, 1281, 1281, 1281,
 /*  2320 */  1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281,
 /*  2330 */  1281, 1281, 1281, 1281, 1281,  426, 1281, 1281, 1281, 1281,
 /*  2340 */   329,  584, 1281, 1281, 1281, 1281, 1281, 1281, 1281,  426,
 /*  2350 */  1281, 1281, 1281, 1281,  329,  584, 1281, 1281, 1281, 1281,
 /*  2360 */  1281, 1281, 1281, 1281,  476, 1281, 1281, 1281, 1281, 1281,
 /*  2370 */  1281, 1281, 1281, 1281, 1281, 1281, 1281, 1281,  476,
};
static const YYCODETYPE yy_lookahead[] = {
 /*     0 */   277,  278,  279,  241,  242,  225,  195,  227,  195,  312,
 /*    10 */   195,  218,  195,  316,  195,  235,  254,  195,  256,   19,
 /*    20 */   297,  277,  278,  279,  218,  206,  213,  214,  206,  218,
 /*    30 */   219,   31,  206,  218,  219,  218,  219,  218,  219,   39,
 /*    40 */   218,  219,  195,   43,   44,   45,  195,   47,   48,   49,
 /*    50 */    50,   51,   52,   53,   54,   55,   56,   57,   58,   19,
 /*    60 */   241,  242,  195,  241,  242,  195,  255,  241,  242,  195,
 /*    70 */   255,  237,  238,  254,  255,  256,  254,  255,  256,  264,
 /*    80 */   254,  207,  256,   43,   44,   45,  264,   47,   48,   49,
 /*    90 */    50,   51,   52,   53,   54,   55,   56,   57,   58,  251,
 /*   100 */   287,  253,  215,  103,  104,  105,  106,  107,  108,  109,
 /*   110 */   110,  111,  112,  113,  114,   82,  265,  195,  271,   11,
 /*   120 */   187,  188,  189,  190,  191,  192,  190,   87,  192,   89,
 /*   130 */   197,   19,  199,  197,  317,  199,  319,   25,  271,  206,
 /*   140 */   218,  219,  206,  103,  104,  105,  106,  107,  108,  109,
 /*   150 */   110,  111,  112,  113,  114,   43,   44,   45,  195,   47,
 /*   160 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
 /*   170 */    58,   60,  139,  140,  241,  242,  289,  241,  242,  309,
 /*   180 */   310,  294,   70,   47,   48,   49,   50,  254,   77,  256,
 /*   190 */   254,  195,  256,   55,   56,   57,   58,   59,  221,   88,
 /*   200 */   109,   90,  269,  240,   93,  269,  107,  108,  109,  110,
 /*   210 */   111,  112,  113,  114,  215,  103,  104,  105,  106,  107,
 /*   220 */   108,  109,  110,  111,  112,  113,  114,  136,  117,  118,
 /*   230 */   119,  298,  141,  300,  298,   19,  300,  129,  130,  317,
 /*   240 */   318,  103,  104,  105,  106,  107,  108,  109,  110,  111,
 /*   250 */   112,  113,  114,  114,  277,  278,  279,  146,  122,   43,
 /*   260 */    44,   45,  195,   47,   48,   49,   50,   51,   52,   53,
 /*   270 */    54,   55,   56,   57,   58,  218,  277,  278,  279,   19,
 /*   280 */    19,  195,  286,   23,   68,  218,  219,   55,   56,   57,
 /*   290 */    58,  103,  104,  105,  106,  107,  108,  109,  110,  111,
 /*   300 */   112,  113,  114,   43,   44,   45,  232,   47,   48,   49,
 /*   310 */    50,   51,   52,   53,   54,   55,   56,   57,   58,  103,
 /*   320 */   104,  105,  106,  107,  108,  109,  110,  111,  112,  113,
 /*   330 */   114,  135,   60,  137,  138,  103,  104,  105,  106,  107,
 /*   340 */   108,  109,  110,  111,  112,  113,  114,   82,  281,  206,
 /*   350 */   195,  109,  110,  111,  112,  113,  114,  195,  195,  195,
 /*   360 */   205,   22,  207,  103,  104,  105,  106,  107,  108,  109,
 /*   370 */   110,  111,  112,  113,  114,  195,   60,  116,  117,  107,
 /*   380 */   108,  218,  219,   19,  241,  242,  121,   23,  116,  117,
 /*   390 */   118,  119,  306,  121,  308,  206,  234,  254,   15,  256,
 /*   400 */   195,  129,  259,  260,  139,  140,  145,   43,   44,   45,
 /*   410 */   200,   47,   48,   49,   50,   51,   52,   53,   54,   55,
 /*   420 */    56,   57,   58,  218,  219,   60,  154,   19,  156,  265,
 /*   430 */   241,  242,   24,  117,  118,  119,  120,   21,   73,  123,
 /*   440 */   124,  125,   74,  254,   61,  256,  107,  108,  221,  133,
 /*   450 */    82,   43,   44,   45,  195,   47,   48,   49,   50,   51,
 /*   460 */    52,   53,   54,   55,   56,   57,   58,  103,  104,  105,
 /*   470 */   106,  107,  108,  109,  110,  111,  112,  113,  114,  195,
 /*   480 */   317,  318,  117,  118,  119,   22,  120,  195,   22,  123,
 /*   490 */   124,  125,   19,   20,  284,   22,  128,   81,  288,  133,
 /*   500 */   195,  195,  218,  219,  277,  278,  279,  139,  140,   36,
 /*   510 */   195,  103,  104,  105,  106,  107,  108,  109,  110,  111,
 /*   520 */   112,  113,  114,  218,  219,   62,   60,  195,  241,  242,
 /*   530 */   271,   19,  240,   60,  189,  190,  191,  192,  233,  255,
 /*   540 */   124,  254,  197,  256,  199,   72,  129,  130,  264,  195,
 /*   550 */   195,  206,   22,   23,   60,   43,   44,   45,  206,   47,
 /*   560 */    48,   49,   50,   51,   52,   53,   54,   55,   56,   57,
 /*   570 */    58,  195,  218,  219,  101,  195,   60,  271,  162,  195,
 /*   580 */   107,  108,  109,  117,  118,  119,  241,  242,  115,   73,
 /*   590 */   117,  118,  119,  241,  242,  122,   60,  195,  266,  254,
 /*   600 */   312,  256,  218,  219,  316,  203,  254,  195,  256,  255,
 /*   610 */   208,  117,  118,  119,  269,  103,  104,  105,  106,  107,
 /*   620 */   108,  109,  110,  111,  112,  113,  114,  154,  155,  156,
 /*   630 */   157,  158,  102,  117,  118,  119,   19,  242,  144,  255,
 /*   640 */    23,  206,   24,  298,  195,  300,  206,  195,  264,  254,
 /*   650 */   206,  256,  240,  117,  118,  119,  183,   22,   22,   23,
 /*   660 */    43,   44,   45,  151,   47,   48,   49,   50,   51,   52,
 /*   670 */    53,   54,   55,   56,   57,   58,  241,  242,   60,  195,
 /*   680 */    19,  241,  242,  195,   23,  241,  242,  195,  152,  254,
 /*   690 */   310,  256,  243,  312,  254,   60,  256,  316,  254,  206,
 /*   700 */   256,   60,  218,  219,   43,   44,   45,  272,   47,   48,
 /*   710 */    49,   50,   51,   52,   53,   54,   55,   56,   57,   58,
 /*   720 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  112,
 /*   730 */   113,  114,  240,   60,  241,  242,  118,   25,  102,  255,
 /*   740 */   166,  167,  101,   22,   26,   19,   20,  254,   22,  256,
 /*   750 */   139,  140,  117,  118,  119,  306,  195,  308,  117,  118,
 /*   760 */   237,  238,   36,  122,  103,  104,  105,  106,  107,  108,
 /*   770 */   109,  110,  111,  112,  113,  114,  195,  195,   60,  218,
 /*   780 */   219,   60,  109,  195,   19,  217,   60,   25,   23,   77,
 /*   790 */   117,  118,  119,  225,  233,  154,  155,  156,   72,  312,
 /*   800 */   218,  219,   90,  316,   22,   93,  303,  304,   43,   44,
 /*   810 */    45,  195,   47,   48,   49,   50,   51,   52,   53,   54,
 /*   820 */    55,   56,   57,   58,  183,  195,  195,  101,   19,  213,
 /*   830 */   214,  243,   23,  107,  108,  117,  118,  119,  117,  118,
 /*   840 */   119,  115,   60,  117,  118,  119,  195,   60,  122,  218,
 /*   850 */   219,   22,   43,   44,   45,   35,   47,   48,   49,   50,
 /*   860 */    51,   52,   53,   54,   55,   56,   57,   58,  103,  104,
 /*   870 */   105,  106,  107,  108,  109,  110,  111,  112,  113,  114,
 /*   880 */   154,  155,  156,  157,  158,  195,  255,   67,  195,   60,
 /*   890 */   101,  240,  311,  312,  306,   75,  308,  316,   29,  117,
 /*   900 */   118,  119,   33,  287,  117,  118,  119,  118,  146,  183,
 /*   910 */   195,  122,  103,  104,  105,  106,  107,  108,  109,  110,
 /*   920 */   111,  112,  113,  114,  215,  195,   77,   60,   25,  195,
 /*   930 */   122,  144,   19,  218,  219,   66,   23,   88,  246,   90,
 /*   940 */   132,   25,   93,  154,  155,  156,  117,  118,  119,  257,
 /*   950 */   195,  131,  218,  219,  195,  265,   43,   44,   45,  195,
 /*   960 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
 /*   970 */    57,   58,  183,  218,  219,  195,   19,  218,  219,  195,
 /*   980 */    23,  195,  218,  219,  117,  118,  119,  195,  233,  255,
 /*   990 */   195,  195,  233,   22,   23,  146,   25,  233,  218,  219,
 /*  1000 */    43,   44,   45,  294,   47,   48,   49,   50,   51,   52,
 /*  1010 */    53,   54,   55,   56,   57,   58,  103,  104,  105,  106,
 /*  1020 */   107,  108,  109,  110,  111,  112,  113,  114,  195,   12,
 /*  1030 */   234,  195,  240,   74,  195,  255,  195,   60,  243,  262,
 /*  1040 */   263,  311,  312,   25,   27,   19,  316,  107,  108,  265,
 /*  1050 */    24,  265,  195,  150,  195,  139,  140,  218,  219,   42,
 /*  1060 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  112,
 /*  1070 */   113,  114,  233,  102,   67,  218,  219,  218,  219,  243,
 /*  1080 */    19,   64,   22,   23,   23,   25,  195,  128,  129,  130,
 /*  1090 */   233,   74,  233,   86,  154,  118,  156,  130,  265,  208,
 /*  1100 */    19,  306,   95,  308,   43,   44,   45,  266,   47,   48,
 /*  1110 */    49,   50,   51,   52,   53,   54,   55,   56,   57,   58,
 /*  1120 */   153,  230,   96,  232,   43,   44,   45,   19,   47,   48,
 /*  1130 */    49,   50,   51,   52,   53,   54,   55,   56,   57,   58,
 /*  1140 */   114,   22,  306,   24,  308,  127,  120,  121,  122,  123,
 /*  1150 */   124,  125,  126,  195,  147,  212,  213,  214,  132,   23,
 /*  1160 */   195,   25,  102,  100,  103,  104,  105,  106,  107,  108,
 /*  1170 */   109,  110,  111,  112,  113,  114,  218,  219,   19,   60,
 /*  1180 */   195,   12,  210,  211,  103,  104,  105,  106,  107,  108,
 /*  1190 */   109,  110,  111,  112,  113,  114,   27,  134,  195,  195,
 /*  1200 */   195,  210,  211,  218,  219,  195,   47,  195,  212,  213,
 /*  1210 */   214,   42,   16,  130,   19,  112,  113,  114,   23,   77,
 /*  1220 */   195,  218,  219,  218,  219,  117,  163,  164,  218,  219,
 /*  1230 */   218,  219,   90,   64,   19,   93,  153,  118,   43,   44,
 /*  1240 */    45,  160,   47,   48,   49,   50,   51,   52,   53,   54,
 /*  1250 */    55,   56,   57,   58,  195,  119,  272,  276,   43,   44,
 /*  1260 */    45,  195,   47,   48,   49,   50,   51,   52,   53,   54,
 /*  1270 */    55,   56,   57,   58,   78,  116,   80,  218,  219,  116,
 /*  1280 */   144,  128,  129,  130,  218,  219,   61,  195,   47,  195,
 /*  1290 */    16,  132,  195,  263,  195,  314,  315,  267,  103,  104,
 /*  1300 */   105,  106,  107,  108,  109,  110,  111,  112,  113,  114,
 /*  1310 */   218,  219,  218,  219,  151,  218,  219,  195,  103,  104,
 /*  1320 */   105,  106,  107,  108,  109,  110,  111,  112,  113,  114,
 /*  1330 */   210,  211,  195,    7,    8,    9,  195,   60,  195,  312,
 /*  1340 */   218,  219,  195,  316,  195,  120,  195,  263,   19,  195,
 /*  1350 */   125,  267,   78,   24,   80,  218,  219,  116,  162,  218,
 /*  1360 */   219,  218,  219,  301,  302,  218,  219,  195,   19,  218,
 /*  1370 */   219,  276,   43,   44,   45,  160,   47,   48,   49,   50,
 /*  1380 */    51,   52,   53,   54,   55,   56,   57,   58,   19,  146,
 /*  1390 */   218,  219,   43,   44,   45,  118,   47,   48,   49,   50,
 /*  1400 */    51,   52,   53,   54,   55,   56,   57,   58,  165,  314,
 /*  1410 */   315,  276,   43,   44,   45,  266,   47,   48,   49,   50,
 /*  1420 */    51,   52,   53,   54,   55,   56,   57,   58,  128,  129,
 /*  1430 */   130,  195,  103,  104,  105,  106,  107,  108,  109,  110,
 /*  1440 */   111,  112,  113,  114,  195,  228,  195,   61,  195,  314,
 /*  1450 */   315,   25,  103,  104,  105,  106,  107,  108,  109,  110,
 /*  1460 */   111,  112,  113,  114,  195,   22,  195,  218,  219,  218,
 /*  1470 */   219,  195,  103,  104,  105,  106,  107,  108,  109,  110,
 /*  1480 */   111,  112,  113,  114,  195,  195,  246,  218,  219,  218,
 /*  1490 */   219,   25,   19,  246,  218,  219,  246,  257,  259,  260,
 /*  1500 */   195,   22,  266,   60,  257,  195,  120,  257,  218,  219,
 /*  1510 */   116,  195,   19,  195,  150,  151,   25,   44,   45,  266,
 /*  1520 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
 /*  1530 */    57,   58,  195,   54,  218,  219,  218,  219,   45,  145,
 /*  1540 */    47,   48,   49,   50,   51,   52,   53,   54,   55,   56,
 /*  1550 */    57,   58,  246,  121,  122,  218,  219,   19,   23,   31,
 /*  1560 */    25,  118,  159,  257,  161,   24,  195,   39,  195,  143,
 /*  1570 */   195,   19,   20,   22,   22,   24,  103,  104,  105,  106,
 /*  1580 */   107,  108,  109,  110,  111,  112,  113,  114,   36,  218,
 /*  1590 */   219,  218,  219,  218,  219,  195,  103,  104,  105,  106,
 /*  1600 */   107,  108,  109,  110,  111,  112,  113,  114,  195,  143,
 /*  1610 */   119,  136,   60,  195,   22,  195,  141,  195,  218,  219,
 /*  1620 */   195,   23,  195,   25,   72,   23,  131,   25,  195,  134,
 /*  1630 */    23,  218,  219,  195,   82,  144,  218,  219,  218,  219,
 /*  1640 */   218,  219,  195,  218,  219,  218,  219,   60,   23,  195,
 /*  1650 */    25,  218,  219,  101,  195,  117,  218,  219,  195,  107,
 /*  1660 */   108,   23,  195,   25,  195,  218,  219,  115,  228,  117,
 /*  1670 */   118,  119,  218,  219,  122,  195,   19,  218,  219,  195,
 /*  1680 */    60,  218,  219,  142,  195,  218,  219,   19,   20,  195,
 /*  1690 */    22,  139,  140,   23,   23,   25,   25,  195,  218,  219,
 /*  1700 */     7,    8,  218,  219,   36,  118,  154,  155,  156,  157,
 /*  1710 */   158,  195,   23,  195,   25,   84,   85,   49,  195,   23,
 /*  1720 */   195,   25,  195,   23,  195,   25,  195,   23,   60,   25,
 /*  1730 */    23,   23,   25,   25,  142,  183,  218,  219,  118,  195,
 /*  1740 */    72,  218,  219,  218,  219,  218,  219,  218,  219,  218,
 /*  1750 */   219,  195,  195,  146,   86,   98,   23,  195,   25,   91,
 /*  1760 */    19,   20,  154,   22,  156,  154,   23,  156,   25,  101,
 /*  1770 */    23,  195,   25,  195,  195,  107,  108,   36,  195,  195,
 /*  1780 */   195,  195,  228,  115,  195,  117,  118,  119,  195,  195,
 /*  1790 */   122,  261,  195,  321,  195,  195,  195,  258,  238,  195,
 /*  1800 */   195,   60,  299,  291,  195,  195,  258,  195,  195,  195,
 /*  1810 */   290,  244,  216,   72,  245,  193,  258,  258,  299,  258,
 /*  1820 */   299,  274,  154,  155,  156,  157,  158,   86,  247,  295,
 /*  1830 */   248,  295,   91,   19,   20,  270,   22,  274,  270,  248,
 /*  1840 */   274,  222,  101,  227,  274,  221,  231,  221,  107,  108,
 /*  1850 */    36,  183,  262,  247,  221,  283,  115,  262,  117,  118,
 /*  1860 */   119,  198,  116,  122,  220,  262,   61,  220,  220,  251,
 /*  1870 */   247,  142,  251,  245,   60,  202,  299,  202,   38,  262,
 /*  1880 */   202,   22,  152,  151,  296,   43,   72,  236,   18,  239,
 /*  1890 */   202,  239,  239,  239,   18,  154,  155,  156,  157,  158,
 /*  1900 */    86,  150,  201,  248,  275,   91,  248,  273,  236,  248,
 /*  1910 */   275,  275,  273,  236,  248,  101,  286,  202,  201,  159,
 /*  1920 */    63,  107,  108,  296,  183,  293,  202,  201,   22,  115,
 /*  1930 */   202,  117,  118,  119,  292,  223,  122,  201,   65,  202,
 /*  1940 */   201,  223,  220,  220,   22,  220,  226,  226,  229,  127,
 /*  1950 */   223,  220,  166,   24,  285,  220,  222,  114,  315,  285,
 /*  1960 */   220,  202,  220,  307,   92,  320,  320,  229,  154,  155,
 /*  1970 */   156,  157,  158,    0,    1,    2,  223,   83,    5,  268,
 /*  1980 */   149,  268,  146,   10,   11,   12,   13,   14,   22,  280,
 /*  1990 */    17,  202,  159,   19,   20,  251,   22,  183,  282,  148,
 /*  2000 */   252,  252,  250,   30,  249,   32,  248,  147,   25,   13,
 /*  2010 */    36,  204,  196,   40,  196,    6,  302,  194,  194,  194,
 /*  2020 */   209,  215,  209,  215,  215,  215,  224,  224,  216,  209,
 /*  2030 */     4,  216,  215,    3,   60,   22,  122,   19,  122,   19,
 /*  2040 */   125,   22,   15,   22,   71,   16,   72,   23,   23,  140,
 /*  2050 */   305,  152,   79,   25,  131,   82,  143,   20,   16,  305,
 /*  2060 */     1,  143,  145,  131,  131,   62,   54,  131,   37,   54,
 /*  2070 */    54,  152,   99,  117,   34,  101,   54,   24,    1,    5,
 /*  2080 */    22,  107,  108,  116,   76,   25,  162,   41,  142,  115,
 /*  2090 */    24,  117,  118,  119,  116,   20,  122,   19,  126,   23,
 /*  2100 */   132,   19,   20,   69,   22,   69,   22,  134,   22,   68,
 /*  2110 */    22,   22,  139,  140,   60,  141,   68,   24,   36,   28,
 /*  2120 */    97,   22,   37,   68,   23,  150,   34,   22,  154,  155,
 /*  2130 */   156,  157,  158,   23,   23,   22,  163,   25,   23,  142,
 /*  2140 */    23,   98,   60,   23,   22,  144,   25,   76,   34,  117,
 /*  2150 */    34,   89,   34,   34,   72,   87,   76,  183,   34,   94,
 /*  2160 */    34,   23,   22,   24,   34,   23,   25,   44,   25,   23,
 /*  2170 */    23,   23,   22,   22,   25,   11,  143,   25,  143,   23,
 /*  2180 */    22,   22,   22,  101,   23,   23,  136,   22,   25,  107,
 /*  2190 */   108,  142,   25,  142,  142,   23,   15,  115,    1,  117,
 /*  2200 */   118,  119,    1,    2,  122,    1,    5,  322,  322,  322,
 /*  2210 */   322,   10,   11,   12,   13,   14,  322,  322,   17,  322,
 /*  2220 */     5,  322,  322,  141,  322,   10,   11,   12,   13,   14,
 /*  2230 */   322,   30,   17,   32,  322,  322,  154,  155,  156,  157,
 /*  2240 */   158,   40,  322,  322,  322,   30,  322,   32,  322,  322,
 /*  2250 */   322,  322,  322,  322,  322,   40,  322,  322,  322,  322,
 /*  2260 */   322,  322,  322,  322,  322,  183,  322,  322,  322,  322,
 /*  2270 */   322,  322,   71,  322,  322,  322,  322,  322,  322,  322,
 /*  2280 */    79,  322,  322,   82,  322,  322,   71,  322,  322,  322,
 /*  2290 */   322,  322,  322,  322,   79,  322,  322,   82,  322,  322,
 /*  2300 */    99,  322,  322,  322,  322,  322,  322,  322,  322,  322,
 /*  2310 */   322,  322,  322,  322,   99,  322,  322,  322,  322,  322,
 /*  2320 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
 /*  2330 */   322,  322,  322,  322,  322,  134,  322,  322,  322,  322,
 /*  2340 */   139,  140,  322,  322,  322,  322,  322,  322,  322,  134,
 /*  2350 */   322,  322,  322,  322,  139,  140,  322,  322,  322,  322,
 /*  2360 */   322,  322,  322,  322,  163,  322,  322,  322,  322,  322,
 /*  2370 */   322,  322,  322,  322,  322,  322,  322,  322,  163,  322,
 /*  2380 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
 /*  2390 */   322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
 /*  2400 */   322,  322,  322,  322,  322,  322,  322,  322,  187,  187,
 /*  2410 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
 /*  2420 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
 /*  2430 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
 /*  2440 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
 /*  2450 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
 /*  2460 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
 /*  2470 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
 /*  2480 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
 /*  2490 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
 /*  2500 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
 /*  2510 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
 /*  2520 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
 /*  2530 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
 /*  2540 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
 /*  2550 */   187,  187,  187,  187,  187,  187,  187,  187,  187,  187,
 /*  2560 */   187,  187,  187,  187,  187,  187,
};
#define YY_SHIFT_COUNT    (599)
#define YY_SHIFT_MIN      (0)
#define YY_SHIFT_MAX      (2215)
static const unsigned short int yy_shift_ofst[] = {
 /*     0 */  2201, 1973, 2215, 1552, 1552,   33,  368, 1668, 1741, 1814,
 /*    10 */   726,  726,  726,  265,   33,   33,   33,   33,   33,    0,
 /*    20 */     0,  216, 1349,  726,  726,  726,  726,  726,  726,  726,
 /*    30 */   726,  726,  726,  726,  726,  726,  726,  726,  272,  272,
 /*    40 */   111,  111,  316,  365,  516,  867,  867,  916,  916,  916,
 /*    50 */   916,   40,  112,  260,  364,  408,  512,  617,  661,  765,
 /*    60 */   809,  913,  957, 1061, 1081, 1195, 1215, 1329, 1349, 1349,
 /*    70 */  1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349, 1349,
 /*    80 */  1349, 1349, 1349, 1349, 1349, 1349, 1369, 1349, 1473, 1493,
 /*    90 */  1493,  473, 1974, 2082,  726,  726,  726,  726,  726,  726,
 /*   100 */   726,  726,  726,  726,  726,  726,  726,  726,  726,  726,
 /*   110 */   726,  726,  726,  726,  726,  726,  726,  726,  726,  726,
 /*   120 */   726,  726,  726,  726,  726,  726,  726,  726,  726,  726,
 /*   130 */   726,  726,  726,  726,  726,  726,  726,  726,  726,  726,
 /*   140 */   726,  726,  726,  726,  726,  726,  138,  232,  232,  232,
 /*   150 */   232,  232,  232,  232,  188,   99,  242,  718,  416, 1159,
 /*   160 */   867,  867,  940,  940,  867, 1103,  417,  574,  574,  574,
 /*   170 */   611,  139,  139, 2379, 2379, 1026, 1026, 1026,  536,  466,
 /*   180 */   466,  466,  466, 1017, 1017,  849,  718,  971, 1060,  867,
 /*   190 */   867,  867,  867,  867,  867,  867,  867,  867,  867,  867,
 /*   200 */   867,  867,  867,  867,  867,  867,  867,  867,  261,  712,
 /*   210 */   712,  867,  108, 1142, 1142,  977, 1108, 1108,  977,  977,
 /*   220 */  1243, 2379, 2379, 2379, 2379, 2379, 2379, 2379,  641,  789,
 /*   230 */   789,  635,  366,  721,  673,  782,  494,  787,  829,  867,
 /*   240 */   867,  867,  867,  867,  867,  867,  867,  867,  867,  867,
 /*   250 */   959,  867,  867,  867,  867,  867,  867,  867,  867,  867,
 /*   260 */   867,  867,  867,  867,  867,  820,  820,  820,  867,  867,
 /*   270 */   867, 1136,  867,  867,  867, 1119, 1007,  867, 1169,  867,
 /*   280 */   867,  867,  867,  867,  867,  867,  867, 1225, 1153,  869,
 /*   290 */   196,  618,  618,  618,  618, 1491,  196,  196,   91,  339,
 /*   300 */  1326, 1386,  383, 1163, 1364, 1426, 1364, 1538,  903, 1163,
 /*   310 */  1163,  903, 1163, 1426, 1538, 1018, 1535, 1241, 1528, 1528,
 /*   320 */  1528, 1394, 1394, 1394, 1394,  762,  762, 1403, 1466, 1475,
 /*   330 */  1551, 1746, 1805, 1746, 1746, 1729, 1729, 1840, 1840, 1729,
 /*   340 */  1730, 1732, 1859, 1842, 1870, 1870, 1870, 1870, 1729, 1876,
 /*   350 */  1751, 1732, 1732, 1751, 1859, 1842, 1751, 1842, 1751, 1729,
 /*   360 */  1876, 1760, 1857, 1729, 1876, 1906, 1729, 1876, 1729, 1876,
 /*   370 */  1906, 1746, 1746, 1746, 1873, 1922, 1922, 1906, 1746, 1822,
 /*   380 */  1746, 1873, 1746, 1746, 1786, 1929, 1843, 1843, 1906, 1729,
 /*   390 */  1872, 1872, 1894, 1894, 1831, 1836, 1966, 1729, 1833, 1831,
 /*   400 */  1851, 1860, 1751, 1983, 1996, 1996, 2009, 2009, 2009, 2379,
 /*   410 */  2379, 2379, 2379, 2379, 2379, 2379, 2379, 2379, 2379, 2379,
 /*   420 */  2379, 2379, 2379, 2379,  136, 1063, 1196,  530,  636, 1274,
 /*   430 */  1300, 1443, 1598, 1495, 1479,  967, 1083, 1602,  463, 1625,
 /*   440 */  1638, 1670, 1541, 1671, 1689, 1696, 1277, 1432, 1693,  808,
 /*   450 */  1700, 1607, 1657, 1587, 1704, 1707, 1631, 1708, 1733, 1608,
 /*   460 */  1611, 1743, 1747, 1620, 1592, 2026, 2030, 2013, 1914, 2018,
 /*   470 */  1916, 2020, 2019, 2021, 1915, 2027, 2029, 2024, 2025, 1909,
 /*   480 */  1899, 1923, 2028, 2028, 1913, 2037, 1917, 2042, 2059, 1918,
 /*   490 */  1932, 2028, 1933, 2003, 2031, 2028, 1919, 2012, 2015, 2016,
 /*   500 */  2022, 1936, 1956, 2040, 2053, 2077, 2074, 2058, 1967, 1924,
 /*   510 */  2034, 2060, 2036, 2008, 2046, 1946, 1978, 2066, 2075, 2078,
 /*   520 */  1968, 1972, 2084, 2041, 2086, 2088, 2076, 2089, 2048, 2054,
 /*   530 */  2093, 2023, 2091, 2099, 2055, 2085, 2101, 2092, 1975, 2105,
 /*   540 */  2110, 2111, 2112, 2115, 2113, 2043, 1997, 2117, 2120, 2032,
 /*   550 */  2114, 2122, 2001, 2121, 2116, 2118, 2119, 2124, 2062, 2071,
 /*   560 */  2068, 2123, 2080, 2065, 2126, 2138, 2140, 2139, 2141, 2143,
 /*   570 */  2130, 2033, 2035, 2142, 2121, 2146, 2147, 2148, 2150, 2149,
 /*   580 */  2152, 2156, 2151, 2164, 2158, 2159, 2161, 2162, 2160, 2165,
 /*   590 */  2163, 2050, 2049, 2051, 2052, 2167, 2172, 2181, 2197, 2204,
};
#define YY_REDUCE_COUNT (423)
#define YY_REDUCE_MIN   (-303)
#define YY_REDUCE_MAX   (1825)
static const short yy_reduce_ofst[] = {
 /*     0 */   -67,  345,  -64, -178, -181,  143,  435,  -78, -183,  163,
 /*    10 */  -185,  284,  384, -174,  189,  352,  440,  444,  493,  -23,
 /*    20 */   227, -277,   -1,  305,  561,  755,  759,  764, -189,  839,
 /*    30 */   857,  354,  484,  859,  631,   67,  734,  780, -187,  616,
 /*    40 */   581,  730,  891,  449,  588,  795,  836, -238,  287, -238,
 /*    50 */   287, -256, -256, -256, -256, -256, -256, -256, -256, -256,
 /*    60 */  -256, -256, -256, -256, -256, -256, -256, -256, -256, -256,
 /*    70 */  -256, -256, -256, -256, -256, -256, -256, -256, -256, -256,
 /*    80 */  -256, -256, -256, -256, -256, -256, -256, -256, -256, -256,
 /*    90 */  -256,  205,  582,  715,  958,  985, 1003, 1005, 1010, 1012,
 /*   100 */  1059, 1066, 1092, 1094, 1097, 1122, 1137, 1141, 1143, 1147,
 /*   110 */  1151, 1172, 1249, 1251, 1269, 1271, 1276, 1290, 1316, 1318,
 /*   120 */  1337, 1371, 1373, 1375, 1400, 1413, 1418, 1420, 1422, 1425,
 /*   130 */  1427, 1433, 1438, 1447, 1454, 1459, 1463, 1467, 1480, 1484,
 /*   140 */  1518, 1523, 1525, 1527, 1529, 1531, -256, -256, -256, -256,
 /*   150 */  -256, -256, -256, -256, -256, -256, -256,  155,  210, -220,
 /*   160 */    86, -130,  943,  996,  402, -256, -113,  981, 1095, 1135,
 /*   170 */   395, -256, -256, -256, -256,  568,  568,  568,   -4, -153,
 /*   180 */  -133,  259,  306, -166,  523, -303, -126,  503,  503,  -37,
 /*   190 */  -149,  164,  690,  292,  412,  492,  651,  784,  332,  786,
 /*   200 */   841, 1149,  833, 1236,  792,  162,  796, 1253,  777,  288,
 /*   210 */   381,  380,  709,  487, 1027,  972, 1030, 1084,  991, 1120,
 /*   220 */  -152, 1062,  692, 1240, 1247, 1250, 1239, 1306, -207, -194,
 /*   230 */    57,  180,   74,  315,  355,  376,  452,  488,  630,  693,
 /*   240 */   965, 1004, 1025, 1099, 1154, 1289, 1305, 1310, 1469, 1489,
 /*   250 */   984, 1494, 1502, 1516, 1544, 1556, 1557, 1562, 1576, 1578,
 /*   260 */  1579, 1583, 1584, 1585, 1586, 1217, 1440, 1554, 1589, 1593,
 /*   270 */  1594, 1530, 1597, 1599, 1600, 1539, 1472, 1601, 1560, 1604,
 /*   280 */   355, 1605, 1609, 1610, 1612, 1613, 1614, 1503, 1512, 1520,
 /*   290 */  1567, 1548, 1558, 1559, 1561, 1530, 1567, 1567, 1569, 1596,
 /*   300 */  1622, 1519, 1521, 1547, 1565, 1581, 1568, 1534, 1582, 1563,
 /*   310 */  1566, 1591, 1570, 1606, 1536, 1619, 1615, 1616, 1624, 1626,
 /*   320 */  1633, 1590, 1595, 1603, 1617, 1618, 1621, 1572, 1623, 1628,
 /*   330 */  1663, 1644, 1577, 1647, 1648, 1673, 1675, 1588, 1627, 1678,
 /*   340 */  1630, 1629, 1634, 1651, 1650, 1652, 1653, 1654, 1688, 1701,
 /*   350 */  1655, 1635, 1636, 1658, 1639, 1672, 1661, 1677, 1666, 1715,
 /*   360 */  1717, 1632, 1642, 1724, 1726, 1712, 1728, 1736, 1737, 1739,
 /*   370 */  1718, 1722, 1723, 1725, 1719, 1720, 1721, 1727, 1731, 1734,
 /*   380 */  1735, 1738, 1740, 1742, 1643, 1656, 1669, 1674, 1753, 1759,
 /*   390 */  1645, 1646, 1711, 1713, 1748, 1744, 1709, 1789, 1716, 1749,
 /*   400 */  1752, 1755, 1758, 1807, 1816, 1818, 1823, 1824, 1825, 1745,
 /*   410 */  1754, 1714, 1811, 1806, 1808, 1809, 1810, 1813, 1802, 1803,
 /*   420 */  1812, 1815, 1817, 1820,
};
static const YYACTIONTYPE yy_default[] = {
 /*     0 */  1691, 1691, 1691, 1516, 1279, 1392, 1279, 1279, 1279, 1279,
 /*    10 */  1516, 1516, 1516, 1279, 1279, 1279, 1279, 1279, 1279, 1422,
 /*    20 */  1422, 1568, 1312, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
 /*    30 */  1279, 1279, 1279, 1279, 1279, 1515, 1279, 1279, 1279, 1279,
 /*    40 */  1607, 1607, 1279, 1279, 1279, 1279, 1279, 1592, 1591, 1279,
 /*    50 */  1279, 1279, 1431, 1279, 1279, 1279, 1438, 1279, 1279, 1279,
 /*    60 */  1279, 1279, 1517, 1518, 1279, 1279, 1279, 1279, 1567, 1569,
 /*    70 */  1533, 1445, 1444, 1443, 1442, 1551, 1410, 1436, 1429, 1433,
 /*    80 */  1512, 1513, 1511, 1670, 1518, 1517, 1279, 1432, 1480, 1496,
 /*    90 */  1479, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   100 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   110 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   120 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   130 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   140 */  1279, 1279, 1279, 1279, 1279, 1279, 1488, 1495, 1494, 1493,
 /*   150 */  1502, 1492, 1489, 1482, 1481, 1483, 1484, 1303, 1300, 1354,
 /*   160 */  1279, 1279, 1279, 1279, 1279, 1485, 1312, 1473, 1472, 1471,
 /*   170 */  1279, 1499, 1486, 1498, 1497, 1575, 1644, 1643, 1534, 1279,
 /*   180 */  1279, 1279, 1279, 1279, 1279, 1607, 1279, 1279, 1279, 1279,
 /*   190 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   200 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1412, 1607,
 /*   210 */  1607, 1279, 1312, 1607, 1607, 1308, 1413, 1413, 1308, 1308,
 /*   220 */  1416, 1587, 1383, 1383, 1383, 1383, 1392, 1383, 1279, 1279,
 /*   230 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   240 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1572, 1570, 1279,
 /*   250 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   260 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   270 */  1279, 1279, 1279, 1279, 1279, 1388, 1279, 1279, 1279, 1279,
 /*   280 */  1279, 1279, 1279, 1279, 1279, 1279, 1637, 1683, 1279, 1546,
 /*   290 */  1368, 1388, 1388, 1388, 1388, 1390, 1369, 1367, 1382, 1313,
 /*   300 */  1286, 1683, 1683, 1448, 1437, 1389, 1437, 1680, 1435, 1448,
 /*   310 */  1448, 1435, 1448, 1389, 1680, 1329, 1659, 1324, 1422, 1422,
 /*   320 */  1422, 1412, 1412, 1412, 1412, 1416, 1416, 1514, 1389, 1382,
 /*   330 */  1279, 1355, 1683, 1355, 1355, 1398, 1398, 1682, 1682, 1398,
 /*   340 */  1534, 1667, 1457, 1357, 1363, 1363, 1363, 1363, 1398, 1297,
 /*   350 */  1435, 1667, 1667, 1435, 1457, 1357, 1435, 1357, 1435, 1398,
 /*   360 */  1297, 1550, 1678, 1398, 1297, 1524, 1398, 1297, 1398, 1297,
 /*   370 */  1524, 1355, 1355, 1355, 1344, 1279, 1279, 1524, 1355, 1329,
 /*   380 */  1355, 1344, 1355, 1355, 1625, 1279, 1528, 1528, 1524, 1398,
 /*   390 */  1617, 1617, 1425, 1425, 1430, 1416, 1519, 1398, 1279, 1430,
 /*   400 */  1428, 1426, 1435, 1347, 1640, 1640, 1636, 1636, 1636, 1688,
 /*   410 */  1688, 1587, 1652, 1312, 1312, 1312, 1312, 1652, 1331, 1331,
 /*   420 */  1313, 1313, 1312, 1652, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   430 */  1279, 1647, 1279, 1279, 1535, 1279, 1279, 1279, 1279, 1279,
 /*   440 */  1279, 1279, 1402, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   450 */  1279, 1279, 1593, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   460 */  1279, 1279, 1279, 1279, 1462, 1279, 1282, 1584, 1279, 1279,
 /*   470 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   480 */  1279, 1279, 1439, 1440, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   490 */  1279, 1454, 1279, 1279, 1279, 1449, 1279, 1279, 1279, 1279,
 /*   500 */  1279, 1279, 1279, 1279, 1403, 1279, 1279, 1279, 1279, 1279,
 /*   510 */  1279, 1549, 1548, 1279, 1279, 1400, 1279, 1279, 1279, 1279,
 /*   520 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1327,
 /*   530 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   540 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   550 */  1279, 1279, 1279, 1427, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   560 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1622, 1417,
 /*   570 */  1279, 1279, 1279, 1279, 1671, 1279, 1279, 1279, 1279, 1377,
 /*   580 */  1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279, 1279,
 /*   590 */  1663, 1371, 1463, 1279, 1466, 1301, 1279, 1291, 1279, 1279,
};
/********** End of lemon-generated parsing tables *****************************/

/* The next table maps tokens (terminal symbols) into fallback tokens.  
** If a construct like the following:
** 
**      %fallback ID X Y Z.
**
** appears in the grammar, then ID becomes a fallback token for X, Y,
** and Z.  Whenever one of the tokens X, Y, or Z is input to the parser
** but it does not parse, the type of the token is changed to ID and
** the parse is retried before an error is thrown.
**
** This feature can be used, for example, to cause some keywords in a language
** to revert to identifiers if they keyword does not apply in the context where
** it appears.
*/
#ifdef YYFALLBACK
static const YYCODETYPE yyFallback[] = {
    0,  /*          $ => nothing */
    0,  /*       SEMI => nothing */
   60,  /*    EXPLAIN => ID */
   60,  /*      QUERY => ID */
   60,  /*       PLAN => ID */
   60,  /*      BEGIN => ID */
    0,  /* TRANSACTION => nothing */
   60,  /*   DEFERRED => ID */
   60,  /*  IMMEDIATE => ID */
   60,  /*  EXCLUSIVE => ID */
    0,  /*     COMMIT => nothing */
   60,  /*        END => ID */
   60,  /*   ROLLBACK => ID */
   60,  /*  SAVEPOINT => ID */
   60,  /*    RELEASE => ID */
    0,  /*         TO => nothing */
    0,  /*      TABLE => nothing */
    0,  /*     CREATE => nothing */
   60,  /*         IF => ID */
    0,  /*        NOT => nothing */
    0,  /*     EXISTS => nothing */
   60,  /*       TEMP => ID */
    0,  /*         LP => nothing */
    0,  /*         RP => nothing */
    0,  /*         AS => nothing */
    0,  /*      COMMA => nothing */
   60,  /*    WITHOUT => ID */
   60,  /*      ABORT => ID */
   60,  /*     ACTION => ID */
   60,  /*      AFTER => ID */
   60,  /*    ANALYZE => ID */
   60,  /*        ASC => ID */
   60,  /*     ATTACH => ID */
   60,  /*     BEFORE => ID */
   60,  /*         BY => ID */
   60,  /*    CASCADE => ID */
   60,  /*       CAST => ID */
   60,  /*   CONFLICT => ID */
   60,  /*   DATABASE => ID */
   60,  /*       DESC => ID */
   60,  /*     DETACH => ID */
   60,  /*       EACH => ID */
   60,  /*       FAIL => ID */
    0,  /*         OR => nothing */
    0,  /*        AND => nothing */
    0,  /*         IS => nothing */
    0,  /*      ISNOT => nothing */
   60,  /*      MATCH => ID */
   60,  /*    LIKE_KW => ID */
    0,  /*    BETWEEN => nothing */
    0,  /*         IN => nothing */
    0,  /*     ISNULL => nothing */
    0,  /*    NOTNULL => nothing */
    0,  /*         NE => nothing */
    0,  /*         EQ => nothing */
    0,  /*         GT => nothing */
    0,  /*         LE => nothing */
    0,  /*         LT => nothing */
    0,  /*         GE => nothing */
    0,  /*     ESCAPE => nothing */
    0,  /*         ID => nothing */
   60,  /*   COLUMNKW => ID */
   60,  /*         DO => ID */
   60,  /*        FOR => ID */
   60,  /*     IGNORE => ID */
   60,  /*  INITIALLY => ID */
   60,  /*    INSTEAD => ID */
   60,  /*         NO => ID */
   60,  /*        KEY => ID */
   60,  /*         OF => ID */
   60,  /*     OFFSET => ID */
   60,  /*     PRAGMA => ID */
   60,  /*      RAISE => ID */
   60,  /*  RECURSIVE => ID */
   60,  /*    REPLACE => ID */
   60,  /*   RESTRICT => ID */
   60,  /*        ROW => ID */
   60,  /*       ROWS => ID */
   60,  /*    TRIGGER => ID */
   60,  /*     VACUUM => ID */
   60,  /*       VIEW => ID */
   60,  /*    VIRTUAL => ID */
   60,  /*       WITH => ID */
   60,  /*      NULLS => ID */
   60,  /*      FIRST => ID */
   60,  /*       LAST => ID */
   60,  /*    CURRENT => ID */
   60,  /*  FOLLOWING => ID */
   60,  /*  PARTITION => ID */
   60,  /*  PRECEDING => ID */
   60,  /*      RANGE => ID */
   60,  /*  UNBOUNDED => ID */
   60,  /*    EXCLUDE => ID */
   60,  /*     GROUPS => ID */
   60,  /*     OTHERS => ID */
   60,  /*       TIES => ID */
   60,  /*  GENERATED => ID */
   60,  /*     ALWAYS => ID */
   60,  /* MATERIALIZED => ID */
   60,  /*    REINDEX => ID */
   60,  /*     RENAME => ID */
   60,  /*   CTIME_KW => ID */
    0,  /*        ANY => nothing */
    0,  /*     BITAND => nothing */
    0,  /*      BITOR => nothing */
    0,  /*     LSHIFT => nothing */
    0,  /*     RSHIFT => nothing */
    0,  /*       PLUS => nothing */
    0,  /*      MINUS => nothing */
    0,  /*       STAR => nothing */
    0,  /*      SLASH => nothing */
    0,  /*        REM => nothing */
    0,  /*     CONCAT => nothing */
    0,  /*        PTR => nothing */
    0,  /*    COLLATE => nothing */
    0,  /*     BITNOT => nothing */
    0,  /*         ON => nothing */
    0,  /*    INDEXED => nothing */
    0,  /*     STRING => nothing */
    0,  /*    JOIN_KW => nothing */
    0,  /* CONSTRAINT => nothing */
    0,  /*    DEFAULT => nothing */
    0,  /*       NULL => nothing */
    0,  /*    PRIMARY => nothing */
    0,  /*     UNIQUE => nothing */
    0,  /*      CHECK => nothing */
    0,  /* REFERENCES => nothing */
    0,  /*   AUTOINCR => nothing */
    0,  /*     INSERT => nothing */
    0,  /*     DELETE => nothing */
    0,  /*     UPDATE => nothing */
    0,  /*        SET => nothing */
    0,  /* DEFERRABLE => nothing */
    0,  /*    FOREIGN => nothing */
    0,  /*       DROP => nothing */
    0,  /*      UNION => nothing */
    0,  /*        ALL => nothing */
    0,  /*     EXCEPT => nothing */
    0,  /*  INTERSECT => nothing */
    0,  /*     SELECT => nothing */
    0,  /*     VALUES => nothing */
    0,  /*   DISTINCT => nothing */
    0,  /*        DOT => nothing */
    0,  /*       FROM => nothing */
    0,  /*       JOIN => nothing */
    0,  /*      USING => nothing */
    0,  /*      ORDER => nothing */
    0,  /*      GROUP => nothing */
    0,  /*     HAVING => nothing */
    0,  /*      LIMIT => nothing */
    0,  /*      WHERE => nothing */
    0,  /*  RETURNING => nothing */
    0,  /*       INTO => nothing */
    0,  /*    NOTHING => nothing */
    0,  /*      FLOAT => nothing */
    0,  /*       BLOB => nothing */
    0,  /*    INTEGER => nothing */
    0,  /*   VARIABLE => nothing */
    0,  /*       CASE => nothing */
    0,  /*       WHEN => nothing */
    0,  /*       THEN => nothing */
    0,  /*       ELSE => nothing */
    0,  /*      INDEX => nothing */
    0,  /*      ALTER => nothing */
    0,  /*        ADD => nothing */
    0,  /*     WINDOW => nothing */
    0,  /*       OVER => nothing */
    0,  /*     FILTER => nothing */
    0,  /*     COLUMN => nothing */
    0,  /* AGG_FUNCTION => nothing */
    0,  /* AGG_COLUMN => nothing */
    0,  /*  TRUEFALSE => nothing */
    0,  /*   FUNCTION => nothing */
    0,  /*      UPLUS => nothing */
    0,  /*     UMINUS => nothing */
    0,  /*      TRUTH => nothing */
    0,  /*   REGISTER => nothing */
    0,  /*     VECTOR => nothing */
    0,  /* SELECT_COLUMN => nothing */
    0,  /* IF_NULL_ROW => nothing */
    0,  /*   ASTERISK => nothing */
    0,  /*       SPAN => nothing */
    0,  /*      ERROR => nothing */
    0,  /*    QNUMBER => nothing */
    0,  /*      SPACE => nothing */
    0,  /*    COMMENT => nothing */
    0,  /*    ILLEGAL => nothing */
};
#endif /* YYFALLBACK */

/* The following structure represents a single element of the
** parser's stack.  Information stored includes:
**
**   +  The state number for the parser at this level of the stack.
**
**   +  The value of the token stored at this level of the stack.
**      (In other words, the "major" token.)
**
**   +  The semantic value stored at this level of the stack.  This is
**      the information used by the action routines in the grammar.
**      It is sometimes called the "minor" token.
**
** After the "shift" half of a SHIFTREDUCE action, the stateno field
** actually contains the reduce action for the second half of the
** SHIFTREDUCE.
*/
struct yyStackEntry {
  YYACTIONTYPE stateno;  /* The state-number, or reduce action in SHIFTREDUCE */
  YYCODETYPE major;      /* The major token value.  This is the code
                         ** number for the token at this stack level */
  YYMINORTYPE minor;     /* The user-supplied minor token value.  This
                         ** is the value of the token  */
};
typedef struct yyStackEntry yyStackEntry;

/* The state of the parser is completely contained in an instance of
** the following structure */
struct yyParser {
  yyStackEntry *yytos;          /* Pointer to top element of the stack */
#ifdef YYTRACKMAXSTACKDEPTH
  int yyhwm;                    /* High-water mark of the stack */
#endif
#ifndef YYNOERRORRECOVERY
  int yyerrcnt;                 /* Shifts left before out of the error */
#endif
  sqlite3ParserARG_SDECL                /* A place to hold %extra_argument */
  sqlite3ParserCTX_SDECL                /* A place to hold %extra_context */
  yyStackEntry *yystackEnd;           /* Last entry in the stack */
  yyStackEntry *yystack;              /* The parser stack */
  yyStackEntry yystk0[YYSTACKDEPTH];  /* Initial stack space */
};
typedef struct yyParser yyParser;

#include <assert.h>
#ifndef NDEBUG
#include <stdio.h>
static FILE *yyTraceFILE = 0;
static char *yyTracePrompt = 0;
#endif /* NDEBUG */

#ifndef NDEBUG
/* 
** Turn parser tracing on by giving a stream to which to write the trace
** and a prompt to preface each trace message.  Tracing is turned off
** by making either argument NULL 
**
** Inputs:
** <ul>
** <li> A FILE* to which trace output should be written.
**      If NULL, then tracing is turned off.
** <li> A prefix string written at the beginning of every
**      line of trace output.  If NULL, then tracing is
**      turned off.
** </ul>
**
** Outputs:
** None.
*/
void sqlite3ParserTrace(FILE *TraceFILE, char *zTracePrompt){
  yyTraceFILE = TraceFILE;
  yyTracePrompt = zTracePrompt;
  if( yyTraceFILE==0 ) yyTracePrompt = 0;
  else if( yyTracePrompt==0 ) yyTraceFILE = 0;
}
#endif /* NDEBUG */

#if defined(YYCOVERAGE) || !defined(NDEBUG)
/* For tracing shifts, the names of all terminals and nonterminals
** are required.  The following table supplies these names */
static const char *const yyTokenName[] = { 
  /*    0 */ "$",
  /*    1 */ "SEMI",
  /*    2 */ "EXPLAIN",
  /*    3 */ "QUERY",
  /*    4 */ "PLAN",
  /*    5 */ "BEGIN",
  /*    6 */ "TRANSACTION",
  /*    7 */ "DEFERRED",
  /*    8 */ "IMMEDIATE",
  /*    9 */ "EXCLUSIVE",
  /*   10 */ "COMMIT",
  /*   11 */ "END",
  /*   12 */ "ROLLBACK",
  /*   13 */ "SAVEPOINT",
  /*   14 */ "RELEASE",
  /*   15 */ "TO",
  /*   16 */ "TABLE",
  /*   17 */ "CREATE",
  /*   18 */ "IF",
  /*   19 */ "NOT",
  /*   20 */ "EXISTS",
  /*   21 */ "TEMP",
  /*   22 */ "LP",
  /*   23 */ "RP",
  /*   24 */ "AS",
  /*   25 */ "COMMA",
  /*   26 */ "WITHOUT",
  /*   27 */ "ABORT",
  /*   28 */ "ACTION",
  /*   29 */ "AFTER",
  /*   30 */ "ANALYZE",
  /*   31 */ "ASC",
  /*   32 */ "ATTACH",
  /*   33 */ "BEFORE",
  /*   34 */ "BY",
  /*   35 */ "CASCADE",
  /*   36 */ "CAST",
  /*   37 */ "CONFLICT",
  /*   38 */ "DATABASE",
  /*   39 */ "DESC",
  /*   40 */ "DETACH",
  /*   41 */ "EACH",
  /*   42 */ "FAIL",
  /*   43 */ "OR",
  /*   44 */ "AND",
  /*   45 */ "IS",
  /*   46 */ "ISNOT",
  /*   47 */ "MATCH",
  /*   48 */ "LIKE_KW",
  /*   49 */ "BETWEEN",
  /*   50 */ "IN",
  /*   51 */ "ISNULL",
  /*   52 */ "NOTNULL",
  /*   53 */ "NE",
  /*   54 */ "EQ",
  /*   55 */ "GT",
  /*   56 */ "LE",
  /*   57 */ "LT",
  /*   58 */ "GE",
  /*   59 */ "ESCAPE",
  /*   60 */ "ID",
  /*   61 */ "COLUMNKW",
  /*   62 */ "DO",
  /*   63 */ "FOR",
  /*   64 */ "IGNORE",
  /*   65 */ "INITIALLY",
  /*   66 */ "INSTEAD",
  /*   67 */ "NO",
  /*   68 */ "KEY",
  /*   69 */ "OF",
  /*   70 */ "OFFSET",
  /*   71 */ "PRAGMA",
  /*   72 */ "RAISE",
  /*   73 */ "RECURSIVE",
  /*   74 */ "REPLACE",
  /*   75 */ "RESTRICT",
  /*   76 */ "ROW",
  /*   77 */ "ROWS",
  /*   78 */ "TRIGGER",
  /*   79 */ "VACUUM",
  /*   80 */ "VIEW",
  /*   81 */ "VIRTUAL",
  /*   82 */ "WITH",
  /*   83 */ "NULLS",
  /*   84 */ "FIRST",
  /*   85 */ "LAST",
  /*   86 */ "CURRENT",
  /*   87 */ "FOLLOWING",
  /*   88 */ "PARTITION",
  /*   89 */ "PRECEDING",
  /*   90 */ "RANGE",
  /*   91 */ "UNBOUNDED",
  /*   92 */ "EXCLUDE",
  /*   93 */ "GROUPS",
  /*   94 */ "OTHERS",
  /*   95 */ "TIES",
  /*   96 */ "GENERATED",
  /*   97 */ "ALWAYS",
  /*   98 */ "MATERIALIZED",
  /*   99 */ "REINDEX",
  /*  100 */ "RENAME",
  /*  101 */ "CTIME_KW",
  /*  102 */ "ANY",
  /*  103 */ "BITAND",
  /*  104 */ "BITOR",
  /*  105 */ "LSHIFT",
  /*  106 */ "RSHIFT",
  /*  107 */ "PLUS",
  /*  108 */ "MINUS",
  /*  109 */ "STAR",
  /*  110 */ "SLASH",
  /*  111 */ "REM",
  /*  112 */ "CONCAT",
  /*  113 */ "PTR",
  /*  114 */ "COLLATE",
  /*  115 */ "BITNOT",
  /*  116 */ "ON",
  /*  117 */ "INDEXED",
  /*  118 */ "STRING",
  /*  119 */ "JOIN_KW",
  /*  120 */ "CONSTRAINT",
  /*  121 */ "DEFAULT",
  /*  122 */ "NULL",
  /*  123 */ "PRIMARY",
  /*  124 */ "UNIQUE",
  /*  125 */ "CHECK",
  /*  126 */ "REFERENCES",
  /*  127 */ "AUTOINCR",
  /*  128 */ "INSERT",
  /*  129 */ "DELETE",
  /*  130 */ "UPDATE",
  /*  131 */ "SET",
  /*  132 */ "DEFERRABLE",
  /*  133 */ "FOREIGN",
  /*  134 */ "DROP",
  /*  135 */ "UNION",
  /*  136 */ "ALL",
  /*  137 */ "EXCEPT",
  /*  138 */ "INTERSECT",
  /*  139 */ "SELECT",
  /*  140 */ "VALUES",
  /*  141 */ "DISTINCT",
  /*  142 */ "DOT",
  /*  143 */ "FROM",
  /*  144 */ "JOIN",
  /*  145 */ "USING",
  /*  146 */ "ORDER",
  /*  147 */ "GROUP",
  /*  148 */ "HAVING",
  /*  149 */ "LIMIT",
  /*  150 */ "WHERE",
  /*  151 */ "RETURNING",
  /*  152 */ "INTO",
  /*  153 */ "NOTHING",
  /*  154 */ "FLOAT",
  /*  155 */ "BLOB",
  /*  156 */ "INTEGER",
  /*  157 */ "VARIABLE",
  /*  158 */ "CASE",
  /*  159 */ "WHEN",
  /*  160 */ "THEN",
  /*  161 */ "ELSE",
  /*  162 */ "INDEX",
  /*  163 */ "ALTER",
  /*  164 */ "ADD",
  /*  165 */ "WINDOW",
  /*  166 */ "OVER",
  /*  167 */ "FILTER",
  /*  168 */ "COLUMN",
  /*  169 */ "AGG_FUNCTION",
  /*  170 */ "AGG_COLUMN",
  /*  171 */ "TRUEFALSE",
  /*  172 */ "FUNCTION",
  /*  173 */ "UPLUS",
  /*  174 */ "UMINUS",
  /*  175 */ "TRUTH",
  /*  176 */ "REGISTER",
  /*  177 */ "VECTOR",
  /*  178 */ "SELECT_COLUMN",
  /*  179 */ "IF_NULL_ROW",
  /*  180 */ "ASTERISK",
  /*  181 */ "SPAN",
  /*  182 */ "ERROR",
  /*  183 */ "QNUMBER",
  /*  184 */ "SPACE",
  /*  185 */ "COMMENT",
  /*  186 */ "ILLEGAL",
  /*  187 */ "input",
  /*  188 */ "cmdlist",
  /*  189 */ "ecmd",
  /*  190 */ "cmdx",
  /*  191 */ "explain",
  /*  192 */ "cmd",
  /*  193 */ "transtype",
  /*  194 */ "trans_opt",
  /*  195 */ "nm",
  /*  196 */ "savepoint_opt",
  /*  197 */ "create_table",
  /*  198 */ "create_table_args",
  /*  199 */ "createkw",
  /*  200 */ "temp",
  /*  201 */ "ifnotexists",
  /*  202 */ "dbnm",
  /*  203 */ "columnlist",
  /*  204 */ "conslist_opt",
  /*  205 */ "table_option_set",
  /*  206 */ "select",
  /*  207 */ "table_option",
  /*  208 */ "columnname",
  /*  209 */ "carglist",
  /*  210 */ "typetoken",
  /*  211 */ "typename",
  /*  212 */ "signed",
  /*  213 */ "plus_num",
  /*  214 */ "minus_num",
  /*  215 */ "scanpt",
  /*  216 */ "scantok",
  /*  217 */ "ccons",
  /*  218 */ "term",
  /*  219 */ "expr",
  /*  220 */ "onconf",
  /*  221 */ "sortorder",
  /*  222 */ "autoinc",
  /*  223 */ "eidlist_opt",
  /*  224 */ "refargs",
  /*  225 */ "defer_subclause",
  /*  226 */ "generated",
  /*  227 */ "refarg",
  /*  228 */ "refact",
  /*  229 */ "init_deferred_pred_opt",
  /*  230 */ "conslist",
  /*  231 */ "tconscomma",
  /*  232 */ "tcons",
  /*  233 */ "sortlist",
  /*  234 */ "eidlist",
  /*  235 */ "defer_subclause_opt",
  /*  236 */ "orconf",
  /*  237 */ "resolvetype",
  /*  238 */ "raisetype",
  /*  239 */ "ifexists",
  /*  240 */ "fullname",
  /*  241 */ "selectnowith",
  /*  242 */ "oneselect",
  /*  243 */ "wqlist",
  /*  244 */ "multiselect_op",
  /*  245 */ "distinct",
  /*  246 */ "selcollist",
  /*  247 */ "from",
  /*  248 */ "where_opt",
  /*  249 */ "groupby_opt",
  /*  250 */ "having_opt",
  /*  251 */ "orderby_opt",
  /*  252 */ "limit_opt",
  /*  253 */ "window_clause",
  /*  254 */ "values",
  /*  255 */ "nexprlist",
  /*  256 */ "mvalues",
  /*  257 */ "sclp",
  /*  258 */ "as",
  /*  259 */ "seltablist",
  /*  260 */ "stl_prefix",
  /*  261 */ "joinop",
  /*  262 */ "on_using",
  /*  263 */ "indexed_by",
  /*  264 */ "exprlist",
  /*  265 */ "xfullname",
  /*  266 */ "idlist",
  /*  267 */ "indexed_opt",
  /*  268 */ "nulls",
  /*  269 */ "with",
  /*  270 */ "where_opt_ret",
  /*  271 */ "setlist",
  /*  272 */ "insert_cmd",
  /*  273 */ "idlist_opt",
  /*  274 */ "upsert",
  /*  275 */ "returning",
  /*  276 */ "filter_over",
  /*  277 */ "likeop",
  /*  278 */ "between_op",
  /*  279 */ "in_op",
  /*  280 */ "paren_exprlist",
  /*  281 */ "case_operand",
  /*  282 */ "case_exprlist",
  /*  283 */ "case_else",
  /*  284 */ "uniqueflag",
  /*  285 */ "collate",
  /*  286 */ "vinto",
  /*  287 */ "nmnum",
  /*  288 */ "trigger_decl",
  /*  289 */ "trigger_cmd_list",
  /*  290 */ "trigger_time",
  /*  291 */ "trigger_event",
  /*  292 */ "foreach_clause",
  /*  293 */ "when_clause",
  /*  294 */ "trigger_cmd",
  /*  295 */ "tridxby",
  /*  296 */ "database_kw_opt",
  /*  297 */ "key_opt",
  /*  298 */ "alter_add",
  /*  299 */ "kwcolumn_opt",
  /*  300 */ "create_vtab",
  /*  301 */ "vtabarglist",
  /*  302 */ "vtabarg",
  /*  303 */ "vtabargtoken",
  /*  304 */ "lp",
  /*  305 */ "anylist",
  /*  306 */ "wqitem",
  /*  307 */ "wqas",
  /*  308 */ "withnm",
  /*  309 */ "windowdefn_list",
  /*  310 */ "windowdefn",
  /*  311 */ "window",
  /*  312 */ "frame_opt",
  /*  313 */ "part_opt",
  /*  314 */ "filter_clause",
  /*  315 */ "over_clause",
  /*  316 */ "range_or_rows",
  /*  317 */ "frame_bound",
  /*  318 */ "frame_bound_s",
  /*  319 */ "frame_bound_e",
  /*  320 */ "frame_exclude_opt",
  /*  321 */ "frame_exclude",
};
#endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */

#ifndef NDEBUG
/* For tracing reduce actions, the names of all rules are required.
*/
static const char *const yyRuleName[] = {
 /*   0 */ "explain ::= EXPLAIN",
 /*   1 */ "explain ::= EXPLAIN QUERY PLAN",
 /*   2 */ "cmdx ::= cmd",
 /*   3 */ "cmd ::= BEGIN transtype trans_opt",
 /*   4 */ "transtype ::=",
 /*   5 */ "transtype ::= DEFERRED",
 /*   6 */ "transtype ::= IMMEDIATE",
 /*   7 */ "transtype ::= EXCLUSIVE",
 /*   8 */ "cmd ::= COMMIT|END trans_opt",
 /*   9 */ "cmd ::= ROLLBACK trans_opt",
 /*  10 */ "cmd ::= SAVEPOINT nm",
 /*  11 */ "cmd ::= RELEASE savepoint_opt nm",
 /*  12 */ "cmd ::= ROLLBACK trans_opt TO savepoint_opt nm",
 /*  13 */ "create_table ::= createkw temp TABLE ifnotexists nm dbnm",
 /*  14 */ "createkw ::= CREATE",
 /*  15 */ "ifnotexists ::=",
 /*  16 */ "ifnotexists ::= IF NOT EXISTS",
 /*  17 */ "temp ::= TEMP",
 /*  18 */ "temp ::=",
 /*  19 */ "create_table_args ::= LP columnlist conslist_opt RP table_option_set",
 /*  20 */ "create_table_args ::= AS select",
 /*  21 */ "table_option_set ::=",
 /*  22 */ "table_option_set ::= table_option_set COMMA table_option",
 /*  23 */ "table_option ::= WITHOUT nm",
 /*  24 */ "table_option ::= nm",
 /*  25 */ "columnname ::= nm typetoken",
 /*  26 */ "typetoken ::=",
 /*  27 */ "typetoken ::= typename LP signed RP",
 /*  28 */ "typetoken ::= typename LP signed COMMA signed RP",
 /*  29 */ "typename ::= typename ID|STRING",
 /*  30 */ "scanpt ::=",
 /*  31 */ "scantok ::=",
 /*  32 */ "ccons ::= CONSTRAINT nm",
 /*  33 */ "ccons ::= DEFAULT scantok term",
 /*  34 */ "ccons ::= DEFAULT LP expr RP",
 /*  35 */ "ccons ::= DEFAULT PLUS scantok term",
 /*  36 */ "ccons ::= DEFAULT MINUS scantok term",
 /*  37 */ "ccons ::= DEFAULT scantok ID|INDEXED",
 /*  38 */ "ccons ::= NOT NULL onconf",
 /*  39 */ "ccons ::= PRIMARY KEY sortorder onconf autoinc",
 /*  40 */ "ccons ::= UNIQUE onconf",
 /*  41 */ "ccons ::= CHECK LP expr RP",
 /*  42 */ "ccons ::= REFERENCES nm eidlist_opt refargs",
 /*  43 */ "ccons ::= defer_subclause",
 /*  44 */ "ccons ::= COLLATE ID|STRING",
 /*  45 */ "generated ::= LP expr RP",
 /*  46 */ "generated ::= LP expr RP ID",
 /*  47 */ "autoinc ::=",
 /*  48 */ "autoinc ::= AUTOINCR",
 /*  49 */ "refargs ::=",
 /*  50 */ "refargs ::= refargs refarg",
 /*  51 */ "refarg ::= MATCH nm",
 /*  52 */ "refarg ::= ON INSERT refact",
 /*  53 */ "refarg ::= ON DELETE refact",
 /*  54 */ "refarg ::= ON UPDATE refact",
 /*  55 */ "refact ::= SET NULL",
 /*  56 */ "refact ::= SET DEFAULT",
 /*  57 */ "refact ::= CASCADE",
 /*  58 */ "refact ::= RESTRICT",
 /*  59 */ "refact ::= NO ACTION",
 /*  60 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt",
 /*  61 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt",
 /*  62 */ "init_deferred_pred_opt ::=",
 /*  63 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED",
 /*  64 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE",
 /*  65 */ "conslist_opt ::=",
 /*  66 */ "tconscomma ::= COMMA",
 /*  67 */ "tcons ::= CONSTRAINT nm",
 /*  68 */ "tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf",
 /*  69 */ "tcons ::= UNIQUE LP sortlist RP onconf",
 /*  70 */ "tcons ::= CHECK LP expr RP onconf",
 /*  71 */ "tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt",
 /*  72 */ "defer_subclause_opt ::=",
 /*  73 */ "onconf ::=",
 /*  74 */ "onconf ::= ON CONFLICT resolvetype",
 /*  75 */ "orconf ::=",
 /*  76 */ "orconf ::= OR resolvetype",
 /*  77 */ "resolvetype ::= IGNORE",
 /*  78 */ "resolvetype ::= REPLACE",
 /*  79 */ "cmd ::= DROP TABLE ifexists fullname",
 /*  80 */ "ifexists ::= IF EXISTS",
 /*  81 */ "ifexists ::=",
 /*  82 */ "cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select",
 /*  83 */ "cmd ::= DROP VIEW ifexists fullname",
 /*  84 */ "cmd ::= select",
 /*  85 */ "select ::= WITH wqlist selectnowith",
 /*  86 */ "select ::= WITH RECURSIVE wqlist selectnowith",
 /*  87 */ "select ::= selectnowith",
 /*  88 */ "selectnowith ::= selectnowith multiselect_op oneselect",
 /*  89 */ "multiselect_op ::= UNION",
 /*  90 */ "multiselect_op ::= UNION ALL",
 /*  91 */ "multiselect_op ::= EXCEPT|INTERSECT",
 /*  92 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt",
 /*  93 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt",
 /*  94 */ "values ::= VALUES LP nexprlist RP",
 /*  95 */ "oneselect ::= mvalues",
 /*  96 */ "mvalues ::= values COMMA LP nexprlist RP",
 /*  97 */ "mvalues ::= mvalues COMMA LP nexprlist RP",
 /*  98 */ "distinct ::= DISTINCT",
 /*  99 */ "distinct ::= ALL",
 /* 100 */ "distinct ::=",
 /* 101 */ "sclp ::=",
 /* 102 */ "selcollist ::= sclp scanpt expr scanpt as",
 /* 103 */ "selcollist ::= sclp scanpt STAR",
 /* 104 */ "selcollist ::= sclp scanpt nm DOT STAR",
 /* 105 */ "as ::= AS nm",
 /* 106 */ "as ::=",
 /* 107 */ "from ::=",
 /* 108 */ "from ::= FROM seltablist",
 /* 109 */ "stl_prefix ::= seltablist joinop",
 /* 110 */ "stl_prefix ::=",
 /* 111 */ "seltablist ::= stl_prefix nm dbnm as on_using",
 /* 112 */ "seltablist ::= stl_prefix nm dbnm as indexed_by on_using",
 /* 113 */ "seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using",
 /* 114 */ "seltablist ::= stl_prefix LP select RP as on_using",
 /* 115 */ "seltablist ::= stl_prefix LP seltablist RP as on_using",
 /* 116 */ "dbnm ::=",
 /* 117 */ "dbnm ::= DOT nm",
 /* 118 */ "fullname ::= nm",
 /* 119 */ "fullname ::= nm DOT nm",
 /* 120 */ "xfullname ::= nm",
 /* 121 */ "xfullname ::= nm DOT nm",
 /* 122 */ "xfullname ::= nm AS nm",
 /* 123 */ "xfullname ::= nm DOT nm AS nm",
 /* 124 */ "joinop ::= COMMA|JOIN",
 /* 125 */ "joinop ::= JOIN_KW JOIN",
 /* 126 */ "joinop ::= JOIN_KW nm JOIN",
 /* 127 */ "joinop ::= JOIN_KW nm nm JOIN",
 /* 128 */ "on_using ::= ON expr",
 /* 129 */ "on_using ::= USING LP idlist RP",
 /* 130 */ "on_using ::=",
 /* 131 */ "indexed_opt ::=",
 /* 132 */ "indexed_by ::= INDEXED BY nm",
 /* 133 */ "indexed_by ::= NOT INDEXED",
 /* 134 */ "orderby_opt ::=",
 /* 135 */ "orderby_opt ::= ORDER BY sortlist",
 /* 136 */ "sortlist ::= sortlist COMMA expr sortorder nulls",
 /* 137 */ "sortlist ::= expr sortorder nulls",
 /* 138 */ "sortorder ::= ASC",
 /* 139 */ "sortorder ::= DESC",
 /* 140 */ "sortorder ::=",
 /* 141 */ "nulls ::= NULLS FIRST",
 /* 142 */ "nulls ::= NULLS LAST",
 /* 143 */ "nulls ::=",
 /* 144 */ "groupby_opt ::=",
 /* 145 */ "groupby_opt ::= GROUP BY nexprlist",
 /* 146 */ "having_opt ::=",
 /* 147 */ "having_opt ::= HAVING expr",
 /* 148 */ "limit_opt ::=",
 /* 149 */ "limit_opt ::= LIMIT expr",
 /* 150 */ "limit_opt ::= LIMIT expr OFFSET expr",
 /* 151 */ "limit_opt ::= LIMIT expr COMMA expr",
 /* 152 */ "cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret",
 /* 153 */ "where_opt ::=",
 /* 154 */ "where_opt ::= WHERE expr",
 /* 155 */ "where_opt_ret ::=",
 /* 156 */ "where_opt_ret ::= WHERE expr",
 /* 157 */ "where_opt_ret ::= RETURNING selcollist",
 /* 158 */ "where_opt_ret ::= WHERE expr RETURNING selcollist",
 /* 159 */ "cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret",
 /* 160 */ "setlist ::= setlist COMMA nm EQ expr",
 /* 161 */ "setlist ::= setlist COMMA LP idlist RP EQ expr",
 /* 162 */ "setlist ::= nm EQ expr",
 /* 163 */ "setlist ::= LP idlist RP EQ expr",
 /* 164 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert",
 /* 165 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning",
 /* 166 */ "upsert ::=",
 /* 167 */ "upsert ::= RETURNING selcollist",
 /* 168 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert",
 /* 169 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert",
 /* 170 */ "upsert ::= ON CONFLICT DO NOTHING returning",
 /* 171 */ "upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning",
 /* 172 */ "returning ::= RETURNING selcollist",
 /* 173 */ "insert_cmd ::= INSERT orconf",
 /* 174 */ "insert_cmd ::= REPLACE",
 /* 175 */ "idlist_opt ::=",
 /* 176 */ "idlist_opt ::= LP idlist RP",
 /* 177 */ "idlist ::= idlist COMMA nm",
 /* 178 */ "idlist ::= nm",
 /* 179 */ "expr ::= LP expr RP",
 /* 180 */ "expr ::= ID|INDEXED|JOIN_KW",
 /* 181 */ "expr ::= nm DOT nm",
 /* 182 */ "expr ::= nm DOT nm DOT nm",
 /* 183 */ "term ::= NULL|FLOAT|BLOB",
 /* 184 */ "term ::= STRING",
 /* 185 */ "term ::= INTEGER",
 /* 186 */ "expr ::= VARIABLE",
 /* 187 */ "expr ::= expr COLLATE ID|STRING",
 /* 188 */ "expr ::= CAST LP expr AS typetoken RP",
 /* 189 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP",
 /* 190 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP",
 /* 191 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP",
 /* 192 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over",
 /* 193 */ "expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over",
 /* 194 */ "expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over",
 /* 195 */ "term ::= CTIME_KW",
 /* 196 */ "expr ::= LP nexprlist COMMA expr RP",
 /* 197 */ "expr ::= expr AND expr",
 /* 198 */ "expr ::= expr OR expr",
 /* 199 */ "expr ::= expr LT|GT|GE|LE expr",
 /* 200 */ "expr ::= expr EQ|NE expr",
 /* 201 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr",
 /* 202 */ "expr ::= expr PLUS|MINUS expr",
 /* 203 */ "expr ::= expr STAR|SLASH|REM expr",
 /* 204 */ "expr ::= expr CONCAT expr",
 /* 205 */ "likeop ::= NOT LIKE_KW|MATCH",
 /* 206 */ "expr ::= expr likeop expr",
 /* 207 */ "expr ::= expr likeop expr ESCAPE expr",
 /* 208 */ "expr ::= expr ISNULL|NOTNULL",
 /* 209 */ "expr ::= expr NOT NULL",
 /* 210 */ "expr ::= expr IS expr",
 /* 211 */ "expr ::= expr IS NOT expr",
 /* 212 */ "expr ::= expr IS NOT DISTINCT FROM expr",
 /* 213 */ "expr ::= expr IS DISTINCT FROM expr",
 /* 214 */ "expr ::= NOT expr",
 /* 215 */ "expr ::= BITNOT expr",
 /* 216 */ "expr ::= PLUS|MINUS expr",
 /* 217 */ "expr ::= expr PTR expr",
 /* 218 */ "between_op ::= BETWEEN",
 /* 219 */ "between_op ::= NOT BETWEEN",
 /* 220 */ "expr ::= expr between_op expr AND expr",
 /* 221 */ "in_op ::= IN",
 /* 222 */ "in_op ::= NOT IN",
 /* 223 */ "expr ::= expr in_op LP exprlist RP",
 /* 224 */ "expr ::= LP select RP",
 /* 225 */ "expr ::= expr in_op LP select RP",
 /* 226 */ "expr ::= expr in_op nm dbnm paren_exprlist",
 /* 227 */ "expr ::= EXISTS LP select RP",
 /* 228 */ "expr ::= CASE case_operand case_exprlist case_else END",
 /* 229 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
 /* 230 */ "case_exprlist ::= WHEN expr THEN expr",
 /* 231 */ "case_else ::= ELSE expr",
 /* 232 */ "case_else ::=",
 /* 233 */ "case_operand ::=",
 /* 234 */ "exprlist ::=",
 /* 235 */ "nexprlist ::= nexprlist COMMA expr",
 /* 236 */ "nexprlist ::= expr",
 /* 237 */ "paren_exprlist ::=",
 /* 238 */ "paren_exprlist ::= LP exprlist RP",
 /* 239 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt",
 /* 240 */ "uniqueflag ::= UNIQUE",
 /* 241 */ "uniqueflag ::=",
 /* 242 */ "eidlist_opt ::=",
 /* 243 */ "eidlist_opt ::= LP eidlist RP",
 /* 244 */ "eidlist ::= eidlist COMMA nm collate sortorder",
 /* 245 */ "eidlist ::= nm collate sortorder",
 /* 246 */ "collate ::=",
 /* 247 */ "collate ::= COLLATE ID|STRING",
 /* 248 */ "cmd ::= DROP INDEX ifexists fullname",
 /* 249 */ "cmd ::= VACUUM vinto",
 /* 250 */ "cmd ::= VACUUM nm vinto",
 /* 251 */ "vinto ::= INTO expr",
 /* 252 */ "vinto ::=",
 /* 253 */ "cmd ::= PRAGMA nm dbnm",
 /* 254 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
 /* 255 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
 /* 256 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
 /* 257 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
 /* 258 */ "plus_num ::= PLUS INTEGER|FLOAT",
 /* 259 */ "minus_num ::= MINUS INTEGER|FLOAT",
 /* 260 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
 /* 261 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",
 /* 262 */ "trigger_time ::= BEFORE|AFTER",
 /* 263 */ "trigger_time ::= INSTEAD OF",
 /* 264 */ "trigger_time ::=",
 /* 265 */ "trigger_event ::= DELETE|INSERT",
 /* 266 */ "trigger_event ::= UPDATE",
 /* 267 */ "trigger_event ::= UPDATE OF idlist",
 /* 268 */ "when_clause ::=",
 /* 269 */ "when_clause ::= WHEN expr",
 /* 270 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
 /* 271 */ "trigger_cmd_list ::= trigger_cmd SEMI",
 /* 272 */ "tridxby ::= INDEXED BY nm",
 /* 273 */ "tridxby ::= NOT INDEXED",
 /* 274 */ "trigger_cmd ::= UPDATE orconf xfullname tridxby SET setlist from where_opt scanpt",
 /* 275 */ "trigger_cmd ::= scanpt insert_cmd INTO xfullname idlist_opt select upsert scanpt",
 /* 276 */ "trigger_cmd ::= DELETE FROM xfullname tridxby where_opt scanpt",
 /* 277 */ "trigger_cmd ::= scanpt select scanpt",
 /* 278 */ "expr ::= RAISE LP IGNORE RP",
 /* 279 */ "expr ::= RAISE LP raisetype COMMA expr RP",
 /* 280 */ "raisetype ::= ROLLBACK",
 /* 281 */ "raisetype ::= ABORT",
 /* 282 */ "raisetype ::= FAIL",
 /* 283 */ "cmd ::= DROP TRIGGER ifexists fullname",
 /* 284 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
 /* 285 */ "cmd ::= DETACH database_kw_opt expr",
 /* 286 */ "key_opt ::=",
 /* 287 */ "key_opt ::= KEY expr",
 /* 288 */ "cmd ::= REINDEX",
 /* 289 */ "cmd ::= REINDEX nm dbnm",
 /* 290 */ "cmd ::= ANALYZE",
 /* 291 */ "cmd ::= ANALYZE nm dbnm",
 /* 292 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
 /* 293 */ "cmd ::= alter_add carglist",
 /* 294 */ "alter_add ::= ALTER TABLE fullname ADD kwcolumn_opt nm typetoken",
 /* 295 */ "cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm",
 /* 296 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm",
 /* 297 */ "cmd ::= ALTER TABLE fullname DROP CONSTRAINT nm",
 /* 298 */ "cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm DROP NOT NULL",
 /* 299 */ "cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm SET NOT NULL onconf",
 /* 300 */ "cmd ::= ALTER TABLE fullname ADD CONSTRAINT nm CHECK LP expr RP onconf",
 /* 301 */ "cmd ::= ALTER TABLE fullname ADD CHECK LP expr RP onconf",
 /* 302 */ "cmd ::= create_vtab",
 /* 303 */ "cmd ::= create_vtab LP vtabarglist RP",
 /* 304 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
 /* 305 */ "vtabarg ::=",
 /* 306 */ "vtabargtoken ::= ANY",
 /* 307 */ "vtabargtoken ::= lp anylist RP",
 /* 308 */ "lp ::= LP",
 /* 309 */ "with ::= WITH wqlist",
 /* 310 */ "with ::= WITH RECURSIVE wqlist",
 /* 311 */ "wqas ::= AS",
 /* 312 */ "wqas ::= AS MATERIALIZED",
 /* 313 */ "wqas ::= AS NOT MATERIALIZED",
 /* 314 */ "wqitem ::= withnm eidlist_opt wqas LP select RP",
 /* 315 */ "withnm ::= nm",
 /* 316 */ "wqlist ::= wqitem",
 /* 317 */ "wqlist ::= wqlist COMMA wqitem",
 /* 318 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn",
 /* 319 */ "windowdefn ::= nm AS LP window RP",
 /* 320 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt",
 /* 321 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt",
 /* 322 */ "window ::= ORDER BY sortlist frame_opt",
 /* 323 */ "window ::= nm ORDER BY sortlist frame_opt",
 /* 324 */ "window ::= nm frame_opt",
 /* 325 */ "frame_opt ::=",
 /* 326 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt",
 /* 327 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt",
 /* 328 */ "range_or_rows ::= RANGE|ROWS|GROUPS",
 /* 329 */ "frame_bound_s ::= frame_bound",
 /* 330 */ "frame_bound_s ::= UNBOUNDED PRECEDING",
 /* 331 */ "frame_bound_e ::= frame_bound",
 /* 332 */ "frame_bound_e ::= UNBOUNDED FOLLOWING",
 /* 333 */ "frame_bound ::= expr PRECEDING|FOLLOWING",
 /* 334 */ "frame_bound ::= CURRENT ROW",
 /* 335 */ "frame_exclude_opt ::=",
 /* 336 */ "frame_exclude_opt ::= EXCLUDE frame_exclude",
 /* 337 */ "frame_exclude ::= NO OTHERS",
 /* 338 */ "frame_exclude ::= CURRENT ROW",
 /* 339 */ "frame_exclude ::= GROUP|TIES",
 /* 340 */ "window_clause ::= WINDOW windowdefn_list",
 /* 341 */ "filter_over ::= filter_clause over_clause",
 /* 342 */ "filter_over ::= over_clause",
 /* 343 */ "filter_over ::= filter_clause",
 /* 344 */ "over_clause ::= OVER LP window RP",
 /* 345 */ "over_clause ::= OVER nm",
 /* 346 */ "filter_clause ::= FILTER LP WHERE expr RP",
 /* 347 */ "term ::= QNUMBER",
 /* 348 */ "input ::= cmdlist",
 /* 349 */ "cmdlist ::= cmdlist ecmd",
 /* 350 */ "cmdlist ::= ecmd",
 /* 351 */ "ecmd ::= SEMI",
 /* 352 */ "ecmd ::= cmdx SEMI",
 /* 353 */ "ecmd ::= explain cmdx SEMI",
 /* 354 */ "trans_opt ::=",
 /* 355 */ "trans_opt ::= TRANSACTION",
 /* 356 */ "trans_opt ::= TRANSACTION nm",
 /* 357 */ "savepoint_opt ::= SAVEPOINT",
 /* 358 */ "savepoint_opt ::=",
 /* 359 */ "cmd ::= create_table create_table_args",
 /* 360 */ "table_option_set ::= table_option",
 /* 361 */ "columnlist ::= columnlist COMMA columnname carglist",
 /* 362 */ "columnlist ::= columnname carglist",
 /* 363 */ "nm ::= ID|INDEXED|JOIN_KW",
 /* 364 */ "nm ::= STRING",
 /* 365 */ "typetoken ::= typename",
 /* 366 */ "typename ::= ID|STRING",
 /* 367 */ "signed ::= plus_num",
 /* 368 */ "signed ::= minus_num",
 /* 369 */ "carglist ::= carglist ccons",
 /* 370 */ "carglist ::=",
 /* 371 */ "ccons ::= NULL onconf",
 /* 372 */ "ccons ::= GENERATED ALWAYS AS generated",
 /* 373 */ "ccons ::= AS generated",
 /* 374 */ "conslist_opt ::= COMMA conslist",
 /* 375 */ "conslist ::= conslist tconscomma tcons",
 /* 376 */ "conslist ::= tcons",
 /* 377 */ "tconscomma ::=",
 /* 378 */ "defer_subclause_opt ::= defer_subclause",
 /* 379 */ "resolvetype ::= raisetype",
 /* 380 */ "selectnowith ::= oneselect",
 /* 381 */ "oneselect ::= values",
 /* 382 */ "sclp ::= selcollist COMMA",
 /* 383 */ "as ::= ID|STRING",
 /* 384 */ "indexed_opt ::= indexed_by",
 /* 385 */ "returning ::=",
 /* 386 */ "expr ::= term",
 /* 387 */ "likeop ::= LIKE_KW|MATCH",
 /* 388 */ "case_operand ::= expr",
 /* 389 */ "exprlist ::= nexprlist",
 /* 390 */ "nmnum ::= plus_num",
 /* 391 */ "nmnum ::= nm",
 /* 392 */ "nmnum ::= ON",
 /* 393 */ "nmnum ::= DELETE",
 /* 394 */ "nmnum ::= DEFAULT",
 /* 395 */ "plus_num ::= INTEGER|FLOAT",
 /* 396 */ "foreach_clause ::=",
 /* 397 */ "foreach_clause ::= FOR EACH ROW",
 /* 398 */ "tridxby ::=",
 /* 399 */ "database_kw_opt ::= DATABASE",
 /* 400 */ "database_kw_opt ::=",
 /* 401 */ "kwcolumn_opt ::=",
 /* 402 */ "kwcolumn_opt ::= COLUMNKW",
 /* 403 */ "vtabarglist ::= vtabarg",
 /* 404 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
 /* 405 */ "vtabarg ::= vtabarg vtabargtoken",
 /* 406 */ "anylist ::=",
 /* 407 */ "anylist ::= anylist LP anylist RP",
 /* 408 */ "anylist ::= anylist ANY",
 /* 409 */ "with ::=",
 /* 410 */ "windowdefn_list ::= windowdefn",
 /* 411 */ "window ::= frame_opt",
};
#endif /* NDEBUG */


#if YYGROWABLESTACK
/*
** Try to increase the size of the parser stack.  Return the number
** of errors.  Return 0 on success.
*/
static int yyGrowStack(yyParser *p){
  int oldSize = 1 + (int)(p->yystackEnd - p->yystack);
  int newSize;
  int idx;
  yyStackEntry *pNew;
#ifdef YYSIZELIMIT
  int nLimit = YYSIZELIMIT(sqlite3ParserCTX(p));
#endif

  newSize = oldSize*2 + 100;
#ifdef YYSIZELIMIT
  if( newSize>nLimit ){
    newSize = nLimit;
    if( newSize<=oldSize ) return 1;
  }
#endif
  idx = (int)(p->yytos - p->yystack);
  if( p->yystack==p->yystk0 ){
    pNew = YYREALLOC(0, newSize*sizeof(pNew[0]), sqlite3ParserCTX(p));
    if( pNew==0 ) return 1;
    memcpy(pNew, p->yystack, oldSize*sizeof(pNew[0]));
  }else{
    pNew = YYREALLOC(p->yystack, newSize*sizeof(pNew[0]), sqlite3ParserCTX(p));
    if( pNew==0 ) return 1;
  }
  p->yystack = pNew;
  p->yytos = &p->yystack[idx];
#ifndef NDEBUG
  if( yyTraceFILE ){
    fprintf(yyTraceFILE,"%sStack grows from %d to %d entries.\n",
            yyTracePrompt, oldSize, newSize);
  }
#endif
  p->yystackEnd = &p->yystack[newSize-1];
  return 0;
}
#endif /* YYGROWABLESTACK */

#if !YYGROWABLESTACK
/* For builds that do no have a growable stack, yyGrowStack always
** returns an error.
*/
# define yyGrowStack(X) 1
#endif

/* Datatype of the argument to the memory allocated passed as the
** second argument to sqlite3ParserAlloc() below.  This can be changed by
** putting an appropriate #define in the %include section of the input
** grammar.
*/
#ifndef YYMALLOCARGTYPE
# define YYMALLOCARGTYPE size_t
#endif

/* Initialize a new parser that has already been allocated.
*/
void sqlite3ParserInit(void *yypRawParser sqlite3ParserCTX_PDECL){
  yyParser *yypParser = (yyParser*)yypRawParser;
  sqlite3ParserCTX_STORE
#ifdef YYTRACKMAXSTACKDEPTH
  yypParser->yyhwm = 0;
#endif
  yypParser->yystack = yypParser->yystk0;
  yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH-1];
#ifndef YYNOERRORRECOVERY
  yypParser->yyerrcnt = -1;
#endif
  yypParser->yytos = yypParser->yystack;
  yypParser->yystack[0].stateno = 0;
  yypParser->yystack[0].major = 0;
}

#ifndef sqlite3Parser_ENGINEALWAYSONSTACK
/* 
** This function allocates a new parser.
** The only argument is a pointer to a function which works like
** malloc.
**
** Inputs:
** A pointer to the function used to allocate memory.
**
** Outputs:
** A pointer to a parser.  This pointer is used in subsequent calls
** to sqlite3Parser and sqlite3ParserFree.
*/
void *sqlite3ParserAlloc(void *(*mallocProc)(YYMALLOCARGTYPE) sqlite3ParserCTX_PDECL){
  yyParser *yypParser;
  yypParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );
  if( yypParser ){
    sqlite3ParserCTX_STORE
    sqlite3ParserInit(yypParser sqlite3ParserCTX_PARAM);
  }
  return (void*)yypParser;
}
#endif /* sqlite3Parser_ENGINEALWAYSONSTACK */


/* The following function deletes the "minor type" or semantic value
** associated with a symbol.  The symbol can be either a terminal
** or nonterminal. "yymajor" is the symbol code, and "yypminor" is
** a pointer to the value to be deleted.  The code used to do the 
** deletions is derived from the %destructor and/or %token_destructor
** directives of the input grammar.
*/
static void yy_destructor(
  yyParser *yypParser,    /* The parser */
  YYCODETYPE yymajor,     /* Type code for object to destroy */
  YYMINORTYPE *yypminor   /* The object to be destroyed */
){
  sqlite3ParserARG_FETCH
  sqlite3ParserCTX_FETCH
  switch( yymajor ){
    /* Here is inserted the actions which take place when a
    ** terminal or non-terminal is destroyed.  This can happen
    ** when the symbol is popped from the stack during a
    ** reduce or during error processing or when a parser is 
    ** being destroyed before it is finished parsing.
    **
    ** Note: during a reduce, the only symbols destroyed are those
    ** which appear on the RHS of the rule, but which are *not* used
    ** inside the C code.
    */
/********* Begin destructor definitions ***************************************/
    case 206: /* select */
    case 241: /* selectnowith */
    case 242: /* oneselect */
    case 254: /* values */
    case 256: /* mvalues */
{
#line 531 "parse.y"
sqlite3SelectDelete(pParse->db, (yypminor->yy555));
#line 2551 "parse.c"
}
      break;
    case 218: /* term */
    case 219: /* expr */
    case 248: /* where_opt */
    case 250: /* having_opt */
    case 270: /* where_opt_ret */
    case 281: /* case_operand */
    case 283: /* case_else */
    case 286: /* vinto */
    case 293: /* when_clause */
    case 297: /* key_opt */
    case 314: /* filter_clause */
{
#line 1141 "parse.y"
sqlite3ExprDelete(pParse->db, (yypminor->yy454));
#line 2568 "parse.c"
}
      break;
    case 223: /* eidlist_opt */
    case 233: /* sortlist */
    case 234: /* eidlist */
    case 246: /* selcollist */
    case 249: /* groupby_opt */
    case 251: /* orderby_opt */
    case 255: /* nexprlist */
    case 257: /* sclp */
    case 264: /* exprlist */
    case 271: /* setlist */
    case 280: /* paren_exprlist */
    case 282: /* case_exprlist */
    case 313: /* part_opt */
{
#line 1665 "parse.y"
sqlite3ExprListDelete(pParse->db, (yypminor->yy14));
#line 2587 "parse.c"
}
      break;
    case 240: /* fullname */
    case 247: /* from */
    case 259: /* seltablist */
    case 260: /* stl_prefix */
    case 265: /* xfullname */
{
#line 830 "parse.y"
sqlite3SrcListDelete(pParse->db, (yypminor->yy203));
#line 2598 "parse.c"
}
      break;
    case 243: /* wqlist */
{
#line 1961 "parse.y"
sqlite3WithDelete(pParse->db, (yypminor->yy59));
#line 2605 "parse.c"
}
      break;
    case 253: /* window_clause */
    case 309: /* windowdefn_list */
{
#line 2090 "parse.y"
sqlite3WindowListDelete(pParse->db, (yypminor->yy211));
#line 2613 "parse.c"
}
      break;
    case 266: /* idlist */
    case 273: /* idlist_opt */
{
#line 1126 "parse.y"
sqlite3IdListDelete(pParse->db, (yypminor->yy132));
#line 2621 "parse.c"
}
      break;
    case 276: /* filter_over */
    case 310: /* windowdefn */
    case 311: /* window */
    case 312: /* frame_opt */
    case 315: /* over_clause */
{
#line 2029 "parse.y"
sqlite3WindowDelete(pParse->db, (yypminor->yy211));
#line 2632 "parse.c"
}
      break;
    case 289: /* trigger_cmd_list */
    case 294: /* trigger_cmd */
{
#line 1784 "parse.y"
sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy427));
#line 2640 "parse.c"
}
      break;
    case 291: /* trigger_event */
{
#line 1770 "parse.y"
sqlite3IdListDelete(pParse->db, (yypminor->yy286).b);
#line 2647 "parse.c"
}
      break;
    case 317: /* frame_bound */
    case 318: /* frame_bound_s */
    case 319: /* frame_bound_e */
{
#line 2034 "parse.y"
sqlite3ExprDelete(pParse->db, (yypminor->yy509).pExpr);
#line 2656 "parse.c"
}
      break;
/********* End destructor definitions *****************************************/
    default:  break;   /* If no destructor action specified: do nothing */
  }
}

/*
** Pop the parser's stack once.
**
** If there is a destructor routine associated with the token which
** is popped from the stack, then call it.
*/
static void yy_pop_parser_stack(yyParser *pParser){
  yyStackEntry *yytos;
  assert( pParser->yytos!=0 );
  assert( pParser->yytos > pParser->yystack );
  yytos = pParser->yytos--;
#ifndef NDEBUG
  if( yyTraceFILE ){
    fprintf(yyTraceFILE,"%sPopping %s\n",
      yyTracePrompt,
      yyTokenName[yytos->major]);
  }
#endif
  yy_destructor(pParser, yytos->major, &yytos->minor);
}

/*
** Clear all secondary memory allocations from the parser
*/
void sqlite3ParserFinalize(void *p){
  yyParser *pParser = (yyParser*)p;

  /* In-lined version of calling yy_pop_parser_stack() for each
  ** element left in the stack */
  yyStackEntry *yytos = pParser->yytos;
  while( yytos>pParser->yystack ){
#ifndef NDEBUG
    if( yyTraceFILE ){
      fprintf(yyTraceFILE,"%sPopping %s\n",
        yyTracePrompt,
        yyTokenName[yytos->major]);
    }
#endif
    if( yytos->major>=YY_MIN_DSTRCTR ){
      yy_destructor(pParser, yytos->major, &yytos->minor);
    }
    yytos--;
  }

#if YYGROWABLESTACK
  if( pParser->yystack!=pParser->yystk0 ){
    YYFREE(pParser->yystack, sqlite3ParserCTX(pParser));
  }
#endif
}

#ifndef sqlite3Parser_ENGINEALWAYSONSTACK
/* 
** Deallocate and destroy a parser.  Destructors are called for
** all stack elements before shutting the parser down.
**
** If the YYPARSEFREENEVERNULL macro exists (for example because it
** is defined in a %include section of the input grammar) then it is
** assumed that the input pointer is never NULL.
*/
void sqlite3ParserFree(
  void *p,                    /* The parser to be deleted */
  void (*freeProc)(void*)     /* Function used to reclaim memory */
){
#ifndef YYPARSEFREENEVERNULL
  if( p==0 ) return;
#endif
  sqlite3ParserFinalize(p);
  (*freeProc)(p);
}
#endif /* sqlite3Parser_ENGINEALWAYSONSTACK */

/*
** Return the peak depth of the stack for a parser.
*/
#ifdef YYTRACKMAXSTACKDEPTH
int sqlite3ParserStackPeak(void *p){
  yyParser *pParser = (yyParser*)p;
  return pParser->yyhwm;
}
#endif

/* This array of booleans keeps track of the parser statement
** coverage.  The element yycoverage[X][Y] is set when the parser
** is in state X and has a lookahead token Y.  In a well-tested
** systems, every element of this matrix should end up being set.
*/
#if defined(YYCOVERAGE)
static unsigned char yycoverage[YYNSTATE][YYNTOKEN];
#endif

/*
** Write into out a description of every state/lookahead combination that
**
**   (1)  has not been used by the parser, and
**   (2)  is not a syntax error.
**
** Return the number of missed state/lookahead combinations.
*/
#if defined(YYCOVERAGE)
int sqlite3ParserCoverage(FILE *out){
  int stateno, iLookAhead, i;
  int nMissed = 0;
  for(stateno=0; stateno<YYNSTATE; stateno++){
    i = yy_shift_ofst[stateno];
    for(iLookAhead=0; iLookAhead<YYNTOKEN; iLookAhead++){
      if( yy_lookahead[i+iLookAhead]!=iLookAhead ) continue;
      if( yycoverage[stateno][iLookAhead]==0 ) nMissed++;
      if( out ){
        fprintf(out,"State %d lookahead %s %s\n", stateno,
                yyTokenName[iLookAhead],
                yycoverage[stateno][iLookAhead] ? "ok" : "missed");
      }
    }
  }
  return nMissed;
}
#endif

/*
** Find the appropriate action for a parser given the terminal
** look-ahead token iLookAhead.
*/
static YYACTIONTYPE yy_find_shift_action(
  YYCODETYPE iLookAhead,    /* The look-ahead token */
  YYACTIONTYPE stateno      /* Current state number */
){
  int i;

  if( stateno>YY_MAX_SHIFT ) return stateno;
  assert( stateno <= YY_SHIFT_COUNT );
#if defined(YYCOVERAGE)
  yycoverage[stateno][iLookAhead] = 1;
#endif
  do{
    i = yy_shift_ofst[stateno];
    assert( i>=0 );
    assert( i<=YY_ACTTAB_COUNT );
    assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD );
    assert( iLookAhead!=YYNOCODE );
    assert( iLookAhead < YYNTOKEN );
    i += iLookAhead;
    assert( i<(int)YY_NLOOKAHEAD );
    if( yy_lookahead[i]!=iLookAhead ){
#ifdef YYFALLBACK
      YYCODETYPE iFallback;            /* Fallback token */
      assert( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0]) );
      iFallback = yyFallback[iLookAhead];
      if( iFallback!=0 ){
#ifndef NDEBUG
        if( yyTraceFILE ){
          fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
             yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
        }
#endif
        assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
        iLookAhead = iFallback;
        continue;
      }
#endif
#ifdef YYWILDCARD
      {
        int j = i - iLookAhead + YYWILDCARD;
        assert( j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) );
        if( yy_lookahead[j]==YYWILDCARD && iLookAhead>0 ){
#ifndef NDEBUG
          if( yyTraceFILE ){
            fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
               yyTracePrompt, yyTokenName[iLookAhead],
               yyTokenName[YYWILDCARD]);
          }
#endif /* NDEBUG */
          return yy_action[j];
        }
      }
#endif /* YYWILDCARD */
      return yy_default[stateno];
    }else{
      assert( i>=0 && i<(int)(sizeof(yy_action)/sizeof(yy_action[0])) );
      return yy_action[i];
    }
  }while(1);
}

/*
** Find the appropriate action for a parser given the non-terminal
** look-ahead token iLookAhead.
*/
static YYACTIONTYPE yy_find_reduce_action(
  YYACTIONTYPE stateno,     /* Current state number */
  YYCODETYPE iLookAhead     /* The look-ahead token */
){
  int i;
#ifdef YYERRORSYMBOL
  if( stateno>YY_REDUCE_COUNT ){
    return yy_default[stateno];
  }
#else
  assert( stateno<=YY_REDUCE_COUNT );
#endif
  i = yy_reduce_ofst[stateno];
  assert( iLookAhead!=YYNOCODE );
  i += iLookAhead;
#ifdef YYERRORSYMBOL
  if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
    return yy_default[stateno];
  }
#else
  assert( i>=0 && i<YY_ACTTAB_COUNT );
  assert( yy_lookahead[i]==iLookAhead );
#endif
  return yy_action[i];
}

/*
** The following routine is called if the stack overflows.
*/
static void yyStackOverflow(yyParser *yypParser){
   sqlite3ParserARG_FETCH
   sqlite3ParserCTX_FETCH
#ifndef NDEBUG
   if( yyTraceFILE ){
     fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
   }
#endif
   while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);
   /* Here code is inserted which will execute if the parser
   ** stack every overflows */
/******** Begin %stack_overflow code ******************************************/
#line 53 "parse.y"

  if( pParse->nErr==0 ) sqlite3ErrorMsg(pParse, "Recursion limit");
#line 2896 "parse.c"
/******** End %stack_overflow code ********************************************/
   sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument var */
   sqlite3ParserCTX_STORE
}

/*
** Print tracing information for a SHIFT action
*/
#ifndef NDEBUG
static void yyTraceShift(yyParser *yypParser, int yyNewState, const char *zTag){
  if( yyTraceFILE ){
    if( yyNewState<YYNSTATE ){
      fprintf(yyTraceFILE,"%s%s '%s', go to state %d\n",
         yyTracePrompt, zTag, yyTokenName[yypParser->yytos->major],
         yyNewState);
    }else{
      fprintf(yyTraceFILE,"%s%s '%s', pending reduce %d\n",
         yyTracePrompt, zTag, yyTokenName[yypParser->yytos->major],
         yyNewState - YY_MIN_REDUCE);
    }
  }
}
#else
# define yyTraceShift(X,Y,Z)
#endif

/*
** Perform a shift action.
*/
static void yy_shift(
  yyParser *yypParser,          /* The parser to be shifted */
  YYACTIONTYPE yyNewState,      /* The new state to shift in */
  YYCODETYPE yyMajor,           /* The major token to shift in */
  sqlite3ParserTOKENTYPE yyMinor        /* The minor token to shift in */
){
  yyStackEntry *yytos;
  yypParser->yytos++;
#ifdef YYTRACKMAXSTACKDEPTH
  if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
    yypParser->yyhwm++;
    assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) );
  }
#endif
  yytos = yypParser->yytos;
  if( yytos>yypParser->yystackEnd ){
    if( yyGrowStack(yypParser) ){
      yypParser->yytos--;
      yyStackOverflow(yypParser);
      return;
    }
    yytos = yypParser->yytos;
    assert( yytos <= yypParser->yystackEnd );
  }
  if( yyNewState > YY_MAX_SHIFT ){
    yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
  }
  yytos->stateno = yyNewState;
  yytos->major = yyMajor;
  yytos->minor.yy0 = yyMinor;
  yyTraceShift(yypParser, yyNewState, "Shift");
}

/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side
** of that rule */
static const YYCODETYPE yyRuleInfoLhs[] = {
   191,  /* (0) explain ::= EXPLAIN */
   191,  /* (1) explain ::= EXPLAIN QUERY PLAN */
   190,  /* (2) cmdx ::= cmd */
   192,  /* (3) cmd ::= BEGIN transtype trans_opt */
   193,  /* (4) transtype ::= */
   193,  /* (5) transtype ::= DEFERRED */
   193,  /* (6) transtype ::= IMMEDIATE */
   193,  /* (7) transtype ::= EXCLUSIVE */
   192,  /* (8) cmd ::= COMMIT|END trans_opt */
   192,  /* (9) cmd ::= ROLLBACK trans_opt */
   192,  /* (10) cmd ::= SAVEPOINT nm */
   192,  /* (11) cmd ::= RELEASE savepoint_opt nm */
   192,  /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
   197,  /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */
   199,  /* (14) createkw ::= CREATE */
   201,  /* (15) ifnotexists ::= */
   201,  /* (16) ifnotexists ::= IF NOT EXISTS */
   200,  /* (17) temp ::= TEMP */
   200,  /* (18) temp ::= */
   198,  /* (19) create_table_args ::= LP columnlist conslist_opt RP table_option_set */
   198,  /* (20) create_table_args ::= AS select */
   205,  /* (21) table_option_set ::= */
   205,  /* (22) table_option_set ::= table_option_set COMMA table_option */
   207,  /* (23) table_option ::= WITHOUT nm */
   207,  /* (24) table_option ::= nm */
   208,  /* (25) columnname ::= nm typetoken */
   210,  /* (26) typetoken ::= */
   210,  /* (27) typetoken ::= typename LP signed RP */
   210,  /* (28) typetoken ::= typename LP signed COMMA signed RP */
   211,  /* (29) typename ::= typename ID|STRING */
   215,  /* (30) scanpt ::= */
   216,  /* (31) scantok ::= */
   217,  /* (32) ccons ::= CONSTRAINT nm */
   217,  /* (33) ccons ::= DEFAULT scantok term */
   217,  /* (34) ccons ::= DEFAULT LP expr RP */
   217,  /* (35) ccons ::= DEFAULT PLUS scantok term */
   217,  /* (36) ccons ::= DEFAULT MINUS scantok term */
   217,  /* (37) ccons ::= DEFAULT scantok ID|INDEXED */
   217,  /* (38) ccons ::= NOT NULL onconf */
   217,  /* (39) ccons ::= PRIMARY KEY sortorder onconf autoinc */
   217,  /* (40) ccons ::= UNIQUE onconf */
   217,  /* (41) ccons ::= CHECK LP expr RP */
   217,  /* (42) ccons ::= REFERENCES nm eidlist_opt refargs */
   217,  /* (43) ccons ::= defer_subclause */
   217,  /* (44) ccons ::= COLLATE ID|STRING */
   226,  /* (45) generated ::= LP expr RP */
   226,  /* (46) generated ::= LP expr RP ID */
   222,  /* (47) autoinc ::= */
   222,  /* (48) autoinc ::= AUTOINCR */
   224,  /* (49) refargs ::= */
   224,  /* (50) refargs ::= refargs refarg */
   227,  /* (51) refarg ::= MATCH nm */
   227,  /* (52) refarg ::= ON INSERT refact */
   227,  /* (53) refarg ::= ON DELETE refact */
   227,  /* (54) refarg ::= ON UPDATE refact */
   228,  /* (55) refact ::= SET NULL */
   228,  /* (56) refact ::= SET DEFAULT */
   228,  /* (57) refact ::= CASCADE */
   228,  /* (58) refact ::= RESTRICT */
   228,  /* (59) refact ::= NO ACTION */
   225,  /* (60) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
   225,  /* (61) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
   229,  /* (62) init_deferred_pred_opt ::= */
   229,  /* (63) init_deferred_pred_opt ::= INITIALLY DEFERRED */
   229,  /* (64) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
   204,  /* (65) conslist_opt ::= */
   231,  /* (66) tconscomma ::= COMMA */
   232,  /* (67) tcons ::= CONSTRAINT nm */
   232,  /* (68) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
   232,  /* (69) tcons ::= UNIQUE LP sortlist RP onconf */
   232,  /* (70) tcons ::= CHECK LP expr RP onconf */
   232,  /* (71) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
   235,  /* (72) defer_subclause_opt ::= */
   220,  /* (73) onconf ::= */
   220,  /* (74) onconf ::= ON CONFLICT resolvetype */
   236,  /* (75) orconf ::= */
   236,  /* (76) orconf ::= OR resolvetype */
   237,  /* (77) resolvetype ::= IGNORE */
   237,  /* (78) resolvetype ::= REPLACE */
   192,  /* (79) cmd ::= DROP TABLE ifexists fullname */
   239,  /* (80) ifexists ::= IF EXISTS */
   239,  /* (81) ifexists ::= */
   192,  /* (82) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
   192,  /* (83) cmd ::= DROP VIEW ifexists fullname */
   192,  /* (84) cmd ::= select */
   206,  /* (85) select ::= WITH wqlist selectnowith */
   206,  /* (86) select ::= WITH RECURSIVE wqlist selectnowith */
   206,  /* (87) select ::= selectnowith */
   241,  /* (88) selectnowith ::= selectnowith multiselect_op oneselect */
   244,  /* (89) multiselect_op ::= UNION */
   244,  /* (90) multiselect_op ::= UNION ALL */
   244,  /* (91) multiselect_op ::= EXCEPT|INTERSECT */
   242,  /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
   242,  /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
   254,  /* (94) values ::= VALUES LP nexprlist RP */
   242,  /* (95) oneselect ::= mvalues */
   256,  /* (96) mvalues ::= values COMMA LP nexprlist RP */
   256,  /* (97) mvalues ::= mvalues COMMA LP nexprlist RP */
   245,  /* (98) distinct ::= DISTINCT */
   245,  /* (99) distinct ::= ALL */
   245,  /* (100) distinct ::= */
   257,  /* (101) sclp ::= */
   246,  /* (102) selcollist ::= sclp scanpt expr scanpt as */
   246,  /* (103) selcollist ::= sclp scanpt STAR */
   246,  /* (104) selcollist ::= sclp scanpt nm DOT STAR */
   258,  /* (105) as ::= AS nm */
   258,  /* (106) as ::= */
   247,  /* (107) from ::= */
   247,  /* (108) from ::= FROM seltablist */
   260,  /* (109) stl_prefix ::= seltablist joinop */
   260,  /* (110) stl_prefix ::= */
   259,  /* (111) seltablist ::= stl_prefix nm dbnm as on_using */
   259,  /* (112) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
   259,  /* (113) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
   259,  /* (114) seltablist ::= stl_prefix LP select RP as on_using */
   259,  /* (115) seltablist ::= stl_prefix LP seltablist RP as on_using */
   202,  /* (116) dbnm ::= */
   202,  /* (117) dbnm ::= DOT nm */
   240,  /* (118) fullname ::= nm */
   240,  /* (119) fullname ::= nm DOT nm */
   265,  /* (120) xfullname ::= nm */
   265,  /* (121) xfullname ::= nm DOT nm */
   265,  /* (122) xfullname ::= nm AS nm */
   265,  /* (123) xfullname ::= nm DOT nm AS nm */
   261,  /* (124) joinop ::= COMMA|JOIN */
   261,  /* (125) joinop ::= JOIN_KW JOIN */
   261,  /* (126) joinop ::= JOIN_KW nm JOIN */
   261,  /* (127) joinop ::= JOIN_KW nm nm JOIN */
   262,  /* (128) on_using ::= ON expr */
   262,  /* (129) on_using ::= USING LP idlist RP */
   262,  /* (130) on_using ::= */
   267,  /* (131) indexed_opt ::= */
   263,  /* (132) indexed_by ::= INDEXED BY nm */
   263,  /* (133) indexed_by ::= NOT INDEXED */
   251,  /* (134) orderby_opt ::= */
   251,  /* (135) orderby_opt ::= ORDER BY sortlist */
   233,  /* (136) sortlist ::= sortlist COMMA expr sortorder nulls */
   233,  /* (137) sortlist ::= expr sortorder nulls */
   221,  /* (138) sortorder ::= ASC */
   221,  /* (139) sortorder ::= DESC */
   221,  /* (140) sortorder ::= */
   268,  /* (141) nulls ::= NULLS FIRST */
   268,  /* (142) nulls ::= NULLS LAST */
   268,  /* (143) nulls ::= */
   249,  /* (144) groupby_opt ::= */
   249,  /* (145) groupby_opt ::= GROUP BY nexprlist */
   250,  /* (146) having_opt ::= */
   250,  /* (147) having_opt ::= HAVING expr */
   252,  /* (148) limit_opt ::= */
   252,  /* (149) limit_opt ::= LIMIT expr */
   252,  /* (150) limit_opt ::= LIMIT expr OFFSET expr */
   252,  /* (151) limit_opt ::= LIMIT expr COMMA expr */
   192,  /* (152) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
   248,  /* (153) where_opt ::= */
   248,  /* (154) where_opt ::= WHERE expr */
   270,  /* (155) where_opt_ret ::= */
   270,  /* (156) where_opt_ret ::= WHERE expr */
   270,  /* (157) where_opt_ret ::= RETURNING selcollist */
   270,  /* (158) where_opt_ret ::= WHERE expr RETURNING selcollist */
   192,  /* (159) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
   271,  /* (160) setlist ::= setlist COMMA nm EQ expr */
   271,  /* (161) setlist ::= setlist COMMA LP idlist RP EQ expr */
   271,  /* (162) setlist ::= nm EQ expr */
   271,  /* (163) setlist ::= LP idlist RP EQ expr */
   192,  /* (164) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
   192,  /* (165) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
   274,  /* (166) upsert ::= */
   274,  /* (167) upsert ::= RETURNING selcollist */
   274,  /* (168) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
   274,  /* (169) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
   274,  /* (170) upsert ::= ON CONFLICT DO NOTHING returning */
   274,  /* (171) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
   275,  /* (172) returning ::= RETURNING selcollist */
   272,  /* (173) insert_cmd ::= INSERT orconf */
   272,  /* (174) insert_cmd ::= REPLACE */
   273,  /* (175) idlist_opt ::= */
   273,  /* (176) idlist_opt ::= LP idlist RP */
   266,  /* (177) idlist ::= idlist COMMA nm */
   266,  /* (178) idlist ::= nm */
   219,  /* (179) expr ::= LP expr RP */
   219,  /* (180) expr ::= ID|INDEXED|JOIN_KW */
   219,  /* (181) expr ::= nm DOT nm */
   219,  /* (182) expr ::= nm DOT nm DOT nm */
   218,  /* (183) term ::= NULL|FLOAT|BLOB */
   218,  /* (184) term ::= STRING */
   218,  /* (185) term ::= INTEGER */
   219,  /* (186) expr ::= VARIABLE */
   219,  /* (187) expr ::= expr COLLATE ID|STRING */
   219,  /* (188) expr ::= CAST LP expr AS typetoken RP */
   219,  /* (189) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
   219,  /* (190) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
   219,  /* (191) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
   219,  /* (192) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
   219,  /* (193) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
   219,  /* (194) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
   218,  /* (195) term ::= CTIME_KW */
   219,  /* (196) expr ::= LP nexprlist COMMA expr RP */
   219,  /* (197) expr ::= expr AND expr */
   219,  /* (198) expr ::= expr OR expr */
   219,  /* (199) expr ::= expr LT|GT|GE|LE expr */
   219,  /* (200) expr ::= expr EQ|NE expr */
   219,  /* (201) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
   219,  /* (202) expr ::= expr PLUS|MINUS expr */
   219,  /* (203) expr ::= expr STAR|SLASH|REM expr */
   219,  /* (204) expr ::= expr CONCAT expr */
   277,  /* (205) likeop ::= NOT LIKE_KW|MATCH */
   219,  /* (206) expr ::= expr likeop expr */
   219,  /* (207) expr ::= expr likeop expr ESCAPE expr */
   219,  /* (208) expr ::= expr ISNULL|NOTNULL */
   219,  /* (209) expr ::= expr NOT NULL */
   219,  /* (210) expr ::= expr IS expr */
   219,  /* (211) expr ::= expr IS NOT expr */
   219,  /* (212) expr ::= expr IS NOT DISTINCT FROM expr */
   219,  /* (213) expr ::= expr IS DISTINCT FROM expr */
   219,  /* (214) expr ::= NOT expr */
   219,  /* (215) expr ::= BITNOT expr */
   219,  /* (216) expr ::= PLUS|MINUS expr */
   219,  /* (217) expr ::= expr PTR expr */
   278,  /* (218) between_op ::= BETWEEN */
   278,  /* (219) between_op ::= NOT BETWEEN */
   219,  /* (220) expr ::= expr between_op expr AND expr */
   279,  /* (221) in_op ::= IN */
   279,  /* (222) in_op ::= NOT IN */
   219,  /* (223) expr ::= expr in_op LP exprlist RP */
   219,  /* (224) expr ::= LP select RP */
   219,  /* (225) expr ::= expr in_op LP select RP */
   219,  /* (226) expr ::= expr in_op nm dbnm paren_exprlist */
   219,  /* (227) expr ::= EXISTS LP select RP */
   219,  /* (228) expr ::= CASE case_operand case_exprlist case_else END */
   282,  /* (229) case_exprlist ::= case_exprlist WHEN expr THEN expr */
   282,  /* (230) case_exprlist ::= WHEN expr THEN expr */
   283,  /* (231) case_else ::= ELSE expr */
   283,  /* (232) case_else ::= */
   281,  /* (233) case_operand ::= */
   264,  /* (234) exprlist ::= */
   255,  /* (235) nexprlist ::= nexprlist COMMA expr */
   255,  /* (236) nexprlist ::= expr */
   280,  /* (237) paren_exprlist ::= */
   280,  /* (238) paren_exprlist ::= LP exprlist RP */
   192,  /* (239) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
   284,  /* (240) uniqueflag ::= UNIQUE */
   284,  /* (241) uniqueflag ::= */
   223,  /* (242) eidlist_opt ::= */
   223,  /* (243) eidlist_opt ::= LP eidlist RP */
   234,  /* (244) eidlist ::= eidlist COMMA nm collate sortorder */
   234,  /* (245) eidlist ::= nm collate sortorder */
   285,  /* (246) collate ::= */
   285,  /* (247) collate ::= COLLATE ID|STRING */
   192,  /* (248) cmd ::= DROP INDEX ifexists fullname */
   192,  /* (249) cmd ::= VACUUM vinto */
   192,  /* (250) cmd ::= VACUUM nm vinto */
   286,  /* (251) vinto ::= INTO expr */
   286,  /* (252) vinto ::= */
   192,  /* (253) cmd ::= PRAGMA nm dbnm */
   192,  /* (254) cmd ::= PRAGMA nm dbnm EQ nmnum */
   192,  /* (255) cmd ::= PRAGMA nm dbnm LP nmnum RP */
   192,  /* (256) cmd ::= PRAGMA nm dbnm EQ minus_num */
   192,  /* (257) cmd ::= PRAGMA nm dbnm LP minus_num RP */
   213,  /* (258) plus_num ::= PLUS INTEGER|FLOAT */
   214,  /* (259) minus_num ::= MINUS INTEGER|FLOAT */
   192,  /* (260) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
   288,  /* (261) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
   290,  /* (262) trigger_time ::= BEFORE|AFTER */
   290,  /* (263) trigger_time ::= INSTEAD OF */
   290,  /* (264) trigger_time ::= */
   291,  /* (265) trigger_event ::= DELETE|INSERT */
   291,  /* (266) trigger_event ::= UPDATE */
   291,  /* (267) trigger_event ::= UPDATE OF idlist */
   293,  /* (268) when_clause ::= */
   293,  /* (269) when_clause ::= WHEN expr */
   289,  /* (270) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
   289,  /* (271) trigger_cmd_list ::= trigger_cmd SEMI */
   295,  /* (272) tridxby ::= INDEXED BY nm */
   295,  /* (273) tridxby ::= NOT INDEXED */
   294,  /* (274) trigger_cmd ::= UPDATE orconf xfullname tridxby SET setlist from where_opt scanpt */
   294,  /* (275) trigger_cmd ::= scanpt insert_cmd INTO xfullname idlist_opt select upsert scanpt */
   294,  /* (276) trigger_cmd ::= DELETE FROM xfullname tridxby where_opt scanpt */
   294,  /* (277) trigger_cmd ::= scanpt select scanpt */
   219,  /* (278) expr ::= RAISE LP IGNORE RP */
   219,  /* (279) expr ::= RAISE LP raisetype COMMA expr RP */
   238,  /* (280) raisetype ::= ROLLBACK */
   238,  /* (281) raisetype ::= ABORT */
   238,  /* (282) raisetype ::= FAIL */
   192,  /* (283) cmd ::= DROP TRIGGER ifexists fullname */
   192,  /* (284) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
   192,  /* (285) cmd ::= DETACH database_kw_opt expr */
   297,  /* (286) key_opt ::= */
   297,  /* (287) key_opt ::= KEY expr */
   192,  /* (288) cmd ::= REINDEX */
   192,  /* (289) cmd ::= REINDEX nm dbnm */
   192,  /* (290) cmd ::= ANALYZE */
   192,  /* (291) cmd ::= ANALYZE nm dbnm */
   192,  /* (292) cmd ::= ALTER TABLE fullname RENAME TO nm */
   192,  /* (293) cmd ::= alter_add carglist */
   298,  /* (294) alter_add ::= ALTER TABLE fullname ADD kwcolumn_opt nm typetoken */
   192,  /* (295) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
   192,  /* (296) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
   192,  /* (297) cmd ::= ALTER TABLE fullname DROP CONSTRAINT nm */
   192,  /* (298) cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm DROP NOT NULL */
   192,  /* (299) cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm SET NOT NULL onconf */
   192,  /* (300) cmd ::= ALTER TABLE fullname ADD CONSTRAINT nm CHECK LP expr RP onconf */
   192,  /* (301) cmd ::= ALTER TABLE fullname ADD CHECK LP expr RP onconf */
   192,  /* (302) cmd ::= create_vtab */
   192,  /* (303) cmd ::= create_vtab LP vtabarglist RP */
   300,  /* (304) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
   302,  /* (305) vtabarg ::= */
   303,  /* (306) vtabargtoken ::= ANY */
   303,  /* (307) vtabargtoken ::= lp anylist RP */
   304,  /* (308) lp ::= LP */
   269,  /* (309) with ::= WITH wqlist */
   269,  /* (310) with ::= WITH RECURSIVE wqlist */
   307,  /* (311) wqas ::= AS */
   307,  /* (312) wqas ::= AS MATERIALIZED */
   307,  /* (313) wqas ::= AS NOT MATERIALIZED */
   306,  /* (314) wqitem ::= withnm eidlist_opt wqas LP select RP */
   308,  /* (315) withnm ::= nm */
   243,  /* (316) wqlist ::= wqitem */
   243,  /* (317) wqlist ::= wqlist COMMA wqitem */
   309,  /* (318) windowdefn_list ::= windowdefn_list COMMA windowdefn */
   310,  /* (319) windowdefn ::= nm AS LP window RP */
   311,  /* (320) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
   311,  /* (321) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
   311,  /* (322) window ::= ORDER BY sortlist frame_opt */
   311,  /* (323) window ::= nm ORDER BY sortlist frame_opt */
   311,  /* (324) window ::= nm frame_opt */
   312,  /* (325) frame_opt ::= */
   312,  /* (326) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
   312,  /* (327) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
   316,  /* (328) range_or_rows ::= RANGE|ROWS|GROUPS */
   318,  /* (329) frame_bound_s ::= frame_bound */
   318,  /* (330) frame_bound_s ::= UNBOUNDED PRECEDING */
   319,  /* (331) frame_bound_e ::= frame_bound */
   319,  /* (332) frame_bound_e ::= UNBOUNDED FOLLOWING */
   317,  /* (333) frame_bound ::= expr PRECEDING|FOLLOWING */
   317,  /* (334) frame_bound ::= CURRENT ROW */
   320,  /* (335) frame_exclude_opt ::= */
   320,  /* (336) frame_exclude_opt ::= EXCLUDE frame_exclude */
   321,  /* (337) frame_exclude ::= NO OTHERS */
   321,  /* (338) frame_exclude ::= CURRENT ROW */
   321,  /* (339) frame_exclude ::= GROUP|TIES */
   253,  /* (340) window_clause ::= WINDOW windowdefn_list */
   276,  /* (341) filter_over ::= filter_clause over_clause */
   276,  /* (342) filter_over ::= over_clause */
   276,  /* (343) filter_over ::= filter_clause */
   315,  /* (344) over_clause ::= OVER LP window RP */
   315,  /* (345) over_clause ::= OVER nm */
   314,  /* (346) filter_clause ::= FILTER LP WHERE expr RP */
   218,  /* (347) term ::= QNUMBER */
   187,  /* (348) input ::= cmdlist */
   188,  /* (349) cmdlist ::= cmdlist ecmd */
   188,  /* (350) cmdlist ::= ecmd */
   189,  /* (351) ecmd ::= SEMI */
   189,  /* (352) ecmd ::= cmdx SEMI */
   189,  /* (353) ecmd ::= explain cmdx SEMI */
   194,  /* (354) trans_opt ::= */
   194,  /* (355) trans_opt ::= TRANSACTION */
   194,  /* (356) trans_opt ::= TRANSACTION nm */
   196,  /* (357) savepoint_opt ::= SAVEPOINT */
   196,  /* (358) savepoint_opt ::= */
   192,  /* (359) cmd ::= create_table create_table_args */
   205,  /* (360) table_option_set ::= table_option */
   203,  /* (361) columnlist ::= columnlist COMMA columnname carglist */
   203,  /* (362) columnlist ::= columnname carglist */
   195,  /* (363) nm ::= ID|INDEXED|JOIN_KW */
   195,  /* (364) nm ::= STRING */
   210,  /* (365) typetoken ::= typename */
   211,  /* (366) typename ::= ID|STRING */
   212,  /* (367) signed ::= plus_num */
   212,  /* (368) signed ::= minus_num */
   209,  /* (369) carglist ::= carglist ccons */
   209,  /* (370) carglist ::= */
   217,  /* (371) ccons ::= NULL onconf */
   217,  /* (372) ccons ::= GENERATED ALWAYS AS generated */
   217,  /* (373) ccons ::= AS generated */
   204,  /* (374) conslist_opt ::= COMMA conslist */
   230,  /* (375) conslist ::= conslist tconscomma tcons */
   230,  /* (376) conslist ::= tcons */
   231,  /* (377) tconscomma ::= */
   235,  /* (378) defer_subclause_opt ::= defer_subclause */
   237,  /* (379) resolvetype ::= raisetype */
   241,  /* (380) selectnowith ::= oneselect */
   242,  /* (381) oneselect ::= values */
   257,  /* (382) sclp ::= selcollist COMMA */
   258,  /* (383) as ::= ID|STRING */
   267,  /* (384) indexed_opt ::= indexed_by */
   275,  /* (385) returning ::= */
   219,  /* (386) expr ::= term */
   277,  /* (387) likeop ::= LIKE_KW|MATCH */
   281,  /* (388) case_operand ::= expr */
   264,  /* (389) exprlist ::= nexprlist */
   287,  /* (390) nmnum ::= plus_num */
   287,  /* (391) nmnum ::= nm */
   287,  /* (392) nmnum ::= ON */
   287,  /* (393) nmnum ::= DELETE */
   287,  /* (394) nmnum ::= DEFAULT */
   213,  /* (395) plus_num ::= INTEGER|FLOAT */
   292,  /* (396) foreach_clause ::= */
   292,  /* (397) foreach_clause ::= FOR EACH ROW */
   295,  /* (398) tridxby ::= */
   296,  /* (399) database_kw_opt ::= DATABASE */
   296,  /* (400) database_kw_opt ::= */
   299,  /* (401) kwcolumn_opt ::= */
   299,  /* (402) kwcolumn_opt ::= COLUMNKW */
   301,  /* (403) vtabarglist ::= vtabarg */
   301,  /* (404) vtabarglist ::= vtabarglist COMMA vtabarg */
   302,  /* (405) vtabarg ::= vtabarg vtabargtoken */
   305,  /* (406) anylist ::= */
   305,  /* (407) anylist ::= anylist LP anylist RP */
   305,  /* (408) anylist ::= anylist ANY */
   269,  /* (409) with ::= */
   309,  /* (410) windowdefn_list ::= windowdefn */
   311,  /* (411) window ::= frame_opt */
};

/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
** of symbols on the right-hand side of that rule. */
static const signed char yyRuleInfoNRhs[] = {
   -1,  /* (0) explain ::= EXPLAIN */
   -3,  /* (1) explain ::= EXPLAIN QUERY PLAN */
   -1,  /* (2) cmdx ::= cmd */
   -3,  /* (3) cmd ::= BEGIN transtype trans_opt */
    0,  /* (4) transtype ::= */
   -1,  /* (5) transtype ::= DEFERRED */
   -1,  /* (6) transtype ::= IMMEDIATE */
   -1,  /* (7) transtype ::= EXCLUSIVE */
   -2,  /* (8) cmd ::= COMMIT|END trans_opt */
   -2,  /* (9) cmd ::= ROLLBACK trans_opt */
   -2,  /* (10) cmd ::= SAVEPOINT nm */
   -3,  /* (11) cmd ::= RELEASE savepoint_opt nm */
   -5,  /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
   -6,  /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */
   -1,  /* (14) createkw ::= CREATE */
    0,  /* (15) ifnotexists ::= */
   -3,  /* (16) ifnotexists ::= IF NOT EXISTS */
   -1,  /* (17) temp ::= TEMP */
    0,  /* (18) temp ::= */
   -5,  /* (19) create_table_args ::= LP columnlist conslist_opt RP table_option_set */
   -2,  /* (20) create_table_args ::= AS select */
    0,  /* (21) table_option_set ::= */
   -3,  /* (22) table_option_set ::= table_option_set COMMA table_option */
   -2,  /* (23) table_option ::= WITHOUT nm */
   -1,  /* (24) table_option ::= nm */
   -2,  /* (25) columnname ::= nm typetoken */
    0,  /* (26) typetoken ::= */
   -4,  /* (27) typetoken ::= typename LP signed RP */
   -6,  /* (28) typetoken ::= typename LP signed COMMA signed RP */
   -2,  /* (29) typename ::= typename ID|STRING */
    0,  /* (30) scanpt ::= */
    0,  /* (31) scantok ::= */
   -2,  /* (32) ccons ::= CONSTRAINT nm */
   -3,  /* (33) ccons ::= DEFAULT scantok term */
   -4,  /* (34) ccons ::= DEFAULT LP expr RP */
   -4,  /* (35) ccons ::= DEFAULT PLUS scantok term */
   -4,  /* (36) ccons ::= DEFAULT MINUS scantok term */
   -3,  /* (37) ccons ::= DEFAULT scantok ID|INDEXED */
   -3,  /* (38) ccons ::= NOT NULL onconf */
   -5,  /* (39) ccons ::= PRIMARY KEY sortorder onconf autoinc */
   -2,  /* (40) ccons ::= UNIQUE onconf */
   -4,  /* (41) ccons ::= CHECK LP expr RP */
   -4,  /* (42) ccons ::= REFERENCES nm eidlist_opt refargs */
   -1,  /* (43) ccons ::= defer_subclause */
   -2,  /* (44) ccons ::= COLLATE ID|STRING */
   -3,  /* (45) generated ::= LP expr RP */
   -4,  /* (46) generated ::= LP expr RP ID */
    0,  /* (47) autoinc ::= */
   -1,  /* (48) autoinc ::= AUTOINCR */
    0,  /* (49) refargs ::= */
   -2,  /* (50) refargs ::= refargs refarg */
   -2,  /* (51) refarg ::= MATCH nm */
   -3,  /* (52) refarg ::= ON INSERT refact */
   -3,  /* (53) refarg ::= ON DELETE refact */
   -3,  /* (54) refarg ::= ON UPDATE refact */
   -2,  /* (55) refact ::= SET NULL */
   -2,  /* (56) refact ::= SET DEFAULT */
   -1,  /* (57) refact ::= CASCADE */
   -1,  /* (58) refact ::= RESTRICT */
   -2,  /* (59) refact ::= NO ACTION */
   -3,  /* (60) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
   -2,  /* (61) defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
    0,  /* (62) init_deferred_pred_opt ::= */
   -2,  /* (63) init_deferred_pred_opt ::= INITIALLY DEFERRED */
   -2,  /* (64) init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
    0,  /* (65) conslist_opt ::= */
   -1,  /* (66) tconscomma ::= COMMA */
   -2,  /* (67) tcons ::= CONSTRAINT nm */
   -7,  /* (68) tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
   -5,  /* (69) tcons ::= UNIQUE LP sortlist RP onconf */
   -5,  /* (70) tcons ::= CHECK LP expr RP onconf */
  -10,  /* (71) tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
    0,  /* (72) defer_subclause_opt ::= */
    0,  /* (73) onconf ::= */
   -3,  /* (74) onconf ::= ON CONFLICT resolvetype */
    0,  /* (75) orconf ::= */
   -2,  /* (76) orconf ::= OR resolvetype */
   -1,  /* (77) resolvetype ::= IGNORE */
   -1,  /* (78) resolvetype ::= REPLACE */
   -4,  /* (79) cmd ::= DROP TABLE ifexists fullname */
   -2,  /* (80) ifexists ::= IF EXISTS */
    0,  /* (81) ifexists ::= */
   -9,  /* (82) cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
   -4,  /* (83) cmd ::= DROP VIEW ifexists fullname */
   -1,  /* (84) cmd ::= select */
   -3,  /* (85) select ::= WITH wqlist selectnowith */
   -4,  /* (86) select ::= WITH RECURSIVE wqlist selectnowith */
   -1,  /* (87) select ::= selectnowith */
   -3,  /* (88) selectnowith ::= selectnowith multiselect_op oneselect */
   -1,  /* (89) multiselect_op ::= UNION */
   -2,  /* (90) multiselect_op ::= UNION ALL */
   -1,  /* (91) multiselect_op ::= EXCEPT|INTERSECT */
   -9,  /* (92) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
  -10,  /* (93) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
   -4,  /* (94) values ::= VALUES LP nexprlist RP */
   -1,  /* (95) oneselect ::= mvalues */
   -5,  /* (96) mvalues ::= values COMMA LP nexprlist RP */
   -5,  /* (97) mvalues ::= mvalues COMMA LP nexprlist RP */
   -1,  /* (98) distinct ::= DISTINCT */
   -1,  /* (99) distinct ::= ALL */
    0,  /* (100) distinct ::= */
    0,  /* (101) sclp ::= */
   -5,  /* (102) selcollist ::= sclp scanpt expr scanpt as */
   -3,  /* (103) selcollist ::= sclp scanpt STAR */
   -5,  /* (104) selcollist ::= sclp scanpt nm DOT STAR */
   -2,  /* (105) as ::= AS nm */
    0,  /* (106) as ::= */
    0,  /* (107) from ::= */
   -2,  /* (108) from ::= FROM seltablist */
   -2,  /* (109) stl_prefix ::= seltablist joinop */
    0,  /* (110) stl_prefix ::= */
   -5,  /* (111) seltablist ::= stl_prefix nm dbnm as on_using */
   -6,  /* (112) seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
   -8,  /* (113) seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
   -6,  /* (114) seltablist ::= stl_prefix LP select RP as on_using */
   -6,  /* (115) seltablist ::= stl_prefix LP seltablist RP as on_using */
    0,  /* (116) dbnm ::= */
   -2,  /* (117) dbnm ::= DOT nm */
   -1,  /* (118) fullname ::= nm */
   -3,  /* (119) fullname ::= nm DOT nm */
   -1,  /* (120) xfullname ::= nm */
   -3,  /* (121) xfullname ::= nm DOT nm */
   -3,  /* (122) xfullname ::= nm AS nm */
   -5,  /* (123) xfullname ::= nm DOT nm AS nm */
   -1,  /* (124) joinop ::= COMMA|JOIN */
   -2,  /* (125) joinop ::= JOIN_KW JOIN */
   -3,  /* (126) joinop ::= JOIN_KW nm JOIN */
   -4,  /* (127) joinop ::= JOIN_KW nm nm JOIN */
   -2,  /* (128) on_using ::= ON expr */
   -4,  /* (129) on_using ::= USING LP idlist RP */
    0,  /* (130) on_using ::= */
    0,  /* (131) indexed_opt ::= */
   -3,  /* (132) indexed_by ::= INDEXED BY nm */
   -2,  /* (133) indexed_by ::= NOT INDEXED */
    0,  /* (134) orderby_opt ::= */
   -3,  /* (135) orderby_opt ::= ORDER BY sortlist */
   -5,  /* (136) sortlist ::= sortlist COMMA expr sortorder nulls */
   -3,  /* (137) sortlist ::= expr sortorder nulls */
   -1,  /* (138) sortorder ::= ASC */
   -1,  /* (139) sortorder ::= DESC */
    0,  /* (140) sortorder ::= */
   -2,  /* (141) nulls ::= NULLS FIRST */
   -2,  /* (142) nulls ::= NULLS LAST */
    0,  /* (143) nulls ::= */
    0,  /* (144) groupby_opt ::= */
   -3,  /* (145) groupby_opt ::= GROUP BY nexprlist */
    0,  /* (146) having_opt ::= */
   -2,  /* (147) having_opt ::= HAVING expr */
    0,  /* (148) limit_opt ::= */
   -2,  /* (149) limit_opt ::= LIMIT expr */
   -4,  /* (150) limit_opt ::= LIMIT expr OFFSET expr */
   -4,  /* (151) limit_opt ::= LIMIT expr COMMA expr */
   -6,  /* (152) cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
    0,  /* (153) where_opt ::= */
   -2,  /* (154) where_opt ::= WHERE expr */
    0,  /* (155) where_opt_ret ::= */
   -2,  /* (156) where_opt_ret ::= WHERE expr */
   -2,  /* (157) where_opt_ret ::= RETURNING selcollist */
   -4,  /* (158) where_opt_ret ::= WHERE expr RETURNING selcollist */
   -9,  /* (159) cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
   -5,  /* (160) setlist ::= setlist COMMA nm EQ expr */
   -7,  /* (161) setlist ::= setlist COMMA LP idlist RP EQ expr */
   -3,  /* (162) setlist ::= nm EQ expr */
   -5,  /* (163) setlist ::= LP idlist RP EQ expr */
   -7,  /* (164) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
   -8,  /* (165) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
    0,  /* (166) upsert ::= */
   -2,  /* (167) upsert ::= RETURNING selcollist */
  -12,  /* (168) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
   -9,  /* (169) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
   -5,  /* (170) upsert ::= ON CONFLICT DO NOTHING returning */
   -8,  /* (171) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
   -2,  /* (172) returning ::= RETURNING selcollist */
   -2,  /* (173) insert_cmd ::= INSERT orconf */
   -1,  /* (174) insert_cmd ::= REPLACE */
    0,  /* (175) idlist_opt ::= */
   -3,  /* (176) idlist_opt ::= LP idlist RP */
   -3,  /* (177) idlist ::= idlist COMMA nm */
   -1,  /* (178) idlist ::= nm */
   -3,  /* (179) expr ::= LP expr RP */
   -1,  /* (180) expr ::= ID|INDEXED|JOIN_KW */
   -3,  /* (181) expr ::= nm DOT nm */
   -5,  /* (182) expr ::= nm DOT nm DOT nm */
   -1,  /* (183) term ::= NULL|FLOAT|BLOB */
   -1,  /* (184) term ::= STRING */
   -1,  /* (185) term ::= INTEGER */
   -1,  /* (186) expr ::= VARIABLE */
   -3,  /* (187) expr ::= expr COLLATE ID|STRING */
   -6,  /* (188) expr ::= CAST LP expr AS typetoken RP */
   -5,  /* (189) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
   -8,  /* (190) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
   -4,  /* (191) expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
   -6,  /* (192) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
   -9,  /* (193) expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
   -5,  /* (194) expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
   -1,  /* (195) term ::= CTIME_KW */
   -5,  /* (196) expr ::= LP nexprlist COMMA expr RP */
   -3,  /* (197) expr ::= expr AND expr */
   -3,  /* (198) expr ::= expr OR expr */
   -3,  /* (199) expr ::= expr LT|GT|GE|LE expr */
   -3,  /* (200) expr ::= expr EQ|NE expr */
   -3,  /* (201) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
   -3,  /* (202) expr ::= expr PLUS|MINUS expr */
   -3,  /* (203) expr ::= expr STAR|SLASH|REM expr */
   -3,  /* (204) expr ::= expr CONCAT expr */
   -2,  /* (205) likeop ::= NOT LIKE_KW|MATCH */
   -3,  /* (206) expr ::= expr likeop expr */
   -5,  /* (207) expr ::= expr likeop expr ESCAPE expr */
   -2,  /* (208) expr ::= expr ISNULL|NOTNULL */
   -3,  /* (209) expr ::= expr NOT NULL */
   -3,  /* (210) expr ::= expr IS expr */
   -4,  /* (211) expr ::= expr IS NOT expr */
   -6,  /* (212) expr ::= expr IS NOT DISTINCT FROM expr */
   -5,  /* (213) expr ::= expr IS DISTINCT FROM expr */
   -2,  /* (214) expr ::= NOT expr */
   -2,  /* (215) expr ::= BITNOT expr */
   -2,  /* (216) expr ::= PLUS|MINUS expr */
   -3,  /* (217) expr ::= expr PTR expr */
   -1,  /* (218) between_op ::= BETWEEN */
   -2,  /* (219) between_op ::= NOT BETWEEN */
   -5,  /* (220) expr ::= expr between_op expr AND expr */
   -1,  /* (221) in_op ::= IN */
   -2,  /* (222) in_op ::= NOT IN */
   -5,  /* (223) expr ::= expr in_op LP exprlist RP */
   -3,  /* (224) expr ::= LP select RP */
   -5,  /* (225) expr ::= expr in_op LP select RP */
   -5,  /* (226) expr ::= expr in_op nm dbnm paren_exprlist */
   -4,  /* (227) expr ::= EXISTS LP select RP */
   -5,  /* (228) expr ::= CASE case_operand case_exprlist case_else END */
   -5,  /* (229) case_exprlist ::= case_exprlist WHEN expr THEN expr */
   -4,  /* (230) case_exprlist ::= WHEN expr THEN expr */
   -2,  /* (231) case_else ::= ELSE expr */
    0,  /* (232) case_else ::= */
    0,  /* (233) case_operand ::= */
    0,  /* (234) exprlist ::= */
   -3,  /* (235) nexprlist ::= nexprlist COMMA expr */
   -1,  /* (236) nexprlist ::= expr */
    0,  /* (237) paren_exprlist ::= */
   -3,  /* (238) paren_exprlist ::= LP exprlist RP */
  -12,  /* (239) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
   -1,  /* (240) uniqueflag ::= UNIQUE */
    0,  /* (241) uniqueflag ::= */
    0,  /* (242) eidlist_opt ::= */
   -3,  /* (243) eidlist_opt ::= LP eidlist RP */
   -5,  /* (244) eidlist ::= eidlist COMMA nm collate sortorder */
   -3,  /* (245) eidlist ::= nm collate sortorder */
    0,  /* (246) collate ::= */
   -2,  /* (247) collate ::= COLLATE ID|STRING */
   -4,  /* (248) cmd ::= DROP INDEX ifexists fullname */
   -2,  /* (249) cmd ::= VACUUM vinto */
   -3,  /* (250) cmd ::= VACUUM nm vinto */
   -2,  /* (251) vinto ::= INTO expr */
    0,  /* (252) vinto ::= */
   -3,  /* (253) cmd ::= PRAGMA nm dbnm */
   -5,  /* (254) cmd ::= PRAGMA nm dbnm EQ nmnum */
   -6,  /* (255) cmd ::= PRAGMA nm dbnm LP nmnum RP */
   -5,  /* (256) cmd ::= PRAGMA nm dbnm EQ minus_num */
   -6,  /* (257) cmd ::= PRAGMA nm dbnm LP minus_num RP */
   -2,  /* (258) plus_num ::= PLUS INTEGER|FLOAT */
   -2,  /* (259) minus_num ::= MINUS INTEGER|FLOAT */
   -5,  /* (260) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
  -11,  /* (261) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
   -1,  /* (262) trigger_time ::= BEFORE|AFTER */
   -2,  /* (263) trigger_time ::= INSTEAD OF */
    0,  /* (264) trigger_time ::= */
   -1,  /* (265) trigger_event ::= DELETE|INSERT */
   -1,  /* (266) trigger_event ::= UPDATE */
   -3,  /* (267) trigger_event ::= UPDATE OF idlist */
    0,  /* (268) when_clause ::= */
   -2,  /* (269) when_clause ::= WHEN expr */
   -3,  /* (270) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
   -2,  /* (271) trigger_cmd_list ::= trigger_cmd SEMI */
   -3,  /* (272) tridxby ::= INDEXED BY nm */
   -2,  /* (273) tridxby ::= NOT INDEXED */
   -9,  /* (274) trigger_cmd ::= UPDATE orconf xfullname tridxby SET setlist from where_opt scanpt */
   -8,  /* (275) trigger_cmd ::= scanpt insert_cmd INTO xfullname idlist_opt select upsert scanpt */
   -6,  /* (276) trigger_cmd ::= DELETE FROM xfullname tridxby where_opt scanpt */
   -3,  /* (277) trigger_cmd ::= scanpt select scanpt */
   -4,  /* (278) expr ::= RAISE LP IGNORE RP */
   -6,  /* (279) expr ::= RAISE LP raisetype COMMA expr RP */
   -1,  /* (280) raisetype ::= ROLLBACK */
   -1,  /* (281) raisetype ::= ABORT */
   -1,  /* (282) raisetype ::= FAIL */
   -4,  /* (283) cmd ::= DROP TRIGGER ifexists fullname */
   -6,  /* (284) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
   -3,  /* (285) cmd ::= DETACH database_kw_opt expr */
    0,  /* (286) key_opt ::= */
   -2,  /* (287) key_opt ::= KEY expr */
   -1,  /* (288) cmd ::= REINDEX */
   -3,  /* (289) cmd ::= REINDEX nm dbnm */
   -1,  /* (290) cmd ::= ANALYZE */
   -3,  /* (291) cmd ::= ANALYZE nm dbnm */
   -6,  /* (292) cmd ::= ALTER TABLE fullname RENAME TO nm */
   -2,  /* (293) cmd ::= alter_add carglist */
   -7,  /* (294) alter_add ::= ALTER TABLE fullname ADD kwcolumn_opt nm typetoken */
   -6,  /* (295) cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
   -8,  /* (296) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
   -6,  /* (297) cmd ::= ALTER TABLE fullname DROP CONSTRAINT nm */
   -9,  /* (298) cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm DROP NOT NULL */
  -10,  /* (299) cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm SET NOT NULL onconf */
  -11,  /* (300) cmd ::= ALTER TABLE fullname ADD CONSTRAINT nm CHECK LP expr RP onconf */
   -9,  /* (301) cmd ::= ALTER TABLE fullname ADD CHECK LP expr RP onconf */
   -1,  /* (302) cmd ::= create_vtab */
   -4,  /* (303) cmd ::= create_vtab LP vtabarglist RP */
   -8,  /* (304) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
    0,  /* (305) vtabarg ::= */
   -1,  /* (306) vtabargtoken ::= ANY */
   -3,  /* (307) vtabargtoken ::= lp anylist RP */
   -1,  /* (308) lp ::= LP */
   -2,  /* (309) with ::= WITH wqlist */
   -3,  /* (310) with ::= WITH RECURSIVE wqlist */
   -1,  /* (311) wqas ::= AS */
   -2,  /* (312) wqas ::= AS MATERIALIZED */
   -3,  /* (313) wqas ::= AS NOT MATERIALIZED */
   -6,  /* (314) wqitem ::= withnm eidlist_opt wqas LP select RP */
   -1,  /* (315) withnm ::= nm */
   -1,  /* (316) wqlist ::= wqitem */
   -3,  /* (317) wqlist ::= wqlist COMMA wqitem */
   -3,  /* (318) windowdefn_list ::= windowdefn_list COMMA windowdefn */
   -5,  /* (319) windowdefn ::= nm AS LP window RP */
   -5,  /* (320) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
   -6,  /* (321) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
   -4,  /* (322) window ::= ORDER BY sortlist frame_opt */
   -5,  /* (323) window ::= nm ORDER BY sortlist frame_opt */
   -2,  /* (324) window ::= nm frame_opt */
    0,  /* (325) frame_opt ::= */
   -3,  /* (326) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
   -6,  /* (327) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
   -1,  /* (328) range_or_rows ::= RANGE|ROWS|GROUPS */
   -1,  /* (329) frame_bound_s ::= frame_bound */
   -2,  /* (330) frame_bound_s ::= UNBOUNDED PRECEDING */
   -1,  /* (331) frame_bound_e ::= frame_bound */
   -2,  /* (332) frame_bound_e ::= UNBOUNDED FOLLOWING */
   -2,  /* (333) frame_bound ::= expr PRECEDING|FOLLOWING */
   -2,  /* (334) frame_bound ::= CURRENT ROW */
    0,  /* (335) frame_exclude_opt ::= */
   -2,  /* (336) frame_exclude_opt ::= EXCLUDE frame_exclude */
   -2,  /* (337) frame_exclude ::= NO OTHERS */
   -2,  /* (338) frame_exclude ::= CURRENT ROW */
   -1,  /* (339) frame_exclude ::= GROUP|TIES */
   -2,  /* (340) window_clause ::= WINDOW windowdefn_list */
   -2,  /* (341) filter_over ::= filter_clause over_clause */
   -1,  /* (342) filter_over ::= over_clause */
   -1,  /* (343) filter_over ::= filter_clause */
   -4,  /* (344) over_clause ::= OVER LP window RP */
   -2,  /* (345) over_clause ::= OVER nm */
   -5,  /* (346) filter_clause ::= FILTER LP WHERE expr RP */
   -1,  /* (347) term ::= QNUMBER */
   -1,  /* (348) input ::= cmdlist */
   -2,  /* (349) cmdlist ::= cmdlist ecmd */
   -1,  /* (350) cmdlist ::= ecmd */
   -1,  /* (351) ecmd ::= SEMI */
   -2,  /* (352) ecmd ::= cmdx SEMI */
   -3,  /* (353) ecmd ::= explain cmdx SEMI */
    0,  /* (354) trans_opt ::= */
   -1,  /* (355) trans_opt ::= TRANSACTION */
   -2,  /* (356) trans_opt ::= TRANSACTION nm */
   -1,  /* (357) savepoint_opt ::= SAVEPOINT */
    0,  /* (358) savepoint_opt ::= */
   -2,  /* (359) cmd ::= create_table create_table_args */
   -1,  /* (360) table_option_set ::= table_option */
   -4,  /* (361) columnlist ::= columnlist COMMA columnname carglist */
   -2,  /* (362) columnlist ::= columnname carglist */
   -1,  /* (363) nm ::= ID|INDEXED|JOIN_KW */
   -1,  /* (364) nm ::= STRING */
   -1,  /* (365) typetoken ::= typename */
   -1,  /* (366) typename ::= ID|STRING */
   -1,  /* (367) signed ::= plus_num */
   -1,  /* (368) signed ::= minus_num */
   -2,  /* (369) carglist ::= carglist ccons */
    0,  /* (370) carglist ::= */
   -2,  /* (371) ccons ::= NULL onconf */
   -4,  /* (372) ccons ::= GENERATED ALWAYS AS generated */
   -2,  /* (373) ccons ::= AS generated */
   -2,  /* (374) conslist_opt ::= COMMA conslist */
   -3,  /* (375) conslist ::= conslist tconscomma tcons */
   -1,  /* (376) conslist ::= tcons */
    0,  /* (377) tconscomma ::= */
   -1,  /* (378) defer_subclause_opt ::= defer_subclause */
   -1,  /* (379) resolvetype ::= raisetype */
   -1,  /* (380) selectnowith ::= oneselect */
   -1,  /* (381) oneselect ::= values */
   -2,  /* (382) sclp ::= selcollist COMMA */
   -1,  /* (383) as ::= ID|STRING */
   -1,  /* (384) indexed_opt ::= indexed_by */
    0,  /* (385) returning ::= */
   -1,  /* (386) expr ::= term */
   -1,  /* (387) likeop ::= LIKE_KW|MATCH */
   -1,  /* (388) case_operand ::= expr */
   -1,  /* (389) exprlist ::= nexprlist */
   -1,  /* (390) nmnum ::= plus_num */
   -1,  /* (391) nmnum ::= nm */
   -1,  /* (392) nmnum ::= ON */
   -1,  /* (393) nmnum ::= DELETE */
   -1,  /* (394) nmnum ::= DEFAULT */
   -1,  /* (395) plus_num ::= INTEGER|FLOAT */
    0,  /* (396) foreach_clause ::= */
   -3,  /* (397) foreach_clause ::= FOR EACH ROW */
    0,  /* (398) tridxby ::= */
   -1,  /* (399) database_kw_opt ::= DATABASE */
    0,  /* (400) database_kw_opt ::= */
    0,  /* (401) kwcolumn_opt ::= */
   -1,  /* (402) kwcolumn_opt ::= COLUMNKW */
   -1,  /* (403) vtabarglist ::= vtabarg */
   -3,  /* (404) vtabarglist ::= vtabarglist COMMA vtabarg */
   -2,  /* (405) vtabarg ::= vtabarg vtabargtoken */
    0,  /* (406) anylist ::= */
   -4,  /* (407) anylist ::= anylist LP anylist RP */
   -2,  /* (408) anylist ::= anylist ANY */
    0,  /* (409) with ::= */
   -1,  /* (410) windowdefn_list ::= windowdefn */
   -1,  /* (411) window ::= frame_opt */
};

static void yy_accept(yyParser*);  /* Forward Declaration */

/*
** Perform a reduce action and the shift that must immediately
** follow the reduce.
**
** The yyLookahead and yyLookaheadToken parameters provide reduce actions
** access to the lookahead token (if any).  The yyLookahead will be YYNOCODE
** if the lookahead token has already been consumed.  As this procedure is
** only called from one place, optimizing compilers will in-line it, which
** means that the extra parameters have no performance impact.
*/
static YYACTIONTYPE yy_reduce(
  yyParser *yypParser,         /* The parser */
  unsigned int yyruleno,       /* Number of the rule by which to reduce */
  int yyLookahead,             /* Lookahead token, or YYNOCODE if none */
  sqlite3ParserTOKENTYPE yyLookaheadToken  /* Value of the lookahead token */
  sqlite3ParserCTX_PDECL                   /* %extra_context */
){
  int yygoto;                     /* The next state */
  YYACTIONTYPE yyact;             /* The next action */
  yyStackEntry *yymsp;            /* The top of the parser's stack */
  int yysize;                     /* Amount to pop the stack */
  sqlite3ParserARG_FETCH
  (void)yyLookahead;
  (void)yyLookaheadToken;
  yymsp = yypParser->yytos;

  switch( yyruleno ){
  /* Beginning here are the reduction cases.  A typical example
  ** follows:
  **   case 0:
  **  #line <lineno> <grammarfile>
  **     { ... }           // User supplied code
  **  #line <lineno> <thisfile>
  **     break;
  */
/********** Begin reduce actions **********************************************/
        YYMINORTYPE yylhsminor;
      case 0: /* explain ::= EXPLAIN */
#line 173 "parse.y"
{ if( pParse->pReprepare==0 ) pParse->explain = 1; }
#line 3835 "parse.c"
        break;
      case 1: /* explain ::= EXPLAIN QUERY PLAN */
#line 174 "parse.y"
{ if( pParse->pReprepare==0 ) pParse->explain = 2; }
#line 3840 "parse.c"
        break;
      case 2: /* cmdx ::= cmd */
#line 176 "parse.y"
{ sqlite3FinishCoding(pParse); }
#line 3845 "parse.c"
        break;
      case 3: /* cmd ::= BEGIN transtype trans_opt */
#line 181 "parse.y"
{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy144);}
#line 3850 "parse.c"
        break;
      case 4: /* transtype ::= */
#line 186 "parse.y"
{yymsp[1].minor.yy144 = TK_DEFERRED;}
#line 3855 "parse.c"
        break;
      case 5: /* transtype ::= DEFERRED */
      case 6: /* transtype ::= IMMEDIATE */ yytestcase(yyruleno==6);
      case 7: /* transtype ::= EXCLUSIVE */ yytestcase(yyruleno==7);
      case 328: /* range_or_rows ::= RANGE|ROWS|GROUPS */ yytestcase(yyruleno==328);
#line 187 "parse.y"
{yymsp[0].minor.yy144 = yymsp[0].major; /*A-overwrites-X*/}
#line 3863 "parse.c"
        break;
      case 8: /* cmd ::= COMMIT|END trans_opt */
      case 9: /* cmd ::= ROLLBACK trans_opt */ yytestcase(yyruleno==9);
#line 190 "parse.y"
{sqlite3EndTransaction(pParse,yymsp[-1].major);}
#line 3869 "parse.c"
        break;
      case 10: /* cmd ::= SAVEPOINT nm */
#line 195 "parse.y"
{
  sqlite3Savepoint(pParse, SAVEPOINT_BEGIN, &yymsp[0].minor.yy0);
}
#line 3876 "parse.c"
        break;
      case 11: /* cmd ::= RELEASE savepoint_opt nm */
#line 198 "parse.y"
{
  sqlite3Savepoint(pParse, SAVEPOINT_RELEASE, &yymsp[0].minor.yy0);
}
#line 3883 "parse.c"
        break;
      case 12: /* cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
#line 201 "parse.y"
{
  sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0);
}
#line 3890 "parse.c"
        break;
      case 13: /* create_table ::= createkw temp TABLE ifnotexists nm dbnm */
#line 208 "parse.y"
{
   sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy144,0,0,yymsp[-2].minor.yy144);
}
#line 3897 "parse.c"
        break;
      case 14: /* createkw ::= CREATE */
#line 211 "parse.y"
{
  disableLookaside(pParse);
}
#line 3904 "parse.c"
        break;
      case 15: /* ifnotexists ::= */
      case 18: /* temp ::= */ yytestcase(yyruleno==18);
      case 47: /* autoinc ::= */ yytestcase(yyruleno==47);
      case 62: /* init_deferred_pred_opt ::= */ yytestcase(yyruleno==62);
      case 72: /* defer_subclause_opt ::= */ yytestcase(yyruleno==72);
      case 81: /* ifexists ::= */ yytestcase(yyruleno==81);
      case 100: /* distinct ::= */ yytestcase(yyruleno==100);
      case 246: /* collate ::= */ yytestcase(yyruleno==246);
#line 216 "parse.y"
{yymsp[1].minor.yy144 = 0;}
#line 3916 "parse.c"
        break;
      case 16: /* ifnotexists ::= IF NOT EXISTS */
#line 217 "parse.y"
{yymsp[-2].minor.yy144 = 1;}
#line 3921 "parse.c"
        break;
      case 17: /* temp ::= TEMP */
#line 220 "parse.y"
{yymsp[0].minor.yy144 = pParse->db->init.busy==0;}
#line 3926 "parse.c"
        break;
      case 19: /* create_table_args ::= LP columnlist conslist_opt RP table_option_set */
#line 223 "parse.y"
{
  sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy391,0);
}
#line 3933 "parse.c"
        break;
      case 20: /* create_table_args ::= AS select */
#line 226 "parse.y"
{
  sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy555);
  sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy555);
}
#line 3941 "parse.c"
        break;
      case 21: /* table_option_set ::= */
#line 232 "parse.y"
{yymsp[1].minor.yy391 = 0;}
#line 3946 "parse.c"
        break;
      case 22: /* table_option_set ::= table_option_set COMMA table_option */
#line 234 "parse.y"
{yylhsminor.yy391 = yymsp[-2].minor.yy391|yymsp[0].minor.yy391;}
#line 3951 "parse.c"
  yymsp[-2].minor.yy391 = yylhsminor.yy391;
        break;
      case 23: /* table_option ::= WITHOUT nm */
#line 235 "parse.y"
{
  if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){
    yymsp[-1].minor.yy391 = TF_WithoutRowid | TF_NoVisibleRowid;
  }else{
    yymsp[-1].minor.yy391 = 0;
    sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
  }
}
#line 3964 "parse.c"
        break;
      case 24: /* table_option ::= nm */
#line 243 "parse.y"
{
  if( yymsp[0].minor.yy0.n==6 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"strict",6)==0 ){
    yylhsminor.yy391 = TF_Strict;
  }else{
    yylhsminor.yy391 = 0;
    sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
  }
}
#line 3976 "parse.c"
  yymsp[0].minor.yy391 = yylhsminor.yy391;
        break;
      case 25: /* columnname ::= nm typetoken */
#line 253 "parse.y"
{sqlite3AddColumn(pParse,yymsp[-1].minor.yy0,yymsp[0].minor.yy0);}
#line 3982 "parse.c"
        break;
      case 26: /* typetoken ::= */
      case 65: /* conslist_opt ::= */ yytestcase(yyruleno==65);
      case 106: /* as ::= */ yytestcase(yyruleno==106);
#line 347 "parse.y"
{yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = 0;}
#line 3989 "parse.c"
        break;
      case 27: /* typetoken ::= typename LP signed RP */
#line 349 "parse.y"
{
  yymsp[-3].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy0.z);
}
#line 3996 "parse.c"
        break;
      case 28: /* typetoken ::= typename LP signed COMMA signed RP */
#line 352 "parse.y"
{
  yymsp[-5].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-5].minor.yy0.z);
}
#line 4003 "parse.c"
        break;
      case 29: /* typename ::= typename ID|STRING */
#line 357 "parse.y"
{yymsp[-1].minor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);}
#line 4008 "parse.c"
        break;
      case 30: /* scanpt ::= */
#line 375 "parse.y"
{
  assert( yyLookahead!=YYNOCODE );
  yymsp[1].minor.yy168 = yyLookaheadToken.z;
}
#line 4016 "parse.c"
        break;
      case 31: /* scantok ::= */
#line 379 "parse.y"
{
  assert( yyLookahead!=YYNOCODE );
  yymsp[1].minor.yy0 = yyLookaheadToken;
}
#line 4024 "parse.c"
        break;
      case 32: /* ccons ::= CONSTRAINT nm */
      case 67: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==67);
#line 389 "parse.y"
{ASSERT_IS_CREATE; pParse->u1.cr.constraintName = yymsp[0].minor.yy0;}
#line 4030 "parse.c"
        break;
      case 33: /* ccons ::= DEFAULT scantok term */
#line 391 "parse.y"
{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy454,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
#line 4035 "parse.c"
        break;
      case 34: /* ccons ::= DEFAULT LP expr RP */
#line 393 "parse.y"
{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy454,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);}
#line 4040 "parse.c"
        break;
      case 35: /* ccons ::= DEFAULT PLUS scantok term */
#line 395 "parse.y"
{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy454,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
#line 4045 "parse.c"
        break;
      case 36: /* ccons ::= DEFAULT MINUS scantok term */
#line 396 "parse.y"
{
  Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy454, 0);
  sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);
}
#line 4053 "parse.c"
        break;
      case 37: /* ccons ::= DEFAULT scantok ID|INDEXED */
#line 400 "parse.y"
{
  Expr *p = tokenExpr(pParse, TK_STRING, yymsp[0].minor.yy0);
  if( p ){
    sqlite3ExprIdToTrueFalse(p);
    testcase( p->op==TK_TRUEFALSE && sqlite3ExprTruthValue(p) );
  }
    sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n);
}
#line 4065 "parse.c"
        break;
      case 38: /* ccons ::= NOT NULL onconf */
#line 413 "parse.y"
{sqlite3AddNotNull(pParse, yymsp[0].minor.yy144);}
#line 4070 "parse.c"
        break;
      case 39: /* ccons ::= PRIMARY KEY sortorder onconf autoinc */
#line 415 "parse.y"
{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy144,yymsp[0].minor.yy144,yymsp[-2].minor.yy144);}
#line 4075 "parse.c"
        break;
      case 40: /* ccons ::= UNIQUE onconf */
#line 416 "parse.y"
{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy144,0,0,0,0,
                                   SQLITE_IDXTYPE_UNIQUE);}
#line 4081 "parse.c"
        break;
      case 41: /* ccons ::= CHECK LP expr RP */
#line 418 "parse.y"
{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy454,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);}
#line 4086 "parse.c"
        break;
      case 42: /* ccons ::= REFERENCES nm eidlist_opt refargs */
#line 420 "parse.y"
{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy14,yymsp[0].minor.yy144);}
#line 4091 "parse.c"
        break;
      case 43: /* ccons ::= defer_subclause */
#line 421 "parse.y"
{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy144);}
#line 4096 "parse.c"
        break;
      case 44: /* ccons ::= COLLATE ID|STRING */
#line 422 "parse.y"
{sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
#line 4101 "parse.c"
        break;
      case 45: /* generated ::= LP expr RP */
#line 425 "parse.y"
{sqlite3AddGenerated(pParse,yymsp[-1].minor.yy454,0);}
#line 4106 "parse.c"
        break;
      case 46: /* generated ::= LP expr RP ID */
#line 426 "parse.y"
{sqlite3AddGenerated(pParse,yymsp[-2].minor.yy454,&yymsp[0].minor.yy0);}
#line 4111 "parse.c"
        break;
      case 48: /* autoinc ::= AUTOINCR */
#line 431 "parse.y"
{yymsp[0].minor.yy144 = 1;}
#line 4116 "parse.c"
        break;
      case 49: /* refargs ::= */
#line 439 "parse.y"
{ yymsp[1].minor.yy144 = OE_None*0x0101; /* EV: R-19803-45884 */}
#line 4121 "parse.c"
        break;
      case 50: /* refargs ::= refargs refarg */
#line 440 "parse.y"
{ yymsp[-1].minor.yy144 = (yymsp[-1].minor.yy144 & ~yymsp[0].minor.yy383.mask) | yymsp[0].minor.yy383.value; }
#line 4126 "parse.c"
        break;
      case 51: /* refarg ::= MATCH nm */
#line 442 "parse.y"
{ yymsp[-1].minor.yy383.value = 0;     yymsp[-1].minor.yy383.mask = 0x000000; }
#line 4131 "parse.c"
        break;
      case 52: /* refarg ::= ON INSERT refact */
#line 443 "parse.y"
{ yymsp[-2].minor.yy383.value = 0;     yymsp[-2].minor.yy383.mask = 0x000000; }
#line 4136 "parse.c"
        break;
      case 53: /* refarg ::= ON DELETE refact */
#line 444 "parse.y"
{ yymsp[-2].minor.yy383.value = yymsp[0].minor.yy144;     yymsp[-2].minor.yy383.mask = 0x0000ff; }
#line 4141 "parse.c"
        break;
      case 54: /* refarg ::= ON UPDATE refact */
#line 445 "parse.y"
{ yymsp[-2].minor.yy383.value = yymsp[0].minor.yy144<<8;  yymsp[-2].minor.yy383.mask = 0x00ff00; }
#line 4146 "parse.c"
        break;
      case 55: /* refact ::= SET NULL */
#line 447 "parse.y"
{ yymsp[-1].minor.yy144 = OE_SetNull;  /* EV: R-33326-45252 */}
#line 4151 "parse.c"
        break;
      case 56: /* refact ::= SET DEFAULT */
#line 448 "parse.y"
{ yymsp[-1].minor.yy144 = OE_SetDflt;  /* EV: R-33326-45252 */}
#line 4156 "parse.c"
        break;
      case 57: /* refact ::= CASCADE */
#line 449 "parse.y"
{ yymsp[0].minor.yy144 = OE_Cascade;  /* EV: R-33326-45252 */}
#line 4161 "parse.c"
        break;
      case 58: /* refact ::= RESTRICT */
#line 450 "parse.y"
{ yymsp[0].minor.yy144 = OE_Restrict; /* EV: R-33326-45252 */}
#line 4166 "parse.c"
        break;
      case 59: /* refact ::= NO ACTION */
#line 451 "parse.y"
{ yymsp[-1].minor.yy144 = OE_None;     /* EV: R-33326-45252 */}
#line 4171 "parse.c"
        break;
      case 60: /* defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt */
#line 453 "parse.y"
{yymsp[-2].minor.yy144 = 0;}
#line 4176 "parse.c"
        break;
      case 61: /* defer_subclause ::= DEFERRABLE init_deferred_pred_opt */
      case 76: /* orconf ::= OR resolvetype */ yytestcase(yyruleno==76);
      case 173: /* insert_cmd ::= INSERT orconf */ yytestcase(yyruleno==173);
#line 454 "parse.y"
{yymsp[-1].minor.yy144 = yymsp[0].minor.yy144;}
#line 4183 "parse.c"
        break;
      case 63: /* init_deferred_pred_opt ::= INITIALLY DEFERRED */
      case 80: /* ifexists ::= IF EXISTS */ yytestcase(yyruleno==80);
      case 219: /* between_op ::= NOT BETWEEN */ yytestcase(yyruleno==219);
      case 222: /* in_op ::= NOT IN */ yytestcase(yyruleno==222);
      case 247: /* collate ::= COLLATE ID|STRING */ yytestcase(yyruleno==247);
#line 457 "parse.y"
{yymsp[-1].minor.yy144 = 1;}
#line 4192 "parse.c"
        break;
      case 64: /* init_deferred_pred_opt ::= INITIALLY IMMEDIATE */
#line 458 "parse.y"
{yymsp[-1].minor.yy144 = 0;}
#line 4197 "parse.c"
        break;
      case 66: /* tconscomma ::= COMMA */
#line 464 "parse.y"
{ASSERT_IS_CREATE; pParse->u1.cr.constraintName.n = 0;}
#line 4202 "parse.c"
        break;
      case 68: /* tcons ::= PRIMARY KEY LP sortlist autoinc RP onconf */
#line 468 "parse.y"
{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy14,yymsp[0].minor.yy144,yymsp[-2].minor.yy144,0);}
#line 4207 "parse.c"
        break;
      case 69: /* tcons ::= UNIQUE LP sortlist RP onconf */
#line 470 "parse.y"
{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy14,yymsp[0].minor.yy144,0,0,0,0,
                                       SQLITE_IDXTYPE_UNIQUE);}
#line 4213 "parse.c"
        break;
      case 70: /* tcons ::= CHECK LP expr RP onconf */
#line 473 "parse.y"
{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy454,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);}
#line 4218 "parse.c"
        break;
      case 71: /* tcons ::= FOREIGN KEY LP eidlist RP REFERENCES nm eidlist_opt refargs defer_subclause_opt */
#line 475 "parse.y"
{
    sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy14, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[-1].minor.yy144);
    sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy144);
}
#line 4226 "parse.c"
        break;
      case 73: /* onconf ::= */
      case 75: /* orconf ::= */ yytestcase(yyruleno==75);
#line 489 "parse.y"
{yymsp[1].minor.yy144 = OE_Default;}
#line 4232 "parse.c"
        break;
      case 74: /* onconf ::= ON CONFLICT resolvetype */
#line 490 "parse.y"
{yymsp[-2].minor.yy144 = yymsp[0].minor.yy144;}
#line 4237 "parse.c"
        break;
      case 77: /* resolvetype ::= IGNORE */
#line 494 "parse.y"
{yymsp[0].minor.yy144 = OE_Ignore;}
#line 4242 "parse.c"
        break;
      case 78: /* resolvetype ::= REPLACE */
      case 174: /* insert_cmd ::= REPLACE */ yytestcase(yyruleno==174);
#line 495 "parse.y"
{yymsp[0].minor.yy144 = OE_Replace;}
#line 4248 "parse.c"
        break;
      case 79: /* cmd ::= DROP TABLE ifexists fullname */
#line 499 "parse.y"
{
  sqlite3DropTable(pParse, yymsp[0].minor.yy203, 0, yymsp[-1].minor.yy144);
}
#line 4255 "parse.c"
        break;
      case 82: /* cmd ::= createkw temp VIEW ifnotexists nm dbnm eidlist_opt AS select */
#line 510 "parse.y"
{
  sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[0].minor.yy555, yymsp[-7].minor.yy144, yymsp[-5].minor.yy144);
}
#line 4262 "parse.c"
        break;
      case 83: /* cmd ::= DROP VIEW ifexists fullname */
#line 513 "parse.y"
{
  sqlite3DropTable(pParse, yymsp[0].minor.yy203, 1, yymsp[-1].minor.yy144);
}
#line 4269 "parse.c"
        break;
      case 84: /* cmd ::= select */
#line 520 "parse.y"
{
  SelectDest dest = {SRT_Output, 0, 0, 0, 0, 0, 0};
  if( (pParse->db->mDbFlags & DBFLAG_EncodingFixed)!=0
   || sqlite3ReadSchema(pParse)==SQLITE_OK
  ){
    sqlite3Select(pParse, yymsp[0].minor.yy555, &dest);
  }
  sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy555);
}
#line 4282 "parse.c"
        break;
      case 85: /* select ::= WITH wqlist selectnowith */
#line 609 "parse.y"
{yymsp[-2].minor.yy555 = attachWithToSelect(pParse,yymsp[0].minor.yy555,yymsp[-1].minor.yy59);}
#line 4287 "parse.c"
        break;
      case 86: /* select ::= WITH RECURSIVE wqlist selectnowith */
#line 611 "parse.y"
{yymsp[-3].minor.yy555 = attachWithToSelect(pParse,yymsp[0].minor.yy555,yymsp[-1].minor.yy59);}
#line 4292 "parse.c"
        break;
      case 87: /* select ::= selectnowith */
#line 614 "parse.y"
{
  Select *p = yymsp[0].minor.yy555;
  if( p ){
    parserDoubleLinkSelect(pParse, p);
  }
}
#line 4302 "parse.c"
        break;
      case 88: /* selectnowith ::= selectnowith multiselect_op oneselect */
#line 623 "parse.y"
{
  Select *pRhs = yymsp[0].minor.yy555;
  Select *pLhs = yymsp[-2].minor.yy555;
  if( pRhs && pRhs->pPrior ){
    SrcList *pFrom;
    Token x;
    x.n = 0;
    parserDoubleLinkSelect(pParse, pRhs);
    pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0);
    pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0);
  }
  if( pRhs ){
    pRhs->op = (u8)yymsp[-1].minor.yy144;
    pRhs->pPrior = pLhs;
    if( ALWAYS(pLhs) ) pLhs->selFlags &= ~(u32)SF_MultiValue;
    pRhs->selFlags &= ~(u32)SF_MultiValue;
    if( yymsp[-1].minor.yy144!=TK_ALL ) pParse->hasCompound = 1;
  }else{
    sqlite3SelectDelete(pParse->db, pLhs);
  }
  yymsp[-2].minor.yy555 = pRhs;
}
#line 4328 "parse.c"
        break;
      case 89: /* multiselect_op ::= UNION */
      case 91: /* multiselect_op ::= EXCEPT|INTERSECT */ yytestcase(yyruleno==91);
#line 646 "parse.y"
{yymsp[0].minor.yy144 = yymsp[0].major; /*A-overwrites-OP*/}
#line 4334 "parse.c"
        break;
      case 90: /* multiselect_op ::= UNION ALL */
#line 647 "parse.y"
{yymsp[-1].minor.yy144 = TK_ALL;}
#line 4339 "parse.c"
        break;
      case 92: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
#line 653 "parse.y"
{
  yymsp[-8].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy14,yymsp[-5].minor.yy203,yymsp[-4].minor.yy454,yymsp[-3].minor.yy14,yymsp[-2].minor.yy454,yymsp[-1].minor.yy14,yymsp[-7].minor.yy144,yymsp[0].minor.yy454);
}
#line 4346 "parse.c"
        break;
      case 93: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
#line 659 "parse.y"
{
  yymsp[-9].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy14,yymsp[-6].minor.yy203,yymsp[-5].minor.yy454,yymsp[-4].minor.yy14,yymsp[-3].minor.yy454,yymsp[-1].minor.yy14,yymsp[-8].minor.yy144,yymsp[0].minor.yy454);
  if( yymsp[-9].minor.yy555 ){
    yymsp[-9].minor.yy555->pWinDefn = yymsp[-2].minor.yy211;
  }else{
    sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy211);
  }
}
#line 4358 "parse.c"
        break;
      case 94: /* values ::= VALUES LP nexprlist RP */
#line 675 "parse.y"
{
  yymsp[-3].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy14,0,0,0,0,0,SF_Values,0);
}
#line 4365 "parse.c"
        break;
      case 95: /* oneselect ::= mvalues */
#line 682 "parse.y"
{
  sqlite3MultiValuesEnd(pParse, yymsp[0].minor.yy555);
}
#line 4372 "parse.c"
        break;
      case 96: /* mvalues ::= values COMMA LP nexprlist RP */
      case 97: /* mvalues ::= mvalues COMMA LP nexprlist RP */ yytestcase(yyruleno==97);
#line 686 "parse.y"
{
  yymsp[-4].minor.yy555 = sqlite3MultiValues(pParse, yymsp[-4].minor.yy555, yymsp[-1].minor.yy14);
}
#line 4380 "parse.c"
        break;
      case 98: /* distinct ::= DISTINCT */
#line 697 "parse.y"
{yymsp[0].minor.yy144 = SF_Distinct;}
#line 4385 "parse.c"
        break;
      case 99: /* distinct ::= ALL */
#line 698 "parse.y"
{yymsp[0].minor.yy144 = SF_All;}
#line 4390 "parse.c"
        break;
      case 101: /* sclp ::= */
      case 134: /* orderby_opt ::= */ yytestcase(yyruleno==134);
      case 144: /* groupby_opt ::= */ yytestcase(yyruleno==144);
      case 234: /* exprlist ::= */ yytestcase(yyruleno==234);
      case 237: /* paren_exprlist ::= */ yytestcase(yyruleno==237);
      case 242: /* eidlist_opt ::= */ yytestcase(yyruleno==242);
#line 711 "parse.y"
{yymsp[1].minor.yy14 = 0;}
#line 4400 "parse.c"
        break;
      case 102: /* selcollist ::= sclp scanpt expr scanpt as */
#line 712 "parse.y"
{
   yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[-2].minor.yy454);
   if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy14, &yymsp[0].minor.yy0, 1);
   sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy14,yymsp[-3].minor.yy168,yymsp[-1].minor.yy168);
}
#line 4409 "parse.c"
        break;
      case 103: /* selcollist ::= sclp scanpt STAR */
#line 717 "parse.y"
{
  Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0);
  sqlite3ExprSetErrorOffset(p, (int)(yymsp[0].minor.yy0.z - pParse->zTail));
  yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy14, p);
}
#line 4418 "parse.c"
        break;
      case 104: /* selcollist ::= sclp scanpt nm DOT STAR */
#line 722 "parse.y"
{
  Expr *pRight, *pLeft, *pDot;
  pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0);
  sqlite3ExprSetErrorOffset(pRight, (int)(yymsp[0].minor.yy0.z - pParse->zTail));
  pLeft = tokenExpr(pParse, TK_ID, yymsp[-2].minor.yy0);
  pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
  yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, pDot);
}
#line 4430 "parse.c"
        break;
      case 105: /* as ::= AS nm */
      case 117: /* dbnm ::= DOT nm */ yytestcase(yyruleno==117);
      case 258: /* plus_num ::= PLUS INTEGER|FLOAT */ yytestcase(yyruleno==258);
      case 259: /* minus_num ::= MINUS INTEGER|FLOAT */ yytestcase(yyruleno==259);
#line 735 "parse.y"
{yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;}
#line 4438 "parse.c"
        break;
      case 107: /* from ::= */
      case 110: /* stl_prefix ::= */ yytestcase(yyruleno==110);
#line 749 "parse.y"
{yymsp[1].minor.yy203 = 0;}
#line 4444 "parse.c"
        break;
      case 108: /* from ::= FROM seltablist */
#line 750 "parse.y"
{
  yymsp[-1].minor.yy203 = yymsp[0].minor.yy203;
  sqlite3SrcListShiftJoinType(pParse,yymsp[-1].minor.yy203);
}
#line 4452 "parse.c"
        break;
      case 109: /* stl_prefix ::= seltablist joinop */
#line 758 "parse.y"
{
   if( ALWAYS(yymsp[-1].minor.yy203 && yymsp[-1].minor.yy203->nSrc>0) ) yymsp[-1].minor.yy203->a[yymsp[-1].minor.yy203->nSrc-1].fg.jointype = (u8)yymsp[0].minor.yy144;
}
#line 4459 "parse.c"
        break;
      case 111: /* seltablist ::= stl_prefix nm dbnm as on_using */
#line 762 "parse.y"
{
  yymsp[-4].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-4].minor.yy203,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
}
#line 4466 "parse.c"
        break;
      case 112: /* seltablist ::= stl_prefix nm dbnm as indexed_by on_using */
#line 765 "parse.y"
{
  yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,0,&yymsp[0].minor.yy269);
  sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy203, &yymsp[-1].minor.yy0);
}
#line 4474 "parse.c"
        break;
      case 113: /* seltablist ::= stl_prefix nm dbnm LP exprlist RP as on_using */
#line 769 "parse.y"
{
  yymsp[-7].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-7].minor.yy203,&yymsp[-6].minor.yy0,&yymsp[-5].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
  sqlite3SrcListFuncArgs(pParse, yymsp[-7].minor.yy203, yymsp[-3].minor.yy14);
}
#line 4482 "parse.c"
        break;
      case 114: /* seltablist ::= stl_prefix LP select RP as on_using */
#line 774 "parse.y"
{
    yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,yymsp[-3].minor.yy555,&yymsp[0].minor.yy269);
  }
#line 4489 "parse.c"
        break;
      case 115: /* seltablist ::= stl_prefix LP seltablist RP as on_using */
#line 777 "parse.y"
{
    if( yymsp[-5].minor.yy203==0 && yymsp[-1].minor.yy0.n==0 && yymsp[0].minor.yy269.pOn==0 && yymsp[0].minor.yy269.pUsing==0 ){
      yymsp[-5].minor.yy203 = yymsp[-3].minor.yy203;
    }else if( ALWAYS(yymsp[-3].minor.yy203!=0) && yymsp[-3].minor.yy203->nSrc==1 ){
      yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
      if( yymsp[-5].minor.yy203 ){
        SrcItem *pNew = &yymsp[-5].minor.yy203->a[yymsp[-5].minor.yy203->nSrc-1];
        SrcItem *pOld = yymsp[-3].minor.yy203->a;
        assert( pOld->fg.fixedSchema==0 );
        pNew->zName = pOld->zName;
        pOld->zName = 0;
        assert( pOld->fg.fixedSchema==0 );
        if( pOld->fg.isSubquery ){
          pNew->fg.isSubquery = 1;
          pNew->u4.pSubq = pOld->u4.pSubq;
          pOld->u4.pSubq = 0;
          pOld->fg.isSubquery = 0;
          assert( pNew->u4.pSubq!=0 && pNew->u4.pSubq->pSelect!=0 );
          if( (pNew->u4.pSubq->pSelect->selFlags & SF_NestedFrom)!=0 ){
            pNew->fg.isNestedFrom = 1;
          }
        }else{
          pNew->u4.zDatabase = pOld->u4.zDatabase;
          pOld->u4.zDatabase = 0;
        }
        if( pOld->fg.isTabFunc ){
          pNew->u1.pFuncArg = pOld->u1.pFuncArg;
          pOld->u1.pFuncArg = 0;
          pOld->fg.isTabFunc = 0;
          pNew->fg.isTabFunc = 1;
        }else if( pOld->fg.isIndexedBy ){
          pNew->u1.zIndexedBy = pOld->u1.zIndexedBy;
          pOld->u1.zIndexedBy = 0;
          pOld->fg.isIndexedBy = 0;
          pNew->fg.isIndexedBy = 1;
        }
        pNew->fg.notIndexed = pOld->fg.notIndexed;
      }
      sqlite3SrcListDelete(pParse->db, yymsp[-3].minor.yy203);
    }else{
      Select *pSubquery;
      sqlite3SrcListShiftJoinType(pParse,yymsp[-3].minor.yy203);
      pSubquery = sqlite3SelectNew(pParse,0,yymsp[-3].minor.yy203,0,0,0,0,SF_NestedFrom,0);
      yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,pSubquery,&yymsp[0].minor.yy269);
    }
  }
#line 4539 "parse.c"
        break;
      case 116: /* dbnm ::= */
      case 131: /* indexed_opt ::= */ yytestcase(yyruleno==131);
#line 826 "parse.y"
{yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;}
#line 4545 "parse.c"
        break;
      case 118: /* fullname ::= nm */
      case 120: /* xfullname ::= nm */ yytestcase(yyruleno==120);
#line 831 "parse.y"
{
  yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0);
  if( IN_RENAME_OBJECT && yylhsminor.yy203 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[0].minor.yy0);
}
#line 4554 "parse.c"
  yymsp[0].minor.yy203 = yylhsminor.yy203;
        break;
      case 119: /* fullname ::= nm DOT nm */
      case 121: /* xfullname ::= nm DOT nm */ yytestcase(yyruleno==121);
#line 835 "parse.y"
{
  yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
  if( IN_RENAME_OBJECT && yylhsminor.yy203 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[0].minor.yy0);
}
#line 4564 "parse.c"
  yymsp[-2].minor.yy203 = yylhsminor.yy203;
        break;
      case 122: /* xfullname ::= nm AS nm */
#line 850 "parse.y"
{
  yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0);
  if( yylhsminor.yy203 ){
    if( IN_RENAME_OBJECT ){
      sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[-2].minor.yy0);
    }else{
      yylhsminor.yy203->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
    }
  }
}
#line 4579 "parse.c"
  yymsp[-2].minor.yy203 = yylhsminor.yy203;
        break;
      case 123: /* xfullname ::= nm DOT nm AS nm */
#line 860 "parse.y"
{
  yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0);
  if( yylhsminor.yy203 ){
    if( IN_RENAME_OBJECT ){
      sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[-2].minor.yy0);
    }else{
      yylhsminor.yy203->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
    }
  }
}
#line 4594 "parse.c"
  yymsp[-4].minor.yy203 = yylhsminor.yy203;
        break;
      case 124: /* joinop ::= COMMA|JOIN */
#line 873 "parse.y"
{ yymsp[0].minor.yy144 = JT_INNER; }
#line 4600 "parse.c"
        break;
      case 125: /* joinop ::= JOIN_KW JOIN */
#line 875 "parse.y"
{yymsp[-1].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0);  /*X-overwrites-A*/}
#line 4605 "parse.c"
        break;
      case 126: /* joinop ::= JOIN_KW nm JOIN */
#line 877 "parse.y"
{yymsp[-2].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/}
#line 4610 "parse.c"
        break;
      case 127: /* joinop ::= JOIN_KW nm nm JOIN */
#line 879 "parse.y"
{yymsp[-3].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/}
#line 4615 "parse.c"
        break;
      case 128: /* on_using ::= ON expr */
#line 900 "parse.y"
{yymsp[-1].minor.yy269.pOn = yymsp[0].minor.yy454; yymsp[-1].minor.yy269.pUsing = 0;}
#line 4620 "parse.c"
        break;
      case 129: /* on_using ::= USING LP idlist RP */
#line 901 "parse.y"
{yymsp[-3].minor.yy269.pOn = 0; yymsp[-3].minor.yy269.pUsing = yymsp[-1].minor.yy132;}
#line 4625 "parse.c"
        break;
      case 130: /* on_using ::= */
#line 902 "parse.y"
{yymsp[1].minor.yy269.pOn = 0; yymsp[1].minor.yy269.pUsing = 0;}
#line 4630 "parse.c"
        break;
      case 132: /* indexed_by ::= INDEXED BY nm */
#line 918 "parse.y"
{yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;}
#line 4635 "parse.c"
        break;
      case 133: /* indexed_by ::= NOT INDEXED */
#line 919 "parse.y"
{yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;}
#line 4640 "parse.c"
        break;
      case 135: /* orderby_opt ::= ORDER BY sortlist */
      case 145: /* groupby_opt ::= GROUP BY nexprlist */ yytestcase(yyruleno==145);
#line 932 "parse.y"
{yymsp[-2].minor.yy14 = yymsp[0].minor.yy14;}
#line 4646 "parse.c"
        break;
      case 136: /* sortlist ::= sortlist COMMA expr sortorder nulls */
#line 933 "parse.y"
{
  yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14,yymsp[-2].minor.yy454);
  sqlite3ExprListSetSortOrder(yymsp[-4].minor.yy14,yymsp[-1].minor.yy144,yymsp[0].minor.yy144);
}
#line 4654 "parse.c"
        break;
      case 137: /* sortlist ::= expr sortorder nulls */
#line 937 "parse.y"
{
  yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy454); /*A-overwrites-Y*/
  sqlite3ExprListSetSortOrder(yymsp[-2].minor.yy14,yymsp[-1].minor.yy144,yymsp[0].minor.yy144);
}
#line 4662 "parse.c"
        break;
      case 138: /* sortorder ::= ASC */
#line 944 "parse.y"
{yymsp[0].minor.yy144 = SQLITE_SO_ASC;}
#line 4667 "parse.c"
        break;
      case 139: /* sortorder ::= DESC */
#line 945 "parse.y"
{yymsp[0].minor.yy144 = SQLITE_SO_DESC;}
#line 4672 "parse.c"
        break;
      case 140: /* sortorder ::= */
      case 143: /* nulls ::= */ yytestcase(yyruleno==143);
#line 946 "parse.y"
{yymsp[1].minor.yy144 = SQLITE_SO_UNDEFINED;}
#line 4678 "parse.c"
        break;
      case 141: /* nulls ::= NULLS FIRST */
#line 949 "parse.y"
{yymsp[-1].minor.yy144 = SQLITE_SO_ASC;}
#line 4683 "parse.c"
        break;
      case 142: /* nulls ::= NULLS LAST */
#line 950 "parse.y"
{yymsp[-1].minor.yy144 = SQLITE_SO_DESC;}
#line 4688 "parse.c"
        break;
      case 146: /* having_opt ::= */
      case 148: /* limit_opt ::= */ yytestcase(yyruleno==148);
      case 153: /* where_opt ::= */ yytestcase(yyruleno==153);
      case 155: /* where_opt_ret ::= */ yytestcase(yyruleno==155);
      case 232: /* case_else ::= */ yytestcase(yyruleno==232);
      case 233: /* case_operand ::= */ yytestcase(yyruleno==233);
      case 252: /* vinto ::= */ yytestcase(yyruleno==252);
#line 960 "parse.y"
{yymsp[1].minor.yy454 = 0;}
#line 4699 "parse.c"
        break;
      case 147: /* having_opt ::= HAVING expr */
      case 154: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==154);
      case 156: /* where_opt_ret ::= WHERE expr */ yytestcase(yyruleno==156);
      case 231: /* case_else ::= ELSE expr */ yytestcase(yyruleno==231);
      case 251: /* vinto ::= INTO expr */ yytestcase(yyruleno==251);
#line 961 "parse.y"
{yymsp[-1].minor.yy454 = yymsp[0].minor.yy454;}
#line 4708 "parse.c"
        break;
      case 149: /* limit_opt ::= LIMIT expr */
#line 975 "parse.y"
{yymsp[-1].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy454,0);}
#line 4713 "parse.c"
        break;
      case 150: /* limit_opt ::= LIMIT expr OFFSET expr */
#line 977 "parse.y"
{yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
#line 4718 "parse.c"
        break;
      case 151: /* limit_opt ::= LIMIT expr COMMA expr */
#line 979 "parse.y"
{yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy454,yymsp[-2].minor.yy454);}
#line 4723 "parse.c"
        break;
      case 152: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret */
#line 997 "parse.y"
{
  sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy203, &yymsp[-1].minor.yy0);
  sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy203,yymsp[0].minor.yy454,0,0);
}
#line 4731 "parse.c"
        break;
      case 157: /* where_opt_ret ::= RETURNING selcollist */
#line 1013 "parse.y"
{sqlite3AddReturning(pParse,yymsp[0].minor.yy14); yymsp[-1].minor.yy454 = 0;}
#line 4736 "parse.c"
        break;
      case 158: /* where_opt_ret ::= WHERE expr RETURNING selcollist */
#line 1015 "parse.y"
{sqlite3AddReturning(pParse,yymsp[0].minor.yy14); yymsp[-3].minor.yy454 = yymsp[-2].minor.yy454;}
#line 4741 "parse.c"
        break;
      case 159: /* cmd ::= with UPDATE orconf xfullname indexed_opt SET setlist from where_opt_ret */
#line 1047 "parse.y"
{
  sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy203, &yymsp[-4].minor.yy0);
  sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy14,"set list"); 
  if( yymsp[-1].minor.yy203 ){
    SrcList *pFromClause = yymsp[-1].minor.yy203;
    if( pFromClause->nSrc>1 ){
      Select *pSubquery;
      Token as;
      pSubquery = sqlite3SelectNew(pParse,0,pFromClause,0,0,0,0,SF_NestedFrom,0);
      as.n = 0;
      as.z = 0;
      pFromClause = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&as,pSubquery,0);
    }
    yymsp[-5].minor.yy203 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy203, pFromClause);
  }
  sqlite3Update(pParse,yymsp[-5].minor.yy203,yymsp[-2].minor.yy14,yymsp[0].minor.yy454,yymsp[-6].minor.yy144,0,0,0);
}
#line 4762 "parse.c"
        break;
      case 160: /* setlist ::= setlist COMMA nm EQ expr */
#line 1071 "parse.y"
{
  yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[0].minor.yy454);
  sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy14, &yymsp[-2].minor.yy0, 1);
}
#line 4770 "parse.c"
        break;
      case 161: /* setlist ::= setlist COMMA LP idlist RP EQ expr */
#line 1075 "parse.y"
{
  yymsp[-6].minor.yy14 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy14, yymsp[-3].minor.yy132, yymsp[0].minor.yy454);
}
#line 4777 "parse.c"
        break;
      case 162: /* setlist ::= nm EQ expr */
#line 1078 "parse.y"
{
  yylhsminor.yy14 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy454);
  sqlite3ExprListSetName(pParse, yylhsminor.yy14, &yymsp[-2].minor.yy0, 1);
}
#line 4785 "parse.c"
  yymsp[-2].minor.yy14 = yylhsminor.yy14;
        break;
      case 163: /* setlist ::= LP idlist RP EQ expr */
#line 1082 "parse.y"
{
  yymsp[-4].minor.yy14 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy132, yymsp[0].minor.yy454);
}
#line 4793 "parse.c"
        break;
      case 164: /* cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
#line 1089 "parse.y"
{
  sqlite3Insert(pParse, yymsp[-3].minor.yy203, yymsp[-1].minor.yy555, yymsp[-2].minor.yy132, yymsp[-5].minor.yy144, yymsp[0].minor.yy122);
}
#line 4800 "parse.c"
        break;
      case 165: /* cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES returning */
#line 1093 "parse.y"
{
  sqlite3Insert(pParse, yymsp[-4].minor.yy203, 0, yymsp[-3].minor.yy132, yymsp[-6].minor.yy144, 0);
}
#line 4807 "parse.c"
        break;
      case 166: /* upsert ::= */
#line 1104 "parse.y"
{ yymsp[1].minor.yy122 = 0; }
#line 4812 "parse.c"
        break;
      case 167: /* upsert ::= RETURNING selcollist */
#line 1105 "parse.y"
{ yymsp[-1].minor.yy122 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy14); }
#line 4817 "parse.c"
        break;
      case 168: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
#line 1108 "parse.y"
{ yymsp[-11].minor.yy122 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy14,yymsp[-6].minor.yy454,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454,yymsp[0].minor.yy122);}
#line 4822 "parse.c"
        break;
      case 169: /* upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
#line 1110 "parse.y"
{ yymsp[-8].minor.yy122 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy14,yymsp[-3].minor.yy454,0,0,yymsp[0].minor.yy122); }
#line 4827 "parse.c"
        break;
      case 170: /* upsert ::= ON CONFLICT DO NOTHING returning */
#line 1112 "parse.y"
{ yymsp[-4].minor.yy122 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); }
#line 4832 "parse.c"
        break;
      case 171: /* upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
#line 1114 "parse.y"
{ yymsp[-7].minor.yy122 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454,0);}
#line 4837 "parse.c"
        break;
      case 172: /* returning ::= RETURNING selcollist */
#line 1116 "parse.y"
{sqlite3AddReturning(pParse,yymsp[0].minor.yy14);}
#line 4842 "parse.c"
        break;
      case 175: /* idlist_opt ::= */
#line 1128 "parse.y"
{yymsp[1].minor.yy132 = 0;}
#line 4847 "parse.c"
        break;
      case 176: /* idlist_opt ::= LP idlist RP */
#line 1129 "parse.y"
{yymsp[-2].minor.yy132 = yymsp[-1].minor.yy132;}
#line 4852 "parse.c"
        break;
      case 177: /* idlist ::= idlist COMMA nm */
#line 1131 "parse.y"
{yymsp[-2].minor.yy132 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy132,&yymsp[0].minor.yy0);}
#line 4857 "parse.c"
        break;
      case 178: /* idlist ::= nm */
#line 1133 "parse.y"
{yymsp[0].minor.yy132 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/}
#line 4862 "parse.c"
        break;
      case 179: /* expr ::= LP expr RP */
#line 1182 "parse.y"
{yymsp[-2].minor.yy454 = yymsp[-1].minor.yy454;}
#line 4867 "parse.c"
        break;
      case 180: /* expr ::= ID|INDEXED|JOIN_KW */
#line 1183 "parse.y"
{yymsp[0].minor.yy454=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/}
#line 4872 "parse.c"
        break;
      case 181: /* expr ::= nm DOT nm */
#line 1184 "parse.y"
{
  Expr *temp1 = tokenExpr(pParse,TK_ID,yymsp[-2].minor.yy0);
  Expr *temp2 = tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0);
  yylhsminor.yy454 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
}
#line 4881 "parse.c"
  yymsp[-2].minor.yy454 = yylhsminor.yy454;
        break;
      case 182: /* expr ::= nm DOT nm DOT nm */
#line 1189 "parse.y"
{
  Expr *temp1 = tokenExpr(pParse,TK_ID,yymsp[-4].minor.yy0);
  Expr *temp2 = tokenExpr(pParse,TK_ID,yymsp[-2].minor.yy0);
  Expr *temp3 = tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0);
  Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3);
  if( IN_RENAME_OBJECT ){
    sqlite3RenameTokenRemap(pParse, 0, temp1);
  }
  yylhsminor.yy454 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
}
#line 4896 "parse.c"
  yymsp[-4].minor.yy454 = yylhsminor.yy454;
        break;
      case 183: /* term ::= NULL|FLOAT|BLOB */
      case 184: /* term ::= STRING */ yytestcase(yyruleno==184);
#line 1199 "parse.y"
{yymsp[0].minor.yy454=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/}
#line 4903 "parse.c"
        break;
      case 185: /* term ::= INTEGER */
#line 1201 "parse.y"
{
  int iValue;
  if( sqlite3GetInt32(yymsp[0].minor.yy0.z, &iValue)==0 ){
    yylhsminor.yy454 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 0);
  }else{
    yylhsminor.yy454 = sqlite3ExprInt32(pParse->db, iValue);
  }
  if( yylhsminor.yy454 ) yylhsminor.yy454->w.iOfst = (int)(yymsp[0].minor.yy0.z - pParse->zTail);
}
#line 4916 "parse.c"
  yymsp[0].minor.yy454 = yylhsminor.yy454;
        break;
      case 186: /* expr ::= VARIABLE */
#line 1210 "parse.y"
{
  if( !(yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1])) ){
    u32 n = yymsp[0].minor.yy0.n;
    yymsp[0].minor.yy454 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0);
    sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy454, n);
  }else{
    /* When doing a nested parse, one can include terms in an expression
    ** that look like this:   #1 #2 ...  These terms refer to registers
    ** in the virtual machine.  #N is the N-th register. */
    Token t = yymsp[0].minor.yy0; /*A-overwrites-X*/
    assert( t.n>=2 );
    if( pParse->nested==0 ){
      parserSyntaxError(pParse, &t);
      yymsp[0].minor.yy454 = 0;
    }else{
      yymsp[0].minor.yy454 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
      if( yymsp[0].minor.yy454 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy454->iTable);
    }
  }
}
#line 4941 "parse.c"
        break;
      case 187: /* expr ::= expr COLLATE ID|STRING */
#line 1230 "parse.y"
{
  yymsp[-2].minor.yy454 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy454, &yymsp[0].minor.yy0, 1);
}
#line 4948 "parse.c"
        break;
      case 188: /* expr ::= CAST LP expr AS typetoken RP */
#line 1234 "parse.y"
{
  yymsp[-5].minor.yy454 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1);
  sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy454, yymsp[-3].minor.yy454, 0);
}
#line 4956 "parse.c"
        break;
      case 189: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP */
#line 1241 "parse.y"
{
  yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy144);
}
#line 4963 "parse.c"
  yymsp[-4].minor.yy454 = yylhsminor.yy454;
        break;
      case 190: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP */
#line 1244 "parse.y"
{
  yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-4].minor.yy14, &yymsp[-7].minor.yy0, yymsp[-5].minor.yy144);
  sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy454, yymsp[-1].minor.yy14);
}
#line 4972 "parse.c"
  yymsp[-7].minor.yy454 = yylhsminor.yy454;
        break;
      case 191: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP */
#line 1248 "parse.y"
{
  yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0);
}
#line 4980 "parse.c"
  yymsp[-3].minor.yy454 = yylhsminor.yy454;
        break;
      case 192: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist RP filter_over */
#line 1312 "parse.y"
{
  yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy14, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy144);
  sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
}
#line 4989 "parse.c"
  yymsp[-5].minor.yy454 = yylhsminor.yy454;
        break;
      case 193: /* expr ::= ID|INDEXED|JOIN_KW LP distinct exprlist ORDER BY sortlist RP filter_over */
#line 1316 "parse.y"
{
  yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-5].minor.yy14, &yymsp[-8].minor.yy0, yymsp[-6].minor.yy144);
  sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
  sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy454, yymsp[-2].minor.yy14);
}
#line 4999 "parse.c"
  yymsp[-8].minor.yy454 = yylhsminor.yy454;
        break;
      case 194: /* expr ::= ID|INDEXED|JOIN_KW LP STAR RP filter_over */
#line 1321 "parse.y"
{
  yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0);
  sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
}
#line 5008 "parse.c"
  yymsp[-4].minor.yy454 = yylhsminor.yy454;
        break;
      case 195: /* term ::= CTIME_KW */
#line 1335 "parse.y"
{
  yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0);
}
#line 5016 "parse.c"
  yymsp[0].minor.yy454 = yylhsminor.yy454;
        break;
      case 196: /* expr ::= LP nexprlist COMMA expr RP */
#line 1339 "parse.y"
{
  ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy14, yymsp[-1].minor.yy454);
  yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
  if( yymsp[-4].minor.yy454 ){
    int i;
    yymsp[-4].minor.yy454->x.pList = pList;
    for(i=0; i<pList->nExpr; i++){
      assert( pList->a[i].pExpr!=0 );
      yymsp[-4].minor.yy454->flags |= pList->a[i].pExpr->flags & EP_Propagate;
    }
  }else{
    sqlite3ExprListDelete(pParse->db, pList);
  }
}
#line 5035 "parse.c"
        break;
      case 197: /* expr ::= expr AND expr */
#line 1354 "parse.y"
{yymsp[-2].minor.yy454=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
#line 5040 "parse.c"
        break;
      case 198: /* expr ::= expr OR expr */
      case 199: /* expr ::= expr LT|GT|GE|LE expr */ yytestcase(yyruleno==199);
      case 200: /* expr ::= expr EQ|NE expr */ yytestcase(yyruleno==200);
      case 201: /* expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */ yytestcase(yyruleno==201);
      case 202: /* expr ::= expr PLUS|MINUS expr */ yytestcase(yyruleno==202);
      case 203: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==203);
      case 204: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==204);
#line 1355 "parse.y"
{yymsp[-2].minor.yy454=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
#line 5051 "parse.c"
        break;
      case 205: /* likeop ::= NOT LIKE_KW|MATCH */
#line 1368 "parse.y"
{yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n|=0x80000000; /*yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0*/}
#line 5056 "parse.c"
        break;
      case 206: /* expr ::= expr likeop expr */
#line 1369 "parse.y"
{
  ExprList *pList;
  int bNot = yymsp[-1].minor.yy0.n & 0x80000000;
  yymsp[-1].minor.yy0.n &= 0x7fffffff;
  pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy454);
  pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy454);
  yymsp[-2].minor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
  if( bNot ) yymsp[-2].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy454, 0);
  if( yymsp[-2].minor.yy454 ) yymsp[-2].minor.yy454->flags |= EP_InfixFunc;
}
#line 5070 "parse.c"
        break;
      case 207: /* expr ::= expr likeop expr ESCAPE expr */
#line 1379 "parse.y"
{
  ExprList *pList;
  int bNot = yymsp[-3].minor.yy0.n & 0x80000000;
  yymsp[-3].minor.yy0.n &= 0x7fffffff;
  pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
  pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy454);
  pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy454);
  yymsp[-4].minor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0);
  if( bNot ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
  if( yymsp[-4].minor.yy454 ) yymsp[-4].minor.yy454->flags |= EP_InfixFunc;
}
#line 5085 "parse.c"
        break;
      case 208: /* expr ::= expr ISNULL|NOTNULL */
#line 1435 "parse.y"
{yymsp[-1].minor.yy454 = sqlite3PExprIsNull(pParse,yymsp[0].major,yymsp[-1].minor.yy454);}
#line 5090 "parse.c"
        break;
      case 209: /* expr ::= expr NOT NULL */
#line 1436 "parse.y"
{yymsp[-2].minor.yy454 = sqlite3PExprIsNull(pParse,TK_NOTNULL,yymsp[-2].minor.yy454);}
#line 5095 "parse.c"
        break;
      case 210: /* expr ::= expr IS expr */
#line 1441 "parse.y"
{
  yymsp[-2].minor.yy454 = sqlite3PExprIs(pParse, TK_IS, yymsp[-2].minor.yy454, yymsp[0].minor.yy454);
}
#line 5102 "parse.c"
        break;
      case 211: /* expr ::= expr IS NOT expr */
#line 1444 "parse.y"
{
  yymsp[-3].minor.yy454 = sqlite3PExprIs(pParse, TK_ISNOT, yymsp[-3].minor.yy454, yymsp[0].minor.yy454);
}
#line 5109 "parse.c"
        break;
      case 212: /* expr ::= expr IS NOT DISTINCT FROM expr */
#line 1447 "parse.y"
{
  yymsp[-5].minor.yy454 = sqlite3PExprIs(pParse, TK_IS, yymsp[-5].minor.yy454, yymsp[0].minor.yy454);
}
#line 5116 "parse.c"
        break;
      case 213: /* expr ::= expr IS DISTINCT FROM expr */
#line 1450 "parse.y"
{
  yymsp[-4].minor.yy454 = sqlite3PExprIs(pParse, TK_ISNOT, yymsp[-4].minor.yy454, yymsp[0].minor.yy454);
}
#line 5123 "parse.c"
        break;
      case 214: /* expr ::= NOT expr */
      case 215: /* expr ::= BITNOT expr */ yytestcase(yyruleno==215);
#line 1455 "parse.y"
{yymsp[-1].minor.yy454 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy454, 0);/*A-overwrites-B*/}
#line 5129 "parse.c"
        break;
      case 216: /* expr ::= PLUS|MINUS expr */
#line 1458 "parse.y"
{
  Expr *p = yymsp[0].minor.yy454;
  u8 op = yymsp[-1].major + (TK_UPLUS-TK_PLUS);
  assert( TK_UPLUS>TK_PLUS );
  assert( TK_UMINUS == TK_MINUS + (TK_UPLUS - TK_PLUS) );
  if( p && p->op==TK_UPLUS ){
    p->op = op;
    yymsp[-1].minor.yy454 = p;
  }else{
    yymsp[-1].minor.yy454 = sqlite3PExpr(pParse, op, p, 0);
    /*A-overwrites-B*/
  }
}
#line 5146 "parse.c"
        break;
      case 217: /* expr ::= expr PTR expr */
#line 1472 "parse.y"
{
  ExprList *pList = sqlite3ExprListAppend(pParse, 0, yymsp[-2].minor.yy454);
  pList = sqlite3ExprListAppend(pParse, pList, yymsp[0].minor.yy454);
  yylhsminor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
}
#line 5155 "parse.c"
  yymsp[-2].minor.yy454 = yylhsminor.yy454;
        break;
      case 218: /* between_op ::= BETWEEN */
      case 221: /* in_op ::= IN */ yytestcase(yyruleno==221);
#line 1479 "parse.y"
{yymsp[0].minor.yy144 = 0;}
#line 5162 "parse.c"
        break;
      case 220: /* expr ::= expr between_op expr AND expr */
#line 1481 "parse.y"
{
  ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
  pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy454);
  yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy454, 0);
  if( yymsp[-4].minor.yy454 ){
    yymsp[-4].minor.yy454->x.pList = pList;
    sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy454);
  }else{
    sqlite3ExprListDelete(pParse->db, pList);
  } 
  if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
}
#line 5178 "parse.c"
        break;
      case 223: /* expr ::= expr in_op LP exprlist RP */
#line 1497 "parse.y"
{
    if( yymsp[-1].minor.yy14==0 ){
      /* Expressions of the form
      **
      **      expr1 IN ()
      **      expr1 NOT IN ()
      **
      ** simplify to constants 0 (false) and 1 (true), respectively.
      **
      ** Except, do not apply this optimization if expr1 contains a function
      ** because that function might be an aggregate (we don't know yet whether
      ** it is or not) and if it is an aggregate, that could change the meaning
      ** of the whole query.
      */
      Expr *pB = sqlite3Expr(pParse->db, TK_STRING, yymsp[-3].minor.yy144 ? "true" : "false");
      if( pB ) sqlite3ExprIdToTrueFalse(pB);
      if( !ExprHasProperty(yymsp[-4].minor.yy454, EP_HasFunc) ){
        sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy454);
        yymsp[-4].minor.yy454 = pB;
      }else{
        yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, yymsp[-3].minor.yy144 ? TK_OR : TK_AND, pB, yymsp[-4].minor.yy454);
      }
    }else{
      Expr *pRHS = yymsp[-1].minor.yy14->a[0].pExpr;
      if( yymsp[-1].minor.yy14->nExpr==1
       && sqlite3ExprIsConstant(pParse,pRHS)
       && pRHS->op!=TK_COLLATE
       && yymsp[-4].minor.yy454->op!=TK_VECTOR
      ){
        yymsp[-1].minor.yy14->a[0].pExpr = 0;
        sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
        pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0);
        yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy454, pRHS);
      }else if( yymsp[-1].minor.yy14->nExpr==1 && pRHS->op==TK_SELECT ){
        yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
        sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pRHS->x.pSelect);
        pRHS->x.pSelect = 0;
        sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
      }else{
        yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
        if( yymsp[-4].minor.yy454==0 ){
          sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
        }else if( yymsp[-4].minor.yy454->pLeft->op==TK_VECTOR ){
          int nExpr = yymsp[-4].minor.yy454->pLeft->x.pList->nExpr;
          Select *pSelectRHS = sqlite3ExprListToValues(pParse, nExpr, yymsp[-1].minor.yy14);
          if( pSelectRHS ){
            parserDoubleLinkSelect(pParse, pSelectRHS);
            sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pSelectRHS);
          }
        }else{
          yymsp[-4].minor.yy454->x.pList = yymsp[-1].minor.yy14;
          sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy454);
        }
      }
      if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
    }
  }
#line 5239 "parse.c"
        break;
      case 224: /* expr ::= LP select RP */
#line 1554 "parse.y"
{
    yymsp[-2].minor.yy454 = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
    sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy454, yymsp[-1].minor.yy555);
  }
#line 5247 "parse.c"
        break;
      case 225: /* expr ::= expr in_op LP select RP */
#line 1558 "parse.y"
{
    yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
    sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, yymsp[-1].minor.yy555);
    if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
  }
#line 5256 "parse.c"
        break;
      case 226: /* expr ::= expr in_op nm dbnm paren_exprlist */
#line 1563 "parse.y"
{
    SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);
    Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0);
    if( yymsp[0].minor.yy14 )  sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy14);
    yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
    sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pSelect);
    if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
  }
#line 5268 "parse.c"
        break;
      case 227: /* expr ::= EXISTS LP select RP */
#line 1571 "parse.y"
{
    Expr *p;
    p = yymsp[-3].minor.yy454 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
    sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy555);
  }
#line 5277 "parse.c"
        break;
      case 228: /* expr ::= CASE case_operand case_exprlist case_else END */
#line 1579 "parse.y"
{
  yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy454, 0);
  if( yymsp[-4].minor.yy454 ){
    yymsp[-4].minor.yy454->x.pList = yymsp[-1].minor.yy454 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454) : yymsp[-2].minor.yy14;
    sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy454);
  }else{
    sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy14);
    sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy454);
  }
}
#line 5291 "parse.c"
        break;
      case 229: /* case_exprlist ::= case_exprlist WHEN expr THEN expr */
#line 1591 "parse.y"
{
  yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[-2].minor.yy454);
  yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[0].minor.yy454);
}
#line 5299 "parse.c"
        break;
      case 230: /* case_exprlist ::= WHEN expr THEN expr */
#line 1595 "parse.y"
{
  yymsp[-3].minor.yy14 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
  yymsp[-3].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy14, yymsp[0].minor.yy454);
}
#line 5307 "parse.c"
        break;
      case 235: /* nexprlist ::= nexprlist COMMA expr */
#line 1616 "parse.y"
{yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[0].minor.yy454);}
#line 5312 "parse.c"
        break;
      case 236: /* nexprlist ::= expr */
#line 1618 "parse.y"
{yymsp[0].minor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy454); /*A-overwrites-Y*/}
#line 5317 "parse.c"
        break;
      case 238: /* paren_exprlist ::= LP exprlist RP */
      case 243: /* eidlist_opt ::= LP eidlist RP */ yytestcase(yyruleno==243);
#line 1626 "parse.y"
{yymsp[-2].minor.yy14 = yymsp[-1].minor.yy14;}
#line 5323 "parse.c"
        break;
      case 239: /* cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
#line 1633 "parse.y"
{
  sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, 
                     sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy14, yymsp[-10].minor.yy144,
                      &yymsp[-11].minor.yy0, yymsp[0].minor.yy454, SQLITE_SO_ASC, yymsp[-8].minor.yy144, SQLITE_IDXTYPE_APPDEF);
  if( IN_RENAME_OBJECT && pParse->pNewIndex ){
    sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
  }
}
#line 5335 "parse.c"
        break;
      case 240: /* uniqueflag ::= UNIQUE */
      case 281: /* raisetype ::= ABORT */ yytestcase(yyruleno==281);
#line 1643 "parse.y"
{yymsp[0].minor.yy144 = OE_Abort;}
#line 5341 "parse.c"
        break;
      case 241: /* uniqueflag ::= */
#line 1644 "parse.y"
{yymsp[1].minor.yy144 = OE_None;}
#line 5346 "parse.c"
        break;
      case 244: /* eidlist ::= eidlist COMMA nm collate sortorder */
#line 1694 "parse.y"
{
  yymsp[-4].minor.yy14 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy14, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy144, yymsp[0].minor.yy144);
}
#line 5353 "parse.c"
        break;
      case 245: /* eidlist ::= nm collate sortorder */
#line 1697 "parse.y"
{
  yymsp[-2].minor.yy14 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy144, yymsp[0].minor.yy144); /*A-overwrites-Y*/
}
#line 5360 "parse.c"
        break;
      case 248: /* cmd ::= DROP INDEX ifexists fullname */
#line 1708 "parse.y"
{sqlite3DropIndex(pParse, yymsp[0].minor.yy203, yymsp[-1].minor.yy144);}
#line 5365 "parse.c"
        break;
      case 249: /* cmd ::= VACUUM vinto */
#line 1715 "parse.y"
{sqlite3Vacuum(pParse,0,yymsp[0].minor.yy454);}
#line 5370 "parse.c"
        break;
      case 250: /* cmd ::= VACUUM nm vinto */
#line 1716 "parse.y"
{sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy454);}
#line 5375 "parse.c"
        break;
      case 253: /* cmd ::= PRAGMA nm dbnm */
#line 1724 "parse.y"
{sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
#line 5380 "parse.c"
        break;
      case 254: /* cmd ::= PRAGMA nm dbnm EQ nmnum */
#line 1725 "parse.y"
{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
#line 5385 "parse.c"
        break;
      case 255: /* cmd ::= PRAGMA nm dbnm LP nmnum RP */
#line 1726 "parse.y"
{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
#line 5390 "parse.c"
        break;
      case 256: /* cmd ::= PRAGMA nm dbnm EQ minus_num */
#line 1728 "parse.y"
{sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
#line 5395 "parse.c"
        break;
      case 257: /* cmd ::= PRAGMA nm dbnm LP minus_num RP */
#line 1730 "parse.y"
{sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
#line 5400 "parse.c"
        break;
      case 260: /* cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
#line 1746 "parse.y"
{
  Token all;
  all.z = yymsp[-3].minor.yy0.z;
  all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
  sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy427, &all);
}
#line 5410 "parse.c"
        break;
      case 261: /* trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */
#line 1755 "parse.y"
{
  sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy144, yymsp[-4].minor.yy286.a, yymsp[-4].minor.yy286.b, yymsp[-2].minor.yy203, yymsp[0].minor.yy454, yymsp[-10].minor.yy144, yymsp[-8].minor.yy144);
  yymsp[-10].minor.yy0 = (yymsp[-6].minor.yy0.n==0?yymsp[-7].minor.yy0:yymsp[-6].minor.yy0); /*A-overwrites-T*/
#ifdef SQLITE_DEBUG
  assert( pParse->isCreate ); /* Set by createkw reduce action */
  pParse->isCreate = 0;       /* But, should not be set for CREATE TRIGGER */
#endif
}
#line 5422 "parse.c"
        break;
      case 262: /* trigger_time ::= BEFORE|AFTER */
#line 1765 "parse.y"
{ yymsp[0].minor.yy144 = yymsp[0].major; /*A-overwrites-X*/ }
#line 5427 "parse.c"
        break;
      case 263: /* trigger_time ::= INSTEAD OF */
#line 1766 "parse.y"
{ yymsp[-1].minor.yy144 = TK_INSTEAD;}
#line 5432 "parse.c"
        break;
      case 264: /* trigger_time ::= */
#line 1767 "parse.y"
{ yymsp[1].minor.yy144 = TK_BEFORE; }
#line 5437 "parse.c"
        break;
      case 265: /* trigger_event ::= DELETE|INSERT */
      case 266: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==266);
#line 1771 "parse.y"
{yymsp[0].minor.yy286.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy286.b = 0;}
#line 5443 "parse.c"
        break;
      case 267: /* trigger_event ::= UPDATE OF idlist */
#line 1773 "parse.y"
{yymsp[-2].minor.yy286.a = TK_UPDATE; yymsp[-2].minor.yy286.b = yymsp[0].minor.yy132;}
#line 5448 "parse.c"
        break;
      case 268: /* when_clause ::= */
      case 286: /* key_opt ::= */ yytestcase(yyruleno==286);
#line 1780 "parse.y"
{ yymsp[1].minor.yy454 = 0; }
#line 5454 "parse.c"
        break;
      case 269: /* when_clause ::= WHEN expr */
      case 287: /* key_opt ::= KEY expr */ yytestcase(yyruleno==287);
#line 1781 "parse.y"
{ yymsp[-1].minor.yy454 = yymsp[0].minor.yy454; }
#line 5460 "parse.c"
        break;
      case 270: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
#line 1785 "parse.y"
{
  yymsp[-2].minor.yy427->pLast->pNext = yymsp[-1].minor.yy427;
  yymsp[-2].minor.yy427->pLast = yymsp[-1].minor.yy427;
}
#line 5468 "parse.c"
        break;
      case 271: /* trigger_cmd_list ::= trigger_cmd SEMI */
#line 1789 "parse.y"
{ 
  yymsp[-1].minor.yy427->pLast = yymsp[-1].minor.yy427;
}
#line 5475 "parse.c"
        break;
      case 272: /* tridxby ::= INDEXED BY nm */
#line 1798 "parse.y"
{
  sqlite3ErrorMsg(pParse,
        "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
        "within triggers");
}
#line 5484 "parse.c"
        break;
      case 273: /* tridxby ::= NOT INDEXED */
#line 1803 "parse.y"
{
  sqlite3ErrorMsg(pParse,
        "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
        "within triggers");
}
#line 5493 "parse.c"
        break;
      case 274: /* trigger_cmd ::= UPDATE orconf xfullname tridxby SET setlist from where_opt scanpt */
#line 1816 "parse.y"
{yylhsminor.yy427 = sqlite3TriggerUpdateStep(pParse, yymsp[-6].minor.yy203, yymsp[-2].minor.yy203, yymsp[-3].minor.yy14, yymsp[-1].minor.yy454, yymsp[-7].minor.yy144, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy168);}
#line 5498 "parse.c"
  yymsp[-8].minor.yy427 = yylhsminor.yy427;
        break;
      case 275: /* trigger_cmd ::= scanpt insert_cmd INTO xfullname idlist_opt select upsert scanpt */
#line 1820 "parse.y"
{
   yylhsminor.yy427 = sqlite3TriggerInsertStep(pParse,yymsp[-4].minor.yy203,yymsp[-3].minor.yy132,yymsp[-2].minor.yy555,yymsp[-6].minor.yy144,yymsp[-1].minor.yy122,yymsp[-7].minor.yy168,yymsp[0].minor.yy168);/*yylhsminor.yy427-overwrites-yymsp[-6].minor.yy144*/
}
#line 5506 "parse.c"
  yymsp[-7].minor.yy427 = yylhsminor.yy427;
        break;
      case 276: /* trigger_cmd ::= DELETE FROM xfullname tridxby where_opt scanpt */
#line 1825 "parse.y"
{yylhsminor.yy427 = sqlite3TriggerDeleteStep(pParse, yymsp[-3].minor.yy203, yymsp[-1].minor.yy454, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy168);}
#line 5512 "parse.c"
  yymsp[-5].minor.yy427 = yylhsminor.yy427;
        break;
      case 277: /* trigger_cmd ::= scanpt select scanpt */
#line 1829 "parse.y"
{yylhsminor.yy427 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy555, yymsp[-2].minor.yy168, yymsp[0].minor.yy168); /*yylhsminor.yy427-overwrites-yymsp[-1].minor.yy555*/}
#line 5518 "parse.c"
  yymsp[-2].minor.yy427 = yylhsminor.yy427;
        break;
      case 278: /* expr ::= RAISE LP IGNORE RP */
#line 1832 "parse.y"
{
  yymsp[-3].minor.yy454 = sqlite3PExpr(pParse, TK_RAISE, 0, 0); 
  if( yymsp[-3].minor.yy454 ){
    yymsp[-3].minor.yy454->affExpr = OE_Ignore;
  }
}
#line 5529 "parse.c"
        break;
      case 279: /* expr ::= RAISE LP raisetype COMMA expr RP */
#line 1838 "parse.y"
{
  yymsp[-5].minor.yy454 = sqlite3PExpr(pParse, TK_RAISE, yymsp[-1].minor.yy454, 0);
  if( yymsp[-5].minor.yy454 ) {
    yymsp[-5].minor.yy454->affExpr = (char)yymsp[-3].minor.yy144;
  }
}
#line 5539 "parse.c"
        break;
      case 280: /* raisetype ::= ROLLBACK */
#line 1847 "parse.y"
{yymsp[0].minor.yy144 = OE_Rollback;}
#line 5544 "parse.c"
        break;
      case 282: /* raisetype ::= FAIL */
#line 1849 "parse.y"
{yymsp[0].minor.yy144 = OE_Fail;}
#line 5549 "parse.c"
        break;
      case 283: /* cmd ::= DROP TRIGGER ifexists fullname */
#line 1854 "parse.y"
{
  sqlite3DropTrigger(pParse,yymsp[0].minor.yy203,yymsp[-1].minor.yy144);
}
#line 5556 "parse.c"
        break;
      case 284: /* cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
#line 1861 "parse.y"
{
  sqlite3Attach(pParse, yymsp[-3].minor.yy454, yymsp[-1].minor.yy454, yymsp[0].minor.yy454);
}
#line 5563 "parse.c"
        break;
      case 285: /* cmd ::= DETACH database_kw_opt expr */
#line 1864 "parse.y"
{
  sqlite3Detach(pParse, yymsp[0].minor.yy454);
}
#line 5570 "parse.c"
        break;
      case 288: /* cmd ::= REINDEX */
#line 1879 "parse.y"
{sqlite3Reindex(pParse, 0, 0);}
#line 5575 "parse.c"
        break;
      case 289: /* cmd ::= REINDEX nm dbnm */
#line 1880 "parse.y"
{sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
#line 5580 "parse.c"
        break;
      case 290: /* cmd ::= ANALYZE */
#line 1885 "parse.y"
{sqlite3Analyze(pParse, 0, 0);}
#line 5585 "parse.c"
        break;
      case 291: /* cmd ::= ANALYZE nm dbnm */
#line 1886 "parse.y"
{sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
#line 5590 "parse.c"
        break;
      case 292: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
#line 1892 "parse.y"
{
  sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy203,&yymsp[0].minor.yy0);
}
#line 5597 "parse.c"
        break;
      case 293: /* cmd ::= alter_add carglist */
#line 1899 "parse.y"
{
  yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n;
  sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0);
}
#line 5605 "parse.c"
        break;
      case 294: /* alter_add ::= ALTER TABLE fullname ADD kwcolumn_opt nm typetoken */
#line 1903 "parse.y"
{
  disableLookaside(pParse);
  sqlite3AlterBeginAddColumn(pParse, yymsp[-4].minor.yy203);
  sqlite3AddColumn(pParse, yymsp[-1].minor.yy0, yymsp[0].minor.yy0);
  yymsp[-6].minor.yy0 = yymsp[-1].minor.yy0;
}
#line 5615 "parse.c"
        break;
      case 295: /* cmd ::= ALTER TABLE fullname DROP kwcolumn_opt nm */
#line 1910 "parse.y"
{
  sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy203, &yymsp[0].minor.yy0);
}
#line 5622 "parse.c"
        break;
      case 296: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
#line 1913 "parse.y"
{
  sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy203, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
}
#line 5629 "parse.c"
        break;
      case 297: /* cmd ::= ALTER TABLE fullname DROP CONSTRAINT nm */
#line 1916 "parse.y"
{
  sqlite3AlterDropConstraint(pParse, yymsp[-3].minor.yy203, &yymsp[0].minor.yy0, 0);
}
#line 5636 "parse.c"
        break;
      case 298: /* cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm DROP NOT NULL */
#line 1919 "parse.y"
{
  sqlite3AlterDropConstraint(pParse, yymsp[-6].minor.yy203, 0, &yymsp[-3].minor.yy0);
}
#line 5643 "parse.c"
        break;
      case 299: /* cmd ::= ALTER TABLE fullname ALTER kwcolumn_opt nm SET NOT NULL onconf */
#line 1922 "parse.y"
{
  sqlite3AlterSetNotNull(pParse, yymsp[-7].minor.yy203, &yymsp[-4].minor.yy0, &yymsp[-2].minor.yy0);
}
#line 5650 "parse.c"
        break;
      case 300: /* cmd ::= ALTER TABLE fullname ADD CONSTRAINT nm CHECK LP expr RP onconf */
#line 1925 "parse.y"
{
  sqlite3AlterAddConstraint(pParse, yymsp[-8].minor.yy203, &yymsp[-6].minor.yy0, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy0.z+1, (yymsp[-1].minor.yy0.z-yymsp[-3].minor.yy0.z-1), yymsp[-2].minor.yy454);
}
#line 5657 "parse.c"
        break;
      case 301: /* cmd ::= ALTER TABLE fullname ADD CHECK LP expr RP onconf */
#line 1928 "parse.y"
{
  sqlite3AlterAddConstraint(pParse, yymsp[-6].minor.yy203, &yymsp[-4].minor.yy0, 0, yymsp[-3].minor.yy0.z+1, (yymsp[-1].minor.yy0.z-yymsp[-3].minor.yy0.z-1), yymsp[-2].minor.yy454);
}
#line 5664 "parse.c"
        break;
      case 302: /* cmd ::= create_vtab */
#line 1940 "parse.y"
{sqlite3VtabFinishParse(pParse,0);}
#line 5669 "parse.c"
        break;
      case 303: /* cmd ::= create_vtab LP vtabarglist RP */
#line 1941 "parse.y"
{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
#line 5674 "parse.c"
        break;
      case 304: /* create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
#line 1943 "parse.y"
{
    sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy144);
}
#line 5681 "parse.c"
        break;
      case 305: /* vtabarg ::= */
#line 1948 "parse.y"
{sqlite3VtabArgInit(pParse);}
#line 5686 "parse.c"
        break;
      case 306: /* vtabargtoken ::= ANY */
      case 307: /* vtabargtoken ::= lp anylist RP */ yytestcase(yyruleno==307);
      case 308: /* lp ::= LP */ yytestcase(yyruleno==308);
#line 1950 "parse.y"
{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
#line 5693 "parse.c"
        break;
      case 309: /* with ::= WITH wqlist */
      case 310: /* with ::= WITH RECURSIVE wqlist */ yytestcase(yyruleno==310);
#line 1967 "parse.y"
{ sqlite3WithPush(pParse, yymsp[0].minor.yy59, 1); }
#line 5699 "parse.c"
        break;
      case 311: /* wqas ::= AS */
#line 1971 "parse.y"
{yymsp[0].minor.yy462 = M10d_Any;}
#line 5704 "parse.c"
        break;
      case 312: /* wqas ::= AS MATERIALIZED */
#line 1972 "parse.y"
{yymsp[-1].minor.yy462 = M10d_Yes;}
#line 5709 "parse.c"
        break;
      case 313: /* wqas ::= AS NOT MATERIALIZED */
#line 1973 "parse.y"
{yymsp[-2].minor.yy462 = M10d_No;}
#line 5714 "parse.c"
        break;
      case 314: /* wqitem ::= withnm eidlist_opt wqas LP select RP */
#line 1974 "parse.y"
{
  yymsp[-5].minor.yy67 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy14, yymsp[-1].minor.yy555, yymsp[-3].minor.yy462); /*A-overwrites-X*/
}
#line 5721 "parse.c"
        break;
      case 315: /* withnm ::= nm */
#line 1977 "parse.y"
{pParse->bHasWith = 1;}
#line 5726 "parse.c"
        break;
      case 316: /* wqlist ::= wqitem */
#line 1978 "parse.y"
{
  yymsp[0].minor.yy59 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy67); /*A-overwrites-X*/
}
#line 5733 "parse.c"
        break;
      case 317: /* wqlist ::= wqlist COMMA wqitem */
#line 1981 "parse.y"
{
  yymsp[-2].minor.yy59 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy59, yymsp[0].minor.yy67);
}
#line 5740 "parse.c"
        break;
      case 318: /* windowdefn_list ::= windowdefn_list COMMA windowdefn */
#line 1997 "parse.y"
{
  assert( yymsp[0].minor.yy211!=0 );
  sqlite3WindowChain(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy211);
  yymsp[0].minor.yy211->pNextWin = yymsp[-2].minor.yy211;
  yylhsminor.yy211 = yymsp[0].minor.yy211;
}
#line 5750 "parse.c"
  yymsp[-2].minor.yy211 = yylhsminor.yy211;
        break;
      case 319: /* windowdefn ::= nm AS LP window RP */
#line 2006 "parse.y"
{
  if( ALWAYS(yymsp[-1].minor.yy211) ){
    yymsp[-1].minor.yy211->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
  }
  yylhsminor.yy211 = yymsp[-1].minor.yy211;
}
#line 5761 "parse.c"
  yymsp[-4].minor.yy211 = yylhsminor.yy211;
        break;
      case 320: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */
#line 2040 "parse.y"
{
  yymsp[-4].minor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy14, yymsp[-1].minor.yy14, 0);
}
#line 5769 "parse.c"
        break;
      case 321: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
#line 2043 "parse.y"
{
  yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy14, yymsp[-1].minor.yy14, &yymsp[-5].minor.yy0);
}
#line 5776 "parse.c"
  yymsp[-5].minor.yy211 = yylhsminor.yy211;
        break;
      case 322: /* window ::= ORDER BY sortlist frame_opt */
#line 2046 "parse.y"
{
  yymsp[-3].minor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, yymsp[-1].minor.yy14, 0);
}
#line 5784 "parse.c"
        break;
      case 323: /* window ::= nm ORDER BY sortlist frame_opt */
#line 2049 "parse.y"
{
  yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0);
}
#line 5791 "parse.c"
  yymsp[-4].minor.yy211 = yylhsminor.yy211;
        break;
      case 324: /* window ::= nm frame_opt */
#line 2053 "parse.y"
{
  yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, 0, &yymsp[-1].minor.yy0);
}
#line 5799 "parse.c"
  yymsp[-1].minor.yy211 = yylhsminor.yy211;
        break;
      case 325: /* frame_opt ::= */
#line 2057 "parse.y"
{ 
  yymsp[1].minor.yy211 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
}
#line 5807 "parse.c"
        break;
      case 326: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
#line 2060 "parse.y"
{ 
  yylhsminor.yy211 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy144, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.yy509.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy462);
}
#line 5814 "parse.c"
  yymsp[-2].minor.yy211 = yylhsminor.yy211;
        break;
      case 327: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
#line 2064 "parse.y"
{ 
  yylhsminor.yy211 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy144, yymsp[-3].minor.yy509.eType, yymsp[-3].minor.yy509.pExpr, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.yy509.pExpr, yymsp[0].minor.yy462);
}
#line 5822 "parse.c"
  yymsp[-5].minor.yy211 = yylhsminor.yy211;
        break;
      case 329: /* frame_bound_s ::= frame_bound */
      case 331: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==331);
#line 2070 "parse.y"
{yylhsminor.yy509 = yymsp[0].minor.yy509;}
#line 5829 "parse.c"
  yymsp[0].minor.yy509 = yylhsminor.yy509;
        break;
      case 330: /* frame_bound_s ::= UNBOUNDED PRECEDING */
      case 332: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==332);
      case 334: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==334);
#line 2071 "parse.y"
{yylhsminor.yy509.eType = yymsp[-1].major; yylhsminor.yy509.pExpr = 0;}
#line 5837 "parse.c"
  yymsp[-1].minor.yy509 = yylhsminor.yy509;
        break;
      case 333: /* frame_bound ::= expr PRECEDING|FOLLOWING */
#line 2076 "parse.y"
{yylhsminor.yy509.eType = yymsp[0].major; yylhsminor.yy509.pExpr = yymsp[-1].minor.yy454;}
#line 5843 "parse.c"
  yymsp[-1].minor.yy509 = yylhsminor.yy509;
        break;
      case 335: /* frame_exclude_opt ::= */
#line 2080 "parse.y"
{yymsp[1].minor.yy462 = 0;}
#line 5849 "parse.c"
        break;
      case 336: /* frame_exclude_opt ::= EXCLUDE frame_exclude */
#line 2081 "parse.y"
{yymsp[-1].minor.yy462 = yymsp[0].minor.yy462;}
#line 5854 "parse.c"
        break;
      case 337: /* frame_exclude ::= NO OTHERS */
      case 338: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==338);
#line 2084 "parse.y"
{yymsp[-1].minor.yy462 = yymsp[-1].major; /*A-overwrites-X*/}
#line 5860 "parse.c"
        break;
      case 339: /* frame_exclude ::= GROUP|TIES */
#line 2086 "parse.y"
{yymsp[0].minor.yy462 = yymsp[0].major; /*A-overwrites-X*/}
#line 5865 "parse.c"
        break;
      case 340: /* window_clause ::= WINDOW windowdefn_list */
#line 2091 "parse.y"
{ yymsp[-1].minor.yy211 = yymsp[0].minor.yy211; }
#line 5870 "parse.c"
        break;
      case 341: /* filter_over ::= filter_clause over_clause */
#line 2093 "parse.y"
{
  if( yymsp[0].minor.yy211 ){
    yymsp[0].minor.yy211->pFilter = yymsp[-1].minor.yy454;
  }else{
    sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy454);
  }
  yylhsminor.yy211 = yymsp[0].minor.yy211;
}
#line 5882 "parse.c"
  yymsp[-1].minor.yy211 = yylhsminor.yy211;
        break;
      case 342: /* filter_over ::= over_clause */
#line 2101 "parse.y"
{
  yylhsminor.yy211 = yymsp[0].minor.yy211;
}
#line 5890 "parse.c"
  yymsp[0].minor.yy211 = yylhsminor.yy211;
        break;
      case 343: /* filter_over ::= filter_clause */
#line 2104 "parse.y"
{
  yylhsminor.yy211 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
  if( yylhsminor.yy211 ){
    yylhsminor.yy211->eFrmType = TK_FILTER;
    yylhsminor.yy211->pFilter = yymsp[0].minor.yy454;
  }else{
    sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy454);
  }
}
#line 5904 "parse.c"
  yymsp[0].minor.yy211 = yylhsminor.yy211;
        break;
      case 344: /* over_clause ::= OVER LP window RP */
#line 2114 "parse.y"
{
  yymsp[-3].minor.yy211 = yymsp[-1].minor.yy211;
  assert( yymsp[-3].minor.yy211!=0 );
}
#line 5913 "parse.c"
        break;
      case 345: /* over_clause ::= OVER nm */
#line 2118 "parse.y"
{
  yymsp[-1].minor.yy211 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
  if( yymsp[-1].minor.yy211 ){
    yymsp[-1].minor.yy211->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
  }
}
#line 5923 "parse.c"
        break;
      case 346: /* filter_clause ::= FILTER LP WHERE expr RP */
#line 2125 "parse.y"
{ yymsp[-4].minor.yy454 = yymsp[-1].minor.yy454; }
#line 5928 "parse.c"
        break;
      case 347: /* term ::= QNUMBER */
#line 2151 "parse.y"
{
  yylhsminor.yy454=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0);
  sqlite3DequoteNumber(pParse, yylhsminor.yy454);
}
#line 5936 "parse.c"
  yymsp[0].minor.yy454 = yylhsminor.yy454;
        break;
      default:
      /* (348) input ::= cmdlist */ yytestcase(yyruleno==348);
      /* (349) cmdlist ::= cmdlist ecmd */ yytestcase(yyruleno==349);
      /* (350) cmdlist ::= ecmd (OPTIMIZED OUT) */ assert(yyruleno!=350);
      /* (351) ecmd ::= SEMI */ yytestcase(yyruleno==351);
      /* (352) ecmd ::= cmdx SEMI */ yytestcase(yyruleno==352);
      /* (353) ecmd ::= explain cmdx SEMI (NEVER REDUCES) */ assert(yyruleno!=353);
      /* (354) trans_opt ::= */ yytestcase(yyruleno==354);
      /* (355) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==355);
      /* (356) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==356);
      /* (357) savepoint_opt ::= SAVEPOINT */ yytestcase(yyruleno==357);
      /* (358) savepoint_opt ::= */ yytestcase(yyruleno==358);
      /* (359) cmd ::= create_table create_table_args */ yytestcase(yyruleno==359);
      /* (360) table_option_set ::= table_option (OPTIMIZED OUT) */ assert(yyruleno!=360);
      /* (361) columnlist ::= columnlist COMMA columnname carglist */ yytestcase(yyruleno==361);
      /* (362) columnlist ::= columnname carglist */ yytestcase(yyruleno==362);
      /* (363) nm ::= ID|INDEXED|JOIN_KW */ yytestcase(yyruleno==363);
      /* (364) nm ::= STRING */ yytestcase(yyruleno==364);
      /* (365) typetoken ::= typename */ yytestcase(yyruleno==365);
      /* (366) typename ::= ID|STRING */ yytestcase(yyruleno==366);
      /* (367) signed ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=367);
      /* (368) signed ::= minus_num (OPTIMIZED OUT) */ assert(yyruleno!=368);
      /* (369) carglist ::= carglist ccons */ yytestcase(yyruleno==369);
      /* (370) carglist ::= */ yytestcase(yyruleno==370);
      /* (371) ccons ::= NULL onconf */ yytestcase(yyruleno==371);
      /* (372) ccons ::= GENERATED ALWAYS AS generated */ yytestcase(yyruleno==372);
      /* (373) ccons ::= AS generated */ yytestcase(yyruleno==373);
      /* (374) conslist_opt ::= COMMA conslist */ yytestcase(yyruleno==374);
      /* (375) conslist ::= conslist tconscomma tcons */ yytestcase(yyruleno==375);
      /* (376) conslist ::= tcons (OPTIMIZED OUT) */ assert(yyruleno!=376);
      /* (377) tconscomma ::= */ yytestcase(yyruleno==377);
      /* (378) defer_subclause_opt ::= defer_subclause (OPTIMIZED OUT) */ assert(yyruleno!=378);
      /* (379) resolvetype ::= raisetype (OPTIMIZED OUT) */ assert(yyruleno!=379);
      /* (380) selectnowith ::= oneselect (OPTIMIZED OUT) */ assert(yyruleno!=380);
      /* (381) oneselect ::= values */ yytestcase(yyruleno==381);
      /* (382) sclp ::= selcollist COMMA */ yytestcase(yyruleno==382);
      /* (383) as ::= ID|STRING */ yytestcase(yyruleno==383);
      /* (384) indexed_opt ::= indexed_by (OPTIMIZED OUT) */ assert(yyruleno!=384);
      /* (385) returning ::= */ yytestcase(yyruleno==385);
      /* (386) expr ::= term (OPTIMIZED OUT) */ assert(yyruleno!=386);
      /* (387) likeop ::= LIKE_KW|MATCH */ yytestcase(yyruleno==387);
      /* (388) case_operand ::= expr */ yytestcase(yyruleno==388);
      /* (389) exprlist ::= nexprlist */ yytestcase(yyruleno==389);
      /* (390) nmnum ::= plus_num (OPTIMIZED OUT) */ assert(yyruleno!=390);
      /* (391) nmnum ::= nm (OPTIMIZED OUT) */ assert(yyruleno!=391);
      /* (392) nmnum ::= ON */ yytestcase(yyruleno==392);
      /* (393) nmnum ::= DELETE */ yytestcase(yyruleno==393);
      /* (394) nmnum ::= DEFAULT */ yytestcase(yyruleno==394);
      /* (395) plus_num ::= INTEGER|FLOAT */ yytestcase(yyruleno==395);
      /* (396) foreach_clause ::= */ yytestcase(yyruleno==396);
      /* (397) foreach_clause ::= FOR EACH ROW */ yytestcase(yyruleno==397);
      /* (398) tridxby ::= */ yytestcase(yyruleno==398);
      /* (399) database_kw_opt ::= DATABASE */ yytestcase(yyruleno==399);
      /* (400) database_kw_opt ::= */ yytestcase(yyruleno==400);
      /* (401) kwcolumn_opt ::= */ yytestcase(yyruleno==401);
      /* (402) kwcolumn_opt ::= COLUMNKW */ yytestcase(yyruleno==402);
      /* (403) vtabarglist ::= vtabarg */ yytestcase(yyruleno==403);
      /* (404) vtabarglist ::= vtabarglist COMMA vtabarg */ yytestcase(yyruleno==404);
      /* (405) vtabarg ::= vtabarg vtabargtoken */ yytestcase(yyruleno==405);
      /* (406) anylist ::= */ yytestcase(yyruleno==406);
      /* (407) anylist ::= anylist LP anylist RP */ yytestcase(yyruleno==407);
      /* (408) anylist ::= anylist ANY */ yytestcase(yyruleno==408);
      /* (409) with ::= */ yytestcase(yyruleno==409);
      /* (410) windowdefn_list ::= windowdefn (OPTIMIZED OUT) */ assert(yyruleno!=410);
      /* (411) window ::= frame_opt (OPTIMIZED OUT) */ assert(yyruleno!=411);
        break;
/********** End reduce actions ************************************************/
  };
  assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );
  yygoto = yyRuleInfoLhs[yyruleno];
  yysize = yyRuleInfoNRhs[yyruleno];
  yyact = yy_find_reduce_action(yymsp[yysize].stateno,(YYCODETYPE)yygoto);

  /* There are no SHIFTREDUCE actions on nonterminals because the table
  ** generator has simplified them to pure REDUCE actions. */
  assert( !(yyact>YY_MAX_SHIFT && yyact<=YY_MAX_SHIFTREDUCE) );

  /* It is not possible for a REDUCE to be followed by an error */
  assert( yyact!=YY_ERROR_ACTION );

  yymsp += yysize+1;
  yypParser->yytos = yymsp;
  yymsp->stateno = (YYACTIONTYPE)yyact;
  yymsp->major = (YYCODETYPE)yygoto;
  yyTraceShift(yypParser, yyact, "... then shift");
  return yyact;
}

/*
** The following code executes when the parse fails
*/
#ifndef YYNOERRORRECOVERY
static void yy_parse_failed(
  yyParser *yypParser           /* The parser */
){
  sqlite3ParserARG_FETCH
  sqlite3ParserCTX_FETCH
#ifndef NDEBUG
  if( yyTraceFILE ){
    fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
  }
#endif
  while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);
  /* Here code is inserted which will be executed whenever the
  ** parser fails */
/************ Begin %parse_failure code ***************************************/
/************ End %parse_failure code *****************************************/
  sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument variable */
  sqlite3ParserCTX_STORE
}
#endif /* YYNOERRORRECOVERY */

/*
** The following code executes when a syntax error first occurs.
*/
static void yy_syntax_error(
  yyParser *yypParser,           /* The parser */
  int yymajor,                   /* The major type of the error token */
  sqlite3ParserTOKENTYPE yyminor         /* The minor type of the error token */
){
  sqlite3ParserARG_FETCH
  sqlite3ParserCTX_FETCH
#define TOKEN yyminor
/************ Begin %syntax_error code ****************************************/
#line 45 "parse.y"

  UNUSED_PARAMETER(yymajor);  /* Silence some compiler warnings */
  if( TOKEN.z[0] ){
    parserSyntaxError(pParse, &TOKEN);
  }else{
    sqlite3ErrorMsg(pParse, "incomplete input");
  }
#line 6071 "parse.c"
/************ End %syntax_error code ******************************************/
  sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument variable */
  sqlite3ParserCTX_STORE
}

/*
** The following is executed when the parser accepts
*/
static void yy_accept(
  yyParser *yypParser           /* The parser */
){
  sqlite3ParserARG_FETCH
  sqlite3ParserCTX_FETCH
#ifndef NDEBUG
  if( yyTraceFILE ){
    fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
  }
#endif
#ifndef YYNOERRORRECOVERY
  yypParser->yyerrcnt = -1;
#endif
  assert( yypParser->yytos==yypParser->yystack );
  /* Here code is inserted which will be executed whenever the
  ** parser accepts */
/*********** Begin %parse_accept code *****************************************/
/*********** End %parse_accept code *******************************************/
  sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument variable */
  sqlite3ParserCTX_STORE
}

/* The main parser program.
** The first argument is a pointer to a structure obtained from
** "sqlite3ParserAlloc" which describes the current state of the parser.
** The second argument is the major token number.  The third is
** the minor token.  The fourth optional argument is whatever the
** user wants (and specified in the grammar) and is available for
** use by the action routines.
**
** Inputs:
** <ul>
** <li> A pointer to the parser (an opaque structure.)
** <li> The major token number.
** <li> The minor token number.
** <li> An option argument of a grammar-specified type.
** </ul>
**
** Outputs:
** None.
*/
void sqlite3Parser(
  void *yyp,                   /* The parser */
  int yymajor,                 /* The major token code number */
  sqlite3ParserTOKENTYPE yyminor       /* The value for the token */
  sqlite3ParserARG_PDECL               /* Optional %extra_argument parameter */
){
  YYMINORTYPE yyminorunion;
  YYACTIONTYPE yyact;   /* The parser action. */
#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
  int yyendofinput;     /* True if we are at the end of input */
#endif
#ifdef YYERRORSYMBOL
  int yyerrorhit = 0;   /* True if yymajor has invoked an error */
#endif
  yyParser *yypParser = (yyParser*)yyp;  /* The parser */
  sqlite3ParserCTX_FETCH
  sqlite3ParserARG_STORE

  assert( yypParser->yytos!=0 );
#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
  yyendofinput = (yymajor==0);
#endif

  yyact = yypParser->yytos->stateno;
#ifndef NDEBUG
  if( yyTraceFILE ){
    if( yyact < YY_MIN_REDUCE ){
      fprintf(yyTraceFILE,"%sInput '%s' in state %d\n",
              yyTracePrompt,yyTokenName[yymajor],yyact);
    }else{
      fprintf(yyTraceFILE,"%sInput '%s' with pending reduce %d\n",
              yyTracePrompt,yyTokenName[yymajor],yyact-YY_MIN_REDUCE);
    }
  }
#endif

  while(1){ /* Exit by "break" */
    assert( yypParser->yytos>=yypParser->yystack );
    assert( yyact==yypParser->yytos->stateno );
    yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact);
    if( yyact >= YY_MIN_REDUCE ){
      unsigned int yyruleno = yyact - YY_MIN_REDUCE; /* Reduce by this rule */
#ifndef NDEBUG
      assert( yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) );
      if( yyTraceFILE ){
        int yysize = yyRuleInfoNRhs[yyruleno];
        if( yysize ){
          fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
            yyTracePrompt,
            yyruleno, yyRuleName[yyruleno],
            yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action",
            yypParser->yytos[yysize].stateno);
        }else{
          fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n",
            yyTracePrompt, yyruleno, yyRuleName[yyruleno],
            yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action");
        }
      }
#endif /* NDEBUG */

      /* Check that the stack is large enough to grow by a single entry
      ** if the RHS of the rule is empty.  This ensures that there is room
      ** enough on the stack to push the LHS value */
      if( yyRuleInfoNRhs[yyruleno]==0 ){
#ifdef YYTRACKMAXSTACKDEPTH
        if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
          yypParser->yyhwm++;
          assert( yypParser->yyhwm ==
                  (int)(yypParser->yytos - yypParser->yystack));
        }
#endif
        if( yypParser->yytos>=yypParser->yystackEnd ){
          if( yyGrowStack(yypParser) ){
            yyStackOverflow(yypParser);
            break;
          }
        }
      }
      yyact = yy_reduce(yypParser,yyruleno,yymajor,yyminor sqlite3ParserCTX_PARAM);
    }else if( yyact <= YY_MAX_SHIFTREDUCE ){
      yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor);
#ifndef YYNOERRORRECOVERY
      yypParser->yyerrcnt--;
#endif
      break;
    }else if( yyact==YY_ACCEPT_ACTION ){
      yypParser->yytos--;
      yy_accept(yypParser);
      return;
    }else{
      assert( yyact == YY_ERROR_ACTION );
      yyminorunion.yy0 = yyminor;
#ifdef YYERRORSYMBOL
      int yymx;
#endif
#ifndef NDEBUG
      if( yyTraceFILE ){
        fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt);
      }
#endif
#ifdef YYERRORSYMBOL
      /* A syntax error has occurred.
      ** The response to an error depends upon whether or not the
      ** grammar defines an error token "ERROR".  
      **
      ** This is what we do if the grammar does define ERROR:
      **
      **  * Call the %syntax_error function.
      **
      **  * Begin popping the stack until we enter a state where
      **    it is legal to shift the error symbol, then shift
      **    the error symbol.
      **
      **  * Set the error count to three.
      **
      **  * Begin accepting and shifting new tokens.  No new error
      **    processing will occur until three tokens have been
      **    shifted successfully.
      **
      */
      if( yypParser->yyerrcnt<0 ){
        yy_syntax_error(yypParser,yymajor,yyminor);
      }
      yymx = yypParser->yytos->major;
      if( yymx==YYERRORSYMBOL || yyerrorhit ){
#ifndef NDEBUG
        if( yyTraceFILE ){
          fprintf(yyTraceFILE,"%sDiscard input token %s\n",
             yyTracePrompt,yyTokenName[yymajor]);
        }
#endif
        yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
        yymajor = YYNOCODE;
      }else{
        while( yypParser->yytos > yypParser->yystack ){
          yyact = yy_find_reduce_action(yypParser->yytos->stateno,
                                        YYERRORSYMBOL);
          if( yyact<=YY_MAX_SHIFTREDUCE ) break;
          yy_pop_parser_stack(yypParser);
        }
        if( yypParser->yytos <= yypParser->yystack || yymajor==0 ){
          yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
          yy_parse_failed(yypParser);
#ifndef YYNOERRORRECOVERY
          yypParser->yyerrcnt = -1;
#endif
          yymajor = YYNOCODE;
        }else if( yymx!=YYERRORSYMBOL ){
          yy_shift(yypParser,yyact,YYERRORSYMBOL,yyminor);
        }
      }
      yypParser->yyerrcnt = 3;
      yyerrorhit = 1;
      if( yymajor==YYNOCODE ) break;
      yyact = yypParser->yytos->stateno;
#elif defined(YYNOERRORRECOVERY)
      /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
      ** do any kind of error recovery.  Instead, simply invoke the syntax
      ** error routine and continue going as if nothing had happened.
      **
      ** Applications can set this macro (for example inside %include) if
      ** they intend to abandon the parse upon the first syntax error seen.
      */
      yy_syntax_error(yypParser,yymajor, yyminor);
      yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
      break;
#else  /* YYERRORSYMBOL is not defined */
      /* This is what we do if the grammar does not define ERROR:
      **
      **  * Report an error message, and throw away the input token.
      **
      **  * If the input token is $, then fail the parse.
      **
      ** As before, subsequent error messages are suppressed until
      ** three input tokens have been successfully shifted.
      */
      if( yypParser->yyerrcnt<=0 ){
        yy_syntax_error(yypParser,yymajor, yyminor);
      }
      yypParser->yyerrcnt = 3;
      yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
      if( yyendofinput ){
        yy_parse_failed(yypParser);
#ifndef YYNOERRORRECOVERY
        yypParser->yyerrcnt = -1;
#endif
      }
      break;
#endif
    }
  }
#ifndef NDEBUG
  if( yyTraceFILE ){
    yyStackEntry *i;
    char cDiv = '[';
    fprintf(yyTraceFILE,"%sReturn. Stack=",yyTracePrompt);
    for(i=&yypParser->yystack[1]; i<=yypParser->yytos; i++){
      fprintf(yyTraceFILE,"%c%s", cDiv, yyTokenName[i->major]);
      cDiv = ' ';
    }
    fprintf(yyTraceFILE,"]\n");
  }
#endif
  return;
}

/*
** Return the fallback token corresponding to canonical token iToken, or
** 0 if iToken has no fallback.
*/
int sqlite3ParserFallback(int iToken){
#ifdef YYFALLBACK
  assert( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) );
  return yyFallback[iToken];
#else
  (void)iToken;
  return 0;
#endif
}