Fossil

** 384, or 512, to determine SHA3 hash variant that is computed.
*/
/* #include "sqlite3ext.h" */
SQLITE_EXTENSION_INIT1
#include <assert.h>
#include <string.h>
#include <stdarg.h>

#ifndef SQLITE_AMALGAMATION
/* typedef sqlite3_uint64 u64; */
#endif /* SQLITE_AMALGAMATION */

/******************************************************************************
** The Hash Engine
*/
/*
** Macros to determine whether the machine is big or little endian,
** and whether or not that determination is run-time or compile-time.

** is a bitmask showing which constraints are available:
**
**    1:    start=VALUE
**    2:    stop=VALUE
**    4:    step=VALUE
**
** Also, if bit 8 is set, that means that the series should be output
** in descending order rather than in ascending order.  If bit 16 is
** set, then output must appear in ascending order.
**
** This routine should initialize the cursor and position it so that it
** is pointing at the first row, or pointing off the end of the table
** (so that seriesEof() will return true) if the table is empty.
*/
static int seriesFilter(
  sqlite3_vtab_cursor *pVtabCursor, 

  if( idxNum & 2 ){
    pCur->mxValue = sqlite3_value_int64(argv[i++]);
  }else{
    pCur->mxValue = 0xffffffff;
  }
  if( idxNum & 4 ){
    pCur->iStep = sqlite3_value_int64(argv[i++]);
    if( pCur->iStep==0 ){
      pCur->iStep = 1;
    }else if( pCur->iStep<0 ){
      pCur->iStep = -pCur->iStep;
      if( (idxNum & 16)==0 ) idxNum |= 8;
    }
  }else{
    pCur->iStep = 1;
  }
  for(i=0; i<argc; i++){
    if( sqlite3_value_type(argv[i])==SQLITE_NULL ){
      /* If any of the constraints have a NULL value, then return no rows.
      ** See ticket https://www.sqlite.org/src/info/fac496b61722daf2 */

  }
  if( (idxNum & 3)==3 ){
    /* Both start= and stop= boundaries are available.  This is the 
    ** the preferred case */
    pIdxInfo->estimatedCost = (double)(2 - ((idxNum&4)!=0));
    pIdxInfo->estimatedRows = 1000;
    if( pIdxInfo->nOrderBy==1 ){
      if( pIdxInfo->aOrderBy[0].desc ){
        idxNum |= 8;
      }else{
        idxNum |= 16;
      }
      pIdxInfo->orderByConsumed = 1;
    }
  }else{
    /* If either boundary is missing, we have to generate a huge span
    ** of numbers.  Make this case very expensive so that the query
    ** planner will work hard to avoid it. */
    pIdxInfo->estimatedRows = 2147483647;

  int nTab = STRLEN(zTab);
  int nByte = sizeof(IdxTable) + nTab + 1;
  IdxTable *pNew = 0;
  int rc, rc2;
  char *pCsr = 0;
  int nPk = 0;

  rc = idxPrintfPrepareStmt(db, &p1, pzErrmsg, "PRAGMA table_xinfo=%Q", zTab);
  while( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(p1) ){
    const char *zCol = (const char*)sqlite3_column_text(p1, 1);
    nByte += 1 + STRLEN(zCol);
    rc = sqlite3_table_column_metadata(
        db, "main", zTab, zCol, 0, &zCol, 0, 0, 0
    );
    nByte += 1 + STRLEN(zCol);

    );
  }

  idxFinalize(&rc, pAllIndex);
  idxFinalize(&rc, pIndexXInfo);
  idxFinalize(&rc, pWrite);

  if( pCtx ){
    for(i=0; i<pCtx->nSlot; i++){
      sqlite3_free(pCtx->aSlot[i].z);
    }
    sqlite3_free(pCtx);
  }

  if( rc==SQLITE_OK ){
    rc = sqlite3_exec(p->dbm, "ANALYZE sqlite_schema", 0, 0, 0);
  }

  sqlite3_exec(p->db, "DROP TABLE IF EXISTS temp."UNIQUE_TABLE_NAME,0,0,0);
  return rc;

  p->nIndent = 0;
  p->iIndent = 0;
}

/*
** Disable and restore .wheretrace and .selecttrace settings.
*/


static unsigned int savedSelectTrace;



static unsigned int savedWhereTrace;

static void disable_debug_trace_modes(void){

  unsigned int zero = 0;
  sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 0, &savedSelectTrace);
  sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 1, &zero);


  sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 2, &savedWhereTrace);
  sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 3, &zero);

}
static void restore_debug_trace_modes(void){

  sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 1, &savedSelectTrace);


  sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 3, &savedWhereTrace);

}

/* Create the TEMP table used to store parameter bindings */
static void bind_table_init(ShellState *p){
  int wrSchema = 0;
  int defensiveMode = 0;
  sqlite3_db_config(p->db, SQLITE_DBCONFIG_DEFENSIVE, -1, &defensiveMode);

      raw_printf(p->out, "oomCounter = %d\n", oomCounter);
      raw_printf(p->out, "oomRepeat  = %d\n", oomRepeat);
    }
  }else
#endif /* SQLITE_DEBUG */

  if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){
    char *zNewFilename = 0;  /* Name of the database file to open */
    int iName = 1;           /* Index in azArg[] of the filename */
    int newFlag = 0;         /* True to delete file before opening */
    /* Close the existing database */
    session_close_all(p);
    close_db(p->db);
    p->db = 0;
    p->zDbFilename = 0;
    sqlite3_free(p->zFreeOnClose);
    p->zFreeOnClose = 0;
    p->openMode = SHELL_OPEN_UNSPEC;
    p->openFlags = 0;
    p->szMax = 0;
    /* Check for command-line arguments */
    for(iName=1; iName<nArg; iName++){
      const char *z = azArg[iName];
      if( optionMatch(z,"new") ){
        newFlag = 1;
#ifdef SQLITE_HAVE_ZLIB
      }else if( optionMatch(z, "zip") ){
        p->openMode = SHELL_OPEN_ZIPFILE;
#endif

      }else if( optionMatch(z, "maxsize") && iName+1<nArg ){
        p->szMax = integerValue(azArg[++iName]);
#endif /* SQLITE_ENABLE_DESERIALIZE */
      }else if( z[0]=='-' ){
        utf8_printf(stderr, "unknown option: %s\n", z);
        rc = 1;
        goto meta_command_exit;
      }else if( zNewFilename ){
        utf8_printf(stderr, "extra argument: \"%s\"\n", z);
        rc = 1;
        goto meta_command_exit;
      }else{
        zNewFilename = sqlite3_mprintf("%s", z);
      }
    }
    /* If a filename is specified, try to open it first */

    if( zNewFilename || p->openMode==SHELL_OPEN_HEXDB ){
      if( newFlag ) shellDeleteFile(zNewFilename);
      p->zDbFilename = zNewFilename;
      open_db(p, OPEN_DB_KEEPALIVE);
      if( p->db==0 ){
        utf8_printf(stderr, "Error: cannot open '%s'\n", zNewFilename);
        sqlite3_free(zNewFilename);

      raw_printf(stderr,"Error: querying schema information\n");
      rc = 1;
    }else{
      rc = 0;
    }
  }else


  if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){
    unsigned int x = nArg>=2 ? (unsigned int)integerValue(azArg[1]) : 0xffffffff;
    sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 1, &x);
  }else


#if defined(SQLITE_ENABLE_SESSION)
  if( c=='s' && strncmp(azArg[0],"session",n)==0 && n>=3 ){
    OpenSession *pSession = &p->aSession[0];
    char **azCmd = &azArg[1];
    int iSes = 0;
    int nCmd = nArg - 1;

      if( zVfsName ){
        utf8_printf(p->out, "%s\n", zVfsName);
        sqlite3_free(zVfsName);
      }
    }
  }else


  if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
    unsigned int x = nArg>=2 ? (unsigned int)integerValue(azArg[1]) : 0xffffffff;
    sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, 3, &x);
  }else


  if( c=='w' && strncmp(azArg[0], "width", n)==0 ){
    int j;
    assert( nArg<=ArraySize(azArg) );
    p->nWidth = nArg-1;
    p->colWidth = realloc(p->colWidth, p->nWidth*sizeof(int)*2);
    if( p->colWidth==0 && p->nWidth>0 ) shell_out_of_memory();

/******************************************************************************
** This file is an amalgamation of many separate C source files from SQLite
** version 3.35.0.  By combining all the individual C code files into this
** single large file, the entire code can be compiled as a single translation
** unit.  This allows many compilers to do optimizations that would not be
** possible if the files were compiled separately.  Performance improvements
** of 5% or more are commonly seen when SQLite is compiled as a single
** translation unit.
**
** This file is all you need to compile SQLite.  To use SQLite in other

  "ENABLE_JSON1",
#endif
#if SQLITE_ENABLE_LOAD_EXTENSION
  "ENABLE_LOAD_EXTENSION",
#endif
#ifdef SQLITE_ENABLE_LOCKING_STYLE
  "ENABLE_LOCKING_STYLE=" CTIMEOPT_VAL(SQLITE_ENABLE_LOCKING_STYLE),
#endif
#if SQLITE_ENABLE_MATH_FUNCTIONS
  "ENABLE_MATH_FUNCTIONS"
#endif
#if SQLITE_ENABLE_MEMORY_MANAGEMENT
  "ENABLE_MEMORY_MANAGEMENT",
#endif
#if SQLITE_ENABLE_MEMSYS3
  "ENABLE_MEMSYS3",
#endif

#endif
#if defined(_MSC_VER) && !defined(SQLITE_DISABLE_INTRINSIC)
# define MSVC_VERSION _MSC_VER
#else
# define MSVC_VERSION 0
#endif

/*
** Some C99 functions in "math.h" are only present for MSVC when its version
** is associated with Visual Studio 2013 or higher.
*/
#ifndef SQLITE_HAVE_C99_MATH_FUNCS
# if MSVC_VERSION==0 || MSVC_VERSION>=1800
#  define SQLITE_HAVE_C99_MATH_FUNCS (1)
# else
#  define SQLITE_HAVE_C99_MATH_FUNCS (0)
# endif
#endif

/* Needed for various definitions... */
#if defined(__GNUC__) && !defined(_GNU_SOURCE)
# define _GNU_SOURCE
#endif

#if defined(__OpenBSD__) && !defined(_BSD_SOURCE)
# define _BSD_SOURCE

** been edited in any way since it was last checked in, then the last
** four hexadecimal digits of the hash may be modified.
**
** See also: [sqlite3_libversion()],
** [sqlite3_libversion_number()], [sqlite3_sourceid()],
** [sqlite_version()] and [sqlite_source_id()].
*/
#define SQLITE_VERSION        "3.35.0"
#define SQLITE_VERSION_NUMBER 3035000
#define SQLITE_SOURCE_ID      "2020-12-15 13:55:38 ea0a7f103a6f6a9e57d7377140ff9f372bf2b156f86f148291fb05a7030f2b36"

/*
** CAPI3REF: Run-Time Library Version Numbers
** KEYWORDS: sqlite3_version sqlite3_sourceid
**
** These interfaces provide the same information as the [SQLITE_VERSION],
** [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros

#define SQLITE_TESTCTRL_SORTER_MMAP             24
#define SQLITE_TESTCTRL_IMPOSTER                25
#define SQLITE_TESTCTRL_PARSER_COVERAGE         26
#define SQLITE_TESTCTRL_RESULT_INTREAL          27
#define SQLITE_TESTCTRL_PRNG_SEED               28
#define SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS     29
#define SQLITE_TESTCTRL_SEEK_COUNT              30
#define SQLITE_TESTCTRL_TRACEFLAGS              31
#define SQLITE_TESTCTRL_LAST                    31  /* Largest TESTCTRL */

/*
** CAPI3REF: SQL Keyword Checking
**
** These routines provide access to the set of SQL language keywords
** recognized by SQLite.  Applications can uses these routines to determine
** whether or not a specific identifier needs to be escaped (for example,

# define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE
#endif

/*
** SELECTTRACE_ENABLED will be either 1 or 0 depending on whether or not
** the Select query generator tracing logic is turned on.
*/
#if !defined(SQLITE_AMALGAMATION)

SQLITE_PRIVATE u32 sqlite3SelectTrace;

#endif
#if defined(SQLITE_DEBUG) \
    && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_SELECTTRACE))
# define SELECTTRACE_ENABLED 1
# define SELECTTRACE(K,P,S,X)  \
  if(sqlite3SelectTrace&(K))   \
    sqlite3DebugPrintf("%u/%d/%p: ",(S)->selId,(P)->addrExplain,(S)),\
    sqlite3DebugPrintf X
#else
# define SELECTTRACE(K,P,S,X)
# define SELECTTRACE_ENABLED 0
#endif

/*
** Macros for "wheretrace"
*/
#if !defined(SQLITE_AMAGAMATION)
SQLITE_PRIVATE u32 sqlite3WhereTrace;
#endif
#if defined(SQLITE_DEBUG) \
    && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_WHERETRACE))
# define WHERETRACE(K,X)  if(sqlite3WhereTrace&(K)) sqlite3DebugPrintf X
# define WHERETRACE_ENABLED 1
#else
# define WHERETRACE(K,X)
#endif


/*
** An instance of the following structure is used to store the busy-handler
** callback for a given sqlite handle.
**
** The sqlite.busyHandler member of the sqlite struct contains the busy
** callback for the database handle. Each pager opened via the sqlite

SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor*, int*);
SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*, u8 flags);

/* Allowed flags for sqlite3BtreeDelete() and sqlite3BtreeInsert() */
#define BTREE_SAVEPOSITION 0x02  /* Leave cursor pointing at NEXT or PREV */
#define BTREE_AUXDELETE    0x04  /* not the primary delete operation */
#define BTREE_APPEND       0x08  /* Insert is likely an append */
#define BTREE_PREFORMAT    0x80  /* Insert is likely an append */

/* An instance of the BtreePayload object describes the content of a single
** entry in either an index or table btree.
**
** Index btrees (used for indexes and also WITHOUT ROWID tables) contain
** an arbitrary key and no data.  These btrees have pKey,nKey set to the
** key and the pData,nData,nZero fields are uninitialized.  The aMem,nMem

SQLITE_PRIVATE int sqlite3BtreeCursorInfo(BtCursor*, int*, int);
SQLITE_PRIVATE void sqlite3BtreeCursorList(Btree*);
#endif

#ifndef SQLITE_OMIT_WAL
SQLITE_PRIVATE   int sqlite3BtreeCheckpoint(Btree*, int, int *, int *);
#endif

SQLITE_PRIVATE int sqlite3BtreeTransferRow(BtCursor*, BtCursor*, i64);

/*
** If we are not using shared cache, then there is no need to
** use mutexes to access the BtShared structures.  So make the
** Enter and Leave procedures no-ops.
*/
#ifndef SQLITE_OMIT_SHARED_CACHE

#define OP_Close         116
#define OP_ColumnsUsed   117
#define OP_SeekScan      118 /* synopsis: Scan-ahead up to P1 rows         */
#define OP_SeekHit       119 /* synopsis: set P2<=seekHit<=P3              */
#define OP_Sequence      120 /* synopsis: r[P2]=cursor[P1].ctr++           */
#define OP_NewRowid      121 /* synopsis: r[P2]=rowid                      */
#define OP_Insert        122 /* synopsis: intkey=r[P3] data=r[P2]          */
#define OP_RowCell       123
#define OP_Delete        124
#define OP_ResetCount    125
#define OP_SorterCompare 126 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */
#define OP_SorterData    127 /* synopsis: r[P2]=data                       */
#define OP_RowData       128 /* synopsis: r[P2]=data                       */
#define OP_Rowid         129 /* synopsis: r[P2]=rowid                      */
#define OP_NullRow       130
#define OP_SeekEnd       131
#define OP_IdxInsert     132 /* synopsis: key=r[P2]                        */
#define OP_SorterInsert  133 /* synopsis: key=r[P2]                        */
#define OP_IdxDelete     134 /* synopsis: key=r[P2@P3]                     */
#define OP_DeferredSeek  135 /* synopsis: Move P3 to P1.rowid if needed    */
#define OP_IdxRowid      136 /* synopsis: r[P2]=rowid                      */
#define OP_FinishSeek    137
#define OP_Destroy       138
#define OP_Clear         139
#define OP_ResetSorter   140
#define OP_CreateBtree   141 /* synopsis: r[P2]=root iDb=P1 flags=P3       */
#define OP_SqlExec       142
#define OP_ParseSchema   143
#define OP_LoadAnalysis  144
#define OP_DropTable     145
#define OP_DropIndex     146
#define OP_DropTrigger   147
#define OP_IntegrityCk   148
#define OP_RowSetAdd     149 /* synopsis: rowset(P1)=r[P2]                 */

#define OP_Real          150 /* same as TK_FLOAT, synopsis: r[P2]=P4       */
#define OP_Param         151
#define OP_FkCounter     152 /* synopsis: fkctr[P1]+=P2                    */
#define OP_MemMax        153 /* synopsis: r[P1]=max(r[P1],r[P2])           */
#define OP_OffsetLimit   154 /* synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) */
#define OP_AggInverse    155 /* synopsis: accum=r[P3] inverse(r[P2@P5])    */
#define OP_AggStep       156 /* synopsis: accum=r[P3] step(r[P2@P5])       */
#define OP_AggStep1      157 /* synopsis: accum=r[P3] step(r[P2@P5])       */
#define OP_AggValue      158 /* synopsis: r[P3]=value N=P2                 */
#define OP_AggFinal      159 /* synopsis: accum=r[P1] N=P2                 */
#define OP_Expire        160
#define OP_CursorLock    161
#define OP_CursorUnlock  162
#define OP_TableLock     163 /* synopsis: iDb=P1 root=P2 write=P3          */
#define OP_VBegin        164
#define OP_VCreate       165
#define OP_VDestroy      166
#define OP_VOpen         167
#define OP_VColumn       168 /* synopsis: r[P3]=vcolumn(P2)                */
#define OP_VRename       169
#define OP_Pagecount     170
#define OP_MaxPgcnt      171
#define OP_Trace         172
#define OP_CursorHint    173
#define OP_ReleaseReg    174 /* synopsis: release r[P1@P2] mask P3         */
#define OP_Noop          175
#define OP_Explain       176
#define OP_Abortable     177

/* Properties such as "out2" or "jump" that are specified in
** comments following the "case" for each opcode in the vdbe.c
** are encoded into bitvectors as follows:
*/
#define OPFLG_JUMP        0x01  /* jump:  P2 holds jmp target */
#define OPFLG_IN1         0x02  /* in1:   P1 is an input */

/*  72 */ 0x10, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10,\
/*  80 */ 0x00, 0x00, 0x02, 0x02, 0x02, 0x00, 0x00, 0x12,\
/*  88 */ 0x20, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00,\
/*  96 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x26, 0x26,\
/* 104 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x00,\
/* 112 */ 0x12, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,\
/* 120 */ 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
/* 128 */ 0x00, 0x10, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00,\
/* 136 */ 0x10, 0x00, 0x10, 0x00, 0x00, 0x10, 0x00, 0x00,\
/* 144 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x10, 0x10,\
/* 152 */ 0x00, 0x04, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00,\
/* 160 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
/* 168 */ 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,\
/* 176 */ 0x00, 0x00,}

/* The sqlite3P2Values() routine is able to run faster if it knows
** the value of the largest JUMP opcode.  The smaller the maximum
** JUMP opcode the better, so the mkopcodeh.tcl script that
** generated this include file strives to group all JUMP opcodes
** together near the beginning of the list.
*/

**   DFUNCTION(zName, nArg, iArg, bNC, xFunc)
**     Like FUNCTION except it omits the SQLITE_FUNC_CONSTANT flag and
**     adds the SQLITE_FUNC_SLOCHNG flag.  Used for date & time functions
**     and functions like sqlite_version() that can change, but not during
**     a single query.  The iArg is ignored.  The user-data is always set
**     to a NULL pointer.  The bNC parameter is not used.
**
**   MFUNCTION(zName, nArg, xPtr, xFunc)
**     For math-library functions.  xPtr is an arbitrary pointer.
**
**   PURE_DATE(zName, nArg, iArg, bNC, xFunc)
**     Used for "pure" date/time functions, this macro is like DFUNCTION
**     except that it does set the SQLITE_FUNC_CONSTANT flags.  iArg is
**     ignored and the user-data for these functions is set to an
**     arbitrary non-NULL pointer.  The bNC parameter is not used.
**
**   AGGREGATE(zName, nArg, iArg, bNC, xStep, xFinal)

   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
#define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \
  {nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
#define SFUNCTION(zName, nArg, iArg, bNC, xFunc) \
  {nArg, SQLITE_UTF8|SQLITE_DIRECTONLY|SQLITE_FUNC_UNSAFE, \
   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
#define MFUNCTION(zName, nArg, xPtr, xFunc) \
  {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8, \
   xPtr, 0, xFunc, 0, 0, 0, #zName, {0} }
#define INLINE_FUNC(zName, nArg, iArg, mFlags) \
  {nArg, SQLITE_UTF8|SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \
   SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
#define TEST_FUNC(zName, nArg, iArg, mFlags) \
  {nArg, SQLITE_UTF8|SQLITE_FUNC_INTERNAL|SQLITE_FUNC_TEST| \
         SQLITE_FUNC_INLINE|SQLITE_FUNC_CONSTANT|(mFlags), \
   SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }

** the operation in progress stops and returns an error code.  But prior
** changes due to the same operation are not backed out and no rollback
** occurs.  IGNORE means that the particular row that caused the constraint
** error is not inserted or updated.  Processing continues and no error
** is returned.  REPLACE means that preexisting database rows that caused
** a UNIQUE constraint violation are removed so that the new insert or
** update can proceed.  Processing continues and no error is reported.
** UPDATE applies to insert operations only and means that the insert
** is omitted and the DO UPDATE clause of an upsert is run instead.
**
** RESTRICT, SETNULL, SETDFLT, and CASCADE actions apply only to foreign keys.
** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the
** same as ROLLBACK for DEFERRED keys.  SETNULL means that the foreign
** key is set to NULL.  SETDFLT means that the foreign key is set
** to its default value.  CASCADE means that a DELETE or UPDATE of the
** referenced table row is propagated into the row that holds the
** foreign key.
**
** The OE_Default value is a place holder that means to use whatever
** conflict resolution algorthm is required from context.
**
** The following symbolic values are used to record which type
** of conflict resolution action to take.
*/
#define OE_None     0   /* There is no constraint to check */
#define OE_Rollback 1   /* Fail the operation and rollback the transaction */
#define OE_Abort    2   /* Back out changes but do no rollback transaction */
#define OE_Fail     3   /* Stop the operation but leave all prior changes */
#define OE_Ignore   4   /* Ignore the error. Do not do the INSERT or UPDATE */
#define OE_Replace  5   /* Delete existing record, then do INSERT or UPDATE */

**
** pUpsertSet is the list of column=expr terms of the UPDATE statement.
** The pUpsertSet field is NULL for a ON CONFLICT DO NOTHING.  The
** pUpsertWhere is the WHERE clause for the UPDATE and is NULL if the
** WHERE clause is omitted.
*/
struct Upsert {
  ExprList *pUpsertTarget;  /* Optional description of conflict target */
  Expr *pUpsertTargetWhere; /* WHERE clause for partial index targets */
  ExprList *pUpsertSet;     /* The SET clause from an ON CONFLICT UPDATE */
  Expr *pUpsertWhere;       /* WHERE clause for the ON CONFLICT UPDATE */
  Upsert *pNextUpsert;      /* Next ON CONFLICT clause in the list */
  u8 isDoUpdate;            /* True for DO UPDATE.  False for DO NOTHING */
  /* Above this point is the parse tree for the ON CONFLICT clauses.
  ** The next group of fields stores intermediate data. */
  void *pToFree;            /* Free memory when deleting the Upsert object */
  /* All fields above are owned by the Upsert object and must be freed
  ** when the Upsert is destroyed.  The fields below are used to transfer
  ** information from the INSERT processing down into the UPDATE processing

  ** while generating code.  The fields below are owned by the INSERT
  ** statement and will be freed by INSERT processing. */
  Index *pUpsertIdx;        /* UNIQUE constraint specified by pUpsertTarget */
  SrcList *pUpsertSrc;      /* Table to be updated */
  int regData;              /* First register holding array of VALUES */
  int iDataCur;             /* Index of the data cursor */
  int iIdxCur;              /* Index of the first index cursor */
};

/*

#define OPFLAG_SEEKEQ        0x02    /* OP_Open** cursor uses EQ seek only */
#define OPFLAG_FORDELETE     0x08    /* OP_Open should use BTREE_FORDELETE */
#define OPFLAG_P2ISREG       0x10    /* P2 to OP_Open** is a register number */
#define OPFLAG_PERMUTE       0x01    /* OP_Compare: use the permutation */
#define OPFLAG_SAVEPOSITION  0x02    /* OP_Delete/Insert: save cursor pos */
#define OPFLAG_AUXDELETE     0x04    /* OP_Delete: index in a DELETE op */
#define OPFLAG_NOCHNG_MAGIC  0x6d    /* OP_MakeRecord: serialtype 10 is ok */
#define OPFLAG_PREFORMAT     0x80    /* OP_Insert uses preformatted cell */

/*
 * Each trigger present in the database schema is stored as an instance of
 * struct Trigger.
 *
 * Pointers to instances of struct Trigger are stored in two ways.
 * 1. In the "trigHash" hash table (part of the sqlite3* that represents the

#ifndef SQLITE_AMALGAMATION
SQLITE_PRIVATE const unsigned char sqlite3OpcodeProperty[];
SQLITE_PRIVATE const char sqlite3StrBINARY[];
SQLITE_PRIVATE const unsigned char sqlite3UpperToLower[];
SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[];
SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config;
SQLITE_PRIVATE FuncDefHash sqlite3BuiltinFunctions;

#ifndef SQLITE_OMIT_WSD
SQLITE_PRIVATE int sqlite3PendingByte;
#endif
#endif /* SQLITE_AMALGAMATION */
#ifdef VDBE_PROFILE
SQLITE_PRIVATE sqlite3_uint64 sqlite3NProfileCnt;
#endif

SQLITE_PRIVATE   void sqlite3WithDelete(sqlite3*,With*);
SQLITE_PRIVATE   void sqlite3WithPush(Parse*, With*, u8);
#else
#define sqlite3WithPush(x,y,z)
#define sqlite3WithDelete(x,y)
#endif
#ifndef SQLITE_OMIT_UPSERT
SQLITE_PRIVATE   Upsert *sqlite3UpsertNew(sqlite3*,ExprList*,Expr*,ExprList*,Expr*,Upsert*);
SQLITE_PRIVATE   void sqlite3UpsertDelete(sqlite3*,Upsert*);
SQLITE_PRIVATE   Upsert *sqlite3UpsertDup(sqlite3*,Upsert*);
SQLITE_PRIVATE   int sqlite3UpsertAnalyzeTarget(Parse*,SrcList*,Upsert*);
SQLITE_PRIVATE   void sqlite3UpsertDoUpdate(Parse*,Upsert*,Table*,Index*,int);
SQLITE_PRIVATE   Upsert *sqlite3UpsertOfIndex(Upsert*,Index*);
SQLITE_PRIVATE   int sqlite3UpsertNextIsIPK(Upsert*);
#else
#define sqlite3UpsertNew(u,v,w,x,y,z) ((Upsert*)0)
#define sqlite3UpsertDelete(x,y)
#define sqlite3UpsertDup(x,y)         ((Upsert*)0)
#define sqlite3UpsertOfIndex(x,y)     ((Upsert*)0)
#define sqlite3UpsertNextIsIPK(x)     0
#endif


/* Declarations for functions in fkey.c. All of these are replaced by
** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign
** key functionality is available. If OMIT_TRIGGER is defined but
** OMIT_FOREIGN_KEY is not, only some of the functions are no-oped. In

** and incorrect behavior.
*/
#ifndef SQLITE_OMIT_WSD
SQLITE_PRIVATE int sqlite3PendingByte = 0x40000000;
#endif

/*
** Tracing flags set by SQLITE_TESTCTRL_TRACEFLAGS.
*/
SQLITE_PRIVATE u32 sqlite3SelectTrace = 0;
SQLITE_PRIVATE u32 sqlite3WhereTrace = 0;

/* #include "opcodes.h" */
/*
** Properties of opcodes.  The OPFLG_INITIALIZER macro is
** created by mkopcodeh.awk during compilation.  Data is obtained
** from the comments following the "case OP_xxxx:" statements in
** the vdbe.c file.

** routine has no return value since the return value would be meaningless.
*/
SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
  if( id->pMethods==0 ) return SQLITE_NOTFOUND;
#ifdef SQLITE_TEST
  if( op!=SQLITE_FCNTL_COMMIT_PHASETWO
   && op!=SQLITE_FCNTL_LOCK_TIMEOUT
   && op!=SQLITE_FCNTL_CKPT_DONE
   && op!=SQLITE_FCNTL_CKPT_START
  ){
    /* Faults are not injected into COMMIT_PHASETWO because, assuming SQLite
    ** is using a regular VFS, it is called after the corresponding
    ** transaction has been committed. Injecting a fault at this point
    ** confuses the test scripts - the COMMIT comand returns SQLITE_NOMEM
    ** but the transaction is committed anyway.
    **
    ** The core must call OsFileControl() though, not OsFileControlHint(),
    ** as if a custom VFS (e.g. zipvfs) returns an error here, it probably
    ** means the commit really has failed and an error should be returned
    ** to the user.
    **
    ** The CKPT_DONE and CKPT_START file-controls are write-only signals
    ** to the cksumvfs.  Their return code is meaningless and is ignored
    ** by the SQLite core, so there is no point in simulating OOMs for them.
    */
    DO_OS_MALLOC_TEST(id);
  }
#endif
  return id->pMethods->xFileControl(id, op, pArg);
}
SQLITE_PRIVATE void sqlite3OsFileControlHint(sqlite3_file *id, int op, void *pArg){
  if( id->pMethods ) (void)id->pMethods->xFileControl(id, op, pArg);

    /* 116 */ "Close"            OpHelp(""),
    /* 117 */ "ColumnsUsed"      OpHelp(""),
    /* 118 */ "SeekScan"         OpHelp("Scan-ahead up to P1 rows"),
    /* 119 */ "SeekHit"          OpHelp("set P2<=seekHit<=P3"),
    /* 120 */ "Sequence"         OpHelp("r[P2]=cursor[P1].ctr++"),
    /* 121 */ "NewRowid"         OpHelp("r[P2]=rowid"),
    /* 122 */ "Insert"           OpHelp("intkey=r[P3] data=r[P2]"),
    /* 123 */ "RowCell"          OpHelp(""),
    /* 124 */ "Delete"           OpHelp(""),
    /* 125 */ "ResetCount"       OpHelp(""),
    /* 126 */ "SorterCompare"    OpHelp("if key(P1)!=trim(r[P3],P4) goto P2"),
    /* 127 */ "SorterData"       OpHelp("r[P2]=data"),
    /* 128 */ "RowData"          OpHelp("r[P2]=data"),
    /* 129 */ "Rowid"            OpHelp("r[P2]=rowid"),
    /* 130 */ "NullRow"          OpHelp(""),
    /* 131 */ "SeekEnd"          OpHelp(""),
    /* 132 */ "IdxInsert"        OpHelp("key=r[P2]"),
    /* 133 */ "SorterInsert"     OpHelp("key=r[P2]"),
    /* 134 */ "IdxDelete"        OpHelp("key=r[P2@P3]"),
    /* 135 */ "DeferredSeek"     OpHelp("Move P3 to P1.rowid if needed"),
    /* 136 */ "IdxRowid"         OpHelp("r[P2]=rowid"),
    /* 137 */ "FinishSeek"       OpHelp(""),
    /* 138 */ "Destroy"          OpHelp(""),
    /* 139 */ "Clear"            OpHelp(""),
    /* 140 */ "ResetSorter"      OpHelp(""),
    /* 141 */ "CreateBtree"      OpHelp("r[P2]=root iDb=P1 flags=P3"),
    /* 142 */ "SqlExec"          OpHelp(""),
    /* 143 */ "ParseSchema"      OpHelp(""),
    /* 144 */ "LoadAnalysis"     OpHelp(""),
    /* 145 */ "DropTable"        OpHelp(""),
    /* 146 */ "DropIndex"        OpHelp(""),
    /* 147 */ "DropTrigger"      OpHelp(""),
    /* 148 */ "IntegrityCk"      OpHelp(""),
    /* 149 */ "RowSetAdd"        OpHelp("rowset(P1)=r[P2]"),

    /* 150 */ "Real"             OpHelp("r[P2]=P4"),
    /* 151 */ "Param"            OpHelp(""),
    /* 152 */ "FkCounter"        OpHelp("fkctr[P1]+=P2"),
    /* 153 */ "MemMax"           OpHelp("r[P1]=max(r[P1],r[P2])"),
    /* 154 */ "OffsetLimit"      OpHelp("if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)"),
    /* 155 */ "AggInverse"       OpHelp("accum=r[P3] inverse(r[P2@P5])"),
    /* 156 */ "AggStep"          OpHelp("accum=r[P3] step(r[P2@P5])"),
    /* 157 */ "AggStep1"         OpHelp("accum=r[P3] step(r[P2@P5])"),
    /* 158 */ "AggValue"         OpHelp("r[P3]=value N=P2"),
    /* 159 */ "AggFinal"         OpHelp("accum=r[P1] N=P2"),
    /* 160 */ "Expire"           OpHelp(""),
    /* 161 */ "CursorLock"       OpHelp(""),
    /* 162 */ "CursorUnlock"     OpHelp(""),
    /* 163 */ "TableLock"        OpHelp("iDb=P1 root=P2 write=P3"),
    /* 164 */ "VBegin"           OpHelp(""),
    /* 165 */ "VCreate"          OpHelp(""),
    /* 166 */ "VDestroy"         OpHelp(""),
    /* 167 */ "VOpen"            OpHelp(""),
    /* 168 */ "VColumn"          OpHelp("r[P3]=vcolumn(P2)"),
    /* 169 */ "VRename"          OpHelp(""),
    /* 170 */ "Pagecount"        OpHelp(""),
    /* 171 */ "MaxPgcnt"         OpHelp(""),
    /* 172 */ "Trace"            OpHelp(""),
    /* 173 */ "CursorHint"       OpHelp(""),
    /* 174 */ "ReleaseReg"       OpHelp("release r[P1@P2] mask P3"),
    /* 175 */ "Noop"             OpHelp(""),
    /* 176 */ "Explain"          OpHelp(""),
    /* 177 */ "Abortable"        OpHelp(""),
  };
  return azName[i];
}
#endif

/************** End of opcodes.c *********************************************/
/************** Begin file os_unix.c *****************************************/

#ifndef SQLITE_OMIT_SHARED_CACHE
  int nRef;             /* Number of references to this structure */
  BtShared *pNext;      /* Next on a list of sharable BtShared structs */
  BtLock *pLock;        /* List of locks held on this shared-btree struct */
  Btree *pWriter;       /* Btree with currently open write transaction */
#endif
  u8 *pTmpSpace;        /* Temp space sufficient to hold a single cell */
  int nPreformatSize;   /* Size of last cell written by TransferRow() */
};

/*
** Allowed values for BtShared.btsFlags
*/
#define BTS_READ_ONLY        0x0001   /* Underlying file is readonly */
#define BTS_PAGESIZE_FIXED   0x0002   /* Page size can no longer be changed */

  if( surplus <= maxLocal ){
    pInfo->nLocal = (u16)surplus;
  }else{
    pInfo->nLocal = (u16)minLocal;
  }
  pInfo->nSize = (u16)(&pInfo->pPayload[pInfo->nLocal] - pCell) + 4;
}

/*
** Given a record with nPayload bytes of payload stored within btree
** page pPage, return the number of bytes of payload stored locally.
*/
static int btreePayloadToLocal(MemPage *pPage, i64 nPayload){
  int maxLocal;  /* Maximum amount of payload held locally */
  maxLocal = pPage->maxLocal;
  if( nPayload<=maxLocal ){
    return nPayload;
  }else{
    int minLocal;  /* Minimum amount of payload held locally */
    int surplus;   /* Overflow payload available for local storage */
    minLocal = pPage->minLocal;
    surplus = minLocal + (nPayload - minLocal)%(pPage->pBt->usableSize-4);
    return ( surplus <= maxLocal ) ? surplus : minLocal;
  }
}

/*
** The following routines are implementations of the MemPage.xParseCell()
** method.
**
** Parse a cell content block and fill in the CellInfo structure.
**

  int idx;
  MemPage *pPage;
  Btree *p = pCur->pBtree;
  BtShared *pBt = p->pBt;
  unsigned char *oldCell;
  unsigned char *newCell = 0;

  assert( (flags & (BTREE_SAVEPOSITION|BTREE_APPEND|BTREE_PREFORMAT))==flags );
  assert( (flags & BTREE_PREFORMAT)==0 || seekResult || pCur->pKeyInfo==0 );

  if( pCur->eState==CURSOR_FAULT ){
    assert( pCur->skipNext!=SQLITE_OK );
    return pCur->skipNext;
  }

  assert( cursorOwnsBtShared(pCur) );
  assert( (pCur->curFlags & BTCF_WriteFlag)!=0
              && pBt->inTransaction==TRANS_WRITE
              && (pBt->btsFlags & BTS_READ_ONLY)==0 );
  assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );

  /* Assert that the caller has been consistent. If this cursor was opened
  ** expecting an index b-tree, then the caller should be inserting blob
  ** keys with no associated data. If the cursor was opened expecting an
  ** intkey table, the caller should be inserting integer keys with a
  ** blob of associated data.  */
  assert( (flags & BTREE_PREFORMAT) || (pX->pKey==0)==(pCur->pKeyInfo==0) );

  /* Save the positions of any other cursors open on this table.
  **
  ** In some cases, the call to btreeMoveto() below is a no-op. For
  ** example, when inserting data into a table with auto-generated integer
  ** keys, the VDBE layer invokes sqlite3BtreeLast() to figure out the
  ** integer key to use. It then calls this function to actually insert the

  }
  assert( pCur->eState==CURSOR_VALID
       || (pCur->eState==CURSOR_INVALID && loc)
       || CORRUPT_DB );

  pPage = pCur->pPage;
  assert( pPage->intKey || pX->nKey>=0 || (flags & BTREE_PREFORMAT) );
  assert( pPage->leaf || !pPage->intKey );
  if( pPage->nFree<0 ){
    if( pCur->eState>CURSOR_INVALID ){
      rc = SQLITE_CORRUPT_BKPT;
    }else{
      rc = btreeComputeFreeSpace(pPage);
    }
    if( rc ) return rc;
  }

  TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n",
          pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno,
          loc==0 ? "overwrite" : "new entry"));
  assert( pPage->isInit );
  newCell = pBt->pTmpSpace;
  assert( newCell!=0 );
  if( flags & BTREE_PREFORMAT ){
    rc = SQLITE_OK;
    szNew = pBt->nPreformatSize;
    if( szNew<4 ) szNew = 4;
    if( ISAUTOVACUUM && szNew>pPage->maxLocal ){
      CellInfo info;
      pPage->xParseCell(pPage, newCell, &info);
      if( info.nPayload!=info.nLocal ){
        Pgno ovfl = get4byte(&newCell[szNew-4]);
        ptrmapPut(pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, &rc);
      }
    }
  }else{
    rc = fillInCell(pPage, newCell, pX, &szNew);
  }
  if( rc ) goto end_insert;
  assert( szNew==pPage->xCellSize(pPage, newCell) );
  assert( szNew <= MX_CELL_SIZE(pBt) );
  idx = pCur->ix;
  if( loc==0 ){
    CellInfo info;
    assert( idx<pPage->nCell );

      pCur->eState = CURSOR_REQUIRESEEK;
      pCur->nKey = pX->nKey;
    }
  }
  assert( pCur->iPage<0 || pCur->pPage->nOverflow==0 );

end_insert:
  return rc;
}

/*
** This function is used as part of copying the current row from cursor
** pSrc into cursor pDest. If the cursors are open on intkey tables, then
** parameter iKey is used as the rowid value when the record is copied
** into pDest. Otherwise, the record is copied verbatim.
**
** This function does not actually write the new value to cursor pDest.
** Instead, it creates and populates any required overflow pages and
** writes the data for the new cell into the BtShared.pTmpSpace buffer
** for the destination database. The size of the cell, in bytes, is left
** in BtShared.nPreformatSize. The caller completes the insertion by
** calling sqlite3BtreeInsert() with the BTREE_PREFORMAT flag specified.
**
** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
*/
SQLITE_PRIVATE int sqlite3BtreeTransferRow(BtCursor *pDest, BtCursor *pSrc, i64 iKey){
  int rc = SQLITE_OK;
  BtShared *pBt = pDest->pBt;
  u8 *aOut = pBt->pTmpSpace;    /* Pointer to next output buffer */
  const u8 *aIn;                /* Pointer to next input buffer */
  int nIn;                      /* Size of input buffer aIn[] */
  int nRem;                     /* Bytes of data still to copy */

  getCellInfo(pSrc);
  aOut += putVarint32(aOut, pSrc->info.nPayload);
  if( pDest->pKeyInfo==0 ) aOut += putVarint(aOut, iKey);
  nIn = pSrc->info.nLocal;
  aIn = pSrc->info.pPayload;
  nRem = pSrc->info.nPayload;
  if( nIn==nRem && nIn<pDest->pPage->maxLocal ){
    memcpy(aOut, aIn, nIn);
    pBt->nPreformatSize = nIn + (aOut - pBt->pTmpSpace);
  }else{
    Pager *pSrcPager = pSrc->pBt->pPager;
    u8 *pPgnoOut = 0;
    Pgno ovflIn = 0;
    DbPage *pPageIn = 0;
    MemPage *pPageOut = 0;
    int nOut;                     /* Size of output buffer aOut[] */

    nOut = btreePayloadToLocal(pDest->pPage, pSrc->info.nPayload);
    pBt->nPreformatSize = nOut + (aOut - pBt->pTmpSpace);
    if( nOut<pSrc->info.nPayload ){
      pPgnoOut = &aOut[nOut];
      pBt->nPreformatSize += 4;
    }

    if( nRem>nIn ){
      ovflIn = get4byte(&pSrc->info.pPayload[nIn]);
    }

    do {
      nRem -= nOut;
      do{
        assert( nOut>0 );
        if( nIn>0 ){
          int nCopy = MIN(nOut, nIn);
          memcpy(aOut, aIn, nCopy);
          nOut -= nCopy;
          nIn -= nCopy;
          aOut += nCopy;
          aIn += nCopy;
        }
        if( nOut>0 ){
          sqlite3PagerUnref(pPageIn);
          pPageIn = 0;
          rc = sqlite3PagerGet(pSrcPager, ovflIn, &pPageIn, PAGER_GET_READONLY);
          if( rc==SQLITE_OK ){
            aIn = (const u8*)sqlite3PagerGetData(pPageIn);
            ovflIn = get4byte(aIn);
            aIn += 4;
            nIn = pSrc->pBt->usableSize - 4;
          }
        }
      }while( rc==SQLITE_OK && nOut>0 );

      if( rc==SQLITE_OK && nRem>0 ){
        Pgno pgnoNew;
        MemPage *pNew = 0;
        rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);
        put4byte(pPgnoOut, pgnoNew);
        if( ISAUTOVACUUM && pPageOut ){
          ptrmapPut(pBt, pgnoNew, PTRMAP_OVERFLOW2, pPageOut->pgno, &rc);
        }
        releasePage(pPageOut);
        pPageOut = pNew;
        if( pPageOut ){
          pPgnoOut = pPageOut->aData;
          put4byte(pPgnoOut, 0);
          aOut = &pPgnoOut[4];
          nOut = MIN(pBt->usableSize - 4, nRem);
        }
      }
    }while( nRem>0 && rc==SQLITE_OK );

    releasePage(pPageOut);
    sqlite3PagerUnref(pPageIn);
  }

  return rc;
}

/*
** Delete the entry that the cursor is pointing to.
**
** If the BTREE_SAVEPOSITION bit of the flags parameter is zero, then

  if( pData->flags & MEM_Zero ){
    x.nZero = pData->u.nZero;
  }else{
    x.nZero = 0;
  }
  x.pKey = 0;
  rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
      (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)),
      seekResult
  );
  pC->deferredMoveto = 0;
  pC->cacheStatus = CACHE_STALE;

  /* Invoke the update-hook if required. */
  if( rc ) goto abort_due_to_error;
  if( pTab ){
    assert( db->xUpdateCallback!=0 );
    assert( pTab->aCol!=0 );
    db->xUpdateCallback(db->pUpdateArg,
           (pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT,
           zDb, pTab->zName, x.nKey);
  }
  break;
}

/* Opcode: RowCell P1 P2 P3 * *
**
** P1 and P2 are both open cursors. Both must be opened on the same type
** of table - intkey or index. This opcode is used as part of copying
** the current row from P2 into P1. If the cursors are opened on intkey
** tables, register P3 contains the rowid to use with the new record in
** P1. If they are opened on index tables, P3 is not used.
**
** This opcode must be followed by either an Insert or InsertIdx opcode
** with the OPFLAG_PREFORMAT flag set to complete the insert operation.
*/
case OP_RowCell: {
  VdbeCursor *pDest;              /* Cursor to write to */
  VdbeCursor *pSrc;               /* Cursor to read from */
  i64 iKey;                       /* Rowid value to insert with */
  assert( pOp[1].opcode==OP_Insert || pOp[1].opcode==OP_IdxInsert );
  assert( pOp[1].p5 & OPFLAG_PREFORMAT );
  pDest = p->apCsr[pOp->p1];
  pSrc = p->apCsr[pOp->p2];
  iKey = pOp->p3 ? aMem[pOp->p3].u.i : 0;
  rc = sqlite3BtreeTransferRow(pDest->uc.pCursor, pSrc->uc.pCursor, iKey);
  if( rc!=SQLITE_OK ) goto abort_due_to_error;
  break;
};

/* Opcode: Delete P1 P2 P3 P4 P5
**
** Delete the record at which the P1 cursor is currently pointing.
**
** If the OPFLAG_SAVEPOSITION bit of the P5 parameter is set, then
** the cursor will be left pointing at  either the next or the previous

  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  pC = p->apCsr[pOp->p1];
  sqlite3VdbeIncrWriteCounter(p, pC);
  assert( pC!=0 );
  assert( !isSorter(pC) );
  pIn2 = &aMem[pOp->p2];
  assert( (pIn2->flags & MEM_Blob) || (pOp->p5 & OPFLAG_PREFORMAT) );
  if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
  assert( pC->eCurType==CURTYPE_BTREE );
  assert( pC->isTable==0 );
  rc = ExpandBlob(pIn2);
  if( rc ) goto abort_due_to_error;
  x.nKey = pIn2->n;
  x.pKey = pIn2->z;
  x.aMem = aMem + pOp->p3;
  x.nMem = (u16)pOp->p4.i;
  rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
       (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION|OPFLAG_PREFORMAT)),
      ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
      );
  assert( pC->deferredMoveto==0 );
  pC->cacheStatus = CACHE_STALE;
  if( rc) goto abort_due_to_error;
  break;
}

    if( zEscape[0]==aWc[1] ) return 0;
    aWc[3] = zEscape[0];
  }

  *pIsNocase = (pDef->funcFlags & SQLITE_FUNC_CASE)==0;
  return 1;
}

/* Mathematical Constants */
#ifndef M_PI
# define M_PI   3.141592653589793238462643383279502884
#endif
#ifndef M_LN10
# define M_LN10 2.302585092994045684017991454684364208
#endif
#ifndef M_LN2
# define M_LN2  0.693147180559945309417232121458176568
#endif


/* Extra math functions that require linking with -lm
*/
#ifdef SQLITE_ENABLE_MATH_FUNCTIONS
/*
** Implementation SQL functions:
**
**   ceil(X)
**   ceiling(X)
**   floor(X)
**
** The sqlite3_user_data() pointer is a pointer to the libm implementation
** of the underlying C function.
*/
static void ceilingFunc(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  assert( argc==1 );
  switch( sqlite3_value_numeric_type(argv[0]) ){
    case SQLITE_INTEGER: {
       sqlite3_result_int64(context, sqlite3_value_int64(argv[0]));
       break;
    }
    case SQLITE_FLOAT: {
       double (*x)(double) = (double(*)(double))sqlite3_user_data(context);
       sqlite3_result_double(context, x(sqlite3_value_double(argv[0])));
       break;
    }
    default: {
       break;
    }
  }
}

/*
** Implementation of SQL functions:
**
**   ln(X)       - natural logarithm
**   log(X)      - log X base 10
**   log10(X)    - log X base 10
**   log(B,X)    - log X base B
*/
static void logFunc(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  double x, b, ans;
  assert( argc==1 || argc==2 );
  switch( sqlite3_value_numeric_type(argv[0]) ){
    case SQLITE_INTEGER:
    case SQLITE_FLOAT:
      x = sqlite3_value_double(argv[0]);
      if( x<0.0 ) return;
      break;
    default:
      return;
  }
  if( argc==2 ){
    switch( sqlite3_value_numeric_type(argv[0]) ){
      case SQLITE_INTEGER:
      case SQLITE_FLOAT:
        b = x;
        x = sqlite3_value_double(argv[1]);
        if( x<0.0 ) return;
        break;
     default:
        return;
    }
    ans = log(x)/log(b);
  }else{
    ans = log(x);
    switch( SQLITE_PTR_TO_INT(sqlite3_user_data(context)) ){
      case 1:
        /* Convert from natural logarithm to log base 10 */
        ans *= 1.0/M_LN10;
        break;
      case 2:
        /* Convert from natural logarithm to log base 2 */
        ans *= 1.0/M_LN2;
        break;
      default:
        break;
    }
  }
  sqlite3_result_double(context, ans);
}

/*
** Functions to converts degrees to radians and radians to degrees.
*/
static double degToRad(double x){ return x*(M_PI/180.0); }
static double radToDeg(double x){ return x*(180.0/M_PI); }

/*
** Implementation of 1-argument SQL math functions:
**
**   exp(X)  - Compute e to the X-th power
*/
static void math1Func(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  int type0;
  double v0, ans;
  double (*x)(double);
  assert( argc==1 );
  type0 = sqlite3_value_numeric_type(argv[0]);
  if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return;
  v0 = sqlite3_value_double(argv[0]);
  x = (double(*)(double))sqlite3_user_data(context);
  ans = x(v0);
  sqlite3_result_double(context, ans);
}

/*
** Implementation of 2-argument SQL math functions:
**
**   power(X,Y)  - Compute X to the Y-th power
*/
static void math2Func(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  int type0, type1;
  double v0, v1, ans;
  double (*x)(double,double);
  assert( argc==2 );
  type0 = sqlite3_value_numeric_type(argv[0]);
  if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return;
  type1 = sqlite3_value_numeric_type(argv[1]);
  if( type1!=SQLITE_INTEGER && type1!=SQLITE_FLOAT ) return;
  v0 = sqlite3_value_double(argv[0]);
  v1 = sqlite3_value_double(argv[1]);
  x = (double(*)(double,double))sqlite3_user_data(context);
  ans = x(v0, v1);
  sqlite3_result_double(context, ans);
}

/*
** Implementation of 2-argument SQL math functions:
**
**   power(X,Y)  - Compute X to the Y-th power
*/
static void piFunc(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  assert( argc==0 );
  sqlite3_result_double(context, M_PI);
}

#endif /* SQLITE_ENABLE_MATH_FUNCTIONS */

/*
** Implementation of sign(X) function.
*/
static void signFunc(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  int type0;
  double x;
  assert( argc==1 );
  type0 = sqlite3_value_numeric_type(argv[0]);
  if( type0!=SQLITE_INTEGER && type0!=SQLITE_FLOAT ) return;
  x = sqlite3_value_double(argv[0]);
  sqlite3_result_int(context, x<0.0 ? -1 : x>0.0 ? +1 : 0);
}

/*
** All of the FuncDef structures in the aBuiltinFunc[] array above
** to the global function hash table.  This occurs at start-time (as
** a consequence of calling sqlite3_initialize()).
**
** After this routine runs

    LIKEFUNC(like, 3, &likeInfoNorm, SQLITE_FUNC_LIKE),
#endif
#ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
    FUNCTION(unknown,           -1, 0, 0, unknownFunc      ),
#endif
    FUNCTION(coalesce,           1, 0, 0, 0                ),
    FUNCTION(coalesce,           0, 0, 0, 0                ),
#ifdef SQLITE_ENABLE_MATH_FUNCTIONS
    MFUNCTION(ceil,              1, ceil,      ceilingFunc ),
    MFUNCTION(ceiling,           1, ceil,      ceilingFunc ),
    MFUNCTION(floor,             1, floor,     ceilingFunc ),
#if SQLITE_HAVE_C99_MATH_FUNCS
    MFUNCTION(trunc,             1, trunc,     ceilingFunc ),
#endif
    FUNCTION(ln,                 1, 0, 0,      logFunc     ),
    FUNCTION(log,                1, 1, 0,      logFunc     ),
    FUNCTION(log10,              1, 1, 0,      logFunc     ),
    FUNCTION(log2,               1, 2, 0,      logFunc     ),
    FUNCTION(log,                2, 0, 0,      logFunc     ),
    MFUNCTION(exp,               1, exp,       math1Func   ),
    MFUNCTION(pow,               2, pow,       math2Func   ),
    MFUNCTION(power,             2, pow,       math2Func   ),
    MFUNCTION(mod,               2, fmod,      math2Func   ),
    MFUNCTION(acos,              1, acos,      math1Func   ),
    MFUNCTION(asin,              1, asin,      math1Func   ),
    MFUNCTION(atan,              1, atan,      math1Func   ),
    MFUNCTION(atan2,             2, atan2,     math2Func   ),
    MFUNCTION(cos,               1, cos,       math1Func   ),
    MFUNCTION(sin,               1, sin,       math1Func   ),
    MFUNCTION(tan,               1, tan,       math1Func   ),
    MFUNCTION(cosh,              1, cosh,      math1Func   ),
    MFUNCTION(sinh,              1, sinh,      math1Func   ),
    MFUNCTION(tanh,              1, tanh,      math1Func   ),
#if SQLITE_HAVE_C99_MATH_FUNCS
    MFUNCTION(acosh,             1, acosh,     math1Func   ),
    MFUNCTION(asinh,             1, asinh,     math1Func   ),
    MFUNCTION(atanh,             1, atanh,     math1Func   ),
#endif
    MFUNCTION(sqrt,              1, sqrt,      math1Func   ),
    MFUNCTION(radians,           1, degToRad,  math1Func   ),
    MFUNCTION(degrees,           1, radToDeg,  math1Func   ),
    FUNCTION(pi,                 0, 0, 0,      piFunc      ),
#endif /* SQLITE_ENABLE_MATH_FUNCTIONS */
    FUNCTION(sign,               1, 0, 0,      signFunc    ),
    INLINE_FUNC(coalesce,       -1, INLINEFUNC_coalesce, 0 ),
    INLINE_FUNC(iif,             3, INLINEFUNC_iif,      0 ),
  };
#ifndef SQLITE_OMIT_ALTERTABLE
  sqlite3AlterFunctions();
#endif
  sqlite3WindowFunctions();

      aRegIdx[i] = ++pParse->nMem;
      pParse->nMem += pIdx->nColumn;
    }
    aRegIdx[i] = ++pParse->nMem;  /* Register to store the table record */
  }
#ifndef SQLITE_OMIT_UPSERT
  if( pUpsert ){
    Upsert *pNx;
    if( IsVirtual(pTab) ){
      sqlite3ErrorMsg(pParse, "UPSERT not implemented for virtual table \"%s\"",
              pTab->zName);
      goto insert_cleanup;
    }
    if( pTab->pSelect ){
      sqlite3ErrorMsg(pParse, "cannot UPSERT a view");
      goto insert_cleanup;
    }
    if( sqlite3HasExplicitNulls(pParse, pUpsert->pUpsertTarget) ){
      goto insert_cleanup;
    }
    pTabList->a[0].iCursor = iDataCur;
    pNx = pUpsert;
    do{
      pNx->pUpsertSrc = pTabList;
      pNx->regData = regData;
      pNx->iDataCur = iDataCur;
      pNx->iIdxCur = iIdxCur;
      if( pNx->pUpsertTarget ){
        sqlite3UpsertAnalyzeTarget(pParse, pTabList, pNx);
      }
      pNx = pNx->pNextUpsert;
    }while( pNx!=0 );
  }
#endif


  /* This is the top of the main insertion loop */
  if( useTempTable ){
    /* This block codes the top of loop only.  The complete loop is the

  }
  testcase( w.eCode==0 );
  testcase( w.eCode==CKCNSTRNT_COLUMN );
  testcase( w.eCode==CKCNSTRNT_ROWID );
  testcase( w.eCode==(CKCNSTRNT_ROWID|CKCNSTRNT_COLUMN) );
  return w.eCode!=0;
}

/*
** The sqlite3GenerateConstraintChecks() routine usually wants to visit
** the indexes of a table in the order provided in the Table->pIndex list.
** However, sometimes (rarely - when there is an upsert) it wants to visit
** the indexes in a different order.  The following data structures accomplish
** this.
**
** The IndexIterator object is used to walk through all of the indexes
** of a table in either Index.pNext order, or in some other order established
** by an array of IndexListTerm objects.
*/
typedef struct IndexListTerm IndexListTerm;
typedef struct IndexIterator IndexIterator;
struct IndexIterator {
  int eType;    /* 0 for Index.pNext list.  1 for an array of IndexListTerm */
  int i;        /* Index of the current item from the list */
  union {
    struct {    /* Use this object for eType==0: A Index.pNext list */
      Index *pIdx;   /* The current Index */
    } lx;
    struct {    /* Use this object for eType==1; Array of IndexListTerm */
      int nIdx;               /* Size of the array */
      IndexListTerm *aIdx;    /* Array of IndexListTerms */
    } ax;
  } u;
};

/* When IndexIterator.eType==1, then each index is an array of instances
** of the following object
*/
struct IndexListTerm {
  Index *p;  /* The index */
  int ix;    /* Which entry in the original Table.pIndex list is this index*/
};

/* Return the first index on the list */
static Index *indexIteratorFirst(IndexIterator *pIter, int *pIx){
  assert( pIter->i==0 );
  if( pIter->eType ){
    *pIx = pIter->u.ax.aIdx[0].ix;
    return pIter->u.ax.aIdx[0].p;
  }else{
    *pIx = 0;
    return pIter->u.lx.pIdx;
  }
}

/* Return the next index from the list.  Return NULL when out of indexes */
static Index *indexIteratorNext(IndexIterator *pIter, int *pIx){
  if( pIter->eType ){
    int i = ++pIter->i;
    if( i>=pIter->u.ax.nIdx ){
      *pIx = i;
      return 0;
    }
    *pIx = pIter->u.ax.aIdx[i].ix;
    return pIter->u.ax.aIdx[i].p;
  }else{
    ++(*pIx);
    pIter->u.lx.pIdx = pIter->u.lx.pIdx->pNext;
    return pIter->u.lx.pIdx;
  }
}

/*
** Generate code to do constraint checks prior to an INSERT or an UPDATE
** on table pTab.
**
** The regNewData parameter is the first register in a range that contains
** the data to be inserted or the data after the update.  There will be

  int ignoreDest,      /* Jump to this label on an OE_Ignore resolution */
  int *pbMayReplace,   /* OUT: Set to true if constraint may cause a replace */
  int *aiChng,         /* column i is unchanged if aiChng[i]<0 */
  Upsert *pUpsert      /* ON CONFLICT clauses, if any.  NULL otherwise */
){
  Vdbe *v;             /* VDBE under constrution */
  Index *pIdx;         /* Pointer to one of the indices */
  Index *pPk = 0;      /* The PRIMARY KEY index for WITHOUT ROWID tables */
  sqlite3 *db;         /* Database connection */
  int i;               /* loop counter */
  int ix;              /* Index loop counter */
  int nCol;            /* Number of columns */
  int onError;         /* Conflict resolution strategy */
  int seenReplace = 0; /* True if REPLACE is used to resolve INT PK conflict */
  int nPkField;        /* Number of fields in PRIMARY KEY. 1 for ROWID tables */
  Upsert *pUpsertClause = 0;  /* The specific ON CONFLICT clause for pIdx */
  u8 isUpdate;           /* True if this is an UPDATE operation */
  u8 bAffinityDone = 0;  /* True if the OP_Affinity operation has been run */
  int upsertIpkReturn = 0; /* Address of Goto at end of IPK uniqueness check */
  int upsertIpkDelay = 0;  /* Address of Goto to bypass initial IPK check */
  int ipkTop = 0;        /* Top of the IPK uniqueness check */
  int ipkBottom = 0;     /* OP_Goto at the end of the IPK uniqueness check */
  /* Variables associated with retesting uniqueness constraints after
  ** replace triggers fire have run */
  int regTrigCnt;       /* Register used to count replace trigger invocations */
  int addrRecheck = 0;  /* Jump here to recheck all uniqueness constraints */
  int lblRecheckOk = 0; /* Each recheck jumps to this label if it passes */
  Trigger *pTrigger;    /* List of DELETE triggers on the table pTab */
  int nReplaceTrig = 0; /* Number of replace triggers coded */
  IndexIterator sIdxIter;  /* Index iterator */

  isUpdate = regOldData!=0;
  db = pParse->db;
  v = pParse->pVdbe;
  assert( v!=0 );
  assert( pTab->pSelect==0 );  /* This table is not a VIEW */
  nCol = pTab->nCol;

  **        default conflict resolution strategy
  **   (C)  Unique index that do use OE_Replace by default.
  **
  ** The ordering of (2) and (3) is accomplished by making sure the linked
  ** list of indexes attached to a table puts all OE_Replace indexes last
  ** in the list.  See sqlite3CreateIndex() for where that happens.
  */
  sIdxIter.eType = 0;
  sIdxIter.i = 0;
  sIdxIter.u.ax.aIdx = 0;  /* Silence harmless compiler warning */
  sIdxIter.u.lx.pIdx = pTab->pIndex;
  if( pUpsert ){
    if( pUpsert->pUpsertTarget==0 ){
      /* There is just on ON CONFLICT clause and it has no constraint-target */
      assert( pUpsert->pNextUpsert==0 );
      if( pUpsert->isDoUpdate==0 ){
        /* A single ON CONFLICT DO NOTHING clause, without a constraint-target.
        ** Make all unique constraint resolution be OE_Ignore */

        overrideError = OE_Ignore;
        pUpsert = 0;
      }else{
        /* A single ON CONFLICT DO UPDATE.  Make all resolutions OE_Update */
        overrideError = OE_Update;
      }
    }else if( pTab->pIndex!=0 ){
      /* Otherwise, we'll need to run the IndexListTerm array version of the
      ** iterator to ensure that all of the ON CONFLICT conditions are
      ** checked first and in order. */
      int nIdx, jj;
      u64 nByte;
      Upsert *pTerm;
      u8 *bUsed;
      for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
         assert( aRegIdx[nIdx]>0 );
      }
      sIdxIter.eType = 1;
      sIdxIter.u.ax.nIdx = nIdx;
      nByte = (sizeof(IndexListTerm)+1)*nIdx + nIdx;
      sIdxIter.u.ax.aIdx = sqlite3DbMallocZero(db, nByte);

      if( sIdxIter.u.ax.aIdx==0 ) return; /* OOM */
      bUsed = (u8*)&sIdxIter.u.ax.aIdx[nIdx];
      pUpsert->pToFree = sIdxIter.u.ax.aIdx;
      for(i=0, pTerm=pUpsert; pTerm; pTerm=pTerm->pNextUpsert){
        if( pTerm->pUpsertTarget==0 ) break;
        if( pTerm->pUpsertIdx==0 ) continue;  /* Skip ON CONFLICT for the IPK */
        jj = 0;
        pIdx = pTab->pIndex;
        while( ALWAYS(pIdx!=0) && pIdx!=pTerm->pUpsertIdx ){
           pIdx = pIdx->pNext;
           jj++;
        }
        if( bUsed[jj] ) continue; /* Duplicate ON CONFLICT clause ignored */
        bUsed[jj] = 1;
        sIdxIter.u.ax.aIdx[i].p = pIdx;
        sIdxIter.u.ax.aIdx[i].ix = jj;
        i++;
      }
      for(jj=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, jj++){
        if( bUsed[jj] ) continue;
        sIdxIter.u.ax.aIdx[i].p = pIdx;
        sIdxIter.u.ax.aIdx[i].ix = jj;
        i++;
      }
      assert( i==nIdx );
    }
  }

  /* Determine if it is possible that triggers (either explicitly coded
  ** triggers or FK resolution actions) might run as a result of deletes
  ** that happen when OE_Replace conflict resolution occurs. (Call these
  ** "replace triggers".)  If any replace triggers run, we will need to

    if( overrideError!=OE_Default ){
      onError = overrideError;
    }else if( onError==OE_Default ){
      onError = OE_Abort;
    }

    /* figure out whether or not upsert applies in this case */
    if( pUpsert ){
      pUpsertClause = sqlite3UpsertOfIndex(pUpsert,0);
      if( pUpsertClause!=0 ){
        if( pUpsertClause->isDoUpdate==0 ){
          onError = OE_Ignore;  /* DO NOTHING is the same as INSERT OR IGNORE */
        }else{
          onError = OE_Update;  /* DO UPDATE */
        }
      }
      if( pUpsertClause!=pUpsert ){
        /* The first ON CONFLICT clause has a conflict target other than
        ** the IPK.  We have to jump ahead to that first ON CONFLICT clause
        ** and then come back here and deal with the IPK afterwards */
        upsertIpkDelay = sqlite3VdbeAddOp0(v, OP_Goto);
      }
    }

    /* If the response to a rowid conflict is REPLACE but the response
    ** to some other UNIQUE constraint is FAIL or IGNORE, then we need
    ** to defer the running of the rowid conflict checking until after
    ** the UNIQUE constraints have run.

      case OE_Ignore: {
        testcase( onError==OE_Ignore );
        sqlite3VdbeGoto(v, ignoreDest);
        break;
      }
    }
    sqlite3VdbeResolveLabel(v, addrRowidOk);
    if( pUpsert && pUpsertClause!=pUpsert ){
      upsertIpkReturn = sqlite3VdbeAddOp0(v, OP_Goto);
    }else if( ipkTop ){
      ipkBottom = sqlite3VdbeAddOp0(v, OP_Goto);
      sqlite3VdbeJumpHere(v, ipkTop-1);
    }
  }

  /* Test all UNIQUE constraints by creating entries for each UNIQUE
  ** index and making sure that duplicate entries do not already exist.
  ** Compute the revised record entries for indices as we go.
  **
  ** This loop also handles the case of the PRIMARY KEY index for a
  ** WITHOUT ROWID table.
  */
  for(pIdx = indexIteratorFirst(&sIdxIter, &ix);
      pIdx;
      pIdx = indexIteratorNext(&sIdxIter, &ix)
  ){
    int regIdx;          /* Range of registers hold conent for pIdx */
    int regR;            /* Range of registers holding conflicting PK */
    int iThisCur;        /* Cursor for this UNIQUE index */
    int addrUniqueOk;    /* Jump here if the UNIQUE constraint is satisfied */
    int addrConflictCk;  /* First opcode in the conflict check logic */

    if( aRegIdx[ix]==0 ) continue;  /* Skip indices that do not change */
    if( pUpsert ){

      pUpsertClause = sqlite3UpsertOfIndex(pUpsert, pIdx);
      if( upsertIpkDelay && pUpsertClause==pUpsert ){
        sqlite3VdbeJumpHere(v, upsertIpkDelay);


      }
    }
    addrUniqueOk = sqlite3VdbeMakeLabel(pParse);
    if( bAffinityDone==0 ){
      sqlite3TableAffinity(v, pTab, regNewData+1);
      bAffinityDone = 1;
    }
    VdbeNoopComment((v, "prep index %s", pIdx->zName));
    iThisCur = iIdxCur+ix;

    if( overrideError!=OE_Default ){
      onError = overrideError;
    }else if( onError==OE_Default ){
      onError = OE_Abort;
    }

    /* Figure out if the upsert clause applies to this index */
    if( pUpsertClause ){
      if( pUpsertClause->isDoUpdate==0 ){
        onError = OE_Ignore;  /* DO NOTHING is the same as INSERT OR IGNORE */
      }else{
        onError = OE_Update;  /* DO UPDATE */
      }
    }

    /* Collision detection may be omitted if all of the following are true:

    /* Check to see if the new index entry will be unique */
    sqlite3VdbeVerifyAbortable(v, onError);
    addrConflictCk =
      sqlite3VdbeAddOp4Int(v, OP_NoConflict, iThisCur, addrUniqueOk,
                           regIdx, pIdx->nKeyCol); VdbeCoverage(v);

    /* Generate code to handle collisions */
    regR = pIdx==pPk ? regIdx : sqlite3GetTempRange(pParse, nPkField);
    if( isUpdate || onError==OE_Replace ){
      if( HasRowid(pTab) ){
        sqlite3VdbeAddOp2(v, OP_IdxRowid, iThisCur, regR);
        /* Conflict only if the rowid of the existing index entry
        ** is different from old-rowid */
        if( isUpdate ){
          sqlite3VdbeAddOp3(v, OP_Eq, regR, addrUniqueOk, regOldData);

          sqlite3VdbeJumpHere(v, addrBypass); /* Terminate the recheck bypass */
        }
        seenReplace = 1;
        break;
      }
    }
    sqlite3VdbeResolveLabel(v, addrUniqueOk);
    if( regR!=regIdx ) sqlite3ReleaseTempRange(pParse, regR, nPkField);
    if( pUpsertClause
     && upsertIpkReturn
     && sqlite3UpsertNextIsIPK(pUpsertClause)
    ){
      sqlite3VdbeGoto(v, upsertIpkDelay+1);
      sqlite3VdbeJumpHere(v, upsertIpkReturn);
      upsertIpkReturn = 0;

    }

  }

  /* If the IPK constraint is a REPLACE, run it last */
  if( ipkTop ){
    sqlite3VdbeGoto(v, ipkTop);
    VdbeComment((v, "Do IPK REPLACE"));
    sqlite3VdbeJumpHere(v, ipkBottom);

  iDbSrc = sqlite3SchemaToIndex(db, pSrc->pSchema);
  v = sqlite3GetVdbe(pParse);
  sqlite3CodeVerifySchema(pParse, iDbSrc);
  iSrc = pParse->nTab++;
  iDest = pParse->nTab++;
  regAutoinc = autoIncBegin(pParse, iDbDest, pDest);
  regData = sqlite3GetTempReg(pParse);
  sqlite3VdbeAddOp2(v, OP_Null, 0, regData);
  regRowid = sqlite3GetTempReg(pParse);
  sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite);
  assert( HasRowid(pDest) || destHasUniqueIdx );
  if( (db->mDbFlags & DBFLAG_Vacuum)==0 && (
      (pDest->iPKey<0 && pDest->pIndex!=0)          /* (1) */
   || destHasUniqueIdx                              /* (2) */
   || (onError!=OE_Abort && onError!=OE_Rollback)   /* (3) */

  }
  if( HasRowid(pSrc) ){
    u8 insFlags;
    sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead);
    emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
    if( pDest->iPKey>=0 ){
      addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
      if( (db->mDbFlags & DBFLAG_Vacuum)==0 ){
        sqlite3VdbeVerifyAbortable(v, onError);
        addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid);
        VdbeCoverage(v);
        sqlite3RowidConstraint(pParse, onError, pDest);
        sqlite3VdbeJumpHere(v, addr2);
      }
      autoIncStep(pParse, regAutoinc, regRowid);
    }else if( pDest->pIndex==0 && !(db->mDbFlags & DBFLAG_VacuumInto) ){
      addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid);
    }else{
      addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
      assert( (pDest->tabFlags & TF_Autoincrement)==0 );
    }

    if( db->mDbFlags & DBFLAG_Vacuum ){
      sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest);
      insFlags = OPFLAG_APPEND|OPFLAG_USESEEKRESULT|OPFLAG_PREFORMAT;
    }else{
      insFlags = OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND|OPFLAG_PREFORMAT;
    }
#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
    if( db->xPreUpdateCallback ){
      sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
      insFlags &= ~OPFLAG_PREFORMAT;
    }else
#endif
    {
      sqlite3VdbeAddOp3(v, OP_RowCell, iDest, iSrc, regRowid);
    }
    sqlite3VdbeAddOp4(v, OP_Insert, iDest, regData, regRowid,
        (char*)pDest, P4_TABLE);
    sqlite3VdbeChangeP5(v, insFlags);

    sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1); VdbeCoverage(v);
    sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
    sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
  }else{
    sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName);
    sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName);
  }

      ** a VACUUM command. In that case keys may not be written in strictly
      ** sorted order.  */
      for(i=0; i<pSrcIdx->nColumn; i++){
        const char *zColl = pSrcIdx->azColl[i];
        if( sqlite3_stricmp(sqlite3StrBINARY, zColl) ) break;
      }
      if( i==pSrcIdx->nColumn ){
        idxInsFlags = OPFLAG_USESEEKRESULT|OPFLAG_PREFORMAT;
        sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest);
        sqlite3VdbeAddOp3(v, OP_RowCell, iDest, iSrc, regData);
      }
    }else if( !HasRowid(pSrc) && pDestIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){
      idxInsFlags |= OPFLAG_NCHANGE;
    }
    if( idxInsFlags!=(OPFLAG_USESEEKRESULT|OPFLAG_PREFORMAT) ){
      sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
    }
    sqlite3VdbeAddOp2(v, OP_IdxInsert, iDest, regData);
    sqlite3VdbeChangeP5(v, idxInsFlags|OPFLAG_APPEND);
    sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1); VdbeCoverage(v);
    sqlite3VdbeJumpHere(v, addr1);
    sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
    sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
  }

  ** success.
  */
  sqlite3AggInfoPersistWalkerInit(&w, pParse);
  sqlite3WalkSelect(&w,pSub1);
  sqlite3SelectDelete(db, pSub1);

#if SELECTTRACE_ENABLED
  if( sqlite3SelectTrace & 0x100 ){
    SELECTTRACE(0x100,pParse,p,("After flattening:\n"));
    sqlite3TreeViewSelect(0, p, 0);
  }
#endif

  return 1;
}

  Walker sWalker;
  memset(&sWalker, 0, sizeof(sWalker));
  sWalker.pParse = pParse;
  sWalker.xExprCallback = havingToWhereExprCb;
  sWalker.u.pSelect = p;
  sqlite3WalkExpr(&sWalker, p->pHaving);
#if SELECTTRACE_ENABLED
  if( sWalker.eCode && (sqlite3SelectTrace & 0x100)!=0 ){
    SELECTTRACE(0x100,pParse,p,("Move HAVING terms into WHERE:\n"));
    sqlite3TreeViewSelect(0, p, 0);
  }
#endif
}

/*

    }
    pSub = pPrior;
  }
  p->pEList->a[0].pExpr = pExpr;
  p->selFlags &= ~SF_Aggregate;

#if SELECTTRACE_ENABLED
  if( sqlite3SelectTrace & 0x400 ){
    SELECTTRACE(0x400,pParse,p,("After count-of-view optimization:\n"));
    sqlite3TreeViewSelect(0, p, 0);
  }
#endif
  return 1;
}
#endif /* SQLITE_COUNTOFVIEW_OPTIMIZATION */

  v = sqlite3GetVdbe(pParse);
  if( p==0 || db->mallocFailed || pParse->nErr ){
    return 1;
  }
  if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
#if SELECTTRACE_ENABLED
  SELECTTRACE(1,pParse,p, ("begin processing:\n", pParse->addrExplain));
  if( sqlite3SelectTrace & 0x100 ){
    sqlite3TreeViewSelect(0, p, 0);
  }
#endif

  assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistFifo );
  assert( p->pOrderBy==0 || pDest->eDest!=SRT_Fifo );
  assert( p->pOrderBy==0 || pDest->eDest!=SRT_DistQueue );

  }
  sqlite3SelectPrep(pParse, p, 0);
  if( pParse->nErr || db->mallocFailed ){
    goto select_end;
  }
  assert( p->pEList!=0 );
#if SELECTTRACE_ENABLED
  if( sqlite3SelectTrace & 0x104 ){
    SELECTTRACE(0x104,pParse,p, ("after name resolution:\n"));
    sqlite3TreeViewSelect(0, p, 0);
  }
#endif

  /* If the SF_UpdateFrom flag is set, then this function is being called
  ** as part of populating the temp table for an UPDATE...FROM statement.

#ifndef SQLITE_OMIT_WINDOWFUNC
  rc = sqlite3WindowRewrite(pParse, p);
  if( rc ){
    assert( db->mallocFailed || pParse->nErr>0 );
    goto select_end;
  }
#if SELECTTRACE_ENABLED
  if( p->pWin && (sqlite3SelectTrace & 0x108)!=0 ){
    SELECTTRACE(0x104,pParse,p, ("after window rewrite:\n"));
    sqlite3TreeViewSelect(0, p, 0);
  }
#endif
#endif /* SQLITE_OMIT_WINDOWFUNC */
  pTabList = p->pSrc;
  isAgg = (p->selFlags & SF_Aggregate)!=0;

  /* Handle compound SELECT statements using the separate multiSelect()
  ** procedure.
  */
  if( p->pPrior ){
    rc = multiSelect(pParse, p, pDest);
#if SELECTTRACE_ENABLED
    SELECTTRACE(0x1,pParse,p,("end compound-select processing\n"));
    if( (sqlite3SelectTrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){
      sqlite3TreeViewSelect(0, p, 0);
    }
#endif
    if( p->pNext==0 ) ExplainQueryPlanPop(pParse);
    return rc;
  }
#endif

  /* Do the WHERE-clause constant propagation optimization if this is
  ** a join.  No need to speed time on this operation for non-join queries
  ** as the equivalent optimization will be handled by query planner in
  ** sqlite3WhereBegin().
  */
  if( pTabList->nSrc>1
   && OptimizationEnabled(db, SQLITE_PropagateConst)
   && propagateConstants(pParse, p)
  ){
#if SELECTTRACE_ENABLED
    if( sqlite3SelectTrace & 0x100 ){
      SELECTTRACE(0x100,pParse,p,("After constant propagation:\n"));
      sqlite3TreeViewSelect(0, p, 0);
    }
#endif
  }else{
    SELECTTRACE(0x100,pParse,p,("Constant propagation not helpful\n"));
  }

    ** inside the subquery.  This can help the subquery to run more efficiently.
    */
    if( OptimizationEnabled(db, SQLITE_PushDown)
     && pushDownWhereTerms(pParse, pSub, p->pWhere, pItem->iCursor,
                           (pItem->fg.jointype & JT_OUTER)!=0)
    ){
#if SELECTTRACE_ENABLED
      if( sqlite3SelectTrace & 0x100 ){
        SELECTTRACE(0x100,pParse,p,
            ("After WHERE-clause push-down into subquery %d:\n", pSub->selId));
        sqlite3TreeViewSelect(0, p, 0);
      }
#endif
    }else{
      SELECTTRACE(0x100,pParse,p,("Push-down not possible\n"));

  pEList = p->pEList;
  pWhere = p->pWhere;
  pGroupBy = p->pGroupBy;
  pHaving = p->pHaving;
  sDistinct.isTnct = (p->selFlags & SF_Distinct)!=0;

#if SELECTTRACE_ENABLED
  if( sqlite3SelectTrace & 0x400 ){
    SELECTTRACE(0x400,pParse,p,("After all FROM-clause analysis:\n"));
    sqlite3TreeViewSelect(0, p, 0);
  }
#endif

  /* If the query is DISTINCT with an ORDER BY but is not an aggregate, and
  ** if the select-list is the same as the ORDER BY list, then this query

    p->selFlags |= SF_Aggregate;
    /* Notice that even thought SF_Distinct has been cleared from p->selFlags,
    ** the sDistinct.isTnct is still set.  Hence, isTnct represents the
    ** original setting of the SF_Distinct flag, not the current setting */
    assert( sDistinct.isTnct );

#if SELECTTRACE_ENABLED
    if( sqlite3SelectTrace & 0x400 ){
      SELECTTRACE(0x400,pParse,p,("Transform DISTINCT into GROUP BY:\n"));
      sqlite3TreeViewSelect(0, p, 0);
    }
#endif
  }

  /* If there is an ORDER BY clause, then create an ephemeral index to

      }
#endif
      sNC.ncFlags &= ~NC_InAggFunc;
    }
    pAggInfo->mxReg = pParse->nMem;
    if( db->mallocFailed ) goto select_end;
#if SELECTTRACE_ENABLED
    if( sqlite3SelectTrace & 0x400 ){
      int ii;
      SELECTTRACE(0x400,pParse,p,("After aggregate analysis %p:\n", pAggInfo));
      sqlite3TreeViewSelect(0, p, 0);
      for(ii=0; ii<pAggInfo->nColumn; ii++){
        sqlite3DebugPrintf("agg-column[%d] iMem=%d\n",
            ii, pAggInfo->aCol[ii].iMem);
        sqlite3TreeViewExpr(0, pAggInfo->aCol[ii].pCExpr, 0);

      assert( pExpr->iAgg==i );
    }
  }
#endif

#if SELECTTRACE_ENABLED
  SELECTTRACE(0x1,pParse,p,("end processing\n"));
  if( (sqlite3SelectTrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){
    sqlite3TreeViewSelect(0, p, 0);
  }
#endif
  ExplainQueryPlanPop(pParse);
  return rc;
}

*/
/* #include "sqliteInt.h" */

#ifndef SQLITE_OMIT_UPSERT
/*
** Free a list of Upsert objects
*/
static void SQLITE_NOINLINE upsertDelete(sqlite3 *db, Upsert *p){
  do{
    Upsert *pNext = p->pNextUpsert;
    sqlite3ExprListDelete(db, p->pUpsertTarget);
    sqlite3ExprDelete(db, p->pUpsertTargetWhere);
    sqlite3ExprListDelete(db, p->pUpsertSet);
    sqlite3ExprDelete(db, p->pUpsertWhere);
    sqlite3DbFree(db, p->pToFree);
    sqlite3DbFree(db, p);
    p = pNext;
  }while( p );
}
SQLITE_PRIVATE void sqlite3UpsertDelete(sqlite3 *db, Upsert *p){
  if( p ) upsertDelete(db, p);
}


/*
** Duplicate an Upsert object.
*/
SQLITE_PRIVATE Upsert *sqlite3UpsertDup(sqlite3 *db, Upsert *p){
  if( p==0 ) return 0;
  return sqlite3UpsertNew(db,
           sqlite3ExprListDup(db, p->pUpsertTarget, 0),
           sqlite3ExprDup(db, p->pUpsertTargetWhere, 0),
           sqlite3ExprListDup(db, p->pUpsertSet, 0),
           sqlite3ExprDup(db, p->pUpsertWhere, 0),
           sqlite3UpsertDup(db, p->pNextUpsert)
         );
}

/*
** Create a new Upsert object.
*/
SQLITE_PRIVATE Upsert *sqlite3UpsertNew(
  sqlite3 *db,           /* Determines which memory allocator to use */
  ExprList *pTarget,     /* Target argument to ON CONFLICT, or NULL */
  Expr *pTargetWhere,    /* Optional WHERE clause on the target */
  ExprList *pSet,        /* UPDATE columns, or NULL for a DO NOTHING */
  Expr *pWhere,          /* WHERE clause for the ON CONFLICT UPDATE */
  Upsert *pNext          /* Next ON CONFLICT clause in the list */
){
  Upsert *pNew;
  pNew = sqlite3DbMallocZero(db, sizeof(Upsert));
  if( pNew==0 ){
    sqlite3ExprListDelete(db, pTarget);
    sqlite3ExprDelete(db, pTargetWhere);
    sqlite3ExprListDelete(db, pSet);
    sqlite3ExprDelete(db, pWhere);
    sqlite3UpsertDelete(db, pNext);
    return 0;
  }else{
    pNew->pUpsertTarget = pTarget;
    pNew->pUpsertTargetWhere = pTargetWhere;
    pNew->pUpsertSet = pSet;
    pNew->pUpsertWhere = pWhere;
    pNew->isDoUpdate = pSet!=0;
    pNew->pNextUpsert = pNext;
  }
  return pNew;
}

/*
** Analyze the ON CONFLICT clause described by pUpsert.  Resolve all
** symbols in the conflict-target.

  int rc;                 /* Result code */
  int iCursor;            /* Cursor used by pTab */
  Index *pIdx;            /* One of the indexes of pTab */
  ExprList *pTarget;      /* The conflict-target clause */
  Expr *pTerm;            /* One term of the conflict-target clause */
  NameContext sNC;        /* Context for resolving symbolic names */
  Expr sCol[2];           /* Index column converted into an Expr */
  int nClause = 0;        /* Counter of ON CONFLICT clauses */

  assert( pTabList->nSrc==1 );
  assert( pTabList->a[0].pTab!=0 );
  assert( pUpsert!=0 );
  assert( pUpsert->pUpsertTarget!=0 );

  /* Resolve all symbolic names in the conflict-target clause, which
  ** includes both the list of columns and the optional partial-index
  ** WHERE clause.
  */
  memset(&sNC, 0, sizeof(sNC));
  sNC.pParse = pParse;
  sNC.pSrcList = pTabList;
  for(; pUpsert && pUpsert->pUpsertTarget;
        pUpsert=pUpsert->pNextUpsert, nClause++){
    rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget);
    if( rc ) return rc;
    rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertTargetWhere);
    if( rc ) return rc;

    /* Check to see if the conflict target matches the rowid. */
    pTab = pTabList->a[0].pTab;
    pTarget = pUpsert->pUpsertTarget;
    iCursor = pTabList->a[0].iCursor;
    if( HasRowid(pTab)
     && pTarget->nExpr==1
     && (pTerm = pTarget->a[0].pExpr)->op==TK_COLUMN
     && pTerm->iColumn==XN_ROWID
    ){
      /* The conflict-target is the rowid of the primary table */
      assert( pUpsert->pUpsertIdx==0 );

      continue;
    }

    /* Initialize sCol[0..1] to be an expression parse tree for a
    ** single column of an index.  The sCol[0] node will be the TK_COLLATE
    ** operator and sCol[1] will be the TK_COLUMN operator.  Code below
    ** will populate the specific collation and column number values
    ** prior to comparing against the conflict-target expression.
    */
    memset(sCol, 0, sizeof(sCol));
    sCol[0].op = TK_COLLATE;
    sCol[0].pLeft = &sCol[1];
    sCol[1].op = TK_COLUMN;
    sCol[1].iTable = pTabList->a[0].iCursor;

    /* Check for matches against other indexes */
    for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
      int ii, jj, nn;
      if( !IsUniqueIndex(pIdx) ) continue;
      if( pTarget->nExpr!=pIdx->nKeyCol ) continue;
      if( pIdx->pPartIdxWhere ){
        if( pUpsert->pUpsertTargetWhere==0 ) continue;
        if( sqlite3ExprCompare(pParse, pUpsert->pUpsertTargetWhere,
                               pIdx->pPartIdxWhere, iCursor)!=0 ){
          continue;
        }
      }
      nn = pIdx->nKeyCol;
      for(ii=0; ii<nn; ii++){
        Expr *pExpr;
        sCol[0].u.zToken = (char*)pIdx->azColl[ii];
        if( pIdx->aiColumn[ii]==XN_EXPR ){
          assert( pIdx->aColExpr!=0 );
          assert( pIdx->aColExpr->nExpr>ii );
          pExpr = pIdx->aColExpr->a[ii].pExpr;
          if( pExpr->op!=TK_COLLATE ){
            sCol[0].pLeft = pExpr;
            pExpr = &sCol[0];
          }
        }else{
          sCol[0].pLeft = &sCol[1];
          sCol[1].iColumn = pIdx->aiColumn[ii];
          pExpr = &sCol[0];
        }
        for(jj=0; jj<nn; jj++){
          if( sqlite3ExprCompare(pParse,pTarget->a[jj].pExpr,pExpr,iCursor)<2 ){
            break;  /* Column ii of the index matches column jj of target */
          }
        }
        if( jj>=nn ){
          /* The target contains no match for column jj of the index */
          break;
        }
      }
      if( ii<nn ){
        /* Column ii of the index did not match any term of the conflict target.
        ** Continue the search with the next index. */
        continue;
      }
      pUpsert->pUpsertIdx = pIdx;
      break;
    }
    if( pUpsert->pUpsertIdx==0 ){
      char zWhich[16];
      if( nClause==0 && pUpsert->pNextUpsert==0 ){
        zWhich[0] = 0;
      }else{
        sqlite3_snprintf(sizeof(zWhich),zWhich,"%r ", nClause+1);
      }
      sqlite3ErrorMsg(pParse, "%sON CONFLICT clause does not match any "
                              "PRIMARY KEY or UNIQUE constraint", zWhich);
      return SQLITE_ERROR;
    }
  }
  return SQLITE_OK;
}

/*
** Return true if pUpsert is the last ON CONFLICT clause with a
** conflict target, or if pUpsert is followed by another ON CONFLICT
** clause that targets the INTEGER PRIMARY KEY.
*/
SQLITE_PRIVATE int sqlite3UpsertNextIsIPK(Upsert *pUpsert){
  Upsert *pNext;
  if( NEVER(pUpsert==0) ) return 0;
  pNext = pUpsert->pNextUpsert;
  if( pNext==0 ) return 1;
  if( pNext->pUpsertTarget==0 ) return 1;
  if( pNext->pUpsertIdx==0 ) return 1;
  return 0;
}

/*
** Given the list of ON CONFLICT clauses described by pUpsert, and
** a particular index pIdx, return a pointer to the particular ON CONFLICT
** clause that applies to the index.  Or, if the index is not subject to
** any ON CONFLICT clause, return NULL.
*/
SQLITE_PRIVATE Upsert *sqlite3UpsertOfIndex(Upsert *pUpsert, Index *pIdx){
  while(
      pUpsert
   && pUpsert->pUpsertTarget!=0
   && pUpsert->pUpsertIdx!=pIdx
  ){
     pUpsert = pUpsert->pNextUpsert;
  }
  return pUpsert;
}

/*
** Generate bytecode that does an UPDATE as part of an upsert.
**
** If pIdx is NULL, then the UNIQUE constraint that failed was the IPK.
** In this case parameter iCur is a cursor open on the table b-tree that

  int iCur              /* Cursor for pIdx (or pTab if pIdx==NULL) */
){
  Vdbe *v = pParse->pVdbe;
  sqlite3 *db = pParse->db;
  SrcList *pSrc;            /* FROM clause for the UPDATE */
  int iDataCur;
  int i;
  Upsert *pTop = pUpsert;

  assert( v!=0 );
  assert( pUpsert!=0 );

  iDataCur = pUpsert->iDataCur;
  pUpsert = sqlite3UpsertOfIndex(pTop, pIdx);
  VdbeNoopComment((v, "Begin DO UPDATE of UPSERT"));
  if( pIdx && iCur!=iDataCur ){
    if( HasRowid(pTab) ){
      int regRowid = sqlite3GetTempReg(pParse);
      sqlite3VdbeAddOp2(v, OP_IdxRowid, iCur, regRowid);
      sqlite3VdbeAddOp3(v, OP_SeekRowid, iDataCur, 0, regRowid);
      VdbeCoverage(v);
      sqlite3ReleaseTempReg(pParse, regRowid);

      VdbeCoverage(v);
      sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CORRUPT, OE_Abort, 0,
            "corrupt database", P4_STATIC);
      sqlite3MayAbort(pParse);
      sqlite3VdbeJumpHere(v, i);
    }
  }
  /* pUpsert does not own pTop->pUpsertSrc - the outer INSERT statement does.
  ** So we have to make a copy before passing it down into sqlite3Update() */
  pSrc = sqlite3SrcListDup(db, pTop->pUpsertSrc, 0);
  /* excluded.* columns of type REAL need to be converted to a hard real */
  for(i=0; i<pTab->nCol; i++){
    if( pTab->aCol[i].affinity==SQLITE_AFF_REAL ){
      sqlite3VdbeAddOp1(v, OP_RealAffinity, pTop->regData+i);
    }
  }
  sqlite3Update(pParse, pSrc, sqlite3ExprListDup(db,pUpsert->pUpsertSet,0),
      sqlite3ExprDup(db,pUpsert->pUpsertWhere,0), OE_Abort, 0, 0, pUpsert);


  VdbeNoopComment((v, "End DO UPDATE of UPSERT"));
}

#endif /* SQLITE_OMIT_UPSERT */

/************** End of upsert.c **********************************************/
/************** Begin file vacuum.c ******************************************/

** This file contains structure and macro definitions for the query
** planner logic in "where.c".  These definitions are broken out into
** a separate source file for easier editing.
*/
#ifndef SQLITE_WHEREINT_H
#define SQLITE_WHEREINT_H















/* Forward references
*/
typedef struct WhereClause WhereClause;
typedef struct WhereMaskSet WhereMaskSet;
typedef struct WhereOrInfo WhereOrInfo;
typedef struct WhereAndInfo WhereAndInfo;

struct HiddenIndexInfo {
  WhereClause *pWC;   /* The Where clause being analyzed */
  Parse *pParse;      /* The parsing context */
};

/* Forward declaration of methods */
static int whereLoopResize(sqlite3*, WhereLoop*, int);







/*
** Return the estimated number of output rows from a WHERE clause
*/
SQLITE_PRIVATE LogEst sqlite3WhereOutputRowCount(WhereInfo *pWInfo){
  return pWInfo->nRowOut;
}

#define sqlite3ParserARG_STORE
#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;
#define YYFALLBACK 1
#define YYNSTATE             558
#define YYNRULE              386
#define YYNRULE_WITH_ACTION  326
#define YYNTOKEN             181
#define YY_MAX_SHIFT         557
#define YY_MIN_SHIFTREDUCE   809
#define YY_MAX_SHIFTREDUCE   1194
#define YY_ERROR_ACTION      1195
#define YY_ACCEPT_ACTION     1196
#define YY_NO_ACTION         1197
#define YY_MIN_REDUCE        1198
#define YY_MAX_REDUCE        1583
/************* 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

**  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 (1968)
static const YYACTIONTYPE yy_action[] = {
 /*     0 */   551, 1229,  551,  456, 1267,  551, 1246,  551,  114,  111,
 /*    10 */   212,  551, 1545,  551, 1267,  528,  114,  111,  212,  396,
 /*    20 */  1239,  348,   42,   42,   42,   42, 1232,   42,   42,   71,
 /*    30 */    71,  943, 1231,   71,   71,   71,   71, 1470, 1501,  944,
 /*    40 */   826,  458,    6,  121,  122,  112, 1172, 1172, 1013, 1016,
 /*    50 */  1006, 1006,  119,  119,  120,  120,  120,  120, 1551,  396,
 /*    60 */  1366, 1525,  557,    2, 1200,  195,  533,  441,  143,  293,
 /*    70 */   533,  136,  533,  375,  262,  509,  273,  389, 1280,  532,
 /*    80 */   508,  498,  165,  121,  122,  112, 1172, 1172, 1013, 1016,
 /*    90 */  1006, 1006,  119,  119,  120,  120,  120,  120, 1366,  447,
 /*   100 */  1522,  118,  118,  118,  118,  117,  117,  116,  116,  116,
 /*   110 */   115,  429,  267,  267,  267,  267, 1506,  362, 1508,  440,
 /*   120 */   361, 1506,  522,  529, 1493,  548, 1121,  548, 1121,  396,
 /*   130 */   410,  242,  209,  114,  111,  212,   98,  292,  542,  222,
 /*   140 */  1036,  118,  118,  118,  118,  117,  117,  116,  116,  116,
 /*   150 */   115,  429, 1149,  121,  122,  112, 1172, 1172, 1013, 1016,
 /*   160 */  1006, 1006,  119,  119,  120,  120,  120,  120,  411,  433,
 /*   170 */   117,  117,  116,  116,  116,  115,  429, 1426,  473,  123,
 /*   180 */   118,  118,  118,  118,  117,  117,  116,  116,  116,  115,
 /*   190 */   429,  116,  116,  116,  115,  429,  545,  545,  545,  396,
 /*   200 */   510,  120,  120,  120,  120,  113, 1058, 1149, 1150, 1151,
 /*   210 */  1058,  118,  118,  118,  118,  117,  117,  116,  116,  116,
 /*   220 */   115,  429, 1469,  121,  122,  112, 1172, 1172, 1013, 1016,
 /*   230 */  1006, 1006,  119,  119,  120,  120,  120,  120,  396,  449,
 /*   240 */   320,   83,  468,   81,  363,  386, 1149,   80,  118,  118,
 /*   250 */   118,  118,  117,  117,  116,  116,  116,  115,  429,  180,
 /*   260 */   439,  429,  121,  122,  112, 1172, 1172, 1013, 1016, 1006,
 /*   270 */  1006,  119,  119,  120,  120,  120,  120,  439,  438,  267,
 /*   280 */   267,  118,  118,  118,  118,  117,  117,  116,  116,  116,
 /*   290 */   115,  429,  548, 1116,  909,  511, 1149,  114,  111,  212,
 /*   300 */  1439, 1149, 1150, 1151,  207,  496, 1116,  396,  454, 1116,
 /*   310 */   550,  334,  120,  120,  120,  120,  300, 1439, 1441,   17,
 /*   320 */   118,  118,  118,  118,  117,  117,  116,  116,  116,  115,
 /*   330 */   429,  121,  122,  112, 1172, 1172, 1013, 1016, 1006, 1006,
 /*   340 */   119,  119,  120,  120,  120,  120,  396, 1366,  439, 1149,
 /*   350 */   487, 1149, 1150, 1151, 1003, 1003, 1014, 1017,  406,  118,
 /*   360 */   118,  118,  118,  117,  117,  116,  116,  116,  115,  429,
 /*   370 */   121,  122,  112, 1172, 1172, 1013, 1016, 1006, 1006,  119,
 /*   380 */   119,  120,  120,  120,  120, 1061, 1061,  470, 1439,  118,
 /*   390 */   118,  118,  118,  117,  117,  116,  116,  116,  115,  429,
 /*   400 */  1149,  456,  551, 1434, 1149, 1150, 1151,  234,  973, 1149,
 /*   410 */   486,  483,  482,  172,  364,  396,  165,  412,  419,  848,
 /*   420 */   481,  165,  186,  338,   71,   71, 1250, 1007,  118,  118,
 /*   430 */   118,  118,  117,  117,  116,  116,  116,  115,  429,  121,
 /*   440 */   122,  112, 1172, 1172, 1013, 1016, 1006, 1006,  119,  119,
 /*   450 */   120,  120,  120,  120,  396, 1149, 1150, 1151,  841,   12,
 /*   460 */   318,  514,  164,  360, 1149, 1150, 1151,  114,  111,  212,
 /*   470 */   513,  292,  542,  551,  277,  181,  292,  542,  121,  122,
 /*   480 */   112, 1172, 1172, 1013, 1016, 1006, 1006,  119,  119,  120,
 /*   490 */   120,  120,  120,  349,  489,   71,   71,  118,  118,  118,
 /*   500 */   118,  117,  117,  116,  116,  116,  115,  429, 1149,  210,
 /*   510 */   416,  528, 1149, 1116, 1579,  382,  253,  270,  346,  492,
 /*   520 */   341,  491,  239,  396,  518,  368, 1116, 1134,  337, 1116,
 /*   530 */   192,  414,  288,   32,  462,  448,  118,  118,  118,  118,
 /*   540 */   117,  117,  116,  116,  116,  115,  429,  121,  122,  112,
 /*   550 */  1172, 1172, 1013, 1016, 1006, 1006,  119,  119,  120,  120,
 /*   560 */   120,  120,  396, 1149, 1150, 1151,  994, 1149, 1150, 1151,
 /*   570 */  1149,  234,  497, 1500,  486,  483,  482,    6,  164,  551,
 /*   580 */   517,  551,  115,  429,  481,    5,  121,  122,  112, 1172,
 /*   590 */  1172, 1013, 1016, 1006, 1006,  119,  119,  120,  120,  120,
 /*   600 */   120,   13,   13,   13,   13,  118,  118,  118,  118,  117,
 /*   610 */   117,  116,  116,  116,  115,  429,  408,  507,  413,  551,
 /*   620 */  1494,  549, 1149,  898,  898, 1149, 1150, 1151, 1481, 1149,
 /*   630 */   276,  396,  814,  815,  816,  978,  427,  427,  427,   16,
 /*   640 */    16,   55,   55, 1249,  118,  118,  118,  118,  117,  117,
 /*   650 */   116,  116,  116,  115,  429,  121,  122,  112, 1172, 1172,
 /*   660 */  1013, 1016, 1006, 1006,  119,  119,  120,  120,  120,  120,
 /*   670 */   396, 1196,    1,    1,  557,    2, 1200, 1149, 1150, 1151,
 /*   680 */   195,  293,  904,  136, 1149, 1150, 1151,  903,  526, 1500,
 /*   690 */  1280,    3,  384,    6,  121,  122,  112, 1172, 1172, 1013,
 /*   700 */  1016, 1006, 1006,  119,  119,  120,  120,  120,  120,  864,
 /*   710 */   551,  930,  551,  118,  118,  118,  118,  117,  117,  116,
 /*   720 */   116,  116,  115,  429,  267,  267, 1099, 1577, 1149,  556,
 /*   730 */  1577, 1200,   13,   13,   13,   13,  293,  548,  136,  396,
 /*   740 */   490,  426,  425,  973,  348, 1280,  473,  415,  865,  281,
 /*   750 */   140,  222,  118,  118,  118,  118,  117,  117,  116,  116,
 /*   760 */   116,  115,  429,  121,  122,  112, 1172, 1172, 1013, 1016,
 /*   770 */  1006, 1006,  119,  119,  120,  120,  120,  120,  551,  267,
 /*   780 */   267,  433,  396, 1149, 1150, 1151, 1179,  836, 1179,  473,
 /*   790 */   436,  145,  548, 1153,  405,  318,  444,  304,  844, 1498,
 /*   800 */    71,   71,  417,    6, 1097,  478,  222,  100,  112, 1172,
 /*   810 */  1172, 1013, 1016, 1006, 1006,  119,  119,  120,  120,  120,
 /*   820 */   120,  118,  118,  118,  118,  117,  117,  116,  116,  116,
 /*   830 */   115,  429,  238, 1433,  551,  456,  433,  289,  993,  551,
 /*   840 */   237,  236,  235,  836,   97,  534,  434, 1272, 1272, 1153,
 /*   850 */   499,  309,  435,  844,  984,  551,   71,   71,  983, 1248,
 /*   860 */   551,   51,   51,  302,  118,  118,  118,  118,  117,  117,
 /*   870 */   116,  116,  116,  115,  429,  195,  103,   70,   70,  267,
 /*   880 */   267,  551,   71,   71,  267,  267,   30,  395,  348,  983,
 /*   890 */   983,  985,  548,  533, 1116,  332,  396,  548,  500,  401,
 /*   900 */   460,  196,  535,   13,   13, 1366,  241, 1116,  278,  282,
 /*   910 */  1116,  282,  306,  462,  308,  337,  396,   31,  189,  424,
 /*   920 */   121,  122,  112, 1172, 1172, 1013, 1016, 1006, 1006,  119,
 /*   930 */   119,  120,  120,  120,  120,  142,  396,  369,  456,  993,
 /*   940 */   121,  122,  112, 1172, 1172, 1013, 1016, 1006, 1006,  119,
 /*   950 */   119,  120,  120,  120,  120,  984,  327, 1149,  330,  983,
 /*   960 */   121,  110,  112, 1172, 1172, 1013, 1016, 1006, 1006,  119,
 /*   970 */   119,  120,  120,  120,  120,  469,  381, 1192,  118,  118,
 /*   980 */   118,  118,  117,  117,  116,  116,  116,  115,  429, 1149,
 /*   990 */   983,  983,  985,  307,    9,  461,  245,  462,  118,  118,
 /*  1000 */   118,  118,  117,  117,  116,  116,  116,  115,  429,  317,
 /*  1010 */   551,  279, 1149, 1150, 1151,  301,  292,  542,  118,  118,
 /*  1020 */   118,  118,  117,  117,  116,  116,  116,  115,  429, 1270,
 /*  1030 */  1270, 1170,   13,   13,  531,  426,  425,  473,  396,  929,
 /*  1040 */   261,  261,   97, 1176, 1149, 1150, 1151,  190, 1178,  267,
 /*  1050 */   267,  473,  138,  548, 1193,  551, 1177,  264,  348,  494,
 /*  1060 */   928,  551,  548,  122,  112, 1172, 1172, 1013, 1016, 1006,
 /*  1070 */  1006,  119,  119,  120,  120,  120,  120,   71,   71, 1149,
 /*  1080 */  1179, 1279, 1179,   13,   13,  904, 1077, 1170,  551,  473,
 /*  1090 */   903,  107,  543,  280,    4, 1275, 1116,  450,  530, 1056,
 /*  1100 */    12, 1078, 1099, 1578,  316,  144, 1578,  525,  546, 1116,
 /*  1110 */    56,   56, 1116, 1499,  428, 1366, 1079,    6,  349,  970,
 /*  1120 */   118,  118,  118,  118,  117,  117,  116,  116,  116,  115,
 /*  1130 */   429,  430, 1278,  325, 1149, 1150, 1151,  884,  267,  267,
 /*  1140 */   855,  107,  543,  540,    4, 1497,  238,  885, 1218,    6,
 /*  1150 */   211,  548,  370,  165,  366,  501,  421, 1496,  546,  268,
 /*  1160 */   268,    6, 1550,  516,  504,  873,  267,  267,  400,  536,
 /*  1170 */     8,  993,  548,  524,  551,  928,  463,  105,  105,  548,
 /*  1180 */  1097,  430,  267,  267,  106,  422,  430,  553,  552,  267,
 /*  1190 */   267,  983,  523,  540, 1381,  548,   15,   15,  267,  267,
 /*  1200 */  1478, 1127,  548,  267,  267, 1077, 1380,  520,  292,  542,
 /*  1210 */   551,  548,  519,  401,  449,  320,  548,  551,  928,  125,
 /*  1220 */  1078,  993,  983,  983,  985,  986,   27,  105,  105,  405,
 /*  1230 */   347, 1519,   44,   44,  106, 1079,  430,  553,  552,   57,
 /*  1240 */    57,  983,  347, 1519,  107,  543,  551,    4,  467,  405,
 /*  1250 */   215, 1127,  464,  295,  381, 1098,  539,  296,  551, 1221,
 /*  1260 */   402,  546,  544,  402,  299,  245,  292,  542,   58,   58,
 /*  1270 */   551, 1284,  983,  983,  985,  986,   27, 1524, 1138,  432,
 /*  1280 */    59,   59,  271,  548,  430,  403,  166,  379,  379,  378,
 /*  1290 */   256,  376,   60,   60,  823, 1187,  540,  551,  274,  551,
 /*  1300 */  1170,  851,  393,  392,  551,  205,  551,  216,  211,  298,
 /*  1310 */   520, 1303,  551,  266,  209,  521, 1316,  297,  275,   61,
 /*  1320 */    61,   62,   62,  451,  993,  205,   45,   45,   46,   46,
 /*  1330 */   105,  105, 1193,  928,   47,   47,  291,  106,  551,  430,
 /*  1340 */   553,  552,  943,  551,  983,  313,  394,  218,  551,  109,
 /*  1350 */   944,  107,  543,  219,    4,  156, 1170,  851,  158,  551,
 /*  1360 */    49,   49,  104,  551,  102,   50,   50,  551,  546, 1315,
 /*  1370 */    63,   63,  551,  443,  217,  983,  983,  985,  986,   27,
 /*  1380 */  1484,   64,   64,  551,  310,   65,   65,  551, 1458,   14,
 /*  1390 */    14,  430, 1457,  551,   66,   66, 1094,  551, 1169,  383,
 /*  1400 */   141,  551,   38,  540,  269,  127,  127,  551,  397,   67,
 /*  1410 */    67,  551,  465,  292,  542,   52,   52,  520,  551,   68,
 /*  1420 */    68, 1043,  519,   69,   69,  315,   95,  322,   97,   53,
 /*  1430 */    53,  993,  975,  151,  151,  244,  437,  105,  105,  200,
 /*  1440 */   152,  152,  455, 1312,  106,  244,  430,  553,  552, 1138,
 /*  1450 */   432,  983,  457,  271,  321,  244,  326,   97,  379,  379,
 /*  1460 */   378,  256,  376,  863,  862,  823,  531,  551,  221,  551,
 /*  1470 */   107,  543,  551,    4,  551,  329,  479, 1043,  216,  240,
 /*  1480 */   298,  331,  983,  983,  985,  986,   27,  546,  297,   76,
 /*  1490 */    76,   54,   54,  333,   72,   72,  128,  128,  870,  871,
 /*  1500 */   107,  543,  551,    4, 1263,  551,  946,  947, 1247,  551,
 /*  1510 */   430,  551,  200, 1055,  551, 1055,  551,  546,  218,  551,
 /*  1520 */   335, 1538,  540,   97,   73,   73,  156,  129,  129,  158,
 /*  1530 */   340,  130,  130,  126,  126,  350,  150,  150,  149,  149,
 /*  1540 */   430,  134,  134,  345, 1039,  217,  937,  240,  901,  244,
 /*  1550 */   993,  109,  540,  344,  987,  551,  105,  105,  908,  351,
 /*  1560 */   551, 1513, 1054,  106, 1054,  430,  553,  552,  551, 1324,
 /*  1570 */   983,  834,   99,  543,  139,    4,  551,  133,  133,  397,
 /*  1580 */   993, 1365,  131,  131,  292,  542,  105,  105, 1299,  546,
 /*  1590 */   132,  132,  287,  106, 1310,  430,  553,  552,   75,   75,
 /*  1600 */   983,  983,  983,  985,  986,   27,  551,  437,  902,  537,
 /*  1610 */   987,  109,  430,  259,  551,  538, 1371, 1228,  474,  551,
 /*  1620 */   198,  551, 1220, 1209,  540, 1208, 1210, 1532,   77,   77,
 /*  1630 */   202,  983,  983,  985,  986,   27,   74,   74, 1296,  353,
 /*  1640 */   355,   43,   43,   48,   48,  357,   11,  380,  214,  343,
 /*  1650 */   303,  442,  993,  312,  305, 1360,  314,  484,  105,  105,
 /*  1660 */   459, 1246,  319,  206, 1430,  106, 1429,  430,  553,  552,
 /*  1670 */   359,  541,  983,  271, 1535, 1187,  168,  248,  379,  379,
 /*  1680 */   378,  256,  376,  201,  193,  823,  373,  194, 1477, 1475,
 /*  1690 */  1184,   79,  404,   82,   83,  453,  178,   95,  216, 1349,
 /*  1700 */   298,  162, 1435,  983,  983,  985,  986,   27,  297, 1354,
 /*  1710 */  1346,   35,  170,  445,  446,  477,  173,  174,  175,  176,
 /*  1720 */   385,  224, 1358, 1361, 1357,  466,  387,   36,  182,  452,
 /*  1730 */   388, 1424,  228,   88,  472,  260,  230, 1446,  218,  187,
 /*  1740 */   475,  328,  231,  390,  324, 1211,  156,  232,  493,  158,
 /*  1750 */   418,   90, 1257, 1266, 1549, 1265, 1264,  855, 1256,  207,
 /*  1760 */   420,  512, 1307, 1548,   94,  217,  352,  391, 1236, 1235,
 /*  1770 */   342, 1234, 1547, 1518,  354,  285,  503,  286,  506,  246,
 /*  1780 */   247, 1504, 1503,  423, 1308,  124,  531, 1306,  356,   10,
 /*  1790 */  1305,  367, 1331,  101,  290,   96,  254,  515, 1217,  397,
 /*  1800 */    34,  554, 1144,  255,  292,  542,  257,  372, 1289,  365,
 /*  1810 */   371,  358, 1288,  197,  258,  555, 1206, 1201, 1462,  153,
 /*  1820 */  1463, 1330, 1461,  154,  137,  283, 1460,  437,  155,  203,
 /*  1830 */   810,  204,   78,  431, 1410,  199,  294,  213,  272,  135,
 /*  1840 */  1053, 1051,  966,  157,  169,  220,  171,  887,  311,  223,
 /*  1850 */  1067,  177,  159,  160,  407,   84,  409,  179,   85,   86,
 /*  1860 */    87,  161, 1070,  225, 1066,  398,  167,  399,   18,  226,
 /*  1870 */   146,  227,  323,  244, 1181,  471,  229, 1059,  183,  184,
 /*  1880 */    37,  825,  344,  476,  233,  336,  488,  480,  185,   89,
 /*  1890 */    19,   20,  485,   92,  853,  339,   91,  163,  866,  147,
 /*  1900 */   284,  495,  502, 1132,  148, 1019,  936, 1102,   39,   93,
 /*  1910 */  1103,   40,  505,  263,  208,  265,  188,  931, 1122,  243,
 /*  1920 */  1126,  109,   33, 1120, 1118,   21, 1106,   22,  527, 1034,
 /*  1930 */    23,   24, 1125,   25,  191,   97,   26, 1020, 1018, 1022,
 /*  1940 */  1076,  250,    7, 1075,  249, 1023,   28,   41,  547,  988,
 /*  1950 */   835,  108,   29,  251,  252, 1540,  374,  897,  377, 1140,
 /*  1960 */  1139, 1197, 1197, 1197, 1197, 1197, 1197, 1539,
};
static const YYCODETYPE yy_lookahead[] = {
 /*     0 */   189,  211,  189,  189,  218,  189,  220,  189,  267,  268,
 /*    10 */   269,  189,  210,  189,  228,  189,  267,  268,  269,   19,
 /*    20 */   218,  189,  211,  212,  211,  212,  211,  211,  212,  211,
 /*    30 */   212,   31,  211,  211,  212,  211,  212,  288,  300,   39,
 /*    40 */    21,  189,  304,   43,   44,   45,   46,   47,   48,   49,

 /*   830 */   110,  111,   46,  233,  189,  189,  291,  248,   99,  189,
 /*   840 */   125,  126,  127,  115,   26,  200,  289,  230,  231,  115,
 /*   850 */   200,   16,  189,  114,  115,  189,  211,  212,  119,  221,
 /*   860 */   189,  211,  212,  258,  101,  102,  103,  104,  105,  106,
 /*   870 */   107,  108,  109,  110,  111,  189,  156,  211,  212,  234,
 /*   880 */   235,  189,  211,  212,  234,  235,   22,  201,  189,  150,
 /*   890 */   151,  152,  247,  248,   76,   16,   19,  247,  248,  113,
 /*   900 */    19,   24,  257,  211,  212,  189,   26,   89,  262,  223,
 /*   910 */    92,  225,   77,  189,   79,  129,   19,   53,  226,  248,
 /*   920 */    43,   44,   45,   46,   47,   48,   49,   50,   51,   52,
 /*   930 */    53,   54,   55,   56,   57,  236,   19,  271,  189,   99,
 /*   940 */    43,   44,   45,   46,   47,   48,   49,   50,   51,   52,
 /*   950 */    53,   54,   55,   56,   57,  115,   77,   59,   79,  119,
 /*   960 */    43,   44,   45,   46,   47,   48,   49,   50,   51,   52,
 /*   970 */    53,   54,   55,   56,   57,  259,   22,   23,  101,  102,
 /*   980 */   103,  104,  105,  106,  107,  108,  109,  110,  111,   59,
 /*   990 */   150,  151,  152,  158,   22,  114,   24,  189,  101,  102,
 /*  1000 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  285,
 /*  1010 */   189,  262,  114,  115,  116,  200,  136,  137,  101,  102,
 /*  1020 */   103,  104,  105,  106,  107,  108,  109,  110,  111,  230,
 /*  1030 */   231,   59,  211,  212,  143,  105,  106,  189,   19,  141,
 /*  1040 */   234,  235,   26,  113,  114,  115,  116,  226,  118,  234,
 /*  1050 */   235,  189,  161,  247,  100,  189,  126,   23,  189,  107,
 /*  1060 */    26,  189,  247,   44,   45,   46,   47,   48,   49,   50,
 /*  1070 */    51,   52,   53,   54,   55,   56,   57,  211,  212,   59,
 /*  1080 */   150,  233,  152,  211,  212,  133,   12,  115,  189,  189,
 /*  1090 */   138,   19,   20,  285,   22,  233,   76,  127,  226,   11,
 /*  1100 */   208,   27,   22,   23,  200,  236,   26,   87,   36,   89,
 /*  1110 */   211,  212,   92,  300,  248,  189,   42,  304,  189,  149,
 /*  1120 */   101,  102,  103,  104,  105,  106,  107,  108,  109,  110,
 /*  1130 */   111,   59,  200,  233,  114,  115,  116,   63,  234,  235,
 /*  1140 */   124,   19,   20,   71,   22,  300,   46,   73,  200,  304,
 /*  1150 */   116,  247,  244,   81,  246,  200,  227,  300,   36,  234,
 /*  1160 */   235,  304,   23,  143,  200,   26,  234,  235,  194,  200,
 /*  1170 */    48,   99,  247,   66,  189,  141,  284,  105,  106,  247,
 /*  1180 */   100,   59,  234,  235,  112,  259,  114,  115,  116,  234,
 /*  1190 */   235,  119,   85,   71,  266,  247,  211,  212,  234,  235,
 /*  1200 */   189,   94,  247,  234,  235,   12,  266,   85,  136,  137,
 /*  1210 */   189,  247,   90,  113,  126,  127,  247,  189,   26,   22,
 /*  1220 */    27,   99,  150,  151,  152,  153,  154,  105,  106,  189,
 /*  1230 */   302,  303,  211,  212,  112,   42,  114,  115,  116,  211,
 /*  1240 */   212,  119,  302,  303,   19,   20,  189,   22,  274,  189,
 /*  1250 */    15,  144,  278,  189,   22,   23,   63,  189,  189,  203,
 /*  1260 */   204,   36,  203,  204,  189,   24,  136,  137,  211,  212,
 /*  1270 */   189,  235,  150,  151,  152,  153,  154,    0,    1,    2,
 /*  1280 */   211,  212,    5,  247,   59,  292,  293,   10,   11,   12,
 /*  1290 */    13,   14,  211,  212,   17,   60,   71,  189,  258,  189,
 /*  1300 */    59,   59,  105,  106,  189,   26,  189,   30,  116,   32,
 /*  1310 */    85,  253,  189,  251,  252,   90,  189,   40,  258,  211,
 /*  1320 */   212,  211,  212,  127,   99,   26,  211,  212,  211,  212,
 /*  1330 */   105,  106,  100,  141,  211,  212,  239,  112,  189,  114,
 /*  1340 */   115,  116,   31,  189,  119,  149,  249,   70,  189,   26,
 /*  1350 */    39,   19,   20,   24,   22,   78,  115,  115,   81,  189,
 /*  1360 */   211,  212,  155,  189,  157,  211,  212,  189,   36,  189,
 /*  1370 */   211,  212,  189,  189,   97,  150,  151,  152,  153,  154,
 /*  1380 */   189,  211,  212,  189,  189,  211,  212,  189,  189,  211,
 /*  1390 */   212,   59,  189,  189,  211,  212,   23,  189,   26,   26,
 /*  1400 */    22,  189,   24,   71,   22,  211,  212,  189,  131,  211,
 /*  1410 */   212,  189,  189,  136,  137,  211,  212,   85,  189,  211,
 /*  1420 */   212,   59,   90,  211,  212,   23,  147,  189,   26,  211,
 /*  1430 */   212,   99,   23,  211,  212,   26,  159,  105,  106,  140,
 /*  1440 */   211,  212,   23,  189,  112,   26,  114,  115,  116,    1,
 /*  1450 */     2,  119,   23,    5,   23,   26,  189,   26,   10,   11,
 /*  1460 */    12,   13,   14,  118,  119,   17,  143,  189,  139,  189,
 /*  1470 */    19,   20,  189,   22,  189,  189,   23,  115,   30,   26,
 /*  1480 */    32,  189,  150,  151,  152,  153,  154,   36,   40,  211,
 /*  1490 */   212,  211,  212,  189,  211,  212,  211,  212,    7,    8,
 /*  1500 */    19,   20,  189,   22,  189,  189,   83,   84,  189,  189,
 /*  1510 */    59,  189,  140,  150,  189,  152,  189,   36,   70,  189,
 /*  1520 */    23,  139,   71,   26,  211,  212,   78,  211,  212,   81,
 /*  1530 */   189,  211,  212,  211,  212,  189,  211,  212,  211,  212,
 /*  1540 */    59,  211,  212,  119,   23,   97,   23,   26,   23,   26,
 /*  1550 */    99,   26,   71,  129,   59,  189,  105,  106,  107,  189,
 /*  1560 */   189,  309,  150,  112,  152,  114,  115,  116,  189,  189,
 /*  1570 */   119,   23,   19,   20,   26,   22,  189,  211,  212,  131,
 /*  1580 */    99,  189,  211,  212,  136,  137,  105,  106,  189,   36,
 /*  1590 */   211,  212,  250,  112,  189,  114,  115,  116,  211,  212,
 /*  1600 */   119,  150,  151,  152,  153,  154,  189,  159,   23,  189,
 /*  1610 */   115,   26,   59,  280,  189,  231,  189,  189,  281,  189,
 /*  1620 */   237,  189,  189,  189,   71,  189,  189,  189,  211,  212,
 /*  1630 */   209,  150,  151,  152,  153,  154,  211,  212,  250,  250,
 /*  1640 */   250,  211,  212,  211,  212,  250,  238,  187,  290,  214,
 /*  1650 */   240,  254,   99,  286,  254,  241,  241,  215,  105,  106,
 /*  1660 */   286,  220,  240,  224,  214,  112,  214,  114,  115,  116,
 /*  1670 */   254,  273,  119,    5,  192,   60,  290,  139,   10,   11,
 /*  1680 */    12,   13,   14,  238,  244,   17,  240,  244,  196,  196,
 /*  1690 */    38,  287,  196,  287,  148,  113,   22,  147,   30,  241,
 /*  1700 */    32,   43,  276,  150,  151,  152,  153,  154,   40,  265,
 /*  1710 */   241,  264,  229,   18,  196,   18,  232,  232,  232,  232,
 /*  1720 */   241,  195,  265,  229,  265,  196,  265,  264,  229,  241,
 /*  1730 */   241,  241,  195,  155,   62,  196,  195,  283,   70,   22,
 /*  1740 */   216,  196,  195,  216,  282,  196,   78,  195,  113,   81,
 /*  1750 */    64,   22,  222,  213,  219,  213,  213,  124,  222,  162,
 /*  1760 */   111,  142,  256,  219,  113,   97,  255,  216,  213,  215,
 /*  1770 */   213,  213,  213,  303,  255,  275,  216,  275,  216,  196,
 /*  1780 */    91,  308,  308,   82,  256,  146,  143,  256,  255,   22,
 /*  1790 */   256,  196,  260,  155,  272,  145,   25,  144,  199,  131,
 /*  1800 */    26,  198,   13,  190,  136,  137,  190,  241,  245,  244,
 /*  1810 */   242,  255,  245,  243,    6,  188,  188,  188,  208,  202,
 /*  1820 */   208,  260,  208,  202,  217,  217,  208,  159,  202,  209,
 /*  1830 */     4,  209,  208,    3,  270,   22,  160,   15,   98,   16,
 /*  1840 */    23,   23,  137,  128,  148,   24,  140,   20,   16,  142,
 /*  1850 */     1,  140,  128,  128,   61,   53,   37,  148,   53,   53,
 /*  1860 */    53,  128,  114,   34,    1,  296,  293,  296,   22,  139,
 /*  1870 */     5,  113,  158,   26,   75,   41,  139,   68,   68,  113,
 /*  1880 */    24,   20,  129,   19,  123,   23,   96,   67,   22,   22,
 /*  1890 */    22,   22,   67,  147,   59,   24,   22,   37,   28,   23,
 /*  1900 */    67,   22,   24,   23,   23,   23,  114,   23,   22,   26,
 /*  1910 */    23,   22,   24,   23,  139,   23,   22,  141,   75,   34,
 /*  1920 */    75,   26,   22,   86,   88,   34,   23,   34,   24,   23,
 /*  1930 */    34,   34,   93,   34,   26,   26,   34,   23,   23,   23,
 /*  1940 */    23,   22,   44,   23,   26,   11,   22,   22,   26,   23,
 /*  1950 */    23,   22,   22,  139,  139,  139,   23,  133,   15,    1,
 /*  1960 */     1,  310,  310,  310,  310,  310,  310,  139,  310,  310,

 /*  1970 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  1980 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  1990 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2000 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2010 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2020 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2030 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2040 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2050 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2060 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2070 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2080 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2090 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2100 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2110 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2120 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2130 */   310,  310,  310,  310,  310,  310,  310,  310,  310,  310,
 /*  2140 */   310,  310,  310,  310,  310,  310,  310,  310,  310,
};
#define YY_SHIFT_COUNT    (557)
#define YY_SHIFT_MIN      (0)
#define YY_SHIFT_MAX      (1959)
static const unsigned short int yy_shift_ofst[] = {
 /*     0 */  1448, 1277, 1668, 1072, 1072,  340, 1122, 1225, 1332, 1481,
 /*    10 */  1481, 1481,  335,    0,    0,  180,  897, 1481, 1481, 1481,
 /*    20 */  1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481,
 /*    30 */   930,  930, 1020, 1020,  290,    1,  340,  340,  340,  340,
 /*    40 */   340,  340,   40,  110,  219,  288,  327,  396,  435,  504,
 /*    50 */   543,  612,  651,  720,  877,  897,  897,  897,  897,  897,
 /*    60 */   897,  897,  897,  897,  897,  897,  897,  897,  897,  897,
 /*    70 */   897,  897,  897,  917,  897, 1019,  763,  763, 1451, 1481,
 /*    80 */  1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481,
 /*    90 */  1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481,
 /*   100 */  1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481, 1481,
 /*   110 */  1481, 1481, 1553, 1481, 1481, 1481, 1481, 1481, 1481, 1481,
 /*   120 */  1481, 1481, 1481, 1481, 1481, 1481,  147,  258,  258,  258,
 /*   130 */   258,  258,   79,   65,   84,  449,   19,  786,  449,  636,
 /*   140 */   636,  449,  880,  880,  880,  880,  113,  142,  142,  472,
 /*   150 */   150, 1968, 1968,  399,  399,  399,   93,  237,  341,  237,
 /*   160 */   237,  237, 1074, 1074,  437,  350,  704, 1080,  449,  449,
 /*   170 */   449,  449,  449,  449,  449,  449,  449,  449,  449,  449,
 /*   180 */   449,  449,  449,  449,  449,  449,  449,  449,  449,  818,
 /*   190 */   818,  449, 1088,  217,  217,  734,  734,  891, 1130, 1968,
 /*   200 */  1968, 1968,  739,  840,  840,  453,  454,  511,  187,  563,
 /*   210 */   570,  898,  669,  449,  449,  449,  449,  449,  449,  449,
 /*   220 */   449,  449,  670,  449,  449,  449,  449,  449,  449,  449,
 /*   230 */   449,  449,  449,  449,  449,  674,  674,  674,  449,  449,
 /*   240 */   449,  449, 1034,  449,  449,  449,  972, 1107,  449,  449,
 /*   250 */  1193,  449,  449,  449,  449,  449,  449,  449,  449,  260,
 /*   260 */   177,  489, 1241, 1241, 1241, 1241, 1192,  489,  489,  952,
 /*   270 */  1197,  625, 1235, 1299,  181,  181,  881, 1279, 1279, 1299,
 /*   280 */   881, 1016, 1139, 1100, 1311, 1311, 1311,  181, 1323, 1323,
 /*   290 */  1207, 1372,  549, 1378, 1615, 1538, 1538, 1652, 1652, 1538,
 /*   300 */  1546, 1582, 1674, 1550, 1658, 1550, 1695, 1695, 1695, 1695,
 /*   310 */  1538, 1697, 1550, 1582, 1582, 1550, 1582, 1674, 1658, 1550,
 /*   320 */  1658, 1550, 1538, 1697, 1578, 1672, 1538, 1697, 1717, 1538,
 /*   330 */  1697, 1538, 1697, 1717, 1635, 1635, 1635, 1686, 1729, 1729,
 /*   340 */  1717, 1635, 1633, 1635, 1686, 1635, 1635, 1597, 1717, 1649,
 /*   350 */  1649, 1717, 1619, 1651, 1619, 1651, 1619, 1651, 1619, 1651,
 /*   360 */  1538, 1689, 1689, 1701, 1701, 1639, 1643, 1767, 1538, 1638,
 /*   370 */  1639, 1650, 1653, 1550, 1771, 1774, 1789, 1789, 1808, 1808,
 /*   380 */  1808, 1968, 1968, 1968, 1968, 1968, 1968, 1968, 1968, 1968,
 /*   390 */  1968, 1968, 1968, 1968, 1968, 1968,  308,  835,  954, 1232,
 /*   400 */   879,  715,  728, 1373,  864, 1329,  970, 1196, 1402,  297,
 /*   410 */  1409, 1419, 1429, 1431, 1453, 1497, 1242, 1345, 1491, 1424,
 /*   420 */  1362, 1521, 1523, 1423, 1525, 1363, 1412, 1548, 1585, 1495,
 /*   430 */  1382, 1826, 1830, 1813, 1676, 1822, 1740, 1823, 1817, 1818,
 /*   440 */  1705, 1696, 1715, 1821, 1706, 1827, 1707, 1832, 1849, 1711,
 /*   450 */  1724, 1725, 1793, 1819, 1709, 1802, 1805, 1806, 1807, 1733,
 /*   460 */  1748, 1829, 1730, 1863, 1865, 1846, 1758, 1714, 1809, 1847,
 /*   470 */  1810, 1799, 1834, 1737, 1766, 1856, 1861, 1864, 1753, 1761,
 /*   480 */  1866, 1820, 1867, 1868, 1862, 1869, 1825, 1835, 1871, 1790,
 /*   490 */  1870, 1874, 1833, 1860, 1876, 1746, 1879, 1880, 1881, 1882,
 /*   500 */  1883, 1884, 1886, 1878, 1887, 1889, 1888, 1775, 1890, 1892,
 /*   510 */  1792, 1885, 1894, 1776, 1895, 1891, 1893, 1896, 1897, 1836,
 /*   520 */  1843, 1837, 1898, 1845, 1839, 1899, 1903, 1900, 1904, 1908,
 /*   530 */  1909, 1902, 1906, 1895, 1914, 1915, 1916, 1917, 1918, 1920,
 /*   540 */  1919, 1934, 1924, 1925, 1926, 1927, 1929, 1930, 1922, 1824,
 /*   550 */  1814, 1815, 1816, 1828, 1933, 1943, 1958, 1959,
};
#define YY_REDUCE_COUNT (395)
#define YY_REDUCE_MIN   (-262)
#define YY_REDUCE_MAX   (1629)
static const short yy_reduce_ofst[] = {
 /*     0 */   490, -122,  545,  645,  650, -120, -189, -187, -184, -182,
 /*    10 */  -178, -176,   45,   30,  200, -251, -134,  390,  392,  521,
 /*    20 */   523,  213,  692,  821,  284,  589,  872,  666,  671,  866,
 /*    30 */    71,  111,  273,  389,  686,  815,  904,  932,  948,  955,
 /*    40 */   964,  969, -259, -259, -259, -259, -259, -259, -259, -259,
 /*    50 */  -259, -259, -259, -259, -259, -259, -259, -259, -259, -259,
 /*    60 */  -259, -259, -259, -259, -259, -259, -259, -259, -259, -259,
 /*    70 */  -259, -259, -259, -259, -259, -259, -259, -259,  428,  430,
 /*    80 */   899,  985, 1021, 1028, 1057, 1069, 1081, 1108, 1110, 1115,
 /*    90 */  1117, 1123, 1149, 1154, 1159, 1170, 1174, 1178, 1183, 1194,
 /*   100 */  1198, 1204, 1208, 1212, 1218, 1222, 1229, 1278, 1280, 1283,
 /*   110 */  1285, 1313, 1316, 1320, 1322, 1325, 1327, 1330, 1366, 1371,
 /*   120 */  1379, 1387, 1417, 1425, 1430, 1432, -259, -259, -259, -259,
 /*   130 */  -259, -259, -259, -259, -259,  557,  974, -214, -174,   -9,
 /*   140 */   431, -124,  806,  925,  806,  925,  251,  928,  940, -259,
 /*   150 */  -259, -259, -259, -198, -198, -198,  127, -186, -168,  212,
 /*   160 */   646,  749,  617,  799, -262,  555,  220,  220,  491,  605,
 /*   170 */  1040, 1060,  699,  -11,  600,  848,  862,  345, -129,  724,
 /*   180 */   -91,  158,  808,  716,  900,  304,  869,  929,  926,  499,
 /*   190 */   813,  322,  892,  845,  857, 1056, 1059,  908, 1036,  993,
 /*   200 */  1062, 1097, -210, -185, -179, -148, -167,  -89,  121,  274,
 /*   210 */   281,  320,  336,  439,  663, 1011, 1064, 1068, 1075, 1127,
 /*   220 */  1180, 1184, -196, 1191, 1195, 1199, 1203, 1223, 1238, 1254,
 /*   230 */  1267, 1286, 1292, 1304, 1315,  205,  422,  638, 1319, 1341,
 /*   240 */  1346, 1370, 1058, 1380, 1392, 1399, 1342, 1252, 1405, 1420,
 /*   250 */  1384, 1427,  121, 1428, 1433, 1434, 1436, 1437, 1438, 1337,
 /*   260 */  1333, 1383, 1388, 1389, 1390, 1395, 1058, 1383, 1383, 1408,
 /*   270 */  1421, 1460, 1358, 1410, 1397, 1400, 1367, 1414, 1415, 1422,
 /*   280 */  1374, 1442, 1439, 1441, 1435, 1450, 1452, 1416, 1440, 1443,
 /*   290 */  1398, 1446, 1445, 1482, 1386, 1492, 1493, 1404, 1406, 1496,
 /*   300 */  1426, 1444, 1447, 1458, 1483, 1469, 1484, 1485, 1486, 1487,
 /*   310 */  1518, 1526, 1479, 1457, 1459, 1488, 1461, 1463, 1494, 1489,
 /*   320 */  1499, 1490, 1529, 1537, 1454, 1462, 1539, 1541, 1524, 1545,
 /*   330 */  1547, 1549, 1552, 1527, 1540, 1542, 1543, 1530, 1535, 1544,
 /*   340 */  1551, 1555, 1554, 1557, 1536, 1558, 1559, 1470, 1560, 1500,
 /*   350 */  1502, 1562, 1506, 1511, 1528, 1519, 1531, 1533, 1534, 1556,
 /*   360 */  1583, 1473, 1474, 1532, 1561, 1563, 1565, 1564, 1595, 1522,
 /*   370 */  1567, 1570, 1568, 1566, 1599, 1603, 1613, 1616, 1627, 1628,
 /*   380 */  1629, 1569, 1571, 1573, 1617, 1610, 1612, 1614, 1618, 1621,
 /*   390 */  1607, 1608, 1620, 1622, 1624, 1626,
};
static const YYACTIONTYPE yy_default[] = {
 /*     0 */  1583, 1583, 1583, 1419, 1195, 1304, 1195, 1195, 1195, 1419,
 /*    10 */  1419, 1419, 1195, 1334, 1334, 1472, 1226, 1195, 1195, 1195,
 /*    20 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1418, 1195, 1195,
 /*    30 */  1195, 1195, 1502, 1502, 1195, 1195, 1195, 1195, 1195, 1195,
 /*    40 */  1195, 1195, 1195, 1343, 1195, 1195, 1195, 1195, 1195, 1195,
 /*    50 */  1420, 1421, 1195, 1195, 1195, 1471, 1473, 1436, 1353, 1352,
 /*    60 */  1351, 1350, 1454, 1321, 1348, 1341, 1345, 1414, 1415, 1413,
 /*    70 */  1417, 1421, 1420, 1195, 1344, 1385, 1399, 1384, 1195, 1195,
 /*    80 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
 /*    90 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
 /*   100 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
 /*   110 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
 /*   120 */  1195, 1195, 1195, 1195, 1195, 1195, 1393, 1398, 1404, 1397,
 /*   130 */  1394, 1387, 1386, 1388, 1389, 1195, 1216, 1268, 1195, 1195,
 /*   140 */  1195, 1195, 1490, 1489, 1195, 1195, 1226, 1379, 1378, 1390,
 /*   150 */  1391, 1401, 1400, 1479, 1537, 1536, 1437, 1195, 1195, 1195,
 /*   160 */  1195, 1195, 1195, 1195, 1502, 1195, 1195, 1195, 1195, 1195,
 /*   170 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
 /*   180 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1502,
 /*   190 */  1502, 1195, 1226, 1502, 1502, 1222, 1222, 1328, 1195, 1485,
 /*   200 */  1304, 1295, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
 /*   210 */  1195, 1195, 1195, 1195, 1195, 1195, 1476, 1474, 1195, 1195,
 /*   220 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
 /*   230 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
 /*   240 */  1195, 1195, 1195, 1195, 1195, 1195, 1300, 1195, 1195, 1195,
 /*   250 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1531, 1195,
 /*   260 */  1449, 1282, 1300, 1300, 1300, 1300, 1302, 1283, 1281, 1294,
 /*   270 */  1227, 1202, 1575, 1301, 1323, 1323, 1572, 1347, 1347, 1301,
 /*   280 */  1572, 1243, 1553, 1238, 1334, 1334, 1334, 1323, 1328, 1328,
 /*   290 */  1416, 1301, 1294, 1195, 1575, 1309, 1309, 1574, 1574, 1309,
 /*   300 */  1437, 1356, 1363, 1347, 1271, 1347, 1277, 1277, 1277, 1277,
 /*   310 */  1309, 1213, 1347, 1356, 1356, 1347, 1356, 1363, 1271, 1347,
 /*   320 */  1271, 1347, 1309, 1213, 1453, 1569, 1309, 1213, 1427, 1309,
 /*   330 */  1213, 1309, 1213, 1427, 1269, 1269, 1269, 1258, 1195, 1195,
 /*   340 */  1427, 1269, 1243, 1269, 1258, 1269, 1269, 1520, 1427, 1431,
 /*   350 */  1431, 1427, 1327, 1322, 1327, 1322, 1327, 1322, 1327, 1322,
 /*   360 */  1309, 1512, 1512, 1337, 1337, 1342, 1328, 1422, 1309, 1195,
 /*   370 */  1342, 1340, 1338, 1347, 1219, 1261, 1534, 1534, 1530, 1530,
 /*   380 */  1530, 1580, 1580, 1485, 1546, 1226, 1226, 1226, 1226, 1546,
 /*   390 */  1245, 1245, 1227, 1227, 1226, 1546, 1195, 1195, 1195, 1195,
 /*   400 */  1195, 1195, 1541, 1195, 1438, 1313, 1195, 1195, 1195, 1195,
 /*   410 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
 /*   420 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
 /*   430 */  1368, 1195, 1198, 1482, 1195, 1195, 1480, 1195, 1195, 1195,
 /*   440 */  1195, 1195, 1195, 1314, 1195, 1195, 1195, 1195, 1195, 1195,
 /*   450 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
 /*   460 */  1195, 1195, 1571, 1195, 1195, 1195, 1195, 1195, 1195, 1452,
 /*   470 */  1451, 1195, 1195, 1311, 1195, 1195, 1195, 1195, 1195, 1195,
 /*   480 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1241, 1195, 1195,
 /*   490 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
 /*   500 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195,
 /*   510 */  1195, 1195, 1195, 1195, 1339, 1195, 1195, 1195, 1195, 1195,
 /*   520 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1517,
 /*   530 */  1329, 1195, 1195, 1562, 1195, 1195, 1195, 1195, 1195, 1195,
 /*   540 */  1195, 1195, 1195, 1195, 1195, 1195, 1195, 1195, 1557, 1285,
 /*   550 */  1370, 1195, 1369, 1373, 1195, 1207, 1195, 1195,
};
/********** 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.

 /* 152 */ "setlist ::= setlist COMMA nm EQ expr",
 /* 153 */ "setlist ::= setlist COMMA LP idlist RP EQ expr",
 /* 154 */ "setlist ::= nm EQ expr",
 /* 155 */ "setlist ::= LP idlist RP EQ expr",
 /* 156 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert",
 /* 157 */ "cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES",
 /* 158 */ "upsert ::=",
 /* 159 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert",
 /* 160 */ "upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert",
 /* 161 */ "upsert ::= ON CONFLICT DO NOTHING",
 /* 162 */ "upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt",
 /* 163 */ "insert_cmd ::= INSERT orconf",
 /* 164 */ "insert_cmd ::= REPLACE",
 /* 165 */ "idlist_opt ::=",
 /* 166 */ "idlist_opt ::= LP idlist RP",
 /* 167 */ "idlist ::= idlist COMMA nm",
 /* 168 */ "idlist ::= nm",
 /* 169 */ "expr ::= LP expr RP",
 /* 170 */ "expr ::= ID|INDEXED",
 /* 171 */ "expr ::= JOIN_KW",
 /* 172 */ "expr ::= nm DOT nm",
 /* 173 */ "expr ::= nm DOT nm DOT nm",
 /* 174 */ "term ::= NULL|FLOAT|BLOB",
 /* 175 */ "term ::= STRING",
 /* 176 */ "term ::= INTEGER",
 /* 177 */ "expr ::= VARIABLE",
 /* 178 */ "expr ::= expr COLLATE ID|STRING",
 /* 179 */ "expr ::= CAST LP expr AS typetoken RP",
 /* 180 */ "expr ::= ID|INDEXED LP distinct exprlist RP",
 /* 181 */ "expr ::= ID|INDEXED LP STAR RP",
 /* 182 */ "expr ::= ID|INDEXED LP distinct exprlist RP filter_over",
 /* 183 */ "expr ::= ID|INDEXED LP STAR RP filter_over",
 /* 184 */ "term ::= CTIME_KW",
 /* 185 */ "expr ::= LP nexprlist COMMA expr RP",
 /* 186 */ "expr ::= expr AND expr",
 /* 187 */ "expr ::= expr OR expr",
 /* 188 */ "expr ::= expr LT|GT|GE|LE expr",
 /* 189 */ "expr ::= expr EQ|NE expr",
 /* 190 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr",
 /* 191 */ "expr ::= expr PLUS|MINUS expr",
 /* 192 */ "expr ::= expr STAR|SLASH|REM expr",
 /* 193 */ "expr ::= expr CONCAT expr",
 /* 194 */ "likeop ::= NOT LIKE_KW|MATCH",

 /* 195 */ "expr ::= expr likeop expr",
 /* 196 */ "expr ::= expr likeop expr ESCAPE expr",
 /* 197 */ "expr ::= expr ISNULL|NOTNULL",
 /* 198 */ "expr ::= expr NOT NULL",
 /* 199 */ "expr ::= expr IS expr",
 /* 200 */ "expr ::= expr IS NOT expr",
 /* 201 */ "expr ::= NOT expr",
 /* 202 */ "expr ::= BITNOT expr",
 /* 203 */ "expr ::= PLUS|MINUS expr",
 /* 204 */ "between_op ::= BETWEEN",
 /* 205 */ "between_op ::= NOT BETWEEN",
 /* 206 */ "expr ::= expr between_op expr AND expr",
 /* 207 */ "in_op ::= IN",
 /* 208 */ "in_op ::= NOT IN",
 /* 209 */ "expr ::= expr in_op LP exprlist RP",
 /* 210 */ "expr ::= LP select RP",
 /* 211 */ "expr ::= expr in_op LP select RP",
 /* 212 */ "expr ::= expr in_op nm dbnm paren_exprlist",
 /* 213 */ "expr ::= EXISTS LP select RP",
 /* 214 */ "expr ::= CASE case_operand case_exprlist case_else END",
 /* 215 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr",
 /* 216 */ "case_exprlist ::= WHEN expr THEN expr",

 /* 217 */ "case_else ::= ELSE expr",
 /* 218 */ "case_else ::=",
 /* 219 */ "case_operand ::= expr",
 /* 220 */ "case_operand ::=",
 /* 221 */ "exprlist ::=",
 /* 222 */ "nexprlist ::= nexprlist COMMA expr",
 /* 223 */ "nexprlist ::= expr",
 /* 224 */ "paren_exprlist ::=",
 /* 225 */ "paren_exprlist ::= LP exprlist RP",
 /* 226 */ "cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt",
 /* 227 */ "uniqueflag ::= UNIQUE",
 /* 228 */ "uniqueflag ::=",
 /* 229 */ "eidlist_opt ::=",
 /* 230 */ "eidlist_opt ::= LP eidlist RP",
 /* 231 */ "eidlist ::= eidlist COMMA nm collate sortorder",
 /* 232 */ "eidlist ::= nm collate sortorder",
 /* 233 */ "collate ::=",
 /* 234 */ "collate ::= COLLATE ID|STRING",
 /* 235 */ "cmd ::= DROP INDEX ifexists fullname",
 /* 236 */ "cmd ::= VACUUM vinto",
 /* 237 */ "cmd ::= VACUUM nm vinto",

 /* 238 */ "vinto ::= INTO expr",
 /* 239 */ "vinto ::=",
 /* 240 */ "cmd ::= PRAGMA nm dbnm",
 /* 241 */ "cmd ::= PRAGMA nm dbnm EQ nmnum",
 /* 242 */ "cmd ::= PRAGMA nm dbnm LP nmnum RP",
 /* 243 */ "cmd ::= PRAGMA nm dbnm EQ minus_num",
 /* 244 */ "cmd ::= PRAGMA nm dbnm LP minus_num RP",
 /* 245 */ "plus_num ::= PLUS INTEGER|FLOAT",
 /* 246 */ "minus_num ::= MINUS INTEGER|FLOAT",
 /* 247 */ "cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END",
 /* 248 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause",

 /* 249 */ "trigger_time ::= BEFORE|AFTER",
 /* 250 */ "trigger_time ::= INSTEAD OF",
 /* 251 */ "trigger_time ::=",
 /* 252 */ "trigger_event ::= DELETE|INSERT",
 /* 253 */ "trigger_event ::= UPDATE",
 /* 254 */ "trigger_event ::= UPDATE OF idlist",
 /* 255 */ "when_clause ::=",
 /* 256 */ "when_clause ::= WHEN expr",
 /* 257 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI",
 /* 258 */ "trigger_cmd_list ::= trigger_cmd SEMI",
 /* 259 */ "trnm ::= nm DOT nm",
 /* 260 */ "tridxby ::= INDEXED BY nm",
 /* 261 */ "tridxby ::= NOT INDEXED",
 /* 262 */ "trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt",
 /* 263 */ "trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt",
 /* 264 */ "trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt",
 /* 265 */ "trigger_cmd ::= scanpt select scanpt",
 /* 266 */ "expr ::= RAISE LP IGNORE RP",
 /* 267 */ "expr ::= RAISE LP raisetype COMMA nm RP",
 /* 268 */ "raisetype ::= ROLLBACK",
 /* 269 */ "raisetype ::= ABORT",
 /* 270 */ "raisetype ::= FAIL",
 /* 271 */ "cmd ::= DROP TRIGGER ifexists fullname",
 /* 272 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt",
 /* 273 */ "cmd ::= DETACH database_kw_opt expr",

 /* 274 */ "key_opt ::=",
 /* 275 */ "key_opt ::= KEY expr",
 /* 276 */ "cmd ::= REINDEX",
 /* 277 */ "cmd ::= REINDEX nm dbnm",
 /* 278 */ "cmd ::= ANALYZE",
 /* 279 */ "cmd ::= ANALYZE nm dbnm",
 /* 280 */ "cmd ::= ALTER TABLE fullname RENAME TO nm",
 /* 281 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist",
 /* 282 */ "add_column_fullname ::= fullname",
 /* 283 */ "cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm",
 /* 284 */ "cmd ::= create_vtab",
 /* 285 */ "cmd ::= create_vtab LP vtabarglist RP",
 /* 286 */ "create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm",
 /* 287 */ "vtabarg ::=",
 /* 288 */ "vtabargtoken ::= ANY",
 /* 289 */ "vtabargtoken ::= lp anylist RP",
 /* 290 */ "lp ::= LP",
 /* 291 */ "with ::= WITH wqlist",
 /* 292 */ "with ::= WITH RECURSIVE wqlist",
 /* 293 */ "wqlist ::= nm eidlist_opt AS LP select RP",
 /* 294 */ "wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP",
 /* 295 */ "windowdefn_list ::= windowdefn",
 /* 296 */ "windowdefn_list ::= windowdefn_list COMMA windowdefn",
 /* 297 */ "windowdefn ::= nm AS LP window RP",
 /* 298 */ "window ::= PARTITION BY nexprlist orderby_opt frame_opt",
 /* 299 */ "window ::= nm PARTITION BY nexprlist orderby_opt frame_opt",
 /* 300 */ "window ::= ORDER BY sortlist frame_opt",
 /* 301 */ "window ::= nm ORDER BY sortlist frame_opt",

 /* 302 */ "window ::= frame_opt",
 /* 303 */ "window ::= nm frame_opt",
 /* 304 */ "frame_opt ::=",
 /* 305 */ "frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt",
 /* 306 */ "frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt",
 /* 307 */ "range_or_rows ::= RANGE|ROWS|GROUPS",
 /* 308 */ "frame_bound_s ::= frame_bound",
 /* 309 */ "frame_bound_s ::= UNBOUNDED PRECEDING",
 /* 310 */ "frame_bound_e ::= frame_bound",
 /* 311 */ "frame_bound_e ::= UNBOUNDED FOLLOWING",
 /* 312 */ "frame_bound ::= expr PRECEDING|FOLLOWING",
 /* 313 */ "frame_bound ::= CURRENT ROW",
 /* 314 */ "frame_exclude_opt ::=",
 /* 315 */ "frame_exclude_opt ::= EXCLUDE frame_exclude",
 /* 316 */ "frame_exclude ::= NO OTHERS",
 /* 317 */ "frame_exclude ::= CURRENT ROW",
 /* 318 */ "frame_exclude ::= GROUP|TIES",
 /* 319 */ "window_clause ::= WINDOW windowdefn_list",
 /* 320 */ "filter_over ::= filter_clause over_clause",
 /* 321 */ "filter_over ::= over_clause",
 /* 322 */ "filter_over ::= filter_clause",
 /* 323 */ "over_clause ::= OVER LP window RP",
 /* 324 */ "over_clause ::= OVER nm",
 /* 325 */ "filter_clause ::= FILTER LP WHERE expr RP",
 /* 326 */ "input ::= cmdlist",
 /* 327 */ "cmdlist ::= cmdlist ecmd",
 /* 328 */ "cmdlist ::= ecmd",

 /* 329 */ "ecmd ::= SEMI",
 /* 330 */ "ecmd ::= cmdx SEMI",
 /* 331 */ "ecmd ::= explain cmdx SEMI",
 /* 332 */ "trans_opt ::=",
 /* 333 */ "trans_opt ::= TRANSACTION",
 /* 334 */ "trans_opt ::= TRANSACTION nm",
 /* 335 */ "savepoint_opt ::= SAVEPOINT",
 /* 336 */ "savepoint_opt ::=",
 /* 337 */ "cmd ::= create_table create_table_args",
 /* 338 */ "columnlist ::= columnlist COMMA columnname carglist",
 /* 339 */ "columnlist ::= columnname carglist",
 /* 340 */ "nm ::= ID|INDEXED",
 /* 341 */ "nm ::= STRING",
 /* 342 */ "nm ::= JOIN_KW",
 /* 343 */ "typetoken ::= typename",
 /* 344 */ "typename ::= ID|STRING",
 /* 345 */ "signed ::= plus_num",
 /* 346 */ "signed ::= minus_num",
 /* 347 */ "carglist ::= carglist ccons",
 /* 348 */ "carglist ::=",
 /* 349 */ "ccons ::= NULL onconf",
 /* 350 */ "ccons ::= GENERATED ALWAYS AS generated",
 /* 351 */ "ccons ::= AS generated",
 /* 352 */ "conslist_opt ::= COMMA conslist",
 /* 353 */ "conslist ::= conslist tconscomma tcons",
 /* 354 */ "conslist ::= tcons",
 /* 355 */ "tconscomma ::=",
 /* 356 */ "defer_subclause_opt ::= defer_subclause",
 /* 357 */ "resolvetype ::= raisetype",
 /* 358 */ "selectnowith ::= oneselect",
 /* 359 */ "oneselect ::= values",
 /* 360 */ "sclp ::= selcollist COMMA",
 /* 361 */ "as ::= ID|STRING",
 /* 362 */ "expr ::= term",
 /* 363 */ "likeop ::= LIKE_KW|MATCH",
 /* 364 */ "exprlist ::= nexprlist",

 /* 365 */ "nmnum ::= plus_num",
 /* 366 */ "nmnum ::= nm",
 /* 367 */ "nmnum ::= ON",
 /* 368 */ "nmnum ::= DELETE",
 /* 369 */ "nmnum ::= DEFAULT",
 /* 370 */ "plus_num ::= INTEGER|FLOAT",
 /* 371 */ "foreach_clause ::=",
 /* 372 */ "foreach_clause ::= FOR EACH ROW",
 /* 373 */ "trnm ::= nm",
 /* 374 */ "tridxby ::=",
 /* 375 */ "database_kw_opt ::= DATABASE",
 /* 376 */ "database_kw_opt ::=",
 /* 377 */ "kwcolumn_opt ::=",
 /* 378 */ "kwcolumn_opt ::= COLUMNKW",
 /* 379 */ "vtabarglist ::= vtabarg",
 /* 380 */ "vtabarglist ::= vtabarglist COMMA vtabarg",
 /* 381 */ "vtabarg ::= vtabarg vtabargtoken",
 /* 382 */ "anylist ::=",
 /* 383 */ "anylist ::= anylist LP anylist RP",
 /* 384 */ "anylist ::= anylist ANY",
 /* 385 */ "with ::=",
};
#endif /* NDEBUG */


#if YYSTACKDEPTH<=0
/*
** Try to increase the size of the parser stack.  Return the number

   262,  /* (152) setlist ::= setlist COMMA nm EQ expr */
   262,  /* (153) setlist ::= setlist COMMA LP idlist RP EQ expr */
   262,  /* (154) setlist ::= nm EQ expr */
   262,  /* (155) setlist ::= LP idlist RP EQ expr */
   186,  /* (156) cmd ::= with insert_cmd INTO xfullname idlist_opt select upsert */
   186,  /* (157) cmd ::= with insert_cmd INTO xfullname idlist_opt DEFAULT VALUES */
   265,  /* (158) upsert ::= */
   265,  /* (159) upsert ::= ON CONFLICT LP sortlist RP where_opt DO UPDATE SET setlist where_opt upsert */
   265,  /* (160) upsert ::= ON CONFLICT LP sortlist RP where_opt DO NOTHING upsert */
   265,  /* (161) upsert ::= ON CONFLICT DO NOTHING */
   265,  /* (162) upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt */
   263,  /* (163) insert_cmd ::= INSERT orconf */
   263,  /* (164) insert_cmd ::= REPLACE */
   264,  /* (165) idlist_opt ::= */
   264,  /* (166) idlist_opt ::= LP idlist RP */
   259,  /* (167) idlist ::= idlist COMMA nm */
   259,  /* (168) idlist ::= nm */
   212,  /* (169) expr ::= LP expr RP */
   212,  /* (170) expr ::= ID|INDEXED */
   212,  /* (171) expr ::= JOIN_KW */
   212,  /* (172) expr ::= nm DOT nm */
   212,  /* (173) expr ::= nm DOT nm DOT nm */
   211,  /* (174) term ::= NULL|FLOAT|BLOB */
   211,  /* (175) term ::= STRING */
   211,  /* (176) term ::= INTEGER */
   212,  /* (177) expr ::= VARIABLE */
   212,  /* (178) expr ::= expr COLLATE ID|STRING */
   212,  /* (179) expr ::= CAST LP expr AS typetoken RP */
   212,  /* (180) expr ::= ID|INDEXED LP distinct exprlist RP */
   212,  /* (181) expr ::= ID|INDEXED LP STAR RP */
   212,  /* (182) expr ::= ID|INDEXED LP distinct exprlist RP filter_over */
   212,  /* (183) expr ::= ID|INDEXED LP STAR RP filter_over */
   211,  /* (184) term ::= CTIME_KW */

   212,  /* (185) expr ::= LP nexprlist COMMA expr RP */
   212,  /* (186) expr ::= expr AND expr */
   212,  /* (187) expr ::= expr OR expr */
   212,  /* (188) expr ::= expr LT|GT|GE|LE expr */
   212,  /* (189) expr ::= expr EQ|NE expr */
   212,  /* (190) expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr */
   212,  /* (191) expr ::= expr PLUS|MINUS expr */
   212,  /* (192) expr ::= expr STAR|SLASH|REM expr */
   212,  /* (193) expr ::= expr CONCAT expr */
   267,  /* (194) likeop ::= NOT LIKE_KW|MATCH */

   212,  /* (195) expr ::= expr likeop expr */
   212,  /* (196) expr ::= expr likeop expr ESCAPE expr */
   212,  /* (197) expr ::= expr ISNULL|NOTNULL */
   212,  /* (198) expr ::= expr NOT NULL */
   212,  /* (199) expr ::= expr IS expr */
   212,  /* (200) expr ::= expr IS NOT expr */
   212,  /* (201) expr ::= NOT expr */
   212,  /* (202) expr ::= BITNOT expr */
   212,  /* (203) expr ::= PLUS|MINUS expr */
   268,  /* (204) between_op ::= BETWEEN */
   268,  /* (205) between_op ::= NOT BETWEEN */
   212,  /* (206) expr ::= expr between_op expr AND expr */
   269,  /* (207) in_op ::= IN */
   269,  /* (208) in_op ::= NOT IN */
   212,  /* (209) expr ::= expr in_op LP exprlist RP */
   212,  /* (210) expr ::= LP select RP */
   212,  /* (211) expr ::= expr in_op LP select RP */
   212,  /* (212) expr ::= expr in_op nm dbnm paren_exprlist */
   212,  /* (213) expr ::= EXISTS LP select RP */
   212,  /* (214) expr ::= CASE case_operand case_exprlist case_else END */
   272,  /* (215) case_exprlist ::= case_exprlist WHEN expr THEN expr */
   272,  /* (216) case_exprlist ::= WHEN expr THEN expr */
   273,  /* (217) case_else ::= ELSE expr */
   273,  /* (218) case_else ::= */
   271,  /* (219) case_operand ::= expr */
   271,  /* (220) case_operand ::= */
   257,  /* (221) exprlist ::= */
   248,  /* (222) nexprlist ::= nexprlist COMMA expr */
   248,  /* (223) nexprlist ::= expr */
   270,  /* (224) paren_exprlist ::= */
   270,  /* (225) paren_exprlist ::= LP exprlist RP */
   186,  /* (226) cmd ::= createkw uniqueflag INDEX ifnotexists nm dbnm ON nm LP sortlist RP where_opt */
   274,  /* (227) uniqueflag ::= UNIQUE */
   274,  /* (228) uniqueflag ::= */
   216,  /* (229) eidlist_opt ::= */
   216,  /* (230) eidlist_opt ::= LP eidlist RP */
   227,  /* (231) eidlist ::= eidlist COMMA nm collate sortorder */
   227,  /* (232) eidlist ::= nm collate sortorder */
   275,  /* (233) collate ::= */
   275,  /* (234) collate ::= COLLATE ID|STRING */
   186,  /* (235) cmd ::= DROP INDEX ifexists fullname */
   186,  /* (236) cmd ::= VACUUM vinto */
   186,  /* (237) cmd ::= VACUUM nm vinto */

   276,  /* (238) vinto ::= INTO expr */
   276,  /* (239) vinto ::= */
   186,  /* (240) cmd ::= PRAGMA nm dbnm */
   186,  /* (241) cmd ::= PRAGMA nm dbnm EQ nmnum */
   186,  /* (242) cmd ::= PRAGMA nm dbnm LP nmnum RP */
   186,  /* (243) cmd ::= PRAGMA nm dbnm EQ minus_num */
   186,  /* (244) cmd ::= PRAGMA nm dbnm LP minus_num RP */
   206,  /* (245) plus_num ::= PLUS INTEGER|FLOAT */
   207,  /* (246) minus_num ::= MINUS INTEGER|FLOAT */
   186,  /* (247) cmd ::= createkw trigger_decl BEGIN trigger_cmd_list END */
   278,  /* (248) trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause */

   280,  /* (249) trigger_time ::= BEFORE|AFTER */
   280,  /* (250) trigger_time ::= INSTEAD OF */
   280,  /* (251) trigger_time ::= */
   281,  /* (252) trigger_event ::= DELETE|INSERT */
   281,  /* (253) trigger_event ::= UPDATE */
   281,  /* (254) trigger_event ::= UPDATE OF idlist */
   283,  /* (255) when_clause ::= */
   283,  /* (256) when_clause ::= WHEN expr */
   279,  /* (257) trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
   279,  /* (258) trigger_cmd_list ::= trigger_cmd SEMI */
   285,  /* (259) trnm ::= nm DOT nm */
   286,  /* (260) tridxby ::= INDEXED BY nm */
   286,  /* (261) tridxby ::= NOT INDEXED */
   284,  /* (262) trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist from where_opt scanpt */
   284,  /* (263) trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
   284,  /* (264) trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
   284,  /* (265) trigger_cmd ::= scanpt select scanpt */
   212,  /* (266) expr ::= RAISE LP IGNORE RP */
   212,  /* (267) expr ::= RAISE LP raisetype COMMA nm RP */
   231,  /* (268) raisetype ::= ROLLBACK */
   231,  /* (269) raisetype ::= ABORT */
   231,  /* (270) raisetype ::= FAIL */
   186,  /* (271) cmd ::= DROP TRIGGER ifexists fullname */
   186,  /* (272) cmd ::= ATTACH database_kw_opt expr AS expr key_opt */
   186,  /* (273) cmd ::= DETACH database_kw_opt expr */

   288,  /* (274) key_opt ::= */
   288,  /* (275) key_opt ::= KEY expr */
   186,  /* (276) cmd ::= REINDEX */
   186,  /* (277) cmd ::= REINDEX nm dbnm */
   186,  /* (278) cmd ::= ANALYZE */
   186,  /* (279) cmd ::= ANALYZE nm dbnm */
   186,  /* (280) cmd ::= ALTER TABLE fullname RENAME TO nm */
   186,  /* (281) cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt columnname carglist */
   289,  /* (282) add_column_fullname ::= fullname */
   186,  /* (283) cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
   186,  /* (284) cmd ::= create_vtab */
   186,  /* (285) cmd ::= create_vtab LP vtabarglist RP */
   291,  /* (286) create_vtab ::= createkw VIRTUAL TABLE ifnotexists nm dbnm USING nm */
   293,  /* (287) vtabarg ::= */
   294,  /* (288) vtabargtoken ::= ANY */
   294,  /* (289) vtabargtoken ::= lp anylist RP */
   295,  /* (290) lp ::= LP */
   261,  /* (291) with ::= WITH wqlist */
   261,  /* (292) with ::= WITH RECURSIVE wqlist */
   236,  /* (293) wqlist ::= nm eidlist_opt AS LP select RP */
   236,  /* (294) wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */
   297,  /* (295) windowdefn_list ::= windowdefn */
   297,  /* (296) windowdefn_list ::= windowdefn_list COMMA windowdefn */
   298,  /* (297) windowdefn ::= nm AS LP window RP */
   299,  /* (298) window ::= PARTITION BY nexprlist orderby_opt frame_opt */
   299,  /* (299) window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
   299,  /* (300) window ::= ORDER BY sortlist frame_opt */

   299,  /* (301) window ::= nm ORDER BY sortlist frame_opt */
   299,  /* (302) window ::= frame_opt */
   299,  /* (303) window ::= nm frame_opt */
   300,  /* (304) frame_opt ::= */
   300,  /* (305) frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
   300,  /* (306) frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
   304,  /* (307) range_or_rows ::= RANGE|ROWS|GROUPS */
   306,  /* (308) frame_bound_s ::= frame_bound */
   306,  /* (309) frame_bound_s ::= UNBOUNDED PRECEDING */
   307,  /* (310) frame_bound_e ::= frame_bound */
   307,  /* (311) frame_bound_e ::= UNBOUNDED FOLLOWING */
   305,  /* (312) frame_bound ::= expr PRECEDING|FOLLOWING */
   305,  /* (313) frame_bound ::= CURRENT ROW */
   308,  /* (314) frame_exclude_opt ::= */
   308,  /* (315) frame_exclude_opt ::= EXCLUDE frame_exclude */
   309,  /* (316) frame_exclude ::= NO OTHERS */
   309,  /* (317) frame_exclude ::= CURRENT ROW */
   309,  /* (318) frame_exclude ::= GROUP|TIES */
   246,  /* (319) window_clause ::= WINDOW windowdefn_list */
   266,  /* (320) filter_over ::= filter_clause over_clause */
   266,  /* (321) filter_over ::= over_clause */
   266,  /* (322) filter_over ::= filter_clause */
   303,  /* (323) over_clause ::= OVER LP window RP */
   303,  /* (324) over_clause ::= OVER nm */
   302,  /* (325) filter_clause ::= FILTER LP WHERE expr RP */
   181,  /* (326) input ::= cmdlist */

   182,  /* (327) cmdlist ::= cmdlist ecmd */
   182,  /* (328) cmdlist ::= ecmd */
   183,  /* (329) ecmd ::= SEMI */
   183,  /* (330) ecmd ::= cmdx SEMI */
   183,  /* (331) ecmd ::= explain cmdx SEMI */
   188,  /* (332) trans_opt ::= */
   188,  /* (333) trans_opt ::= TRANSACTION */
   188,  /* (334) trans_opt ::= TRANSACTION nm */
   190,  /* (335) savepoint_opt ::= SAVEPOINT */
   190,  /* (336) savepoint_opt ::= */
   186,  /* (337) cmd ::= create_table create_table_args */
   197,  /* (338) columnlist ::= columnlist COMMA columnname carglist */
   197,  /* (339) columnlist ::= columnname carglist */

   189,  /* (340) nm ::= ID|INDEXED */
   189,  /* (341) nm ::= STRING */
   189,  /* (342) nm ::= JOIN_KW */
   203,  /* (343) typetoken ::= typename */
   204,  /* (344) typename ::= ID|STRING */
   205,  /* (345) signed ::= plus_num */
   205,  /* (346) signed ::= minus_num */
   202,  /* (347) carglist ::= carglist ccons */
   202,  /* (348) carglist ::= */
   210,  /* (349) ccons ::= NULL onconf */
   210,  /* (350) ccons ::= GENERATED ALWAYS AS generated */
   210,  /* (351) ccons ::= AS generated */
   198,  /* (352) conslist_opt ::= COMMA conslist */
   223,  /* (353) conslist ::= conslist tconscomma tcons */
   223,  /* (354) conslist ::= tcons */
   224,  /* (355) tconscomma ::= */
   228,  /* (356) defer_subclause_opt ::= defer_subclause */
   230,  /* (357) resolvetype ::= raisetype */
   234,  /* (358) selectnowith ::= oneselect */
   235,  /* (359) oneselect ::= values */
   249,  /* (360) sclp ::= selcollist COMMA */
   250,  /* (361) as ::= ID|STRING */
   212,  /* (362) expr ::= term */
   267,  /* (363) likeop ::= LIKE_KW|MATCH */
   257,  /* (364) exprlist ::= nexprlist */

   277,  /* (365) nmnum ::= plus_num */
   277,  /* (366) nmnum ::= nm */
   277,  /* (367) nmnum ::= ON */
   277,  /* (368) nmnum ::= DELETE */
   277,  /* (369) nmnum ::= DEFAULT */
   206,  /* (370) plus_num ::= INTEGER|FLOAT */
   282,  /* (371) foreach_clause ::= */
   282,  /* (372) foreach_clause ::= FOR EACH ROW */
   285,  /* (373) trnm ::= nm */
   286,  /* (374) tridxby ::= */
   287,  /* (375) database_kw_opt ::= DATABASE */
   287,  /* (376) database_kw_opt ::= */
   290,  /* (377) kwcolumn_opt ::= */
   290,  /* (378) kwcolumn_opt ::= COLUMNKW */
   292,  /* (379) vtabarglist ::= vtabarg */
   292,  /* (380) vtabarglist ::= vtabarglist COMMA vtabarg */
   293,  /* (381) vtabarg ::= vtabarg vtabargtoken */
   296,  /* (382) anylist ::= */
   296,  /* (383) anylist ::= anylist LP anylist RP */
   296,  /* (384) anylist ::= anylist ANY */
   261,  /* (385) with ::= */
};

/* 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 */