text: /*
  ** 2001 September 15
  **
  ** The author disclaims copyright to this source code.  In place of
  ** a legal notice, here is a blessing:
  **
  **    May you do good and not evil.
  **    May you find forgiveness for yourself and forgive others.
  **    May you share freely, never taking more than you give.
  **
  *************************************************************************
  ** The code in this file implements the function that runs the
  ** bytecode of a prepared statement.
  **
  ** Various scripts scan this source file in order to generate HTML
  ** documentation, headers files, or other derived files.  The formatting
  ** of the code in this file is, therefore, important.  See other comments
  ** in this file for details.  If in doubt, do not deviate from existing
  ** commenting and indentation practices when changing or adding code.
  */
  #include "sqliteInt.h"
  #include "vdbeInt.h"
  
  /*
  ** Invoke this macro on memory cells just prior to changing the
  ** value of the cell.  This macro verifies that shallow copies are
  ** not misused.  A shallow copy of a string or blob just copies a
  ** pointer to the string or blob, not the content.  If the original
  ** is changed while the copy is still in use, the string or blob might
  ** be changed out from under the copy.  This macro verifies that nothing
  ** like that ever happens.
  */
  #ifdef SQLITE_DEBUG
  # define memAboutToChange(P,M) sqlite3VdbeMemAboutToChange(P,M)
  #else
  # define memAboutToChange(P,M)
  #endif
  
  /*
  ** The following global variable is incremented every time a cursor
  ** moves, either by the OP_SeekXX, OP_Next, or OP_Prev opcodes.  The test
  ** procedures use this information to make sure that indices are
  ** working correctly.  This variable has no function other than to
  ** help verify the correct operation of the library.
  */
  #ifdef SQLITE_TEST
  int sqlite3_search_count = 0;
  #endif
  
  /*
  ** When this global variable is positive, it gets decremented once before
  ** each instruction in the VDBE.  When it reaches zero, the u1.isInterrupted
  ** field of the sqlite3 structure is set in order to simulate an interrupt.
  **
  ** This facility is used for testing purposes only.  It does not function
  ** in an ordinary build.
  */
  #ifdef SQLITE_TEST
  int sqlite3_interrupt_count = 0;
  #endif
  
  /*
  ** The next global variable is incremented each type the OP_Sort opcode
  ** is executed.  The test procedures use this information to make sure that
  ** sorting is occurring or not occurring at appropriate times.   This variable
  ** has no function other than to help verify the correct operation of the
  ** library.
  */
  #ifdef SQLITE_TEST
  int sqlite3_sort_count = 0;
  #endif
  
  /*
  ** The next global variable records the size of the largest MEM_Blob
  ** or MEM_Str that has been used by a VDBE opcode.  The test procedures
  ** use this information to make sure that the zero-blob functionality
  ** is working correctly.   This variable has no function other than to
  ** help verify the correct operation of the library.
  */
  #ifdef SQLITE_TEST
  int sqlite3_max_blobsize = 0;
  static void updateMaxBlobsize(Mem *p){
    if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlite3_max_blobsize ){
      sqlite3_max_blobsize = p->n;
    }
  }
  #endif
  
  /*
  ** This macro evaluates to true if either the update hook or the preupdate
  ** hook are enabled for database connect DB.
  */
  #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
  # define HAS_UPDATE_HOOK(DB) ((DB)->xPreUpdateCallback||(DB)->xUpdateCallback)
  #else
  # define HAS_UPDATE_HOOK(DB) ((DB)->xUpdateCallback)
  #endif
  
  /*
  ** The next global variable is incremented each time the OP_Found opcode
  ** is executed. This is used to test whether or not the foreign key
  ** operation implemented using OP_FkIsZero is working. This variable
  ** has no function other than to help verify the correct operation of the
  ** library.
  */
  #ifdef SQLITE_TEST
  int sqlite3_found_count = 0;
  #endif
  
  /*
  ** Test a register to see if it exceeds the current maximum blob size.
  ** If it does, record the new maximum blob size.
  */
  #if defined(SQLITE_TEST) && !defined(SQLITE_UNTESTABLE)
  # define UPDATE_MAX_BLOBSIZE(P)  updateMaxBlobsize(P)
  #else
  # define UPDATE_MAX_BLOBSIZE(P)
  #endif
  
  #ifdef SQLITE_DEBUG
  /* This routine provides a convenient place to set a breakpoint during
  ** tracing with PRAGMA vdbe_trace=on.  The breakpoint fires right after
  ** each opcode is printed.  Variables "pc" (program counter) and pOp are
  ** available to add conditionals to the breakpoint.  GDB example:
  **
  **         break test_trace_breakpoint if pc=22
  **
  ** Other useful labels for breakpoints include:
  **   test_addop_breakpoint(pc,pOp)
  **   sqlite3CorruptError(lineno)
  **   sqlite3MisuseError(lineno)
  **   sqlite3CantopenError(lineno)
  */
  static void test_trace_breakpoint(int pc, Op *pOp, Vdbe *v){
    static int n = 0;
    n++;
  }
  #endif
  
  /*
  ** Invoke the VDBE coverage callback, if that callback is defined.  This
  ** feature is used for test suite validation only and does not appear an
  ** production builds.
  **
  ** M is the type of branch.  I is the direction taken for this instance of
  ** the branch.
  **
  **   M: 2 - two-way branch (I=0: fall-thru   1: jump                )
  **      3 - two-way + NULL (I=0: fall-thru   1: jump      2: NULL   )
  **      4 - OP_Jump        (I=0: jump p1     1: jump p2   2: jump p3)
  **
  ** In other words, if M is 2, then I is either 0 (for fall-through) or
  ** 1 (for when the branch is taken).  If M is 3, the I is 0 for an
  ** ordinary fall-through, I is 1 if the branch was taken, and I is 2 
  ** if the result of comparison is NULL.  For M=3, I=2 the jump may or
  ** may not be taken, depending on the SQLITE_JUMPIFNULL flags in p5.
  ** When M is 4, that means that an OP_Jump is being run.  I is 0, 1, or 2
  ** depending on if the operands are less than, equal, or greater than.
  **
  ** iSrcLine is the source code line (from the __LINE__ macro) that
  ** generated the VDBE instruction combined with flag bits.  The source
  ** code line number is in the lower 24 bits of iSrcLine and the upper
  ** 8 bytes are flags.  The lower three bits of the flags indicate
  ** values for I that should never occur.  For example, if the branch is
  ** always taken, the flags should be 0x05 since the fall-through and
  ** alternate branch are never taken.  If a branch is never taken then
  ** flags should be 0x06 since only the fall-through approach is allowed.
  **
  ** Bit 0x08 of the flags indicates an OP_Jump opcode that is only
  ** interested in equal or not-equal.  In other words, I==0 and I==2
  ** should be treated as equivalent
  **
  ** Since only a line number is retained, not the filename, this macro
  ** only works for amalgamation builds.  But that is ok, since these macros
  ** should be no-ops except for special builds used to measure test coverage.
  */
  #if !defined(SQLITE_VDBE_COVERAGE)
  # define VdbeBranchTaken(I,M)
  #else
  # define VdbeBranchTaken(I,M) vdbeTakeBranch(pOp->iSrcLine,I,M)
    static void vdbeTakeBranch(u32 iSrcLine, u8 I, u8 M){
      u8 mNever;
      assert( I<=2 );  /* 0: fall through,  1: taken,  2: alternate taken */
      assert( M<=4 );  /* 2: two-way branch, 3: three-way branch, 4: OP_Jump */
      assert( I<M );   /* I can only be 2 if M is 3 or 4 */
      /* Transform I from a integer [0,1,2] into a bitmask of [1,2,4] */
      I = 1<<I;
      /* The upper 8 bits of iSrcLine are flags.  The lower three bits of
      ** the flags indicate directions that the branch can never go.  If
      ** a branch really does go in one of those directions, assert right
      ** away. */
      mNever = iSrcLine >> 24;
      assert( (I & mNever)==0 );
      if( sqlite3GlobalConfig.xVdbeBranch==0 ) return;  /*NO_TEST*/
      /* Invoke the branch coverage callback with three arguments:
      **    iSrcLine - the line number of the VdbeCoverage() macro, with
      **               flags removed.
      **    I        - Mask of bits 0x07 indicating which cases are are
      **               fulfilled by this instance of the jump.  0x01 means
      **               fall-thru, 0x02 means taken, 0x04 means NULL.  Any
      **               impossible cases (ex: if the comparison is never NULL)
      **               are filled in automatically so that the coverage
      **               measurement logic does not flag those impossible cases
      **               as missed coverage.
      **    M        - Type of jump.  Same as M argument above
      */
      I |= mNever;
      if( M==2 ) I |= 0x04;
      if( M==4 ){
        I |= 0x08;
        if( (mNever&0x08)!=0 && (I&0x05)!=0) I |= 0x05; /*NO_TEST*/
      }
      sqlite3GlobalConfig.xVdbeBranch(sqlite3GlobalConfig.pVdbeBranchArg,
                                      iSrcLine&0xffffff, I, M);
    }
  #endif
  
  /*
  ** An ephemeral string value (signified by the MEM_Ephem flag) contains
  ** a pointer to a dynamically allocated string where some other entity
  ** is responsible for deallocating that string.  Because the register
  ** does not control the string, it might be deleted without the register
  ** knowing it.
  **
  ** This routine converts an ephemeral string into a dynamically allocated
  ** string that the register itself controls.  In other words, it
  ** converts an MEM_Ephem string into a string with P.z==P.zMalloc.
  */
  #define Deephemeralize(P) \
     if( ((P)->flags&MEM_Ephem)!=0 \
         && sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;}
  
  /* Return true if the cursor was opened using the OP_OpenSorter opcode. */
  #define isSorter(x) ((x)->eCurType==CURTYPE_SORTER)
  
  /*
  ** Allocate VdbeCursor number iCur.  Return a pointer to it.  Return NULL
  ** if we run out of memory.
  */
  static VdbeCursor *allocateCursor(
    Vdbe *p,              /* The virtual machine */
    int iCur,             /* Index of the new VdbeCursor */
    int nField,           /* Number of fields in the table or index */
    int iDb,              /* Database the cursor belongs to, or -1 */
    u8 eCurType           /* Type of the new cursor */
  ){
    /* Find the memory cell that will be used to store the blob of memory
    ** required for this VdbeCursor structure. It is convenient to use a 
    ** vdbe memory cell to manage the memory allocation required for a
    ** VdbeCursor structure for the following reasons:
    **
    **   * Sometimes cursor numbers are used for a couple of different
    **     purposes in a vdbe program. The different uses might require
    **     different sized allocations. Memory cells provide growable
    **     allocations.
    **
    **   * When using ENABLE_MEMORY_MANAGEMENT, memory cell buffers can
    **     be freed lazily via the sqlite3_release_memory() API. This
    **     minimizes the number of malloc calls made by the system.
    **
    ** The memory cell for cursor 0 is aMem[0]. The rest are allocated from
    ** the top of the register space.  Cursor 1 is at Mem[p->nMem-1].
    ** Cursor 2 is at Mem[p->nMem-2]. And so forth.
    */
    Mem *pMem = iCur>0 ? &p->aMem[p->nMem-iCur] : p->aMem;
  
    int nByte;
    VdbeCursor *pCx = 0;
    nByte = 
        ROUND8(sizeof(VdbeCursor)) + 2*sizeof(u32)*nField + 
        (eCurType==CURTYPE_BTREE?sqlite3BtreeCursorSize():0);
  
    assert( iCur>=0 && iCur<p->nCursor );
    if( p->apCsr[iCur] ){ /*OPTIMIZATION-IF-FALSE*/
      /* Before calling sqlite3VdbeFreeCursor(), ensure the isEphemeral flag
      ** is clear. Otherwise, if this is an ephemeral cursor created by 
      ** OP_OpenDup, the cursor will not be closed and will still be part
      ** of a BtShared.pCursor list.  */
      if( p->apCsr[iCur]->pBtx==0 ) p->apCsr[iCur]->isEphemeral = 0;
      sqlite3VdbeFreeCursor(p, p->apCsr[iCur]);
      p->apCsr[iCur] = 0;
    }
    if( SQLITE_OK==sqlite3VdbeMemClearAndResize(pMem, nByte) ){
      p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->z;
      memset(pCx, 0, offsetof(VdbeCursor,pAltCursor));
      pCx->eCurType = eCurType;
      pCx->iDb = iDb;
      pCx->nField = nField;
      pCx->aOffset = &pCx->aType[nField];
      if( eCurType==CURTYPE_BTREE ){
        pCx->uc.pCursor = (BtCursor*)
            &pMem->z[ROUND8(sizeof(VdbeCursor))+2*sizeof(u32)*nField];
        sqlite3BtreeCursorZero(pCx->uc.pCursor);
      }
    }
    return pCx;
  }
  
  /*
  ** The string in pRec is known to look like an integer and to have a
  ** floating point value of rValue.  Return true and set *piValue to the
  ** integer value if the string is in range to be an integer.  Otherwise,
  ** return false.
  */
  static int alsoAnInt(Mem *pRec, double rValue, i64 *piValue){
    i64 iValue = (double)rValue;
    if( sqlite3RealSameAsInt(rValue,iValue) ){
      *piValue = iValue;
      return 1;
    }
    return 0==sqlite3Atoi64(pRec->z, piValue, pRec->n, pRec->enc);
  }
  
  /*
  ** Try to convert a value into a numeric representation if we can
  ** do so without loss of information.  In other words, if the string
  ** looks like a number, convert it into a number.  If it does not
  ** look like a number, leave it alone.
  **
  ** If the bTryForInt flag is true, then extra effort is made to give
  ** an integer representation.  Strings that look like floating point
  ** values but which have no fractional component (example: '48.00')
  ** will have a MEM_Int representation when bTryForInt is true.
  **
  ** If bTryForInt is false, then if the input string contains a decimal
  ** point or exponential notation, the result is only MEM_Real, even
  ** if there is an exact integer representation of the quantity.
  */
  static void applyNumericAffinity(Mem *pRec, int bTryForInt){
    double rValue;
    u8 enc = pRec->enc;
    int rc;
    assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real|MEM_IntReal))==MEM_Str );
    rc = sqlite3AtoF(pRec->z, &rValue, pRec->n, enc);
    if( rc<=0 ) return;
    if( rc==1 && alsoAnInt(pRec, rValue, &pRec->u.i) ){
      pRec->flags |= MEM_Int;
    }else{
      pRec->u.r = rValue;
      pRec->flags |= MEM_Real;
      if( bTryForInt ) sqlite3VdbeIntegerAffinity(pRec);
    }
    /* TEXT->NUMERIC is many->one.  Hence, it is important to invalidate the
    ** string representation after computing a numeric equivalent, because the
    ** string representation might not be the canonical representation for the
    ** numeric value.  Ticket [343634942dd54ab57b7024] 2018-01-31. */
    pRec->flags &= ~MEM_Str;
  }
  
  /*
  ** Processing is determine by the affinity parameter:
  **
  ** SQLITE_AFF_INTEGER:
  ** SQLITE_AFF_REAL:
  ** SQLITE_AFF_NUMERIC:
  **    Try to convert pRec to an integer representation or a 
  **    floating-point representation if an integer representation
  **    is not possible.  Note that the integer representation is
  **    always preferred, even if the affinity is REAL, because
  **    an integer representation is more space efficient on disk.
  **
  ** SQLITE_AFF_TEXT:
  **    Convert pRec to a text representation.
  **
  ** SQLITE_AFF_BLOB:
  ** SQLITE_AFF_NONE:
  **    No-op.  pRec is unchanged.
  */
  static void applyAffinity(
    Mem *pRec,          /* The value to apply affinity to */
    char affinity,      /* The affinity to be applied */
    u8 enc              /* Use this text encoding */
  ){
    if( affinity>=SQLITE_AFF_NUMERIC ){
      assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL
               || affinity==SQLITE_AFF_NUMERIC );
      if( (pRec->flags & MEM_Int)==0 ){ /*OPTIMIZATION-IF-FALSE*/
        if( (pRec->flags & MEM_Real)==0 ){
          if( pRec->flags & MEM_Str ) applyNumericAffinity(pRec,1);
        }else{
          sqlite3VdbeIntegerAffinity(pRec);
        }
      }
    }else if( affinity==SQLITE_AFF_TEXT ){
      /* Only attempt the conversion to TEXT if there is an integer or real
      ** representation (blob and NULL do not get converted) but no string
      ** representation.  It would be harmless to repeat the conversion if 
      ** there is already a string rep, but it is pointless to waste those
      ** CPU cycles. */
      if( 0==(pRec->flags&MEM_Str) ){ /*OPTIMIZATION-IF-FALSE*/
        if( (pRec->flags&(MEM_Real|MEM_Int|MEM_IntReal)) ){
          testcase( pRec->flags & MEM_Int );
          testcase( pRec->flags & MEM_Real );
          testcase( pRec->flags & MEM_IntReal );
          sqlite3VdbeMemStringify(pRec, enc, 1);
        }
      }
      pRec->flags &= ~(MEM_Real|MEM_Int|MEM_IntReal);
    }
  }
  
  /*
  ** Try to convert the type of a function argument or a result column
  ** into a numeric representation.  Use either INTEGER or REAL whichever
  ** is appropriate.  But only do the conversion if it is possible without
  ** loss of information and return the revised type of the argument.
  */
  int sqlite3_value_numeric_type(sqlite3_value *pVal){
    int eType = sqlite3_value_type(pVal);
    if( eType==SQLITE_TEXT ){
      Mem *pMem = (Mem*)pVal;
      applyNumericAffinity(pMem, 0);
      eType = sqlite3_value_type(pVal);
    }
    return eType;
  }
  
  /*
  ** Exported version of applyAffinity(). This one works on sqlite3_value*, 
  ** not the internal Mem* type.
  */
  void sqlite3ValueApplyAffinity(
    sqlite3_value *pVal, 
    u8 affinity, 
    u8 enc
  ){
    applyAffinity((Mem *)pVal, affinity, enc);
  }
  
  /*
  ** pMem currently only holds a string type (or maybe a BLOB that we can
  ** interpret as a string if we want to).  Compute its corresponding
  ** numeric type, if has one.  Set the pMem->u.r and pMem->u.i fields
  ** accordingly.
  */
  static u16 SQLITE_NOINLINE computeNumericType(Mem *pMem){
    int rc;
    sqlite3_int64 ix;
    assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 );
    assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 );
    ExpandBlob(pMem);
    rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
    if( rc<=0 ){
      if( rc==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1 ){
        pMem->u.i = ix;
        return MEM_Int;
      }else{
        return MEM_Real;
      }
    }else if( rc==1 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)==0 ){
      pMem->u.i = ix;
      return MEM_Int;
    }
    return MEM_Real;
  }
  
  /*
  ** Return the numeric type for pMem, either MEM_Int or MEM_Real or both or
  ** none.  
  **
  ** Unlike applyNumericAffinity(), this routine does not modify pMem->flags.
  ** But it does set pMem->u.r and pMem->u.i appropriately.
  */
  static u16 numericType(Mem *pMem){
    if( pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal) ){
      testcase( pMem->flags & MEM_Int );
      testcase( pMem->flags & MEM_Real );
      testcase( pMem->flags & MEM_IntReal );
      return pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal);
    }
    if( pMem->flags & (MEM_Str|MEM_Blob) ){
      testcase( pMem->flags & MEM_Str );
      testcase( pMem->flags & MEM_Blob );
      return computeNumericType(pMem);
    }
    return 0;
  }
  
  #ifdef SQLITE_DEBUG
  /*
  ** Write a nice string representation of the contents of cell pMem
  ** into buffer zBuf, length nBuf.
  */
  void sqlite3VdbeMemPrettyPrint(Mem *pMem, StrAccum *pStr){
    int f = pMem->flags;
    static const char *const encnames[] = {"(X)", "(8)", "(16LE)", "(16BE)"};
    if( f&MEM_Blob ){
      int i;
      char c;
      if( f & MEM_Dyn ){
        c = 'z';
        assert( (f & (MEM_Static|MEM_Ephem))==0 );
      }else if( f & MEM_Static ){
        c = 't';
        assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
      }else if( f & MEM_Ephem ){
        c = 'e';
        assert( (f & (MEM_Static|MEM_Dyn))==0 );
      }else{
        c = 's';
      }
      sqlite3_str_appendf(pStr, "%cx[", c);
      for(i=0; i<25 && i<pMem->n; i++){
        sqlite3_str_appendf(pStr, "%02X", ((int)pMem->z[i] & 0xFF));
      }
      sqlite3_str_appendf(pStr, "|");
      for(i=0; i<25 && i<pMem->n; i++){
        char z = pMem->z[i];
        sqlite3_str_appendchar(pStr, 1, (z<32||z>126)?'.':z);
      }
      sqlite3_str_appendf(pStr,"]");
      if( f & MEM_Zero ){
        sqlite3_str_appendf(pStr, "+%dz",pMem->u.nZero);
      }
    }else if( f & MEM_Str ){
      int j;
      u8 c;
      if( f & MEM_Dyn ){
        c = 'z';
        assert( (f & (MEM_Static|MEM_Ephem))==0 );
      }else if( f & MEM_Static ){
        c = 't';
        assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
      }else if( f & MEM_Ephem ){
        c = 'e';
        assert( (f & (MEM_Static|MEM_Dyn))==0 );
      }else{
        c = 's';
      }
      sqlite3_str_appendf(pStr, " %c%d[", c, pMem->n);
      for(j=0; j<25 && j<pMem->n; j++){
        c = pMem->z[j];
        sqlite3_str_appendchar(pStr, 1, (c>=0x20&&c<=0x7f) ? c : '.');
      }
      sqlite3_str_appendf(pStr, "]%s", encnames[pMem->enc]);
    }
  }
  #endif
  
  #ifdef SQLITE_DEBUG
  /*
  ** Print the value of a register for tracing purposes:
  */
  static void memTracePrint(Mem *p){
    if( p->flags & MEM_Undefined ){
      printf(" undefined");
    }else if( p->flags & MEM_Null ){
      printf(p->flags & MEM_Zero ? " NULL-nochng" : " NULL");
    }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){
      printf(" si:%lld", p->u.i);
    }else if( (p->flags & (MEM_IntReal))!=0 ){
      printf(" ir:%lld", p->u.i);
    }else if( p->flags & MEM_Int ){
      printf(" i:%lld", p->u.i);
  #ifndef SQLITE_OMIT_FLOATING_POINT
    }else if( p->flags & MEM_Real ){
      printf(" r:%.17g", p->u.r);
  #endif
    }else if( sqlite3VdbeMemIsRowSet(p) ){
      printf(" (rowset)");
    }else{
      StrAccum acc;
      char zBuf[1000];
      sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0);
      sqlite3VdbeMemPrettyPrint(p, &acc);
      printf(" %s", sqlite3StrAccumFinish(&acc));
    }
    if( p->flags & MEM_Subtype ) printf(" subtype=0x%02x", p->eSubtype);
  }
  static void registerTrace(int iReg, Mem *p){
    printf("R[%d] = ", iReg);
    memTracePrint(p);
    if( p->pScopyFrom ){
      printf(" <== R[%d]", (int)(p->pScopyFrom - &p[-iReg]));
    }
    printf("\n");
    sqlite3VdbeCheckMemInvariants(p);
  }
  #endif
  
  #ifdef SQLITE_DEBUG
  /*
  ** Show the values of all registers in the virtual machine.  Used for
  ** interactive debugging.
  */
  void sqlite3VdbeRegisterDump(Vdbe *v){
    int i;
    for(i=1; i<v->nMem; i++) registerTrace(i, v->aMem+i);
  }
  #endif /* SQLITE_DEBUG */
  
  
  #ifdef SQLITE_DEBUG
  #  define REGISTER_TRACE(R,M) if(db->flags&SQLITE_VdbeTrace)registerTrace(R,M)
  #else
  #  define REGISTER_TRACE(R,M)
  #endif
  
  
  #ifdef VDBE_PROFILE
  
  /* 
  ** hwtime.h contains inline assembler code for implementing 
  ** high-performance timing routines.
  */
  #include "hwtime.h"
  
  #endif
  
  #ifndef NDEBUG
  /*
  ** This function is only called from within an assert() expression. It
  ** checks that the sqlite3.nTransaction variable is correctly set to
  ** the number of non-transaction savepoints currently in the 
  ** linked list starting at sqlite3.pSavepoint.
  ** 
  ** Usage:
  **
  **     assert( checkSavepointCount(db) );
  */
  static int checkSavepointCount(sqlite3 *db){
    int n = 0;
    Savepoint *p;
    for(p=db->pSavepoint; p; p=p->pNext) n++;
    assert( n==(db->nSavepoint + db->isTransactionSavepoint) );
    return 1;
  }
  #endif
  
  /*
  ** Return the register of pOp->p2 after first preparing it to be
  ** overwritten with an integer value.
  */
  static SQLITE_NOINLINE Mem *out2PrereleaseWithClear(Mem *pOut){
    sqlite3VdbeMemSetNull(pOut);
    pOut->flags = MEM_Int;
    return pOut;
  }
  static Mem *out2Prerelease(Vdbe *p, VdbeOp *pOp){
    Mem *pOut;
    assert( pOp->p2>0 );
    assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
    pOut = &p->aMem[pOp->p2];
    memAboutToChange(p, pOut);
    if( VdbeMemDynamic(pOut) ){ /*OPTIMIZATION-IF-FALSE*/
      return out2PrereleaseWithClear(pOut);
    }else{
      pOut->flags = MEM_Int;
      return pOut;
    }
  }
  
  
  /*
  ** Execute as much of a VDBE program as we can.
  ** This is the core of sqlite3_step().  
  */
  int sqlite3VdbeExec(
    Vdbe *p                    /* The VDBE */
  ){
    Op *aOp = p->aOp;          /* Copy of p->aOp */
    Op *pOp = aOp;             /* Current operation */
  #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
    Op *pOrigOp;               /* Value of pOp at the top of the loop */
  #endif
  #ifdef SQLITE_DEBUG
    int nExtraDelete = 0;      /* Verifies FORDELETE and AUXDELETE flags */
  #endif
    int rc = SQLITE_OK;        /* Value to return */
    sqlite3 *db = p->db;       /* The database */
    u8 resetSchemaOnFault = 0; /* Reset schema after an error if positive */
    u8 encoding = ENC(db);     /* The database encoding */
    int iCompare = 0;          /* Result of last comparison */
    unsigned nVmStep = 0;      /* Number of virtual machine steps */
  #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
    unsigned nProgressLimit;   /* Invoke xProgress() when nVmStep reaches this */
  #endif
    Mem *aMem = p->aMem;       /* Copy of p->aMem */
    Mem *pIn1 = 0;             /* 1st input operand */
    Mem *pIn2 = 0;             /* 2nd input operand */
    Mem *pIn3 = 0;             /* 3rd input operand */
    Mem *pOut = 0;             /* Output operand */
  #ifdef VDBE_PROFILE
    u64 start;                 /* CPU clock count at start of opcode */
  #endif
    /*** INSERT STACK UNION HERE ***/
  
    assert( p->magic==VDBE_MAGIC_RUN );  /* sqlite3_step() verifies this */
    sqlite3VdbeEnter(p);
  #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
    if( db->xProgress ){
      u32 iPrior = p->aCounter[SQLITE_STMTSTATUS_VM_STEP];
      assert( 0 < db->nProgressOps );
      nProgressLimit = db->nProgressOps - (iPrior % db->nProgressOps);
    }else{
      nProgressLimit = 0xffffffff;
    }
  #endif
    if( p->rc==SQLITE_NOMEM ){
      /* This happens if a malloc() inside a call to sqlite3_column_text() or
      ** sqlite3_column_text16() failed.  */
      goto no_mem;
    }
    assert( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_BUSY );
    testcase( p->rc!=SQLITE_OK );
    p->rc = SQLITE_OK;
    assert( p->bIsReader || p->readOnly!=0 );
    p->iCurrentTime = 0;
    assert( p->explain==0 );
    p->pResultSet = 0;
    db->busyHandler.nBusy = 0;
    if( AtomicLoad(&db->u1.isInterrupted) ) goto abort_due_to_interrupt;
    sqlite3VdbeIOTraceSql(p);
  #ifdef SQLITE_DEBUG
    sqlite3BeginBenignMalloc();
    if( p->pc==0
     && (p->db->flags & (SQLITE_VdbeListing|SQLITE_VdbeEQP|SQLITE_VdbeTrace))!=0
    ){
      int i;
      int once = 1;
      sqlite3VdbePrintSql(p);
      if( p->db->flags & SQLITE_VdbeListing ){
        printf("VDBE Program Listing:\n");
        for(i=0; i<p->nOp; i++){
          sqlite3VdbePrintOp(stdout, i, &aOp[i]);
        }
      }
      if( p->db->flags & SQLITE_VdbeEQP ){
        for(i=0; i<p->nOp; i++){
          if( aOp[i].opcode==OP_Explain ){
            if( once ) printf("VDBE Query Plan:\n");
            printf("%s\n", aOp[i].p4.z);
            once = 0;
          }
        }
      }
      if( p->db->flags & SQLITE_VdbeTrace )  printf("VDBE Trace:\n");
    }
    sqlite3EndBenignMalloc();
  #endif
    for(pOp=&aOp[p->pc]; 1; pOp++){
      /* Errors are detected by individual opcodes, with an immediate
      ** jumps to abort_due_to_error. */
      assert( rc==SQLITE_OK );
  
      assert( pOp>=aOp && pOp<&aOp[p->nOp]);
  #ifdef VDBE_PROFILE
      start = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime();
  #endif
      nVmStep++;
  #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
      if( p->anExec ) p->anExec[(int)(pOp-aOp)]++;
  #endif
  
      /* Only allow tracing if SQLITE_DEBUG is defined.
      */
  #ifdef SQLITE_DEBUG
      if( db->flags & SQLITE_VdbeTrace ){
        sqlite3VdbePrintOp(stdout, (int)(pOp - aOp), pOp);
        test_trace_breakpoint((int)(pOp - aOp),pOp,p);
      }
  #endif
        
  
      /* Check to see if we need to simulate an interrupt.  This only happens
      ** if we have a special test build.
      */
  #ifdef SQLITE_TEST
      if( sqlite3_interrupt_count>0 ){
        sqlite3_interrupt_count--;
        if( sqlite3_interrupt_count==0 ){
          sqlite3_interrupt(db);
        }
      }
  #endif
  
      /* Sanity checking on other operands */
  #ifdef SQLITE_DEBUG
      {
        u8 opProperty = sqlite3OpcodeProperty[pOp->opcode];
        if( (opProperty & OPFLG_IN1)!=0 ){
          assert( pOp->p1>0 );
          assert( pOp->p1<=(p->nMem+1 - p->nCursor) );
          assert( memIsValid(&aMem[pOp->p1]) );
          assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p1]) );
          REGISTER_TRACE(pOp->p1, &aMem[pOp->p1]);
        }
        if( (opProperty & OPFLG_IN2)!=0 ){
          assert( pOp->p2>0 );
          assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
          assert( memIsValid(&aMem[pOp->p2]) );
          assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p2]) );
          REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]);
        }
        if( (opProperty & OPFLG_IN3)!=0 ){
          assert( pOp->p3>0 );
          assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
          assert( memIsValid(&aMem[pOp->p3]) );
          assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p3]) );
          REGISTER_TRACE(pOp->p3, &aMem[pOp->p3]);
        }
        if( (opProperty & OPFLG_OUT2)!=0 ){
          assert( pOp->p2>0 );
          assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
          memAboutToChange(p, &aMem[pOp->p2]);
        }
        if( (opProperty & OPFLG_OUT3)!=0 ){
          assert( pOp->p3>0 );
          assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
          memAboutToChange(p, &aMem[pOp->p3]);
        }
      }
  #endif
  #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
      pOrigOp = pOp;
  #endif
    
      switch( pOp->opcode ){
  
  /*****************************************************************************
  ** What follows is a massive switch statement where each case implements a
  ** separate instruction in the virtual machine.  If we follow the usual
  ** indentation conventions, each case should be indented by 6 spaces.  But
  ** that is a lot of wasted space on the left margin.  So the code within
  ** the switch statement will break with convention and be flush-left. Another
  ** big comment (similar to this one) will mark the point in the code where
  ** we transition back to normal indentation.
  **
  ** The formatting of each case is important.  The makefile for SQLite
  ** generates two C files "opcodes.h" and "opcodes.c" by scanning this
  ** file looking for lines that begin with "case OP_".  The opcodes.h files
  ** will be filled with #defines that give unique integer values to each
  ** opcode and the opcodes.c file is filled with an array of strings where
  ** each string is the symbolic name for the corresponding opcode.  If the
  ** case statement is followed by a comment of the form "/# same as ... #/"
  ** that comment is used to determine the particular value of the opcode.
  **
  ** Other keywords in the comment that follows each case are used to
  ** construct the OPFLG_INITIALIZER value that initializes opcodeProperty[].
  ** Keywords include: in1, in2, in3, out2, out3.  See
  ** the mkopcodeh.awk script for additional information.
  **
  ** Documentation about VDBE opcodes is generated by scanning this file
  ** for lines of that contain "Opcode:".  That line and all subsequent
  ** comment lines are used in the generation of the opcode.html documentation
  ** file.
  **
  ** SUMMARY:
  **
  **     Formatting is important to scripts that scan this file.
  **     Do not deviate from the formatting style currently in use.
  **
  *****************************************************************************/
  
  /* Opcode:  Goto * P2 * * *
  **
  ** An unconditional jump to address P2.
  ** The next instruction executed will be 
  ** the one at index P2 from the beginning of
  ** the program.
  **
  ** The P1 parameter is not actually used by this opcode.  However, it
  ** is sometimes set to 1 instead of 0 as a hint to the command-line shell
  ** that this Goto is the bottom of a loop and that the lines from P2 down
  ** to the current line should be indented for EXPLAIN output.
  */
  case OP_Goto: {             /* jump */
  
  #ifdef SQLITE_DEBUG
    /* In debuggging mode, when the p5 flags is set on an OP_Goto, that
    ** means we should really jump back to the preceeding OP_ReleaseReg
    ** instruction. */
    if( pOp->p5 ){
      assert( pOp->p2 < (int)(pOp - aOp) );
      assert( pOp->p2 > 1 );
      pOp = &aOp[pOp->p2 - 2];
      assert( pOp[1].opcode==OP_ReleaseReg );
      goto check_for_interrupt;
    }
  #endif
  
  jump_to_p2_and_check_for_interrupt:
    pOp = &aOp[pOp->p2 - 1];
  
    /* Opcodes that are used as the bottom of a loop (OP_Next, OP_Prev,
    ** OP_VNext, or OP_SorterNext) all jump here upon
    ** completion.  Check to see if sqlite3_interrupt() has been called
    ** or if the progress callback needs to be invoked. 
    **
    ** This code uses unstructured "goto" statements and does not look clean.
    ** But that is not due to sloppy coding habits. The code is written this
    ** way for performance, to avoid having to run the interrupt and progress
    ** checks on every opcode.  This helps sqlite3_step() to run about 1.5%
    ** faster according to "valgrind --tool=cachegrind" */
  check_for_interrupt:
    if( AtomicLoad(&db->u1.isInterrupted) ) goto abort_due_to_interrupt;
  #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
    /* Call the progress callback if it is configured and the required number
    ** of VDBE ops have been executed (either since this invocation of
    ** sqlite3VdbeExec() or since last time the progress callback was called).
    ** If the progress callback returns non-zero, exit the virtual machine with
    ** a return code SQLITE_ABORT.
    */
    while( nVmStep>=nProgressLimit && db->xProgress!=0 ){
      assert( db->nProgressOps!=0 );
      nProgressLimit += db->nProgressOps;
      if( db->xProgress(db->pProgressArg) ){
        nProgressLimit = 0xffffffff;
        rc = SQLITE_INTERRUPT;
        goto abort_due_to_error;
      }
    }
  #endif
    
    break;
  }
  
  /* Opcode:  Gosub P1 P2 * * *
  **
  ** Write the current address onto register P1
  ** and then jump to address P2.
  */
  case OP_Gosub: {            /* jump */
    assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
    pIn1 = &aMem[pOp->p1];
    assert( VdbeMemDynamic(pIn1)==0 );
    memAboutToChange(p, pIn1);
    pIn1->flags = MEM_Int;
    pIn1->u.i = (int)(pOp-aOp);
    REGISTER_TRACE(pOp->p1, pIn1);
  
    /* Most jump operations do a goto to this spot in order to update
    ** the pOp pointer. */
  jump_to_p2:
    pOp = &aOp[pOp->p2 - 1];
    break;
  }
  
  /* Opcode:  Return P1 * * * *
  **
  ** Jump to the next instruction after the address in register P1.  After
  ** the jump, register P1 becomes undefined.
  */
  case OP_Return: {           /* in1 */
    pIn1 = &aMem[pOp->p1];
    assert( pIn1->flags==MEM_Int );
    pOp = &aOp[pIn1->u.i];
    pIn1->flags = MEM_Undefined;
    break;
  }
  
  /* Opcode: InitCoroutine P1 P2 P3 * *
  **
  ** Set up register P1 so that it will Yield to the coroutine
  ** located at address P3.
  **
  ** If P2!=0 then the coroutine implementation immediately follows
  ** this opcode.  So jump over the coroutine implementation to
  ** address P2.
  **
  ** See also: EndCoroutine
  */
  case OP_InitCoroutine: {     /* jump */
    assert( pOp->p1>0 &&  pOp->p1<=(p->nMem+1 - p->nCursor) );
    assert( pOp->p2>=0 && pOp->p2<p->nOp );
    assert( pOp->p3>=0 && pOp->p3<p->nOp );
    pOut = &aMem[pOp->p1];
    assert( !VdbeMemDynamic(pOut) );
    pOut->u.i = pOp->p3 - 1;
    pOut->flags = MEM_Int;
    if( pOp->p2 ) goto jump_to_p2;
    break;
  }
  
  /* Opcode:  EndCoroutine P1 * * * *
  **
  ** The instruction at the address in register P1 is a Yield.
  ** Jump to the P2 parameter of that Yield.
  ** After the jump, register P1 becomes undefined.
  **
  ** See also: InitCoroutine
  */
  case OP_EndCoroutine: {           /* in1 */
    VdbeOp *pCaller;
    pIn1 = &aMem[pOp->p1];
    assert( pIn1->flags==MEM_Int );
    assert( pIn1->u.i>=0 && pIn1->u.i<p->nOp );
    pCaller = &aOp[pIn1->u.i];
    assert( pCaller->opcode==OP_Yield );
    assert( pCaller->p2>=0 && pCaller->p2<p->nOp );
    pOp = &aOp[pCaller->p2 - 1];
    pIn1->flags = MEM_Undefined;
    break;
  }
  
  /* Opcode:  Yield P1 P2 * * *
  **
  ** Swap the program counter with the value in register P1.  This
  ** has the effect of yielding to a coroutine.
  **
  ** If the coroutine that is launched by this instruction ends with
  ** Yield or Return then continue to the next instruction.  But if
  ** the coroutine launched by this instruction ends with
  ** EndCoroutine, then jump to P2 rather than continuing with the
  ** next instruction.
  **
  ** See also: InitCoroutine
  */
  case OP_Yield: {            /* in1, jump */
    int pcDest;
    pIn1 = &aMem[pOp->p1];
    assert( VdbeMemDynamic(pIn1)==0 );
    pIn1->flags = MEM_Int;
    pcDest = (int)pIn1->u.i;
    pIn1->u.i = (int)(pOp - aOp);
    REGISTER_TRACE(pOp->p1, pIn1);
    pOp = &aOp[pcDest];
    break;
  }
  
  /* Opcode:  HaltIfNull  P1 P2 P3 P4 P5
  ** Synopsis: if r[P3]=null halt
  **
  ** Check the value in register P3.  If it is NULL then Halt using
  ** parameter P1, P2, and P4 as if this were a Halt instruction.  If the
  ** value in register P3 is not NULL, then this routine is a no-op.
  ** The P5 parameter should be 1.
  */
  case OP_HaltIfNull: {      /* in3 */
    pIn3 = &aMem[pOp->p3];
  #ifdef SQLITE_DEBUG
    if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
  #endif
    if( (pIn3->flags & MEM_Null)==0 ) break;
    /* Fall through into OP_Halt */
  }
  
  /* Opcode:  Halt P1 P2 * P4 P5
  **
  ** Exit immediately.  All open cursors, etc are closed
  ** automatically.
  **
  ** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(),
  ** or sqlite3_finalize().  For a normal halt, this should be SQLITE_OK (0).
  ** For errors, it can be some other value.  If P1!=0 then P2 will determine
  ** whether or not to rollback the current transaction.  Do not rollback
  ** if P2==OE_Fail. Do the rollback if P2==OE_Rollback.  If P2==OE_Abort,
  ** then back out all changes that have occurred during this execution of the
  ** VDBE, but do not rollback the transaction. 
  **
  ** If P4 is not null then it is an error message string.
  **
  ** P5 is a value between 0 and 4, inclusive, that modifies the P4 string.
  **
  **    0:  (no change)
  **    1:  NOT NULL contraint failed: P4
  **    2:  UNIQUE constraint failed: P4
  **    3:  CHECK constraint failed: P4
  **    4:  FOREIGN KEY constraint failed: P4
  **
  ** If P5 is not zero and P4 is NULL, then everything after the ":" is
  ** omitted.
  **
  ** There is an implied "Halt 0 0 0" instruction inserted at the very end of
  ** every program.  So a jump past the last instruction of the program
  ** is the same as executing Halt.
  */
  case OP_Halt: {
    VdbeFrame *pFrame;
    int pcx;
  
    pcx = (int)(pOp - aOp);
  #ifdef SQLITE_DEBUG
    if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
  #endif
    if( pOp->p1==SQLITE_OK && p->pFrame ){
      /* Halt the sub-program. Return control to the parent frame. */
      pFrame = p->pFrame;
      p->pFrame = pFrame->pParent;
      p->nFrame--;
      sqlite3VdbeSetChanges(db, p->nChange);
      pcx = sqlite3VdbeFrameRestore(pFrame);
      if( pOp->p2==OE_Ignore ){
        /* Instruction pcx is the OP_Program that invoked the sub-program 
        ** currently being halted. If the p2 instruction of this OP_Halt
        ** instruction is set to OE_Ignore, then the sub-program is throwing
        ** an IGNORE exception. In this case jump to the address specified
        ** as the p2 of the calling OP_Program.  */
        pcx = p->aOp[pcx].p2-1;
      }
      aOp = p->aOp;
      aMem = p->aMem;
      pOp = &aOp[pcx];
      break;
    }
    p->rc = pOp->p1;
    p->errorAction = (u8)pOp->p2;
    p->pc = pcx;
    assert( pOp->p5<=4 );
    if( p->rc ){
      if( pOp->p5 ){
        static const char * const azType[] = { "NOT NULL", "UNIQUE", "CHECK",
                                               "FOREIGN KEY" };
        testcase( pOp->p5==1 );
        testcase( pOp->p5==2 );
        testcase( pOp->p5==3 );
        testcase( pOp->p5==4 );
        sqlite3VdbeError(p, "%s constraint failed", azType[pOp->p5-1]);
        if( pOp->p4.z ){
          p->zErrMsg = sqlite3MPrintf(db, "%z: %s", p->zErrMsg, pOp->p4.z);
        }
      }else{
        sqlite3VdbeError(p, "%s", pOp->p4.z);
      }
      sqlite3_log(pOp->p1, "abort at %d in [%s]: %s", pcx, p->zSql, p->zErrMsg);
    }
    rc = sqlite3VdbeHalt(p);
    assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR );
    if( rc==SQLITE_BUSY ){
      p->rc = SQLITE_BUSY;
    }else{
      assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT );
      assert( rc==SQLITE_OK || db->nDeferredCons>0 || db->nDeferredImmCons>0 );
      rc = p->rc ? SQLITE_ERROR : SQLITE_DONE;
    }
    goto vdbe_return;
  }
  
  /* Opcode: Integer P1 P2 * * *
  ** Synopsis: r[P2]=P1
  **
  ** The 32-bit integer value P1 is written into register P2.
  */
  case OP_Integer: {         /* out2 */
    pOut = out2Prerelease(p, pOp);
    pOut->u.i = pOp->p1;
    break;
  }
  
  /* Opcode: Int64 * P2 * P4 *
  ** Synopsis: r[P2]=P4
  **
  ** P4 is a pointer to a 64-bit integer value.
  ** Write that value into register P2.
  */
  case OP_Int64: {           /* out2 */
    pOut = out2Prerelease(p, pOp);
    assert( pOp->p4.pI64!=0 );
    pOut->u.i = *pOp->p4.pI64;
    break;
  }
  
  #ifndef SQLITE_OMIT_FLOATING_POINT
  /* Opcode: Real * P2 * P4 *
  ** Synopsis: r[P2]=P4
  **
  ** P4 is a pointer to a 64-bit floating point value.
  ** Write that value into register P2.
  */
  case OP_Real: {            /* same as TK_FLOAT, out2 */
    pOut = out2Prerelease(p, pOp);
    pOut->flags = MEM_Real;
    assert( !sqlite3IsNaN(*pOp->p4.pReal) );
    pOut->u.r = *pOp->p4.pReal;
    break;
  }
  #endif
  
  /* Opcode: String8 * P2 * P4 *
  ** Synopsis: r[P2]='P4'
  **
  ** P4 points to a nul terminated UTF-8 string. This opcode is transformed 
  ** into a String opcode before it is executed for the first time.  During
  ** this transformation, the length of string P4 is computed and stored
  ** as the P1 parameter.
  */
  case OP_String8: {         /* same as TK_STRING, out2 */
    assert( pOp->p4.z!=0 );
    pOut = out2Prerelease(p, pOp);
    pOp->p1 = sqlite3Strlen30(pOp->p4.z);
  
  #ifndef SQLITE_OMIT_UTF16
    if( encoding!=SQLITE_UTF8 ){
      rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC);
      assert( rc==SQLITE_OK || rc==SQLITE_TOOBIG );
      if( rc ) goto too_big;
      if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
      assert( pOut->szMalloc>0 && pOut->zMalloc==pOut->z );
      assert( VdbeMemDynamic(pOut)==0 );
      pOut->szMalloc = 0;
      pOut->flags |= MEM_Static;
      if( pOp->p4type==P4_DYNAMIC ){
        sqlite3DbFree(db, pOp->p4.z);
      }
      pOp->p4type = P4_DYNAMIC;
      pOp->p4.z = pOut->z;
      pOp->p1 = pOut->n;
    }
  #endif
    if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
      goto too_big;
    }
    pOp->opcode = OP_String;
    assert( rc==SQLITE_OK );
    /* Fall through to the next case, OP_String */
  }
    
  /* Opcode: String P1 P2 P3 P4 P5
  ** Synopsis: r[P2]='P4' (len=P1)
  **
  ** The string value P4 of length P1 (bytes) is stored in register P2.
  **
  ** If P3 is not zero and the content of register P3 is equal to P5, then
  ** the datatype of the register P2 is converted to BLOB.  The content is
  ** the same sequence of bytes, it is merely interpreted as a BLOB instead
  ** of a string, as if it had been CAST.  In other words:
  **
  ** if( P3!=0 and reg[P3]==P5 ) reg[P2] := CAST(reg[P2] as BLOB)
  */
  case OP_String: {          /* out2 */
    assert( pOp->p4.z!=0 );
    pOut = out2Prerelease(p, pOp);
    pOut->flags = MEM_Str|MEM_Static|MEM_Term;
    pOut->z = pOp->p4.z;
    pOut->n = pOp->p1;
    pOut->enc = encoding;
    UPDATE_MAX_BLOBSIZE(pOut);
  #ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS
    if( pOp->p3>0 ){
      assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
      pIn3 = &aMem[pOp->p3];
      assert( pIn3->flags & MEM_Int );
      if( pIn3->u.i==pOp->p5 ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term;
    }
  #endif
    break;
  }
  
  /* Opcode: Null P1 P2 P3 * *
  ** Synopsis: r[P2..P3]=NULL
  **
  ** Write a NULL into registers P2.  If P3 greater than P2, then also write
  ** NULL into register P3 and every register in between P2 and P3.  If P3
  ** is less than P2 (typically P3 is zero) then only register P2 is
  ** set to NULL.
  **
  ** If the P1 value is non-zero, then also set the MEM_Cleared flag so that
  ** NULL values will not compare equal even if SQLITE_NULLEQ is set on
  ** OP_Ne or OP_Eq.
  */
  case OP_Null: {           /* out2 */
    int cnt;
    u16 nullFlag;
    pOut = out2Prerelease(p, pOp);
    cnt = pOp->p3-pOp->p2;
    assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
    pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null;
    pOut->n = 0;
  #ifdef SQLITE_DEBUG
    pOut->uTemp = 0;
  #endif
    while( cnt>0 ){
      pOut++;
      memAboutToChange(p, pOut);
      sqlite3VdbeMemSetNull(pOut);
      pOut->flags = nullFlag;
      pOut->n = 0;
      cnt--;
    }
    break;
  }
  
  /* Opcode: SoftNull P1 * * * *
  ** Synopsis: r[P1]=NULL
  **
  ** Set register P1 to have the value NULL as seen by the OP_MakeRecord
  ** instruction, but do not free any string or blob memory associated with
  ** the register, so that if the value was a string or blob that was
  ** previously copied using OP_SCopy, the copies will continue to be valid.
  */
  case OP_SoftNull: {
    assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
    pOut = &aMem[pOp->p1];
    pOut->flags = (pOut->flags&~(MEM_Undefined|MEM_AffMask))|MEM_Null;
    break;
  }
  
  /* Opcode: Blob P1 P2 * P4 *
  ** Synopsis: r[P2]=P4 (len=P1)
  **
  ** P4 points to a blob of data P1 bytes long.  Store this
  ** blob in register P2.
  */
  case OP_Blob: {                /* out2 */
    assert( pOp->p1 <= SQLITE_MAX_LENGTH );
    pOut = out2Prerelease(p, pOp);
    sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0);
    pOut->enc = encoding;
    UPDATE_MAX_BLOBSIZE(pOut);
    break;
  }
  
  /* Opcode: Variable P1 P2 * P4 *
  ** Synopsis: r[P2]=parameter(P1,P4)
  **
  ** Transfer the values of bound parameter P1 into register P2
  **
  ** If the parameter is named, then its name appears in P4.
  ** The P4 value is used by sqlite3_bind_parameter_name().
  */
  case OP_Variable: {            /* out2 */
    Mem *pVar;       /* Value being transferred */
  
    assert( pOp->p1>0 && pOp->p1<=p->nVar );
    assert( pOp->p4.z==0 || pOp->p4.z==sqlite3VListNumToName(p->pVList,pOp->p1) );
    pVar = &p->aVar[pOp->p1 - 1];
    if( sqlite3VdbeMemTooBig(pVar) ){
      goto too_big;
    }
    pOut = &aMem[pOp->p2];
    if( VdbeMemDynamic(pOut) ) sqlite3VdbeMemSetNull(pOut);
    memcpy(pOut, pVar, MEMCELLSIZE);
    pOut->flags &= ~(MEM_Dyn|MEM_Ephem);
    pOut->flags |= MEM_Static|MEM_FromBind;
    UPDATE_MAX_BLOBSIZE(pOut);
    break;
  }
  
  /* Opcode: Move P1 P2 P3 * *
  ** Synopsis: r[P2@P3]=r[P1@P3]
  **
  ** Move the P3 values in register P1..P1+P3-1 over into
  ** registers P2..P2+P3-1.  Registers P1..P1+P3-1 are
  ** left holding a NULL.  It is an error for register ranges
  ** P1..P1+P3-1 and P2..P2+P3-1 to overlap.  It is an error
  ** for P3 to be less than 1.
  */
  case OP_Move: {
    int n;           /* Number of registers left to copy */
    int p1;          /* Register to copy from */
    int p2;          /* Register to copy to */
  
    n = pOp->p3;
    p1 = pOp->p1;
    p2 = pOp->p2;
    assert( n>0 && p1>0 && p2>0 );
    assert( p1+n<=p2 || p2+n<=p1 );
  
    pIn1 = &aMem[p1];
    pOut = &aMem[p2];
    do{
      assert( pOut<=&aMem[(p->nMem+1 - p->nCursor)] );
      assert( pIn1<=&aMem[(p->nMem+1 - p->nCursor)] );
      assert( memIsValid(pIn1) );
      memAboutToChange(p, pOut);
      sqlite3VdbeMemMove(pOut, pIn1);
  #ifdef SQLITE_DEBUG
      pIn1->pScopyFrom = 0;
      { int i;
        for(i=1; i<p->nMem; i++){
          if( aMem[i].pScopyFrom==pIn1 ){
            aMem[i].pScopyFrom = pOut;
          }
        }
      }
  #endif
      Deephemeralize(pOut);
      REGISTER_TRACE(p2++, pOut);
      pIn1++;
      pOut++;
    }while( --n );
    break;
  }
  
  /* Opcode: Copy P1 P2 P3 * *
  ** Synopsis: r[P2@P3+1]=r[P1@P3+1]
  **
  ** Make a copy of registers P1..P1+P3 into registers P2..P2+P3.
  **
  ** This instruction makes a deep copy of the value.  A duplicate
  ** is made of any string or blob constant.  See also OP_SCopy.
  */
  case OP_Copy: {
    int n;
  
    n = pOp->p3;
    pIn1 = &aMem[pOp->p1];
    pOut = &aMem[pOp->p2];
    assert( pOut!=pIn1 );
    while( 1 ){
      memAboutToChange(p, pOut);
      sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
      Deephemeralize(pOut);
  #ifdef SQLITE_DEBUG
      pOut->pScopyFrom = 0;
  #endif
      REGISTER_TRACE(pOp->p2+pOp->p3-n, pOut);
      if( (n--)==0 ) break;
      pOut++;
      pIn1++;
    }
    break;
  }
  
  /* Opcode: SCopy P1 P2 * * *
  ** Synopsis: r[P2]=r[P1]
  **
  ** Make a shallow copy of register P1 into register P2.
  **
  ** This instruction makes a shallow copy of the value.  If the value
  ** is a string or blob, then the copy is only a pointer to the
  ** original and hence if the original changes so will the copy.
  ** Worse, if the original is deallocated, the copy becomes invalid.
  ** Thus the program must guarantee that the original will not change
  ** during the lifetime of the copy.  Use OP_Copy to make a complete
  ** copy.
  */
  case OP_SCopy: {            /* out2 */
    pIn1 = &aMem[pOp->p1];
    pOut = &aMem[pOp->p2];
    assert( pOut!=pIn1 );
    sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
  #ifdef SQLITE_DEBUG
    pOut->pScopyFrom = pIn1;
    pOut->mScopyFlags = pIn1->flags;
  #endif
    break;
  }
  
  /* Opcode: IntCopy P1 P2 * * *
  ** Synopsis: r[P2]=r[P1]
  **
  ** Transfer the integer value held in register P1 into register P2.
  **
  ** This is an optimized version of SCopy that works only for integer
  ** values.
  */
  case OP_IntCopy: {            /* out2 */
    pIn1 = &aMem[pOp->p1];
    assert( (pIn1->flags & MEM_Int)!=0 );
    pOut = &aMem[pOp->p2];
    sqlite3VdbeMemSetInt64(pOut, pIn1->u.i);
    break;
  }
  
  /* Opcode: ResultRow P1 P2 * * *
  ** Synopsis: output=r[P1@P2]
  **
  ** The registers P1 through P1+P2-1 contain a single row of
  ** results. This opcode causes the sqlite3_step() call to terminate
  ** with an SQLITE_ROW return code and it sets up the sqlite3_stmt
  ** structure to provide access to the r(P1)..r(P1+P2-1) values as
  ** the result row.
  */
  case OP_ResultRow: {
    Mem *pMem;
    int i;
    assert( p->nResColumn==pOp->p2 );
    assert( pOp->p1>0 );
    assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );
  
    /* If this statement has violated immediate foreign key constraints, do
    ** not return the number of rows modified. And do not RELEASE the statement
    ** transaction. It needs to be rolled back.  */
    if( SQLITE_OK!=(rc = sqlite3VdbeCheckFk(p, 0)) ){
      assert( db->flags&SQLITE_CountRows );
      assert( p->usesStmtJournal );
      goto abort_due_to_error;
    }
  
    /* If the SQLITE_CountRows flag is set in sqlite3.flags mask, then 
    ** DML statements invoke this opcode to return the number of rows 
    ** modified to the user. This is the only way that a VM that
    ** opens a statement transaction may invoke this opcode.
    **
    ** In case this is such a statement, close any statement transaction
    ** opened by this VM before returning control to the user. This is to
    ** ensure that statement-transactions are always nested, not overlapping.
    ** If the open statement-transaction is not closed here, then the user
    ** may step another VM that opens its own statement transaction. This
    ** may lead to overlapping statement transactions.
    **
    ** The statement transaction is never a top-level transaction.  Hence
    ** the RELEASE call below can never fail.
    */
    assert( p->iStatement==0 || db->flags&SQLITE_CountRows );
    rc = sqlite3VdbeCloseStatement(p, SAVEPOINT_RELEASE);
    assert( rc==SQLITE_OK );
  
    /* Invalidate all ephemeral cursor row caches */
    p->cacheCtr = (p->cacheCtr + 2)|1;
  
    /* Make sure the results of the current row are \000 terminated
    ** and have an assigned type.  The results are de-ephemeralized as
    ** a side effect.
    */
    pMem = p->pResultSet = &aMem[pOp->p1];
    for(i=0; i<pOp->p2; i++){
      assert( memIsValid(&pMem[i]) );
      Deephemeralize(&pMem[i]);
      assert( (pMem[i].flags & MEM_Ephem)==0
              || (pMem[i].flags & (MEM_Str|MEM_Blob))==0 );
      sqlite3VdbeMemNulTerminate(&pMem[i]);
      REGISTER_TRACE(pOp->p1+i, &pMem[i]);
  #ifdef SQLITE_DEBUG
      /* The registers in the result will not be used again when the
      ** prepared statement restarts.  This is because sqlite3_column()
      ** APIs might have caused type conversions of made other changes to
      ** the register values.  Therefore, we can go ahead and break any
      ** OP_SCopy dependencies. */
      pMem[i].pScopyFrom = 0;
  #endif
    }
    if( db->mallocFailed ) goto no_mem;
  
    if( db->mTrace & SQLITE_TRACE_ROW ){
      db->xTrace(SQLITE_TRACE_ROW, db->pTraceArg, p, 0);
    }
  
  
    /* Return SQLITE_ROW
    */
    p->pc = (int)(pOp - aOp) + 1;
    rc = SQLITE_ROW;
    goto vdbe_return;
  }
  
  /* Opcode: Concat P1 P2 P3 * *
  ** Synopsis: r[P3]=r[P2]+r[P1]
  **
  ** Add the text in register P1 onto the end of the text in
  ** register P2 and store the result in register P3.
  ** If either the P1 or P2 text are NULL then store NULL in P3.
  **
  **   P3 = P2 || P1
  **
  ** It is illegal for P1 and P3 to be the same register. Sometimes,
  ** if P3 is the same register as P2, the implementation is able
  ** to avoid a memcpy().
  */
  case OP_Concat: {           /* same as TK_CONCAT, in1, in2, out3 */
    i64 nByte;          /* Total size of the output string or blob */
    u16 flags1;         /* Initial flags for P1 */
    u16 flags2;         /* Initial flags for P2 */
  
    pIn1 = &aMem[pOp->p1];
    pIn2 = &aMem[pOp->p2];
    pOut = &aMem[pOp->p3];
    testcase( pOut==pIn2 );
    assert( pIn1!=pOut );
    flags1 = pIn1->flags;
    testcase( flags1 & MEM_Null );
    testcase( pIn2->flags & MEM_Null );
    if( (flags1 | pIn2->flags) & MEM_Null ){
      sqlite3VdbeMemSetNull(pOut);
      break;
    }
    if( (flags1 & (MEM_Str|MEM_Blob))==0 ){
      if( sqlite3VdbeMemStringify(pIn1,encoding,0) ) goto no_mem;
      flags1 = pIn1->flags & ~MEM_Str;
    }else if( (flags1 & MEM_Zero)!=0 ){
      if( sqlite3VdbeMemExpandBlob(pIn1) ) goto no_mem;
      flags1 = pIn1->flags & ~MEM_Str;
    }
    flags2 = pIn2->flags;
    if( (flags2 & (MEM_Str|MEM_Blob))==0 ){
      if( sqlite3VdbeMemStringify(pIn2,encoding,0) ) goto no_mem;
      flags2 = pIn2->flags & ~MEM_Str;
    }else if( (flags2 & MEM_Zero)!=0 ){
      if( sqlite3VdbeMemExpandBlob(pIn2) ) goto no_mem;
      flags2 = pIn2->flags & ~MEM_Str;
    }
    nByte = pIn1->n + pIn2->n;
    if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
      goto too_big;
    }
    if( sqlite3VdbeMemGrow(pOut, (int)nByte+3, pOut==pIn2) ){
      goto no_mem;
    }
    MemSetTypeFlag(pOut, MEM_Str);
    if( pOut!=pIn2 ){
      memcpy(pOut->z, pIn2->z, pIn2->n);
      assert( (pIn2->flags & MEM_Dyn) == (flags2 & MEM_Dyn) );
      pIn2->flags = flags2;
    }
    memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);
    assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) );
    pIn1->flags = flags1;
    pOut->z[nByte]=0;
    pOut->z[nByte+1] = 0;
    pOut->z[nByte+2] = 0;
    pOut->flags |= MEM_Term;
    pOut->n = (int)nByte;
    pOut->enc = encoding;
    UPDATE_MAX_BLOBSIZE(pOut);
    break;
  }
  
  /* Opcode: Add P1 P2 P3 * *
  ** Synopsis: r[P3]=r[P1]+r[P2]
  **
  ** Add the value in register P1 to the value in register P2
  ** and store the result in register P3.
  ** If either input is NULL, the result is NULL.
  */
  /* Opcode: Multiply P1 P2 P3 * *
  ** Synopsis: r[P3]=r[P1]*r[P2]
  **
  **
  ** Multiply the value in register P1 by the value in register P2
  ** and store the result in register P3.
  ** If either input is NULL, the result is NULL.
  */
  /* Opcode: Subtract P1 P2 P3 * *
  ** Synopsis: r[P3]=r[P2]-r[P1]
  **
  ** Subtract the value in register P1 from the value in register P2
  ** and store the result in register P3.
  ** If either input is NULL, the result is NULL.
  */
  /* Opcode: Divide P1 P2 P3 * *
  ** Synopsis: r[P3]=r[P2]/r[P1]
  **
  ** Divide the value in register P1 by the value in register P2
  ** and store the result in register P3 (P3=P2/P1). If the value in 
  ** register P1 is zero, then the result is NULL. If either input is 
  ** NULL, the result is NULL.
  */
  /* Opcode: Remainder P1 P2 P3 * *
  ** Synopsis: r[P3]=r[P2]%r[P1]
  **
  ** Compute the remainder after integer register P2 is divided by 
  ** register P1 and store the result in register P3. 
  ** If the value in register P1 is zero the result is NULL.
  ** If either operand is NULL, the result is NULL.
  */
  case OP_Add:                   /* same as TK_PLUS, in1, in2, out3 */
  case OP_Subtract:              /* same as TK_MINUS, in1, in2, out3 */
  case OP_Multiply:              /* same as TK_STAR, in1, in2, out3 */
  case OP_Divide:                /* same as TK_SLASH, in1, in2, out3 */
  case OP_Remainder: {           /* same as TK_REM, in1, in2, out3 */
    u16 flags;      /* Combined MEM_* flags from both inputs */
    u16 type1;      /* Numeric type of left operand */
    u16 type2;      /* Numeric type of right operand */
    i64 iA;         /* Integer value of left operand */
    i64 iB;         /* Integer value of right operand */
    double rA;      /* Real value of left operand */
    double rB;      /* Real value of right operand */
  
    pIn1 = &aMem[pOp->p1];
    type1 = numericType(pIn1);
    pIn2 = &aMem[pOp->p2];
    type2 = numericType(pIn2);
    pOut = &aMem[pOp->p3];
    flags = pIn1->flags | pIn2->flags;
    if( (type1 & type2 & MEM_Int)!=0 ){
      iA = pIn1->u.i;
      iB = pIn2->u.i;
      switch( pOp->opcode ){
        case OP_Add:       if( sqlite3AddInt64(&iB,iA) ) goto fp_math;  break;
        case OP_Subtract:  if( sqlite3SubInt64(&iB,iA) ) goto fp_math;  break;
        case OP_Multiply:  if( sqlite3MulInt64(&iB,iA) ) goto fp_math;  break;
        case OP_Divide: {
          if( iA==0 ) goto arithmetic_result_is_null;
          if( iA==-1 && iB==SMALLEST_INT64 ) goto fp_math;
          iB /= iA;
          break;
        }
        default: {
          if( iA==0 ) goto arithmetic_result_is_null;
          if( iA==-1 ) iA = 1;
          iB %= iA;
          break;
        }
      }
      pOut->u.i = iB;
      MemSetTypeFlag(pOut, MEM_Int);
    }else if( (flags & MEM_Null)!=0 ){
      goto arithmetic_result_is_null;
    }else{
  fp_math:
      rA = sqlite3VdbeRealValue(pIn1);
      rB = sqlite3VdbeRealValue(pIn2);
      switch( pOp->opcode ){
        case OP_Add:         rB += rA;       break;
        case OP_Subtract:    rB -= rA;       break;
        case OP_Multiply:    rB *= rA;       break;
        case OP_Divide: {
          /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
          if( rA==(double)0 ) goto arithmetic_result_is_null;
          rB /= rA;
          break;
        }
        default: {
          iA = sqlite3VdbeIntValue(pIn1);
          iB = sqlite3VdbeIntValue(pIn2);
          if( iA==0 ) goto arithmetic_result_is_null;
          if( iA==-1 ) iA = 1;
          rB = (double)(iB % iA);
          break;
        }
      }
  #ifdef SQLITE_OMIT_FLOATING_POINT
      pOut->u.i = rB;
      MemSetTypeFlag(pOut, MEM_Int);
  #else
      if( sqlite3IsNaN(rB) ){
        goto arithmetic_result_is_null;
      }
      pOut->u.r = rB;
      MemSetTypeFlag(pOut, MEM_Real);
  #endif
    }
    break;
  
  arithmetic_result_is_null:
    sqlite3VdbeMemSetNull(pOut);
    break;
  }
  
  /* Opcode: CollSeq P1 * * P4
  **
  ** P4 is a pointer to a CollSeq object. If the next call to a user function
  ** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will
  ** be returned. This is used by the built-in min(), max() and nullif()
  ** functions.
  **
  ** If P1 is not zero, then it is a register that a subsequent min() or
  ** max() aggregate will set to 1 if the current row is not the minimum or
  ** maximum.  The P1 register is initialized to 0 by this instruction.
  **
  ** The interface used by the implementation of the aforementioned functions
  ** to retrieve the collation sequence set by this opcode is not available
  ** publicly.  Only built-in functions have access to this feature.
  */
  case OP_CollSeq: {
    assert( pOp->p4type==P4_COLLSEQ );
    if( pOp->p1 ){
      sqlite3VdbeMemSetInt64(&aMem[pOp->p1], 0);
    }
    break;
  }
  
  /* Opcode: BitAnd P1 P2 P3 * *
  ** Synopsis: r[P3]=r[P1]&r[P2]
  **
  ** Take the bit-wise AND of the values in register P1 and P2 and
  ** store the result in register P3.
  ** If either input is NULL, the result is NULL.
  */
  /* Opcode: BitOr P1 P2 P3 * *
  ** Synopsis: r[P3]=r[P1]|r[P2]
  **
  ** Take the bit-wise OR of the values in register P1 and P2 and
  ** store the result in register P3.
  ** If either input is NULL, the result is NULL.
  */
  /* Opcode: ShiftLeft P1 P2 P3 * *
  ** Synopsis: r[P3]=r[P2]<<r[P1]
  **
  ** Shift the integer value in register P2 to the left by the
  ** number of bits specified by the integer in register P1.
  ** Store the result in register P3.
  ** If either input is NULL, the result is NULL.
  */
  /* Opcode: ShiftRight P1 P2 P3 * *
  ** Synopsis: r[P3]=r[P2]>>r[P1]
  **
  ** Shift the integer value in register P2 to the right by the
  ** number of bits specified by the integer in register P1.
  ** Store the result in register P3.
  ** If either input is NULL, the result is NULL.
  */
  case OP_BitAnd:                 /* same as TK_BITAND, in1, in2, out3 */
  case OP_BitOr:                  /* same as TK_BITOR, in1, in2, out3 */
  case OP_ShiftLeft:              /* same as TK_LSHIFT, in1, in2, out3 */
  case OP_ShiftRight: {           /* same as TK_RSHIFT, in1, in2, out3 */
    i64 iA;
    u64 uA;
    i64 iB;
    u8 op;
  
    pIn1 = &aMem[pOp->p1];
    pIn2 = &aMem[pOp->p2];
    pOut = &aMem[pOp->p3];
    if( (pIn1->flags | pIn2->flags) & MEM_Null ){
      sqlite3VdbeMemSetNull(pOut);
      break;
    }
    iA = sqlite3VdbeIntValue(pIn2);
    iB = sqlite3VdbeIntValue(pIn1);
    op = pOp->opcode;
    if( op==OP_BitAnd ){
      iA &= iB;
    }else if( op==OP_BitOr ){
      iA |= iB;
    }else if( iB!=0 ){
      assert( op==OP_ShiftRight || op==OP_ShiftLeft );
  
      /* If shifting by a negative amount, shift in the other direction */
      if( iB<0 ){
        assert( OP_ShiftRight==OP_ShiftLeft+1 );
        op = 2*OP_ShiftLeft + 1 - op;
        iB = iB>(-64) ? -iB : 64;
      }
  
      if( iB>=64 ){
        iA = (iA>=0 || op==OP_ShiftLeft) ? 0 : -1;
      }else{
        memcpy(&uA, &iA, sizeof(uA));
        if( op==OP_ShiftLeft ){
          uA <<= iB;
        }else{
          uA >>= iB;
          /* Sign-extend on a right shift of a negative number */
          if( iA<0 ) uA |= ((((u64)0xffffffff)<<32)|0xffffffff) << (64-iB);
        }
        memcpy(&iA, &uA, sizeof(iA));
      }
    }
    pOut->u.i = iA;
    MemSetTypeFlag(pOut, MEM_Int);
    break;
  }
  
  /* Opcode: AddImm  P1 P2 * * *
  ** Synopsis: r[P1]=r[P1]+P2
  ** 
  ** Add the constant P2 to the value in register P1.
  ** The result is always an integer.
  **
  ** To force any register to be an integer, just add 0.
  */
  case OP_AddImm: {            /* in1 */
    pIn1 = &aMem[pOp->p1];
    memAboutToChange(p, pIn1);
    sqlite3VdbeMemIntegerify(pIn1);
    pIn1->u.i += pOp->p2;
    break;
  }
  
  /* Opcode: MustBeInt P1 P2 * * *
  ** 
  ** Force the value in register P1 to be an integer.  If the value
  ** in P1 is not an integer and cannot be converted into an integer
  ** without data loss, then jump immediately to P2, or if P2==0
  ** raise an SQLITE_MISMATCH exception.
  */
  case OP_MustBeInt: {            /* jump, in1 */
    pIn1 = &aMem[pOp->p1];
    if( (pIn1->flags & MEM_Int)==0 ){
      applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding);
      if( (pIn1->flags & MEM_Int)==0 ){
        VdbeBranchTaken(1, 2);
        if( pOp->p2==0 ){
          rc = SQLITE_MISMATCH;
          goto abort_due_to_error;
        }else{
          goto jump_to_p2;
        }
      }
    }
    VdbeBranchTaken(0, 2);
    MemSetTypeFlag(pIn1, MEM_Int);
    break;
  }
  
  #ifndef SQLITE_OMIT_FLOATING_POINT
  /* Opcode: RealAffinity P1 * * * *
  **
  ** If register P1 holds an integer convert it to a real value.
  **
  ** This opcode is used when extracting information from a column that
  ** has REAL affinity.  Such column values may still be stored as
  ** integers, for space efficiency, but after extraction we want them
  ** to have only a real value.
  */
  case OP_RealAffinity: {                  /* in1 */
    pIn1 = &aMem[pOp->p1];
    if( pIn1->flags & (MEM_Int|MEM_IntReal) ){
      testcase( pIn1->flags & MEM_Int );
      testcase( pIn1->flags & MEM_IntReal );
      sqlite3VdbeMemRealify(pIn1);
      REGISTER_TRACE(pOp->p1, pIn1);
    }
    break;
  }
  #endif
  
  #ifndef SQLITE_OMIT_CAST
  /* Opcode: Cast P1 P2 * * *
  ** Synopsis: affinity(r[P1])
  **
  ** Force the value in register P1 to be the type defined by P2.
  ** 
  ** <ul>
  ** <li> P2=='A' &rarr; BLOB
  ** <li> P2=='B' &rarr; TEXT
  ** <li> P2=='C' &rarr; NUMERIC
  ** <li> P2=='D' &rarr; INTEGER
  ** <li> P2=='E' &rarr; REAL
  ** </ul>
  **
  ** A NULL value is not changed by this routine.  It remains NULL.
  */
  case OP_Cast: {                  /* in1 */
    assert( pOp->p2>=SQLITE_AFF_BLOB && pOp->p2<=SQLITE_AFF_REAL );
    testcase( pOp->p2==SQLITE_AFF_TEXT );
    testcase( pOp->p2==SQLITE_AFF_BLOB );
    testcase( pOp->p2==SQLITE_AFF_NUMERIC );
    testcase( pOp->p2==SQLITE_AFF_INTEGER );
    testcase( pOp->p2==SQLITE_AFF_REAL );
    pIn1 = &aMem[pOp->p1];
    memAboutToChange(p, pIn1);
    rc = ExpandBlob(pIn1);
    if( rc ) goto abort_due_to_error;
    rc = sqlite3VdbeMemCast(pIn1, pOp->p2, encoding);
    if( rc ) goto abort_due_to_error;
    UPDATE_MAX_BLOBSIZE(pIn1);
    REGISTER_TRACE(pOp->p1, pIn1);
    break;
  }
  #endif /* SQLITE_OMIT_CAST */
  
  /* Opcode: Eq P1 P2 P3 P4 P5
  ** Synopsis: IF r[P3]==r[P1]
  **
  ** Compare the values in register P1 and P3.  If reg(P3)==reg(P1) then
  ** jump to address P2.  Or if the SQLITE_STOREP2 flag is set in P5, then
  ** store the result of comparison in register P2.
  **
  ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
  ** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made 
  ** to coerce both inputs according to this affinity before the
  ** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric
  ** affinity is used. Note that the affinity conversions are stored
  ** back into the input registers P1 and P3.  So this opcode can cause
  ** persistent changes to registers P1 and P3.
  **
  ** Once any conversions have taken place, and neither value is NULL, 
  ** the values are compared. If both values are blobs then memcmp() is
  ** used to determine the results of the comparison.  If both values
  ** are text, then the appropriate collating function specified in
  ** P4 is used to do the comparison.  If P4 is not specified then
  ** memcmp() is used to compare text string.  If both values are
  ** numeric, then a numeric comparison is used. If the two values
  ** are of different types, then numbers are considered less than
  ** strings and strings are considered less than blobs.
  **
  ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
  ** true or false and is never NULL.  If both operands are NULL then the result
  ** of comparison is true.  If either operand is NULL then the result is false.
  ** If neither operand is NULL the result is the same as it would be if
  ** the SQLITE_NULLEQ flag were omitted from P5.
  **
  ** If both SQLITE_STOREP2 and SQLITE_KEEPNULL flags are set then the
  ** content of r[P2] is only changed if the new value is NULL or 0 (false).
  ** In other words, a prior r[P2] value will not be overwritten by 1 (true).
  */
  /* Opcode: Ne P1 P2 P3 P4 P5
  ** Synopsis: IF r[P3]!=r[P1]
  **
  ** This works just like the Eq opcode except that the jump is taken if
  ** the operands in registers P1 and P3 are not equal.  See the Eq opcode for
  ** additional information.
  **
  ** If both SQLITE_STOREP2 and SQLITE_KEEPNULL flags are set then the
  ** content of r[P2] is only changed if the new value is NULL or 1 (true).
  ** In other words, a prior r[P2] value will not be overwritten by 0 (false).
  */
  /* Opcode: Lt P1 P2 P3 P4 P5
  ** Synopsis: IF r[P3]<r[P1]
  **
  ** Compare the values in register P1 and P3.  If reg(P3)<reg(P1) then
  ** jump to address P2.  Or if the SQLITE_STOREP2 flag is set in P5 store
  ** the result of comparison (0 or 1 or NULL) into register P2.
  **
  ** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or
  ** reg(P3) is NULL then the take the jump.  If the SQLITE_JUMPIFNULL 
  ** bit is clear then fall through if either operand is NULL.
  **
  ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
  ** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made 
  ** to coerce both inputs according to this affinity before the
  ** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric
  ** affinity is used. Note that the affinity conversions are stored
  ** back into the input registers P1 and P3.  So this opcode can cause
  ** persistent changes to registers P1 and P3.
  **
  ** Once any conversions have taken place, and neither value is NULL, 
  ** the values are compared. If both values are blobs then memcmp() is
  ** used to determine the results of the comparison.  If both values
  ** are text, then the appropriate collating function specified in
  ** P4 is  used to do the comparison.  If P4 is not specified then
  ** memcmp() is used to compare text string.  If both values are
  ** numeric, then a numeric comparison is used. If the two values
  ** are of different types, then numbers are considered less than
  ** strings and strings are considered less than blobs.
  */
  /* Opcode: Le P1 P2 P3 P4 P5
  ** Synopsis: IF r[P3]<=r[P1]
  **
  ** This works just like the Lt opcode except that the jump is taken if
  ** the content of register P3 is less than or equal to the content of
  ** register P1.  See the Lt opcode for additional information.
  */
  /* Opcode: Gt P1 P2 P3 P4 P5
  ** Synopsis: IF r[P3]>r[P1]
  **
  ** This works just like the Lt opcode except that the jump is taken if
  ** the content of register P3 is greater than the content of
  ** register P1.  See the Lt opcode for additional information.
  */
  /* Opcode: Ge P1 P2 P3 P4 P5
  ** Synopsis: IF r[P3]>=r[P1]
  **
  ** This works just like the Lt opcode except that the jump is taken if
  ** the content of register P3 is greater than or equal to the content of
  ** register P1.  See the Lt opcode for additional information.
  */
  case OP_Eq:               /* same as TK_EQ, jump, in1, in3 */
  case OP_Ne:               /* same as TK_NE, jump, in1, in3 */
  case OP_Lt:               /* same as TK_LT, jump, in1, in3 */
  case OP_Le:               /* same as TK_LE, jump, in1, in3 */
  case OP_Gt:               /* same as TK_GT, jump, in1, in3 */
  case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
    int res, res2;      /* Result of the comparison of pIn1 against pIn3 */
    char affinity;      /* Affinity to use for comparison */
    u16 flags1;         /* Copy of initial value of pIn1->flags */
    u16 flags3;         /* Copy of initial value of pIn3->flags */
  
    pIn1 = &aMem[pOp->p1];
    pIn3 = &aMem[pOp->p3];
    flags1 = pIn1->flags;
    flags3 = pIn3->flags;
    if( (flags1 | flags3)&MEM_Null ){
      /* One or both operands are NULL */
      if( pOp->p5 & SQLITE_NULLEQ ){
        /* If SQLITE_NULLEQ is set (which will only happen if the operator is
        ** OP_Eq or OP_Ne) then take the jump or not depending on whether
        ** or not both operands are null.
        */
        assert( (flags1 & MEM_Cleared)==0 );
        assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 || CORRUPT_DB );
        testcase( (pOp->p5 & SQLITE_JUMPIFNULL)!=0 );
        if( (flags1&flags3&MEM_Null)!=0
         && (flags3&MEM_Cleared)==0
        ){
          res = 0;  /* Operands are equal */
        }else{
          res = ((flags3 & MEM_Null) ? -1 : +1);  /* Operands are not equal */
        }
      }else{
        /* SQLITE_NULLEQ is clear and at least one operand is NULL,
        ** then the result is always NULL.
        ** The jump is taken if the SQLITE_JUMPIFNULL bit is set.
        */
        if( pOp->p5 & SQLITE_STOREP2 ){
          pOut = &aMem[pOp->p2];
          iCompare = 1;    /* Operands are not equal */
          memAboutToChange(p, pOut);
          MemSetTypeFlag(pOut, MEM_Null);
          REGISTER_TRACE(pOp->p2, pOut);
        }else{
          VdbeBranchTaken(2,3);
          if( pOp->p5 & SQLITE_JUMPIFNULL ){
            goto jump_to_p2;
          }
        }
        break;
      }
    }else{
      /* Neither operand is NULL.  Do a comparison. */
      affinity = pOp->p5 & SQLITE_AFF_MASK;
      if( affinity>=SQLITE_AFF_NUMERIC ){
        if( (flags1 | flags3)&MEM_Str ){
          if( (flags1 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){
            applyNumericAffinity(pIn1,0);
            testcase( flags3==pIn3->flags );
            flags3 = pIn3->flags;
          }
          if( (flags3 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){
            applyNumericAffinity(pIn3,0);
          }
        }
        /* Handle the common case of integer comparison here, as an
        ** optimization, to avoid a call to sqlite3MemCompare() */
        if( (pIn1->flags & pIn3->flags & MEM_Int)!=0 ){
          if( pIn3->u.i > pIn1->u.i ){ res = +1; goto compare_op; }
          if( pIn3->u.i < pIn1->u.i ){ res = -1; goto compare_op; }
          res = 0;
          goto compare_op;
        }
      }else if( affinity==SQLITE_AFF_TEXT ){
        if( (flags1 & MEM_Str)==0 && (flags1&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){
          testcase( pIn1->flags & MEM_Int );
          testcase( pIn1->flags & MEM_Real );
          testcase( pIn1->flags & MEM_IntReal );
          sqlite3VdbeMemStringify(pIn1, encoding, 1);
          testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) );
          flags1 = (pIn1->flags & ~MEM_TypeMask) | (flags1 & MEM_TypeMask);
          if( NEVER(pIn1==pIn3) ) flags3 = flags1 | MEM_Str;
        }
        if( (flags3 & MEM_Str)==0 && (flags3&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){
          testcase( pIn3->flags & MEM_Int );
          testcase( pIn3->flags & MEM_Real );
          testcase( pIn3->flags & MEM_IntReal );
          sqlite3VdbeMemStringify(pIn3, encoding, 1);
          testcase( (flags3&MEM_Dyn) != (pIn3->flags&MEM_Dyn) );
          flags3 = (pIn3->flags & ~MEM_TypeMask) | (flags3 & MEM_TypeMask);
        }
      }
      assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );
      res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl);
    }
  compare_op:
    /* At this point, res is negative, zero, or positive if reg[P1] is
    ** less than, equal to, or greater than reg[P3], respectively.  Compute
    ** the answer to this operator in res2, depending on what the comparison
    ** operator actually is.  The next block of code depends on the fact
    ** that the 6 comparison operators are consecutive integers in this
    ** order:  NE, EQ, GT, LE, LT, GE */
    assert( OP_Eq==OP_Ne+1 ); assert( OP_Gt==OP_Ne+2 ); assert( OP_Le==OP_Ne+3 );
    assert( OP_Lt==OP_Ne+4 ); assert( OP_Ge==OP_Ne+5 );
    if( res<0 ){                        /* ne, eq, gt, le, lt, ge */
      static const unsigned char aLTb[] = { 1,  0,  0,  1,  1,  0 };
      res2 = aLTb[pOp->opcode - OP_Ne];
    }else if( res==0 ){
      static const unsigned char aEQb[] = { 0,  1,  0,  1,  0,  1 };
      res2 = aEQb[pOp->opcode - OP_Ne];
    }else{
      static const unsigned char aGTb[] = { 1,  0,  1,  0,  0,  1 };
      res2 = aGTb[pOp->opcode - OP_Ne];
    }
  
    /* Undo any changes made by applyAffinity() to the input registers. */
    assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) );
    pIn3->flags = flags3;
    assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) );
    pIn1->flags = flags1;
  
    if( pOp->p5 & SQLITE_STOREP2 ){
      pOut = &aMem[pOp->p2];
      iCompare = res;
      if( (pOp->p5 & SQLITE_KEEPNULL)!=0 ){
        /* The KEEPNULL flag prevents OP_Eq from overwriting a NULL with 1
        ** and prevents OP_Ne from overwriting NULL with 0.  This flag
        ** is only used in contexts where either:
        **   (1) op==OP_Eq && (r[P2]==NULL || r[P2]==0)
        **   (2) op==OP_Ne && (r[P2]==NULL || r[P2]==1)
        ** Therefore it is not necessary to check the content of r[P2] for
        ** NULL. */
        assert( pOp->opcode==OP_Ne || pOp->opcode==OP_Eq );
        assert( res2==0 || res2==1 );
        testcase( res2==0 && pOp->opcode==OP_Eq );
        testcase( res2==1 && pOp->opcode==OP_Eq );
        testcase( res2==0 && pOp->opcode==OP_Ne );
        testcase( res2==1 && pOp->opcode==OP_Ne );
        if( (pOp->opcode==OP_Eq)==res2 ) break;
      }
      memAboutToChange(p, pOut);
      MemSetTypeFlag(pOut, MEM_Int);
      pOut->u.i = res2;
      REGISTER_TRACE(pOp->p2, pOut);
    }else{
      VdbeBranchTaken(res2!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3);
      if( res2 ){
        goto jump_to_p2;
      }
    }
    break;
  }
  
  /* Opcode: ElseNotEq * P2 * * *
  **
  ** This opcode must follow an OP_Lt or OP_Gt comparison operator.  There
  ** can be zero or more OP_ReleaseReg opcodes intervening, but no other
  ** opcodes are allowed to occur between this instruction and the previous
  ** OP_Lt or OP_Gt.  Furthermore, the prior OP_Lt or OP_Gt must have the
  ** SQLITE_STOREP2 bit set in the P5 field.
  **
  ** If result of an OP_Eq comparison on the same two operands as the
  ** prior OP_Lt or OP_Gt would have been NULL or false (0), then then
  ** jump to P2.  If the result of an OP_Eq comparison on the two previous
  ** operands would have been true (1), then fall through.
  */
  case OP_ElseNotEq: {       /* same as TK_ESCAPE, jump */
  
  #ifdef SQLITE_DEBUG
    /* Verify the preconditions of this opcode - that it follows an OP_Lt or
    ** OP_Gt with the SQLITE_STOREP2 flag set, with zero or more intervening
    ** OP_ReleaseReg opcodes */
    int iAddr;
    for(iAddr = (int)(pOp - aOp) - 1; ALWAYS(iAddr>=0); iAddr--){
      if( aOp[iAddr].opcode==OP_ReleaseReg ) continue;
      assert( aOp[iAddr].opcode==OP_Lt || aOp[iAddr].opcode==OP_Gt );
      assert( aOp[iAddr].p5 & SQLITE_STOREP2 );
      break;
    }
  #endif /* SQLITE_DEBUG */
    VdbeBranchTaken(iCompare!=0, 2);
    if( iCompare!=0 ) goto jump_to_p2;
    break;
  }
  
  
  /* Opcode: Permutation * * * P4 *
  **
  ** Set the permutation used by the OP_Compare operator in the next
  ** instruction.  The permutation is stored in the P4 operand.
  **
  ** The permutation is only valid until the next OP_Compare that has
  ** the OPFLAG_PERMUTE bit set in P5. Typically the OP_Permutation should 
  ** occur immediately prior to the OP_Compare.
  **
  ** The first integer in the P4 integer array is the length of the array
  ** and does not become part of the permutation.
  */
  case OP_Permutation: {
    assert( pOp->p4type==P4_INTARRAY );
    assert( pOp->p4.ai );
    assert( pOp[1].opcode==OP_Compare );
    assert( pOp[1].p5 & OPFLAG_PERMUTE );
    break;
  }
  
  /* Opcode: Compare P1 P2 P3 P4 P5
  ** Synopsis: r[P1@P3] <-> r[P2@P3]
  **
  ** Compare two vectors of registers in reg(P1)..reg(P1+P3-1) (call this
  ** vector "A") and in reg(P2)..reg(P2+P3-1) ("B").  Save the result of
  ** the comparison for use by the next OP_Jump instruct.
  **
  ** If P5 has the OPFLAG_PERMUTE bit set, then the order of comparison is
  ** determined by the most recent OP_Permutation operator.  If the
  ** OPFLAG_PERMUTE bit is clear, then register are compared in sequential
  ** order.
  **
  ** P4 is a KeyInfo structure that defines collating sequences and sort
  ** orders for the comparison.  The permutation applies to registers
  ** only.  The KeyInfo elements are used sequentially.
  **
  ** The comparison is a sort comparison, so NULLs compare equal,
  ** NULLs are less than numbers, numbers are less than strings,
  ** and strings are less than blobs.
  */
  case OP_Compare: {
    int n;
    int i;
    int p1;
    int p2;
    const KeyInfo *pKeyInfo;
    int idx;
    CollSeq *pColl;    /* Collating sequence to use on this term */
    int bRev;          /* True for DESCENDING sort order */
    int *aPermute;     /* The permutation */
  
    if( (pOp->p5 & OPFLAG_PERMUTE)==0 ){
      aPermute = 0;
    }else{
      assert( pOp>aOp );
      assert( pOp[-1].opcode==OP_Permutation );
      assert( pOp[-1].p4type==P4_INTARRAY );
      aPermute = pOp[-1].p4.ai + 1;
      assert( aPermute!=0 );
    }
    n = pOp->p3;
    pKeyInfo = pOp->p4.pKeyInfo;
    assert( n>0 );
    assert( pKeyInfo!=0 );
    p1 = pOp->p1;
    p2 = pOp->p2;
  #ifdef SQLITE_DEBUG
    if( aPermute ){
      int k, mx = 0;
      for(k=0; k<n; k++) if( aPermute[k]>mx ) mx = aPermute[k];
      assert( p1>0 && p1+mx<=(p->nMem+1 - p->nCursor)+1 );
      assert( p2>0 && p2+mx<=(p->nMem+1 - p->nCursor)+1 );
    }else{
      assert( p1>0 && p1+n<=(p->nMem+1 - p->nCursor)+1 );
      assert( p2>0 && p2+n<=(p->nMem+1 - p->nCursor)+1 );
    }
  #endif /* SQLITE_DEBUG */
    for(i=0; i<n; i++){
      idx = aPermute ? aPermute[i] : i;
      assert( memIsValid(&aMem[p1+idx]) );
      assert( memIsValid(&aMem[p2+idx]) );
      REGISTER_TRACE(p1+idx, &aMem[p1+idx]);
      REGISTER_TRACE(p2+idx, &aMem[p2+idx]);
      assert( i<pKeyInfo->nKeyField );
      pColl = pKeyInfo->aColl[i];
      bRev = (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC);
      iCompare = sqlite3MemCompare(&aMem[p1+idx], &aMem[p2+idx], pColl);
      if( iCompare ){
        if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) 
         && ((aMem[p1+idx].flags & MEM_Null) || (aMem[p2+idx].flags & MEM_Null))
        ){
          iCompare = -iCompare;
        }
        if( bRev ) iCompare = -iCompare;
        break;
      }
    }
    break;
  }
  
  /* Opcode: Jump P1 P2 P3 * *
  **
  ** Jump to the instruction at address P1, P2, or P3 depending on whether
  ** in the most recent OP_Compare instruction the P1 vector was less than
  ** equal to, or greater than the P2 vector, respectively.
  */
  case OP_Jump: {             /* jump */
    if( iCompare<0 ){
      VdbeBranchTaken(0,4); pOp = &aOp[pOp->p1 - 1];
    }else if( iCompare==0 ){
      VdbeBranchTaken(1,4); pOp = &aOp[pOp->p2 - 1];
    }else{
      VdbeBranchTaken(2,4); pOp = &aOp[pOp->p3 - 1];
    }
    break;
  }
  
  /* Opcode: And P1 P2 P3 * *
  ** Synopsis: r[P3]=(r[P1] && r[P2])
  **
  ** Take the logical AND of the values in registers P1 and P2 and
  ** write the result into register P3.
  **
  ** If either P1 or P2 is 0 (false) then the result is 0 even if
  ** the other input is NULL.  A NULL and true or two NULLs give
  ** a NULL output.
  */
  /* Opcode: Or P1 P2 P3 * *
  ** Synopsis: r[P3]=(r[P1] || r[P2])
  **
  ** Take the logical OR of the values in register P1 and P2 and
  ** store the answer in register P3.
  **
  ** If either P1 or P2 is nonzero (true) then the result is 1 (true)
  ** even if the other input is NULL.  A NULL and false or two NULLs
  ** give a NULL output.
  */
  case OP_And:              /* same as TK_AND, in1, in2, out3 */
  case OP_Or: {             /* same as TK_OR, in1, in2, out3 */
    int v1;    /* Left operand:  0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
    int v2;    /* Right operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
  
    v1 = sqlite3VdbeBooleanValue(&aMem[pOp->p1], 2);
    v2 = sqlite3VdbeBooleanValue(&aMem[pOp->p2], 2);
    if( pOp->opcode==OP_And ){
      static const unsigned char and_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 };
      v1 = and_logic[v1*3+v2];
    }else{
      static const unsigned char or_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 };
      v1 = or_logic[v1*3+v2];
    }
    pOut = &aMem[pOp->p3];
    if( v1==2 ){
      MemSetTypeFlag(pOut, MEM_Null);
    }else{
      pOut->u.i = v1;
      MemSetTypeFlag(pOut, MEM_Int);
    }
    break;
  }
  
  /* Opcode: IsTrue P1 P2 P3 P4 *
  ** Synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4
  **
  ** This opcode implements the IS TRUE, IS FALSE, IS NOT TRUE, and
  ** IS NOT FALSE operators.
  **
  ** Interpret the value in register P1 as a boolean value.  Store that
  ** boolean (a 0 or 1) in register P2.  Or if the value in register P1 is 
  ** NULL, then the P3 is stored in register P2.  Invert the answer if P4
  ** is 1.
  **
  ** The logic is summarized like this:
  **
  ** <ul> 
  ** <li> If P3==0 and P4==0  then  r[P2] := r[P1] IS TRUE
  ** <li> If P3==1 and P4==1  then  r[P2] := r[P1] IS FALSE
  ** <li> If P3==0 and P4==1  then  r[P2] := r[P1] IS NOT TRUE
  ** <li> If P3==1 and P4==0  then  r[P2] := r[P1] IS NOT FALSE
  ** </ul>
  */
  case OP_IsTrue: {               /* in1, out2 */
    assert( pOp->p4type==P4_INT32 );
    assert( pOp->p4.i==0 || pOp->p4.i==1 );
    assert( pOp->p3==0 || pOp->p3==1 );
    sqlite3VdbeMemSetInt64(&aMem[pOp->p2],
        sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3) ^ pOp->p4.i);
    break;
  }
  
  /* Opcode: Not P1 P2 * * *
  ** Synopsis: r[P2]= !r[P1]
  **
  ** Interpret the value in register P1 as a boolean value.  Store the
  ** boolean complement in register P2.  If the value in register P1 is 
  ** NULL, then a NULL is stored in P2.
  */
  case OP_Not: {                /* same as TK_NOT, in1, out2 */
    pIn1 = &aMem[pOp->p1];
    pOut = &aMem[pOp->p2];
    if( (pIn1->flags & MEM_Null)==0 ){
      sqlite3VdbeMemSetInt64(pOut, !sqlite3VdbeBooleanValue(pIn1,0));
    }else{
      sqlite3VdbeMemSetNull(pOut);
    }
    break;
  }
  
  /* Opcode: BitNot P1 P2 * * *
  ** Synopsis: r[P2]= ~r[P1]
  **
  ** Interpret the content of register P1 as an integer.  Store the
  ** ones-complement of the P1 value into register P2.  If P1 holds
  ** a NULL then store a NULL in P2.
  */
  case OP_BitNot: {             /* same as TK_BITNOT, in1, out2 */
    pIn1 = &aMem[pOp->p1];
    pOut = &aMem[pOp->p2];
    sqlite3VdbeMemSetNull(pOut);
    if( (pIn1->flags & MEM_Null)==0 ){
      pOut->flags = MEM_Int;
      pOut->u.i = ~sqlite3VdbeIntValue(pIn1);
    }
    break;
  }
  
  /* Opcode: Once P1 P2 * * *
  **
  ** Fall through to the next instruction the first time this opcode is
  ** encountered on each invocation of the byte-code program.  Jump to P2
  ** on the second and all subsequent encounters during the same invocation.
  **
  ** Top-level programs determine first invocation by comparing the P1
  ** operand against the P1 operand on the OP_Init opcode at the beginning
  ** of the program.  If the P1 values differ, then fall through and make
  ** the P1 of this opcode equal to the P1 of OP_Init.  If P1 values are
  ** the same then take the jump.
  **
  ** For subprograms, there is a bitmask in the VdbeFrame that determines
  ** whether or not the jump should be taken.  The bitmask is necessary
  ** because the self-altering code trick does not work for recursive
  ** triggers.
  */
  case OP_Once: {             /* jump */
    u32 iAddr;                /* Address of this instruction */
    assert( p->aOp[0].opcode==OP_Init );
    if( p->pFrame ){
      iAddr = (int)(pOp - p->aOp);
      if( (p->pFrame->aOnce[iAddr/8] & (1<<(iAddr & 7)))!=0 ){
        VdbeBranchTaken(1, 2);
        goto jump_to_p2;
      }
      p->pFrame->aOnce[iAddr/8] |= 1<<(iAddr & 7);
    }else{
      if( p->aOp[0].p1==pOp->p1 ){
        VdbeBranchTaken(1, 2);
        goto jump_to_p2;
      }
    }
    VdbeBranchTaken(0, 2);
    pOp->p1 = p->aOp[0].p1;
    break;
  }
  
  /* Opcode: If P1 P2 P3 * *
  **
  ** Jump to P2 if the value in register P1 is true.  The value
  ** is considered true if it is numeric and non-zero.  If the value
  ** in P1 is NULL then take the jump if and only if P3 is non-zero.
  */
  case OP_If:  {               /* jump, in1 */
    int c;
    c = sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3);
    VdbeBranchTaken(c!=0, 2);
    if( c ) goto jump_to_p2;
    break;
  }
  
  /* Opcode: IfNot P1 P2 P3 * *
  **
  ** Jump to P2 if the value in register P1 is False.  The value
  ** is considered false if it has a numeric value of zero.  If the value
  ** in P1 is NULL then take the jump if and only if P3 is non-zero.
  */
  case OP_IfNot: {            /* jump, in1 */
    int c;
    c = !sqlite3VdbeBooleanValue(&aMem[pOp->p1], !pOp->p3);
    VdbeBranchTaken(c!=0, 2);
    if( c ) goto jump_to_p2;
    break;
  }
  
  /* Opcode: IsNull P1 P2 * * *
  ** Synopsis: if r[P1]==NULL goto P2
  **
  ** Jump to P2 if the value in register P1 is NULL.
  */
  case OP_IsNull: {            /* same as TK_ISNULL, jump, in1 */
    pIn1 = &aMem[pOp->p1];
    VdbeBranchTaken( (pIn1->flags & MEM_Null)!=0, 2);
    if( (pIn1->flags & MEM_Null)!=0 ){
      goto jump_to_p2;
    }
    break;
  }
  
  /* Opcode: NotNull P1 P2 * * *
  ** Synopsis: if r[P1]!=NULL goto P2
  **
  ** Jump to P2 if the value in register P1 is not NULL.  
  */
  case OP_NotNull: {            /* same as TK_NOTNULL, jump, in1 */
    pIn1 = &aMem[pOp->p1];
    VdbeBranchTaken( (pIn1->flags & MEM_Null)==0, 2);
    if( (pIn1->flags & MEM_Null)==0 ){
      goto jump_to_p2;
    }
    break;
  }
  
  /* Opcode: IfNullRow P1 P2 P3 * *
  ** Synopsis: if P1.nullRow then r[P3]=NULL, goto P2
  **
  ** Check the cursor P1 to see if it is currently pointing at a NULL row.
  ** If it is, then set register P3 to NULL and jump immediately to P2.
  ** If P1 is not on a NULL row, then fall through without making any
  ** changes.
  */
  case OP_IfNullRow: {         /* jump */
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    assert( p->apCsr[pOp->p1]!=0 );
    if( p->apCsr[pOp->p1]->nullRow ){
      sqlite3VdbeMemSetNull(aMem + pOp->p3);
      goto jump_to_p2;
    }
    break;
  }
  
  #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC
  /* Opcode: Offset P1 P2 P3 * *
  ** Synopsis: r[P3] = sqlite_offset(P1)
  **
  ** Store in register r[P3] the byte offset into the database file that is the
  ** start of the payload for the record at which that cursor P1 is currently
  ** pointing.
  **
  ** P2 is the column number for the argument to the sqlite_offset() function.
  ** This opcode does not use P2 itself, but the P2 value is used by the
  ** code generator.  The P1, P2, and P3 operands to this opcode are the
  ** same as for OP_Column.
  **
  ** This opcode is only available if SQLite is compiled with the
  ** -DSQLITE_ENABLE_OFFSET_SQL_FUNC option.
  */
  case OP_Offset: {          /* out3 */
    VdbeCursor *pC;    /* The VDBE cursor */
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    pOut = &p->aMem[pOp->p3];
    if( NEVER(pC==0) || pC->eCurType!=CURTYPE_BTREE ){
      sqlite3VdbeMemSetNull(pOut);
    }else{
      sqlite3VdbeMemSetInt64(pOut, sqlite3BtreeOffset(pC->uc.pCursor));
    }
    break;
  }
  #endif /* SQLITE_ENABLE_OFFSET_SQL_FUNC */
  
  /* Opcode: Column P1 P2 P3 P4 P5
  ** Synopsis: r[P3]=PX
  **
  ** Interpret the data that cursor P1 points to as a structure built using
  ** the MakeRecord instruction.  (See the MakeRecord opcode for additional
  ** information about the format of the data.)  Extract the P2-th column
  ** from this record.  If there are less that (P2+1) 
  ** values in the record, extract a NULL.
  **
  ** The value extracted is stored in register P3.
  **
  ** If the record contains fewer than P2 fields, then extract a NULL.  Or,
  ** if the P4 argument is a P4_MEM use the value of the P4 argument as
  ** the result.
  **
  ** If the OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG bits are set on P5 then
  ** the result is guaranteed to only be used as the argument of a length()
  ** or typeof() function, respectively.  The loading of large blobs can be
  ** skipped for length() and all content loading can be skipped for typeof().
  */
  case OP_Column: {
    int p2;            /* column number to retrieve */
    VdbeCursor *pC;    /* The VDBE cursor */
    BtCursor *pCrsr;   /* The BTree cursor */
    u32 *aOffset;      /* aOffset[i] is offset to start of data for i-th column */
    int len;           /* The length of the serialized data for the column */
    int i;             /* Loop counter */
    Mem *pDest;        /* Where to write the extracted value */
    Mem sMem;          /* For storing the record being decoded */
    const u8 *zData;   /* Part of the record being decoded */
    const u8 *zHdr;    /* Next unparsed byte of the header */
    const u8 *zEndHdr; /* Pointer to first byte after the header */
    u64 offset64;      /* 64-bit offset */
    u32 t;             /* A type code from the record header */
    Mem *pReg;         /* PseudoTable input register */
  
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    p2 = pOp->p2;
  
    /* If the cursor cache is stale (meaning it is not currently point at
    ** the correct row) then bring it up-to-date by doing the necessary 
    ** B-Tree seek. */
    rc = sqlite3VdbeCursorMoveto(&pC, &p2);
    if( rc ) goto abort_due_to_error;
  
    assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
    pDest = &aMem[pOp->p3];
    memAboutToChange(p, pDest);
    assert( pC!=0 );
    assert( p2<pC->nField );
    aOffset = pC->aOffset;
    assert( pC->eCurType!=CURTYPE_VTAB );
    assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
    assert( pC->eCurType!=CURTYPE_SORTER );
  
    if( pC->cacheStatus!=p->cacheCtr ){                /*OPTIMIZATION-IF-FALSE*/
      if( pC->nullRow ){
        if( pC->eCurType==CURTYPE_PSEUDO ){
          /* For the special case of as pseudo-cursor, the seekResult field
          ** identifies the register that holds the record */
          assert( pC->seekResult>0 );
          pReg = &aMem[pC->seekResult];
          assert( pReg->flags & MEM_Blob );
          assert( memIsValid(pReg) );
          pC->payloadSize = pC->szRow = pReg->n;
          pC->aRow = (u8*)pReg->z;
        }else{
          sqlite3VdbeMemSetNull(pDest);
          goto op_column_out;
        }
      }else{
        pCrsr = pC->uc.pCursor;
        assert( pC->eCurType==CURTYPE_BTREE );
        assert( pCrsr );
        assert( sqlite3BtreeCursorIsValid(pCrsr) );
        pC->payloadSize = sqlite3BtreePayloadSize(pCrsr);
        pC->aRow = sqlite3BtreePayloadFetch(pCrsr, &pC->szRow);
        assert( pC->szRow<=pC->payloadSize );
        assert( pC->szRow<=65536 );  /* Maximum page size is 64KiB */
        if( pC->payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
          goto too_big;
        }
      }
      pC->cacheStatus = p->cacheCtr;
      pC->iHdrOffset = getVarint32(pC->aRow, aOffset[0]);
      pC->nHdrParsed = 0;
  
  
      if( pC->szRow<aOffset[0] ){      /*OPTIMIZATION-IF-FALSE*/
        /* pC->aRow does not have to hold the entire row, but it does at least
        ** need to cover the header of the record.  If pC->aRow does not contain
        ** the complete header, then set it to zero, forcing the header to be
        ** dynamically allocated. */
        pC->aRow = 0;
        pC->szRow = 0;
  
        /* Make sure a corrupt database has not given us an oversize header.
        ** Do this now to avoid an oversize memory allocation.
        **
        ** Type entries can be between 1 and 5 bytes each.  But 4 and 5 byte
        ** types use so much data space that there can only be 4096 and 32 of
        ** them, respectively.  So the maximum header length results from a
        ** 3-byte type for each of the maximum of 32768 columns plus three
        ** extra bytes for the header length itself.  32768*3 + 3 = 98307.
        */
        if( aOffset[0] > 98307 || aOffset[0] > pC->payloadSize ){
          goto op_column_corrupt;
        }
      }else{
        /* This is an optimization.  By skipping over the first few tests
        ** (ex: pC->nHdrParsed<=p2) in the next section, we achieve a
        ** measurable performance gain.
        **
        ** This branch is taken even if aOffset[0]==0.  Such a record is never
        ** generated by SQLite, and could be considered corruption, but we
        ** accept it for historical reasons.  When aOffset[0]==0, the code this
        ** branch jumps to reads past the end of the record, but never more
        ** than a few bytes.  Even if the record occurs at the end of the page
        ** content area, the "page header" comes after the page content and so
        ** this overread is harmless.  Similar overreads can occur for a corrupt
        ** database file.
        */
        zData = pC->aRow;
        assert( pC->nHdrParsed<=p2 );         /* Conditional skipped */
        testcase( aOffset[0]==0 );
        goto op_column_read_header;
      }
    }
  
    /* Make sure at least the first p2+1 entries of the header have been
    ** parsed and valid information is in aOffset[] and pC->aType[].
    */
    if( pC->nHdrParsed<=p2 ){
      /* If there is more header available for parsing in the record, try
      ** to extract additional fields up through the p2+1-th field 
      */
      if( pC->iHdrOffset<aOffset[0] ){
        /* Make sure zData points to enough of the record to cover the header. */
        if( pC->aRow==0 ){
          memset(&sMem, 0, sizeof(sMem));
          rc = sqlite3VdbeMemFromBtreeZeroOffset(pC->uc.pCursor,aOffset[0],&sMem);
          if( rc!=SQLITE_OK ) goto abort_due_to_error;
          zData = (u8*)sMem.z;
        }else{
          zData = pC->aRow;
        }
    
        /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */
      op_column_read_header:
        i = pC->nHdrParsed;
        offset64 = aOffset[i];
        zHdr = zData + pC->iHdrOffset;
        zEndHdr = zData + aOffset[0];
        testcase( zHdr>=zEndHdr );
        do{
          if( (pC->aType[i] = t = zHdr[0])<0x80 ){
            zHdr++;
            offset64 += sqlite3VdbeOneByteSerialTypeLen(t);
          }else{
            zHdr += sqlite3GetVarint32(zHdr, &t);
            pC->aType[i] = t;
            offset64 += sqlite3VdbeSerialTypeLen(t);
          }
          aOffset[++i] = (u32)(offset64 & 0xffffffff);
        }while( i<=p2 && zHdr<zEndHdr );
  
        /* The record is corrupt if any of the following are true:
        ** (1) the bytes of the header extend past the declared header size
        ** (2) the entire header was used but not all data was used
        ** (3) the end of the data extends beyond the end of the record.
        */
        if( (zHdr>=zEndHdr && (zHdr>zEndHdr || offset64!=pC->payloadSize))
         || (offset64 > pC->payloadSize)
        ){
          if( aOffset[0]==0 ){
            i = 0;
            zHdr = zEndHdr;
          }else{
            if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
            goto op_column_corrupt;
          }
        }
  
        pC->nHdrParsed = i;
        pC->iHdrOffset = (u32)(zHdr - zData);
        if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
      }else{
        t = 0;
      }
  
      /* If after trying to extract new entries from the header, nHdrParsed is
      ** still not up to p2, that means that the record has fewer than p2
      ** columns.  So the result will be either the default value or a NULL.
      */
      if( pC->nHdrParsed<=p2 ){
        if( pOp->p4type==P4_MEM ){
          sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static);
        }else{
          sqlite3VdbeMemSetNull(pDest);
        }
        goto op_column_out;
      }
    }else{
      t = pC->aType[p2];
    }
  
    /* Extract the content for the p2+1-th column.  Control can only
    ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are
    ** all valid.
    */
    assert( p2<pC->nHdrParsed );
    assert( rc==SQLITE_OK );
    assert( sqlite3VdbeCheckMemInvariants(pDest) );
    if( VdbeMemDynamic(pDest) ){
      sqlite3VdbeMemSetNull(pDest);
    }
    assert( t==pC->aType[p2] );
    if( pC->szRow>=aOffset[p2+1] ){
      /* This is the common case where the desired content fits on the original
      ** page - where the content is not on an overflow page */
      zData = pC->aRow + aOffset[p2];
      if( t<12 ){
        sqlite3VdbeSerialGet(zData, t, pDest);
      }else{
        /* If the column value is a string, we need a persistent value, not
        ** a MEM_Ephem value.  This branch is a fast short-cut that is equivalent
        ** to calling sqlite3VdbeSerialGet() and sqlite3VdbeDeephemeralize().
        */
        static const u16 aFlag[] = { MEM_Blob, MEM_Str|MEM_Term };
        pDest->n = len = (t-12)/2;
        pDest->enc = encoding;
        if( pDest->szMalloc < len+2 ){
          pDest->flags = MEM_Null;
          if( sqlite3VdbeMemGrow(pDest, len+2, 0) ) goto no_mem;
        }else{
          pDest->z = pDest->zMalloc;
        }
        memcpy(pDest->z, zData, len);
        pDest->z[len] = 0;
        pDest->z[len+1] = 0;
        pDest->flags = aFlag[t&1];
      }
    }else{
      pDest->enc = encoding;
      /* This branch happens only when content is on overflow pages */
      if( ((pOp->p5 & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG))!=0
            && ((t>=12 && (t&1)==0) || (pOp->p5 & OPFLAG_TYPEOFARG)!=0))
       || (len = sqlite3VdbeSerialTypeLen(t))==0
      ){
        /* Content is irrelevant for
        **    1. the typeof() function,
        **    2. the length(X) function if X is a blob, and
        **    3. if the content length is zero.
        ** So we might as well use bogus content rather than reading
        ** content from disk. 
        **
        ** Although sqlite3VdbeSerialGet() may read at most 8 bytes from the
        ** buffer passed to it, debugging function VdbeMemPrettyPrint() may
        ** read more.  Use the global constant sqlite3CtypeMap[] as the array,
        ** as that array is 256 bytes long (plenty for VdbeMemPrettyPrint())
        ** and it begins with a bunch of zeros.
        */
        sqlite3VdbeSerialGet((u8*)sqlite3CtypeMap, t, pDest);
      }else{
        rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, aOffset[p2], len, pDest);
        if( rc!=SQLITE_OK ) goto abort_due_to_error;
        sqlite3VdbeSerialGet((const u8*)pDest->z, t, pDest);
        pDest->flags &= ~MEM_Ephem;
      }
    }
  
  op_column_out:
    UPDATE_MAX_BLOBSIZE(pDest);
    REGISTER_TRACE(pOp->p3, pDest);
    break;
  
  op_column_corrupt:
    if( aOp[0].p3>0 ){
      pOp = &aOp[aOp[0].p3-1];
      break;
    }else{
      rc = SQLITE_CORRUPT_BKPT;
      goto abort_due_to_error;
    }
  }
  
  /* Opcode: Affinity P1 P2 * P4 *
  ** Synopsis: affinity(r[P1@P2])
  **
  ** Apply affinities to a range of P2 registers starting with P1.
  **
  ** P4 is a string that is P2 characters long. The N-th character of the
  ** string indicates the column affinity that should be used for the N-th
  ** memory cell in the range.
  */
  case OP_Affinity: {
    const char *zAffinity;   /* The affinity to be applied */
  
    zAffinity = pOp->p4.z;
    assert( zAffinity!=0 );
    assert( pOp->p2>0 );
    assert( zAffinity[pOp->p2]==0 );
    pIn1 = &aMem[pOp->p1];
    while( 1 /*exit-by-break*/ ){
      assert( pIn1 <= &p->aMem[(p->nMem+1 - p->nCursor)] );
      assert( zAffinity[0]==SQLITE_AFF_NONE || memIsValid(pIn1) );
      applyAffinity(pIn1, zAffinity[0], encoding);
      if( zAffinity[0]==SQLITE_AFF_REAL && (pIn1->flags & MEM_Int)!=0 ){
        /* When applying REAL affinity, if the result is still an MEM_Int
        ** that will fit in 6 bytes, then change the type to MEM_IntReal
        ** so that we keep the high-resolution integer value but know that
        ** the type really wants to be REAL. */
        testcase( pIn1->u.i==140737488355328LL );
        testcase( pIn1->u.i==140737488355327LL );
        testcase( pIn1->u.i==-140737488355328LL );
        testcase( pIn1->u.i==-140737488355329LL );
        if( pIn1->u.i<=140737488355327LL && pIn1->u.i>=-140737488355328LL ){
          pIn1->flags |= MEM_IntReal;
          pIn1->flags &= ~MEM_Int;
        }else{
          pIn1->u.r = (double)pIn1->u.i;
          pIn1->flags |= MEM_Real;
          pIn1->flags &= ~MEM_Int;
        }
      }
      REGISTER_TRACE((int)(pIn1-aMem), pIn1);
      zAffinity++;
      if( zAffinity[0]==0 ) break;
      pIn1++;
    }
    break;
  }
  
  /* Opcode: MakeRecord P1 P2 P3 P4 *
  ** Synopsis: r[P3]=mkrec(r[P1@P2])
  **
  ** Convert P2 registers beginning with P1 into the [record format]
  ** use as a data record in a database table or as a key
  ** in an index.  The OP_Column opcode can decode the record later.
  **
  ** P4 may be a string that is P2 characters long.  The N-th character of the
  ** string indicates the column affinity that should be used for the N-th
  ** field of the index key.
  **
  ** The mapping from character to affinity is given by the SQLITE_AFF_
  ** macros defined in sqliteInt.h.
  **
  ** If P4 is NULL then all index fields have the affinity BLOB.
  */
  case OP_MakeRecord: {
    Mem *pRec;             /* The new record */
    u64 nData;             /* Number of bytes of data space */
    int nHdr;              /* Number of bytes of header space */
    i64 nByte;             /* Data space required for this record */
    i64 nZero;             /* Number of zero bytes at the end of the record */
    int nVarint;           /* Number of bytes in a varint */
    u32 serial_type;       /* Type field */
    Mem *pData0;           /* First field to be combined into the record */
    Mem *pLast;            /* Last field of the record */
    int nField;            /* Number of fields in the record */
    char *zAffinity;       /* The affinity string for the record */
    int file_format;       /* File format to use for encoding */
    u32 len;               /* Length of a field */
    u8 *zHdr;              /* Where to write next byte of the header */
    u8 *zPayload;          /* Where to write next byte of the payload */
  
    /* Assuming the record contains N fields, the record format looks
    ** like this:
    **
    ** ------------------------------------------------------------------------
    ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 | 
    ** ------------------------------------------------------------------------
    **
    ** Data(0) is taken from register P1.  Data(1) comes from register P1+1
    ** and so forth.
    **
    ** Each type field is a varint representing the serial type of the 
    ** corresponding data element (see sqlite3VdbeSerialType()). The
    ** hdr-size field is also a varint which is the offset from the beginning
    ** of the record to data0.
    */
    nData = 0;         /* Number of bytes of data space */
    nHdr = 0;          /* Number of bytes of header space */
    nZero = 0;         /* Number of zero bytes at the end of the record */
    nField = pOp->p1;
    zAffinity = pOp->p4.z;
    assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem+1 - p->nCursor)+1 );
    pData0 = &aMem[nField];
    nField = pOp->p2;
    pLast = &pData0[nField-1];
    file_format = p->minWriteFileFormat;
  
    /* Identify the output register */
    assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
    pOut = &aMem[pOp->p3];
    memAboutToChange(p, pOut);
  
    /* Apply the requested affinity to all inputs
    */
    assert( pData0<=pLast );
    if( zAffinity ){
      pRec = pData0;
      do{
        applyAffinity(pRec, zAffinity[0], encoding);
        if( zAffinity[0]==SQLITE_AFF_REAL && (pRec->flags & MEM_Int) ){
          pRec->flags |= MEM_IntReal;
          pRec->flags &= ~(MEM_Int);
        }
        REGISTER_TRACE((int)(pRec-aMem), pRec);
        zAffinity++;
        pRec++;
        assert( zAffinity[0]==0 || pRec<=pLast );
      }while( zAffinity[0] );
    }
  
  #ifdef SQLITE_ENABLE_NULL_TRIM
    /* NULLs can be safely trimmed from the end of the record, as long as
    ** as the schema format is 2 or more and none of the omitted columns
    ** have a non-NULL default value.  Also, the record must be left with
    ** at least one field.  If P5>0 then it will be one more than the
    ** index of the right-most column with a non-NULL default value */
    if( pOp->p5 ){
      while( (pLast->flags & MEM_Null)!=0 && nField>pOp->p5 ){
        pLast--;
        nField--;
      }
    }
  #endif
  
    /* Loop through the elements that will make up the record to figure
    ** out how much space is required for the new record.  After this loop,
    ** the Mem.uTemp field of each term should hold the serial-type that will
    ** be used for that term in the generated record:
    **
    **   Mem.uTemp value    type
    **   ---------------    ---------------
    **      0               NULL
    **      1               1-byte signed integer
    **      2               2-byte signed integer
    **      3               3-byte signed integer
    **      4               4-byte signed integer
    **      5               6-byte signed integer
    **      6               8-byte signed integer
    **      7               IEEE float
    **      8               Integer constant 0
    **      9               Integer constant 1
    **     10,11            reserved for expansion
    **    N>=12 and even    BLOB
    **    N>=13 and odd     text
    **
    ** The following additional values are computed:
    **     nHdr        Number of bytes needed for the record header
    **     nData       Number of bytes of data space needed for the record
    **     nZero       Zero bytes at the end of the record
    */
    pRec = pLast;
    do{
      assert( memIsValid(pRec) );
      if( pRec->flags & MEM_Null ){
        if( pRec->flags & MEM_Zero ){
          /* Values with MEM_Null and MEM_Zero are created by xColumn virtual
          ** table methods that never invoke sqlite3_result_xxxxx() while
          ** computing an unchanging column value in an UPDATE statement.
          ** Give such values a special internal-use-only serial-type of 10
          ** so that they can be passed through to xUpdate and have
          ** a true sqlite3_value_nochange(). */
          assert( pOp->p5==OPFLAG_NOCHNG_MAGIC || CORRUPT_DB );
          pRec->uTemp = 10;
        }else{
          pRec->uTemp = 0;
        }
        nHdr++;
      }else if( pRec->flags & (MEM_Int|MEM_IntReal) ){
        /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */
        i64 i = pRec->u.i;
        u64 uu;
        testcase( pRec->flags & MEM_Int );
        testcase( pRec->flags & MEM_IntReal );
        if( i<0 ){
          uu = ~i;
        }else{
          uu = i;
        }
        nHdr++;
        testcase( uu==127 );               testcase( uu==128 );
        testcase( uu==32767 );             testcase( uu==32768 );
        testcase( uu==8388607 );           testcase( uu==8388608 );
        testcase( uu==2147483647 );        testcase( uu==2147483648 );
        testcase( uu==140737488355327LL ); testcase( uu==140737488355328LL );
        if( uu<=127 ){
          if( (i&1)==i && file_format>=4 ){
            pRec->uTemp = 8+(u32)uu;
          }else{
            nData++;
            pRec->uTemp = 1;
          }
        }else if( uu<=32767 ){
          nData += 2;
          pRec->uTemp = 2;
        }else if( uu<=8388607 ){
          nData += 3;
          pRec->uTemp = 3;
        }else if( uu<=2147483647 ){
          nData += 4;
          pRec->uTemp = 4;
        }else if( uu<=140737488355327LL ){
          nData += 6;
          pRec->uTemp = 5;
        }else{
          nData += 8;
          if( pRec->flags & MEM_IntReal ){
            /* If the value is IntReal and is going to take up 8 bytes to store
            ** as an integer, then we might as well make it an 8-byte floating
            ** point value */
            pRec->u.r = (double)pRec->u.i;
            pRec->flags &= ~MEM_IntReal;
            pRec->flags |= MEM_Real;
            pRec->uTemp = 7;
          }else{
            pRec->uTemp = 6;
          }
        }
      }else if( pRec->flags & MEM_Real ){
        nHdr++;
        nData += 8;
        pRec->uTemp = 7;
      }else{
        assert( db->mallocFailed || pRec->flags&(MEM_Str|MEM_Blob) );
        assert( pRec->n>=0 );
        len = (u32)pRec->n;
        serial_type = (len*2) + 12 + ((pRec->flags & MEM_Str)!=0);
        if( pRec->flags & MEM_Zero ){
          serial_type += pRec->u.nZero*2;
          if( nData ){
            if( sqlite3VdbeMemExpandBlob(pRec) ) goto no_mem;
            len += pRec->u.nZero;
          }else{
            nZero += pRec->u.nZero;
          }
        }
        nData += len;
        nHdr += sqlite3VarintLen(serial_type);
        pRec->uTemp = serial_type;
      }
      if( pRec==pData0 ) break;
      pRec--;
    }while(1);
  
    /* EVIDENCE-OF: R-22564-11647 The header begins with a single varint
    ** which determines the total number of bytes in the header. The varint
    ** value is the size of the header in bytes including the size varint
    ** itself. */
    testcase( nHdr==126 );
    testcase( nHdr==127 );
    if( nHdr<=126 ){
      /* The common case */
      nHdr += 1;
    }else{
      /* Rare case of a really large header */
      nVarint = sqlite3VarintLen(nHdr);
      nHdr += nVarint;
      if( nVarint<sqlite3VarintLen(nHdr) ) nHdr++;
    }
    nByte = nHdr+nData;
  
    /* Make sure the output register has a buffer large enough to store 
    ** the new record. The output register (pOp->p3) is not allowed to
    ** be one of the input registers (because the following call to
    ** sqlite3VdbeMemClearAndResize() could clobber the value before it is used).
    */
    if( nByte+nZero<=pOut->szMalloc ){
      /* The output register is already large enough to hold the record.
      ** No error checks or buffer enlargement is required */
      pOut->z = pOut->zMalloc;
    }else{
      /* Need to make sure that the output is not too big and then enlarge
      ** the output register to hold the full result */
      if( nByte+nZero>db->aLimit[SQLITE_LIMIT_LENGTH] ){
        goto too_big;
      }
      if( sqlite3VdbeMemClearAndResize(pOut, (int)nByte) ){
        goto no_mem;
      }
    }
    pOut->n = (int)nByte;
    pOut->flags = MEM_Blob;
    if( nZero ){
      pOut->u.nZero = nZero;
      pOut->flags |= MEM_Zero;
    }
    UPDATE_MAX_BLOBSIZE(pOut);
    zHdr = (u8 *)pOut->z;
    zPayload = zHdr + nHdr;
  
    /* Write the record */
    zHdr += putVarint32(zHdr, nHdr);
    assert( pData0<=pLast );
    pRec = pData0;
    do{
      serial_type = pRec->uTemp;
      /* EVIDENCE-OF: R-06529-47362 Following the size varint are one or more
      ** additional varints, one per column. */
      zHdr += putVarint32(zHdr, serial_type);            /* serial type */
      /* EVIDENCE-OF: R-64536-51728 The values for each column in the record
      ** immediately follow the header. */
      zPayload += sqlite3VdbeSerialPut(zPayload, pRec, serial_type); /* content */
    }while( (++pRec)<=pLast );
    assert( nHdr==(int)(zHdr - (u8*)pOut->z) );
    assert( nByte==(int)(zPayload - (u8*)pOut->z) );
  
    assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
    REGISTER_TRACE(pOp->p3, pOut);
    break;
  }
  
  /* Opcode: Count P1 P2 p3 * *
  ** Synopsis: r[P2]=count()
  **
  ** Store the number of entries (an integer value) in the table or index 
  ** opened by cursor P1 in register P2.
  **
  ** If P3==0, then an exact count is obtained, which involves visiting
  ** every btree page of the table.  But if P3 is non-zero, an estimate
  ** is returned based on the current cursor position.  
  */
  case OP_Count: {         /* out2 */
    i64 nEntry;
    BtCursor *pCrsr;
  
    assert( p->apCsr[pOp->p1]->eCurType==CURTYPE_BTREE );
    pCrsr = p->apCsr[pOp->p1]->uc.pCursor;
    assert( pCrsr );
    if( pOp->p3 ){
      nEntry = sqlite3BtreeRowCountEst(pCrsr);
    }else{
      nEntry = 0;  /* Not needed.  Only used to silence a warning. */
      rc = sqlite3BtreeCount(db, pCrsr, &nEntry);
      if( rc ) goto abort_due_to_error;
    }
    pOut = out2Prerelease(p, pOp);
    pOut->u.i = nEntry;
    goto check_for_interrupt;
  }
  
  /* Opcode: Savepoint P1 * * P4 *
  **
  ** Open, release or rollback the savepoint named by parameter P4, depending
  ** on the value of P1. To open a new savepoint set P1==0 (SAVEPOINT_BEGIN).
  ** To release (commit) an existing savepoint set P1==1 (SAVEPOINT_RELEASE).
  ** To rollback an existing savepoint set P1==2 (SAVEPOINT_ROLLBACK).
  */
  case OP_Savepoint: {
    int p1;                         /* Value of P1 operand */
    char *zName;                    /* Name of savepoint */
    int nName;
    Savepoint *pNew;
    Savepoint *pSavepoint;
    Savepoint *pTmp;
    int iSavepoint;
    int ii;
  
    p1 = pOp->p1;
    zName = pOp->p4.z;
  
    /* Assert that the p1 parameter is valid. Also that if there is no open
    ** transaction, then there cannot be any savepoints. 
    */
    assert( db->pSavepoint==0 || db->autoCommit==0 );
    assert( p1==SAVEPOINT_BEGIN||p1==SAVEPOINT_RELEASE||p1==SAVEPOINT_ROLLBACK );
    assert( db->pSavepoint || db->isTransactionSavepoint==0 );
    assert( checkSavepointCount(db) );
    assert( p->bIsReader );
  
    if( p1==SAVEPOINT_BEGIN ){
      if( db->nVdbeWrite>0 ){
        /* A new savepoint cannot be created if there are active write 
        ** statements (i.e. open read/write incremental blob handles).
        */
        sqlite3VdbeError(p, "cannot open savepoint - SQL statements in progress");
        rc = SQLITE_BUSY;
      }else{
        nName = sqlite3Strlen30(zName);
  
  #ifndef SQLITE_OMIT_VIRTUALTABLE
        /* This call is Ok even if this savepoint is actually a transaction
        ** savepoint (and therefore should not prompt xSavepoint()) callbacks.
        ** If this is a transaction savepoint being opened, it is guaranteed
        ** that the db->aVTrans[] array is empty.  */
        assert( db->autoCommit==0 || db->nVTrans==0 );
        rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN,
                                  db->nStatement+db->nSavepoint);
        if( rc!=SQLITE_OK ) goto abort_due_to_error;
  #endif
  
        /* Create a new savepoint structure. */
        pNew = sqlite3DbMallocRawNN(db, sizeof(Savepoint)+nName+1);
        if( pNew ){
          pNew->zName = (char *)&pNew[1];
          memcpy(pNew->zName, zName, nName+1);
      
          /* If there is no open transaction, then mark this as a special
          ** "transaction savepoint". */
          if( db->autoCommit ){
            db->autoCommit = 0;
            db->isTransactionSavepoint = 1;
          }else{
            db->nSavepoint++;
          }
  
          /* Link the new savepoint into the database handle's list. */
          pNew->pNext = db->pSavepoint;
          db->pSavepoint = pNew;
          pNew->nDeferredCons = db->nDeferredCons;
          pNew->nDeferredImmCons = db->nDeferredImmCons;
        }
      }
    }else{
      assert( p1==SAVEPOINT_RELEASE || p1==SAVEPOINT_ROLLBACK );
      iSavepoint = 0;
  
      /* Find the named savepoint. If there is no such savepoint, then an
      ** an error is returned to the user.  */
      for(
        pSavepoint = db->pSavepoint; 
        pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName);
        pSavepoint = pSavepoint->pNext
      ){
        iSavepoint++;
      }
      if( !pSavepoint ){
        sqlite3VdbeError(p, "no such savepoint: %s", zName);
        rc = SQLITE_ERROR;
      }else if( db->nVdbeWrite>0 && p1==SAVEPOINT_RELEASE ){
        /* It is not possible to release (commit) a savepoint if there are 
        ** active write statements.
        */
        sqlite3VdbeError(p, "cannot release savepoint - "
                            "SQL statements in progress");
        rc = SQLITE_BUSY;
      }else{
  
        /* Determine whether or not this is a transaction savepoint. If so,
        ** and this is a RELEASE command, then the current transaction 
        ** is committed. 
        */
        int isTransaction = pSavepoint->pNext==0 && db->isTransactionSavepoint;
        if( isTransaction && p1==SAVEPOINT_RELEASE ){
          if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
            goto vdbe_return;
          }
          db->autoCommit = 1;
          if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){
            p->pc = (int)(pOp - aOp);
            db->autoCommit = 0;
            p->rc = rc = SQLITE_BUSY;
            goto vdbe_return;
          }
          rc = p->rc;
          if( rc ){
            db->autoCommit = 0;
          }else{
            db->isTransactionSavepoint = 0;
          }
        }else{
          int isSchemaChange;
          iSavepoint = db->nSavepoint - iSavepoint - 1;
          if( p1==SAVEPOINT_ROLLBACK ){
            isSchemaChange = (db->mDbFlags & DBFLAG_SchemaChange)!=0;
            for(ii=0; ii<db->nDb; ii++){
              rc = sqlite3BtreeTripAllCursors(db->aDb[ii].pBt,
                                         SQLITE_ABORT_ROLLBACK,
                                         isSchemaChange==0);
              if( rc!=SQLITE_OK ) goto abort_due_to_error;
            }
          }else{
            assert( p1==SAVEPOINT_RELEASE );
            isSchemaChange = 0;
          }
          for(ii=0; ii<db->nDb; ii++){
            rc = sqlite3BtreeSavepoint(db->aDb[ii].pBt, p1, iSavepoint);
            if( rc!=SQLITE_OK ){
              goto abort_due_to_error;
            }
          }
          if( isSchemaChange ){
            sqlite3ExpirePreparedStatements(db, 0);
            sqlite3ResetAllSchemasOfConnection(db);
            db->mDbFlags |= DBFLAG_SchemaChange;
          }
        }
        if( rc ) goto abort_due_to_error;
    
        /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all 
        ** savepoints nested inside of the savepoint being operated on. */
        while( db->pSavepoint!=pSavepoint ){
          pTmp = db->pSavepoint;
          db->pSavepoint = pTmp->pNext;
          sqlite3DbFree(db, pTmp);
          db->nSavepoint--;
        }
  
        /* If it is a RELEASE, then destroy the savepoint being operated on 
        ** too. If it is a ROLLBACK TO, then set the number of deferred 
        ** constraint violations present in the database to the value stored
        ** when the savepoint was created.  */
        if( p1==SAVEPOINT_RELEASE ){
          assert( pSavepoint==db->pSavepoint );
          db->pSavepoint = pSavepoint->pNext;
          sqlite3DbFree(db, pSavepoint);
          if( !isTransaction ){
            db->nSavepoint--;
          }
        }else{
          assert( p1==SAVEPOINT_ROLLBACK );
          db->nDeferredCons = pSavepoint->nDeferredCons;
          db->nDeferredImmCons = pSavepoint->nDeferredImmCons;
        }
  
        if( !isTransaction || p1==SAVEPOINT_ROLLBACK ){
          rc = sqlite3VtabSavepoint(db, p1, iSavepoint);
          if( rc!=SQLITE_OK ) goto abort_due_to_error;
        }
      }
    }
    if( rc ) goto abort_due_to_error;
  
    break;
  }
  
  /* Opcode: AutoCommit P1 P2 * * *
  **
  ** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll
  ** back any currently active btree transactions. If there are any active
  ** VMs (apart from this one), then a ROLLBACK fails.  A COMMIT fails if
  ** there are active writing VMs or active VMs that use shared cache.
  **
  ** This instruction causes the VM to halt.
  */
  case OP_AutoCommit: {
    int desiredAutoCommit;
    int iRollback;
  
    desiredAutoCommit = pOp->p1;
    iRollback = pOp->p2;
    assert( desiredAutoCommit==1 || desiredAutoCommit==0 );
    assert( desiredAutoCommit==1 || iRollback==0 );
    assert( db->nVdbeActive>0 );  /* At least this one VM is active */
    assert( p->bIsReader );
  
    if( desiredAutoCommit!=db->autoCommit ){
      if( iRollback ){
        assert( desiredAutoCommit==1 );
        sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
        db->autoCommit = 1;
      }else if( desiredAutoCommit && db->nVdbeWrite>0 ){
        /* If this instruction implements a COMMIT and other VMs are writing
        ** return an error indicating that the other VMs must complete first. 
        */
        sqlite3VdbeError(p, "cannot commit transaction - "
                            "SQL statements in progress");
        rc = SQLITE_BUSY;
        goto abort_due_to_error;
      }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
        goto vdbe_return;
      }else{
        db->autoCommit = (u8)desiredAutoCommit;
      }
      if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){
        p->pc = (int)(pOp - aOp);
        db->autoCommit = (u8)(1-desiredAutoCommit);
        p->rc = rc = SQLITE_BUSY;
        goto vdbe_return;
      }
      sqlite3CloseSavepoints(db);
      if( p->rc==SQLITE_OK ){
        rc = SQLITE_DONE;
      }else{
        rc = SQLITE_ERROR;
      }
      goto vdbe_return;
    }else{
      sqlite3VdbeError(p,
          (!desiredAutoCommit)?"cannot start a transaction within a transaction":(
          (iRollback)?"cannot rollback - no transaction is active":
                     "cannot commit - no transaction is active"));
           
      rc = SQLITE_ERROR;
      goto abort_due_to_error;
    }
    /*NOTREACHED*/ assert(0);
  }
  
  /* Opcode: Transaction P1 P2 P3 P4 P5
  **
  ** Begin a transaction on database P1 if a transaction is not already
  ** active.
  ** If P2 is non-zero, then a write-transaction is started, or if a 
  ** read-transaction is already active, it is upgraded to a write-transaction.
  ** If P2 is zero, then a read-transaction is started.
  **
  ** P1 is the index of the database file on which the transaction is
  ** started.  Index 0 is the main database file and index 1 is the
  ** file used for temporary tables.  Indices of 2 or more are used for
  ** attached databases.
  **
  ** If a write-transaction is started and the Vdbe.usesStmtJournal flag is
  ** true (this flag is set if the Vdbe may modify more than one row and may
  ** throw an ABORT exception), a statement transaction may also be opened.
  ** More specifically, a statement transaction is opened iff the database
  ** connection is currently not in autocommit mode, or if there are other
  ** active statements. A statement transaction allows the changes made by this
  ** VDBE to be rolled back after an error without having to roll back the
  ** entire transaction. If no error is encountered, the statement transaction
  ** will automatically commit when the VDBE halts.
  **
  ** If P5!=0 then this opcode also checks the schema cookie against P3
  ** and the schema generation counter against P4.
  ** The cookie changes its value whenever the database schema changes.
  ** This operation is used to detect when that the cookie has changed
  ** and that the current process needs to reread the schema.  If the schema
  ** cookie in P3 differs from the schema cookie in the database header or
  ** if the schema generation counter in P4 differs from the current
  ** generation counter, then an SQLITE_SCHEMA error is raised and execution
  ** halts.  The sqlite3_step() wrapper function might then reprepare the
  ** statement and rerun it from the beginning.
  */
  case OP_Transaction: {
    Btree *pBt;
    int iMeta = 0;
  
    assert( p->bIsReader );
    assert( p->readOnly==0 || pOp->p2==0 );
    assert( pOp->p1>=0 && pOp->p1<db->nDb );
    assert( DbMaskTest(p->btreeMask, pOp->p1) );
    if( pOp->p2 && (db->flags & SQLITE_QueryOnly)!=0 ){
      rc = SQLITE_READONLY;
      goto abort_due_to_error;
    }
    pBt = db->aDb[pOp->p1].pBt;
  
    if( pBt ){
      rc = sqlite3BtreeBeginTrans(pBt, pOp->p2, &iMeta);
      testcase( rc==SQLITE_BUSY_SNAPSHOT );
      testcase( rc==SQLITE_BUSY_RECOVERY );
      if( rc!=SQLITE_OK ){
        if( (rc&0xff)==SQLITE_BUSY ){
          p->pc = (int)(pOp - aOp);
          p->rc = rc;
          goto vdbe_return;
        }
        goto abort_due_to_error;
      }
  
      if( p->usesStmtJournal
       && pOp->p2
       && (db->autoCommit==0 || db->nVdbeRead>1) 
      ){
        assert( sqlite3BtreeIsInTrans(pBt) );
        if( p->iStatement==0 ){
          assert( db->nStatement>=0 && db->nSavepoint>=0 );
          db->nStatement++; 
          p->iStatement = db->nSavepoint + db->nStatement;
        }
  
        rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, p->iStatement-1);
        if( rc==SQLITE_OK ){
          rc = sqlite3BtreeBeginStmt(pBt, p->iStatement);
        }
  
        /* Store the current value of the database handles deferred constraint
        ** counter. If the statement transaction needs to be rolled back,
        ** the value of this counter needs to be restored too.  */
        p->nStmtDefCons = db->nDeferredCons;
        p->nStmtDefImmCons = db->nDeferredImmCons;
      }
    }
    assert( pOp->p5==0 || pOp->p4type==P4_INT32 );
    if( pOp->p5
     && (iMeta!=pOp->p3
        || db->aDb[pOp->p1].pSchema->iGeneration!=pOp->p4.i)
    ){
      /*
      ** IMPLEMENTATION-OF: R-03189-51135 As each SQL statement runs, the schema
      ** version is checked to ensure that the schema has not changed since the
      ** SQL statement was prepared.
      */
      sqlite3DbFree(db, p->zErrMsg);
      p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed");
      /* If the schema-cookie from the database file matches the cookie 
      ** stored with the in-memory representation of the schema, do
      ** not reload the schema from the database file.
      **
      ** If virtual-tables are in use, this is not just an optimization.
      ** Often, v-tables store their data in other SQLite tables, which
      ** are queried from within xNext() and other v-table methods using
      ** prepared queries. If such a query is out-of-date, we do not want to
      ** discard the database schema, as the user code implementing the
      ** v-table would have to be ready for the sqlite3_vtab structure itself
      ** to be invalidated whenever sqlite3_step() is called from within 
      ** a v-table method.
      */
      if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){
        sqlite3ResetOneSchema(db, pOp->p1);
      }
      p->expired = 1;
      rc = SQLITE_SCHEMA;
    }
    if( rc ) goto abort_due_to_error;
    break;
  }
  
  /* Opcode: ReadCookie P1 P2 P3 * *
  **
  ** Read cookie number P3 from database P1 and write it into register P2.
  ** P3==1 is the schema version.  P3==2 is the database format.
  ** P3==3 is the recommended pager cache size, and so forth.  P1==0 is
  ** the main database file and P1==1 is the database file used to store
  ** temporary tables.
  **
  ** There must be a read-lock on the database (either a transaction
  ** must be started or there must be an open cursor) before
  ** executing this instruction.
  */
  case OP_ReadCookie: {               /* out2 */
    int iMeta;
    int iDb;
    int iCookie;
  
    assert( p->bIsReader );
    iDb = pOp->p1;
    iCookie = pOp->p3;
    assert( pOp->p3<SQLITE_N_BTREE_META );
    assert( iDb>=0 && iDb<db->nDb );
    assert( db->aDb[iDb].pBt!=0 );
    assert( DbMaskTest(p->btreeMask, iDb) );
  
    sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta);
    pOut = out2Prerelease(p, pOp);
    pOut->u.i = iMeta;
    break;
  }
  
  /* Opcode: SetCookie P1 P2 P3 * *
  **
  ** Write the integer value P3 into cookie number P2 of database P1.
  ** P2==1 is the schema version.  P2==2 is the database format.
  ** P2==3 is the recommended pager cache 
  ** size, and so forth.  P1==0 is the main database file and P1==1 is the 
  ** database file used to store temporary tables.
  **
  ** A transaction must be started before executing this opcode.
  */
  case OP_SetCookie: {
    Db *pDb;
  
    sqlite3VdbeIncrWriteCounter(p, 0);
    assert( pOp->p2<SQLITE_N_BTREE_META );
    assert( pOp->p1>=0 && pOp->p1<db->nDb );
    assert( DbMaskTest(p->btreeMask, pOp->p1) );
    assert( p->readOnly==0 );
    pDb = &db->aDb[pOp->p1];
    assert( pDb->pBt!=0 );
    assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
    /* See note about index shifting on OP_ReadCookie */
    rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, pOp->p3);
    if( pOp->p2==BTREE_SCHEMA_VERSION ){
      /* When the schema cookie changes, record the new cookie internally */
      pDb->pSchema->schema_cookie = pOp->p3;
      db->mDbFlags |= DBFLAG_SchemaChange;
    }else if( pOp->p2==BTREE_FILE_FORMAT ){
      /* Record changes in the file format */
      pDb->pSchema->file_format = pOp->p3;
    }
    if( pOp->p1==1 ){
      /* Invalidate all prepared statements whenever the TEMP database
      ** schema is changed.  Ticket #1644 */
      sqlite3ExpirePreparedStatements(db, 0);
      p->expired = 0;
    }
    if( rc ) goto abort_due_to_error;
    break;
  }
  
  /* Opcode: OpenRead P1 P2 P3 P4 P5
  ** Synopsis: root=P2 iDb=P3
  **
  ** Open a read-only cursor for the database table whose root page is
  ** P2 in a database file.  The database file is determined by P3. 
  ** P3==0 means the main database, P3==1 means the database used for 
  ** temporary tables, and P3>1 means used the corresponding attached
  ** database.  Give the new cursor an identifier of P1.  The P1
  ** values need not be contiguous but all P1 values should be small integers.
  ** It is an error for P1 to be negative.
  **
  ** Allowed P5 bits:
  ** <ul>
  ** <li>  <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
  **       equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT
  **       of OP_SeekLE/OP_IdxLT)
  ** </ul>
  **
  ** The P4 value may be either an integer (P4_INT32) or a pointer to
  ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo 
  ** object, then table being opened must be an [index b-tree] where the
  ** KeyInfo object defines the content and collating 
  ** sequence of that index b-tree. Otherwise, if P4 is an integer 
  ** value, then the table being opened must be a [table b-tree] with a
  ** number of columns no less than the value of P4.
  **
  ** See also: OpenWrite, ReopenIdx
  */
  /* Opcode: ReopenIdx P1 P2 P3 P4 P5
  ** Synopsis: root=P2 iDb=P3
  **
  ** The ReopenIdx opcode works like OP_OpenRead except that it first
  ** checks to see if the cursor on P1 is already open on the same
  ** b-tree and if it is this opcode becomes a no-op.  In other words,
  ** if the cursor is already open, do not reopen it.
  **
  ** The ReopenIdx opcode may only be used with P5==0 or P5==OPFLAG_SEEKEQ
  ** and with P4 being a P4_KEYINFO object.  Furthermore, the P3 value must
  ** be the same as every other ReopenIdx or OpenRead for the same cursor
  ** number.
  **
  ** Allowed P5 bits:
  ** <ul>
  ** <li>  <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
  **       equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT
  **       of OP_SeekLE/OP_IdxLT)
  ** </ul>
  **
  ** See also: OP_OpenRead, OP_OpenWrite
  */
  /* Opcode: OpenWrite P1 P2 P3 P4 P5
  ** Synopsis: root=P2 iDb=P3
  **
  ** Open a read/write cursor named P1 on the table or index whose root
  ** page is P2 (or whose root page is held in register P2 if the
  ** OPFLAG_P2ISREG bit is set in P5 - see below).
  **
  ** The P4 value may be either an integer (P4_INT32) or a pointer to
  ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo 
  ** object, then table being opened must be an [index b-tree] where the
  ** KeyInfo object defines the content and collating 
  ** sequence of that index b-tree. Otherwise, if P4 is an integer 
  ** value, then the table being opened must be a [table b-tree] with a
  ** number of columns no less than the value of P4.
  **
  ** Allowed P5 bits:
  ** <ul>
  ** <li>  <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
  **       equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT
  **       of OP_SeekLE/OP_IdxLT)
  ** <li>  <b>0x08 OPFLAG_FORDELETE</b>: This cursor is used only to seek
  **       and subsequently delete entries in an index btree.  This is a
  **       hint to the storage engine that the storage engine is allowed to
  **       ignore.  The hint is not used by the official SQLite b*tree storage
  **       engine, but is used by COMDB2.
  ** <li>  <b>0x10 OPFLAG_P2ISREG</b>: Use the content of register P2
  **       as the root page, not the value of P2 itself.
  ** </ul>
  **
  ** This instruction works like OpenRead except that it opens the cursor
  ** in read/write mode.
  **
  ** See also: OP_OpenRead, OP_ReopenIdx
  */
  case OP_ReopenIdx: {
    int nField;
    KeyInfo *pKeyInfo;
    int p2;
    int iDb;
    int wrFlag;
    Btree *pX;
    VdbeCursor *pCur;
    Db *pDb;
  
    assert( pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
    assert( pOp->p4type==P4_KEYINFO );
    pCur = p->apCsr[pOp->p1];
    if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
      assert( pCur->iDb==pOp->p3 );      /* Guaranteed by the code generator */
      goto open_cursor_set_hints;
    }
    /* If the cursor is not currently open or is open on a different
    ** index, then fall through into OP_OpenRead to force a reopen */
  case OP_OpenRead:
  case OP_OpenWrite:
  
    assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
    assert( p->bIsReader );
    assert( pOp->opcode==OP_OpenRead || pOp->opcode==OP_ReopenIdx
            || p->readOnly==0 );
  
    if( p->expired==1 ){
      rc = SQLITE_ABORT_ROLLBACK;
      goto abort_due_to_error;
    }
  
    nField = 0;
    pKeyInfo = 0;
    p2 = pOp->p2;
    iDb = pOp->p3;
    assert( iDb>=0 && iDb<db->nDb );
    assert( DbMaskTest(p->btreeMask, iDb) );
    pDb = &db->aDb[iDb];
    pX = pDb->pBt;
    assert( pX!=0 );
    if( pOp->opcode==OP_OpenWrite ){
      assert( OPFLAG_FORDELETE==BTREE_FORDELETE );
      wrFlag = BTREE_WRCSR | (pOp->p5 & OPFLAG_FORDELETE);
      assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
      if( pDb->pSchema->file_format < p->minWriteFileFormat ){
        p->minWriteFileFormat = pDb->pSchema->file_format;
      }
    }else{
      wrFlag = 0;
    }
    if( pOp->p5 & OPFLAG_P2ISREG ){
      assert( p2>0 );
      assert( p2<=(p->nMem+1 - p->nCursor) );
      assert( pOp->opcode==OP_OpenWrite );
      pIn2 = &aMem[p2];
      assert( memIsValid(pIn2) );
      assert( (pIn2->flags & MEM_Int)!=0 );
      sqlite3VdbeMemIntegerify(pIn2);
      p2 = (int)pIn2->u.i;
      /* The p2 value always comes from a prior OP_CreateBtree opcode and
      ** that opcode will always set the p2 value to 2 or more or else fail.
      ** If there were a failure, the prepared statement would have halted
      ** before reaching this instruction. */
      assert( p2>=2 );
    }
    if( pOp->p4type==P4_KEYINFO ){
      pKeyInfo = pOp->p4.pKeyInfo;
      assert( pKeyInfo->enc==ENC(db) );
      assert( pKeyInfo->db==db );
      nField = pKeyInfo->nAllField;
    }else if( pOp->p4type==P4_INT32 ){
      nField = pOp->p4.i;
    }
    assert( pOp->p1>=0 );
    assert( nField>=0 );
    testcase( nField==0 );  /* Table with INTEGER PRIMARY KEY and nothing else */
    pCur = allocateCursor(p, pOp->p1, nField, iDb, CURTYPE_BTREE);
    if( pCur==0 ) goto no_mem;
    pCur->nullRow = 1;
    pCur->isOrdered = 1;
    pCur->pgnoRoot = p2;
  #ifdef SQLITE_DEBUG
    pCur->wrFlag = wrFlag;
  #endif
    rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
    pCur->pKeyInfo = pKeyInfo;
    /* Set the VdbeCursor.isTable variable. Previous versions of
    ** SQLite used to check if the root-page flags were sane at this point
    ** and report database corruption if they were not, but this check has
    ** since moved into the btree layer.  */  
    pCur->isTable = pOp->p4type!=P4_KEYINFO;
  
  open_cursor_set_hints:
    assert( OPFLAG_BULKCSR==BTREE_BULKLOAD );
    assert( OPFLAG_SEEKEQ==BTREE_SEEK_EQ );
    testcase( pOp->p5 & OPFLAG_BULKCSR );
    testcase( pOp->p2 & OPFLAG_SEEKEQ );
    sqlite3BtreeCursorHintFlags(pCur->uc.pCursor,
                                 (pOp->p5 & (OPFLAG_BULKCSR|OPFLAG_SEEKEQ)));
    if( rc ) goto abort_due_to_error;
    break;
  }
  
  /* Opcode: OpenDup P1 P2 * * *
  **
  ** Open a new cursor P1 that points to the same ephemeral table as
  ** cursor P2.  The P2 cursor must have been opened by a prior OP_OpenEphemeral
  ** opcode.  Only ephemeral cursors may be duplicated.
  **
  ** Duplicate ephemeral cursors are used for self-joins of materialized views.
  */
  case OP_OpenDup: {
    VdbeCursor *pOrig;    /* The original cursor to be duplicated */
    VdbeCursor *pCx;      /* The new cursor */
  
    pOrig = p->apCsr[pOp->p2];
    assert( pOrig );
    assert( pOrig->pBtx!=0 );  /* Only ephemeral cursors can be duplicated */
  
    pCx = allocateCursor(p, pOp->p1, pOrig->nField, -1, CURTYPE_BTREE);
    if( pCx==0 ) goto no_mem;
    pCx->nullRow = 1;
    pCx->isEphemeral = 1;
    pCx->pKeyInfo = pOrig->pKeyInfo;
    pCx->isTable = pOrig->isTable;
    pCx->pgnoRoot = pOrig->pgnoRoot;
    pCx->isOrdered = pOrig->isOrdered;
    rc = sqlite3BtreeCursor(pOrig->pBtx, pCx->pgnoRoot, BTREE_WRCSR,
                            pCx->pKeyInfo, pCx->uc.pCursor);
    /* The sqlite3BtreeCursor() routine can only fail for the first cursor
    ** opened for a database.  Since there is already an open cursor when this
    ** opcode is run, the sqlite3BtreeCursor() cannot fail */
    assert( rc==SQLITE_OK );
    break;
  }
  
  
  /* Opcode: OpenEphemeral P1 P2 * P4 P5
  ** Synopsis: nColumn=P2
  **
  ** Open a new cursor P1 to a transient table.
  ** The cursor is always opened read/write even if 
  ** the main database is read-only.  The ephemeral
  ** table is deleted automatically when the cursor is closed.
  **
  ** If the cursor P1 is already opened on an ephemeral table, the table
  ** is cleared (all content is erased).
  **
  ** P2 is the number of columns in the ephemeral table.
  ** The cursor points to a BTree table if P4==0 and to a BTree index
  ** if P4 is not 0.  If P4 is not NULL, it points to a KeyInfo structure
  ** that defines the format of keys in the index.
  **
  ** The P5 parameter can be a mask of the BTREE_* flags defined
  ** in btree.h.  These flags control aspects of the operation of
  ** the btree.  The BTREE_OMIT_JOURNAL and BTREE_SINGLE flags are
  ** added automatically.
  */
  /* Opcode: OpenAutoindex P1 P2 * P4 *
  ** Synopsis: nColumn=P2
  **
  ** This opcode works the same as OP_OpenEphemeral.  It has a
  ** different name to distinguish its use.  Tables created using
  ** by this opcode will be used for automatically created transient
  ** indices in joins.
  */
  case OP_OpenAutoindex: 
  case OP_OpenEphemeral: {
    VdbeCursor *pCx;
    KeyInfo *pKeyInfo;
  
    static const int vfsFlags = 
        SQLITE_OPEN_READWRITE |
        SQLITE_OPEN_CREATE |
        SQLITE_OPEN_EXCLUSIVE |
        SQLITE_OPEN_DELETEONCLOSE |
        SQLITE_OPEN_TRANSIENT_DB;
    assert( pOp->p1>=0 );
    assert( pOp->p2>=0 );
    pCx = p->apCsr[pOp->p1];
    if( pCx && pCx->pBtx ){
      /* If the ephermeral table is already open, erase all existing content
      ** so that the table is empty again, rather than creating a new table. */
      assert( pCx->isEphemeral );
      pCx->seqCount = 0;
      pCx->cacheStatus = CACHE_STALE;
      rc = sqlite3BtreeClearTable(pCx->pBtx, pCx->pgnoRoot, 0);
    }else{
      pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, CURTYPE_BTREE);
      if( pCx==0 ) goto no_mem;
      pCx->isEphemeral = 1;
      rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->pBtx, 
                            BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5,
                            vfsFlags);
      if( rc==SQLITE_OK ){
        rc = sqlite3BtreeBeginTrans(pCx->pBtx, 1, 0);
      }
      if( rc==SQLITE_OK ){
        /* If a transient index is required, create it by calling
        ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before
        ** opening it. If a transient table is required, just use the
        ** automatically created table with root-page 1 (an BLOB_INTKEY table).
        */
        if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){
          assert( pOp->p4type==P4_KEYINFO );
          rc = sqlite3BtreeCreateTable(pCx->pBtx, (int*)&pCx->pgnoRoot,
                                       BTREE_BLOBKEY | pOp->p5); 
          if( rc==SQLITE_OK ){
            assert( pCx->pgnoRoot==MASTER_ROOT+1 );
            assert( pKeyInfo->db==db );
            assert( pKeyInfo->enc==ENC(db) );
            rc = sqlite3BtreeCursor(pCx->pBtx, pCx->pgnoRoot, BTREE_WRCSR,
                                    pKeyInfo, pCx->uc.pCursor);
          }
          pCx->isTable = 0;
        }else{
          pCx->pgnoRoot = MASTER_ROOT;
          rc = sqlite3BtreeCursor(pCx->pBtx, MASTER_ROOT, BTREE_WRCSR,
                                  0, pCx->uc.pCursor);
          pCx->isTable = 1;
        }
      }
      pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED);
    }
    if( rc ) goto abort_due_to_error;
    pCx->nullRow = 1;
    break;
  }
  
  /* Opcode: SorterOpen P1 P2 P3 P4 *
  **
  ** This opcode works like OP_OpenEphemeral except that it opens
  ** a transient index that is specifically designed to sort large
  ** tables using an external merge-sort algorithm.
  **
  ** If argument P3 is non-zero, then it indicates that the sorter may
  ** assume that a stable sort considering the first P3 fields of each
  ** key is sufficient to produce the required results.
  */
  case OP_SorterOpen: {
    VdbeCursor *pCx;
  
    assert( pOp->p1>=0 );
    assert( pOp->p2>=0 );
    pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, CURTYPE_SORTER);
    if( pCx==0 ) goto no_mem;
    pCx->pKeyInfo = pOp->p4.pKeyInfo;
    assert( pCx->pKeyInfo->db==db );
    assert( pCx->pKeyInfo->enc==ENC(db) );
    rc = sqlite3VdbeSorterInit(db, pOp->p3, pCx);
    if( rc ) goto abort_due_to_error;
    break;
  }
  
  /* Opcode: SequenceTest P1 P2 * * *
  ** Synopsis: if( cursor[P1].ctr++ ) pc = P2
  **
  ** P1 is a sorter cursor. If the sequence counter is currently zero, jump
  ** to P2. Regardless of whether or not the jump is taken, increment the
  ** the sequence value.
  */
  case OP_SequenceTest: {
    VdbeCursor *pC;
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    assert( isSorter(pC) );
    if( (pC->seqCount++)==0 ){
      goto jump_to_p2;
    }
    break;
  }
  
  /* Opcode: OpenPseudo P1 P2 P3 * *
  ** Synopsis: P3 columns in r[P2]
  **
  ** Open a new cursor that points to a fake table that contains a single
  ** row of data.  The content of that one row is the content of memory
  ** register P2.  In other words, cursor P1 becomes an alias for the 
  ** MEM_Blob content contained in register P2.
  **
  ** A pseudo-table created by this opcode is used to hold a single
  ** row output from the sorter so that the row can be decomposed into
  ** individual columns using the OP_Column opcode.  The OP_Column opcode
  ** is the only cursor opcode that works with a pseudo-table.
  **
  ** P3 is the number of fields in the records that will be stored by
  ** the pseudo-table.
  */
  case OP_OpenPseudo: {
    VdbeCursor *pCx;
  
    assert( pOp->p1>=0 );
    assert( pOp->p3>=0 );
    pCx = allocateCursor(p, pOp->p1, pOp->p3, -1, CURTYPE_PSEUDO);
    if( pCx==0 ) goto no_mem;
    pCx->nullRow = 1;
    pCx->seekResult = pOp->p2;
    pCx->isTable = 1;
    /* Give this pseudo-cursor a fake BtCursor pointer so that pCx
    ** can be safely passed to sqlite3VdbeCursorMoveto().  This avoids a test
    ** for pCx->eCurType==CURTYPE_BTREE inside of sqlite3VdbeCursorMoveto()
    ** which is a performance optimization */
    pCx->uc.pCursor = sqlite3BtreeFakeValidCursor();
    assert( pOp->p5==0 );
    break;
  }
  
  /* Opcode: Close P1 * * * *
  **
  ** Close a cursor previously opened as P1.  If P1 is not
  ** currently open, this instruction is a no-op.
  */
  case OP_Close: {
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    sqlite3VdbeFreeCursor(p, p->apCsr[pOp->p1]);
    p->apCsr[pOp->p1] = 0;
    break;
  }
  
  #ifdef SQLITE_ENABLE_COLUMN_USED_MASK
  /* Opcode: ColumnsUsed P1 * * P4 *
  **
  ** This opcode (which only exists if SQLite was compiled with
  ** SQLITE_ENABLE_COLUMN_USED_MASK) identifies which columns of the
  ** table or index for cursor P1 are used.  P4 is a 64-bit integer
  ** (P4_INT64) in which the first 63 bits are one for each of the
  ** first 63 columns of the table or index that are actually used
  ** by the cursor.  The high-order bit is set if any column after
  ** the 64th is used.
  */
  case OP_ColumnsUsed: {
    VdbeCursor *pC;
    pC = p->apCsr[pOp->p1];
    assert( pC->eCurType==CURTYPE_BTREE );
    pC->maskUsed = *(u64*)pOp->p4.pI64;
    break;
  }
  #endif
  
  /* Opcode: SeekGE P1 P2 P3 P4 *
  ** Synopsis: key=r[P3@P4]
  **
  ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), 
  ** use the value in register P3 as the key.  If cursor P1 refers 
  ** to an SQL index, then P3 is the first in an array of P4 registers 
  ** that are used as an unpacked index key. 
  **
  ** Reposition cursor P1 so that  it points to the smallest entry that 
  ** is greater than or equal to the key value. If there are no records 
  ** greater than or equal to the key and P2 is not zero, then jump to P2.
  **
  ** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this
  ** opcode will either land on a record that exactly matches the key, or
  ** else it will cause a jump to P2.  When the cursor is OPFLAG_SEEKEQ,
  ** this opcode must be followed by an IdxLE opcode with the same arguments.
  ** The IdxGT opcode will be skipped if this opcode succeeds, but the
  ** IdxGT opcode will be used on subsequent loop iterations.  The 
  ** OPFLAG_SEEKEQ flags is a hint to the btree layer to say that this
  ** is an equality search.
  **
  ** This opcode leaves the cursor configured to move in forward order,
  ** from the beginning toward the end.  In other words, the cursor is
  ** configured to use Next, not Prev.
  **
  ** See also: Found, NotFound, SeekLt, SeekGt, SeekLe
  */
  /* Opcode: SeekGT P1 P2 P3 P4 *
  ** Synopsis: key=r[P3@P4]
  **
  ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), 
  ** use the value in register P3 as a key. If cursor P1 refers 
  ** to an SQL index, then P3 is the first in an array of P4 registers 
  ** that are used as an unpacked index key. 
  **
  ** Reposition cursor P1 so that it points to the smallest entry that 
  ** is greater than the key value. If there are no records greater than 
  ** the key and P2 is not zero, then jump to P2.
  **
  ** This opcode leaves the cursor configured to move in forward order,
  ** from the beginning toward the end.  In other words, the cursor is
  ** configured to use Next, not Prev.
  **
  ** See also: Found, NotFound, SeekLt, SeekGe, SeekLe
  */
  /* Opcode: SeekLT P1 P2 P3 P4 * 
  ** Synopsis: key=r[P3@P4]
  **
  ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), 
  ** use the value in register P3 as a key. If cursor P1 refers 
  ** to an SQL index, then P3 is the first in an array of P4 registers 
  ** that are used as an unpacked index key. 
  **
  ** Reposition cursor P1 so that  it points to the largest entry that 
  ** is less than the key value. If there are no records less than 
  ** the key and P2 is not zero, then jump to P2.
  **
  ** This opcode leaves the cursor configured to move in reverse order,
  ** from the end toward the beginning.  In other words, the cursor is
  ** configured to use Prev, not Next.
  **
  ** See also: Found, NotFound, SeekGt, SeekGe, SeekLe
  */
  /* Opcode: SeekLE P1 P2 P3 P4 *
  ** Synopsis: key=r[P3@P4]
  **
  ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), 
  ** use the value in register P3 as a key. If cursor P1 refers 
  ** to an SQL index, then P3 is the first in an array of P4 registers 
  ** that are used as an unpacked index key. 
  **
  ** Reposition cursor P1 so that it points to the largest entry that 
  ** is less than or equal to the key value. If there are no records 
  ** less than or equal to the key and P2 is not zero, then jump to P2.
  **
  ** This opcode leaves the cursor configured to move in reverse order,
  ** from the end toward the beginning.  In other words, the cursor is
  ** configured to use Prev, not Next.
  **
  ** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this
  ** opcode will either land on a record that exactly matches the key, or
  ** else it will cause a jump to P2.  When the cursor is OPFLAG_SEEKEQ,
  ** this opcode must be followed by an IdxLE opcode with the same arguments.
  ** The IdxGE opcode will be skipped if this opcode succeeds, but the
  ** IdxGE opcode will be used on subsequent loop iterations.  The 
  ** OPFLAG_SEEKEQ flags is a hint to the btree layer to say that this
  ** is an equality search.
  **
  ** See also: Found, NotFound, SeekGt, SeekGe, SeekLt
  */
  case OP_SeekLT:         /* jump, in3, group */
  case OP_SeekLE:         /* jump, in3, group */
  case OP_SeekGE:         /* jump, in3, group */
  case OP_SeekGT: {       /* jump, in3, group */
    int res;           /* Comparison result */
    int oc;            /* Opcode */
    VdbeCursor *pC;    /* The cursor to seek */
    UnpackedRecord r;  /* The key to seek for */
    int nField;        /* Number of columns or fields in the key */
    i64 iKey;          /* The rowid we are to seek to */
    int eqOnly;        /* Only interested in == results */
  
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    assert( pOp->p2!=0 );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    assert( pC->eCurType==CURTYPE_BTREE );
    assert( OP_SeekLE == OP_SeekLT+1 );
    assert( OP_SeekGE == OP_SeekLT+2 );
    assert( OP_SeekGT == OP_SeekLT+3 );
    assert( pC->isOrdered );
    assert( pC->uc.pCursor!=0 );
    oc = pOp->opcode;
    eqOnly = 0;
    pC->nullRow = 0;
  #ifdef SQLITE_DEBUG
    pC->seekOp = pOp->opcode;
  #endif
  
    pC->deferredMoveto = 0;
    pC->cacheStatus = CACHE_STALE;
    if( pC->isTable ){
      u16 flags3, newType;
      /* The OPFLAG_SEEKEQ/BTREE_SEEK_EQ flag is only set on index cursors */
      assert( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ)==0
                || CORRUPT_DB );
  
      /* The input value in P3 might be of any type: integer, real, string,
      ** blob, or NULL.  But it needs to be an integer before we can do
      ** the seek, so convert it. */
      pIn3 = &aMem[pOp->p3];
      flags3 = pIn3->flags;
      if( (flags3 & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Str))==MEM_Str ){
        applyNumericAffinity(pIn3, 0);
      }
      iKey = sqlite3VdbeIntValue(pIn3); /* Get the integer key value */
      newType = pIn3->flags; /* Record the type after applying numeric affinity */
      pIn3->flags = flags3;  /* But convert the type back to its original */
  
      /* If the P3 value could not be converted into an integer without
      ** loss of information, then special processing is required... */
      if( (newType & (MEM_Int|MEM_IntReal))==0 ){
        if( (newType & MEM_Real)==0 ){
          if( (newType & MEM_Null) || oc>=OP_SeekGE ){
            VdbeBranchTaken(1,2);
            goto jump_to_p2;
          }else{
            rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
            if( rc!=SQLITE_OK ) goto abort_due_to_error;
            goto seek_not_found;
          }
        }else
  
        /* If the approximation iKey is larger than the actual real search
        ** term, substitute >= for > and < for <=. e.g. if the search term
        ** is 4.9 and the integer approximation 5:
        **
        **        (x >  4.9)    ->     (x >= 5)
        **        (x <= 4.9)    ->     (x <  5)
        */
        if( pIn3->u.r<(double)iKey ){
          assert( OP_SeekGE==(OP_SeekGT-1) );
          assert( OP_SeekLT==(OP_SeekLE-1) );
          assert( (OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001) );
          if( (oc & 0x0001)==(OP_SeekGT & 0x0001) ) oc--;
        }
  
        /* If the approximation iKey is smaller than the actual real search
        ** term, substitute <= for < and > for >=.  */
        else if( pIn3->u.r>(double)iKey ){
          assert( OP_SeekLE==(OP_SeekLT+1) );
          assert( OP_SeekGT==(OP_SeekGE+1) );
          assert( (OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001) );
          if( (oc & 0x0001)==(OP_SeekLT & 0x0001) ) oc++;
        }
      }
      rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)iKey, 0, &res);
      pC->movetoTarget = iKey;  /* Used by OP_Delete */
      if( rc!=SQLITE_OK ){
        goto abort_due_to_error;
      }
    }else{
      /* For a cursor with the OPFLAG_SEEKEQ/BTREE_SEEK_EQ hint, only the
      ** OP_SeekGE and OP_SeekLE opcodes are allowed, and these must be
      ** immediately followed by an OP_IdxGT or OP_IdxLT opcode, respectively,
      ** with the same key.
      */
      if( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ) ){
        eqOnly = 1;
        assert( pOp->opcode==OP_SeekGE || pOp->opcode==OP_SeekLE );
        assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT );
        assert( pOp->opcode==OP_SeekGE || pOp[1].opcode==OP_IdxLT );
        assert( pOp->opcode==OP_SeekLE || pOp[1].opcode==OP_IdxGT );
        assert( pOp[1].p1==pOp[0].p1 );
        assert( pOp[1].p2==pOp[0].p2 );
        assert( pOp[1].p3==pOp[0].p3 );
        assert( pOp[1].p4.i==pOp[0].p4.i );
      }
  
      nField = pOp->p4.i;
      assert( pOp->p4type==P4_INT32 );
      assert( nField>0 );
      r.pKeyInfo = pC->pKeyInfo;
      r.nField = (u16)nField;
  
      /* The next line of code computes as follows, only faster:
      **   if( oc==OP_SeekGT || oc==OP_SeekLE ){
      **     r.default_rc = -1;
      **   }else{
      **     r.default_rc = +1;
      **   }
      */
      r.default_rc = ((1 & (oc - OP_SeekLT)) ? -1 : +1);
      assert( oc!=OP_SeekGT || r.default_rc==-1 );
      assert( oc!=OP_SeekLE || r.default_rc==-1 );
      assert( oc!=OP_SeekGE || r.default_rc==+1 );
      assert( oc!=OP_SeekLT || r.default_rc==+1 );
  
      r.aMem = &aMem[pOp->p3];
  #ifdef SQLITE_DEBUG
      { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
  #endif
      r.eqSeen = 0;
      rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, &r, 0, 0, &res);
      if( rc!=SQLITE_OK ){
        goto abort_due_to_error;
      }
      if( eqOnly && r.eqSeen==0 ){
        assert( res!=0 );
        goto seek_not_found;
      }
    }
  #ifdef SQLITE_TEST
    sqlite3_search_count++;
  #endif
    if( oc>=OP_SeekGE ){  assert( oc==OP_SeekGE || oc==OP_SeekGT );
      if( res<0 || (res==0 && oc==OP_SeekGT) ){
        res = 0;
        rc = sqlite3BtreeNext(pC->uc.pCursor, 0);
        if( rc!=SQLITE_OK ){
          if( rc==SQLITE_DONE ){
            rc = SQLITE_OK;
            res = 1;
          }else{
            goto abort_due_to_error;
          }
        }
      }else{
        res = 0;
      }
    }else{
      assert( oc==OP_SeekLT || oc==OP_SeekLE );
      if( res>0 || (res==0 && oc==OP_SeekLT) ){
        res = 0;
        rc = sqlite3BtreePrevious(pC->uc.pCursor, 0);
        if( rc!=SQLITE_OK ){
          if( rc==SQLITE_DONE ){
            rc = SQLITE_OK;
            res = 1;
          }else{
            goto abort_due_to_error;
          }
        }
      }else{
        /* res might be negative because the table is empty.  Check to
        ** see if this is the case.
        */
        res = sqlite3BtreeEof(pC->uc.pCursor);
      }
    }
  seek_not_found:
    assert( pOp->p2>0 );
    VdbeBranchTaken(res!=0,2);
    if( res ){
      goto jump_to_p2;
    }else if( eqOnly ){
      assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT );
      pOp++; /* Skip the OP_IdxLt or OP_IdxGT that follows */
    }
    break;
  }
  
  /* Opcode: SeekHit P1 P2 * * *
  ** Synopsis: seekHit=P2
  **
  ** Set the seekHit flag on cursor P1 to the value in P2.
  * The seekHit flag is used by the IfNoHope opcode.
  **
  ** P1 must be a valid b-tree cursor.  P2 must be a boolean value,
  ** either 0 or 1.
  */
  case OP_SeekHit: {
    VdbeCursor *pC;
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    assert( pOp->p2==0 || pOp->p2==1 );
    pC->seekHit = pOp->p2 & 1;
    break;
  }
  
  /* Opcode: IfNotOpen P1 P2 * * *
  ** Synopsis: if( !csr[P1] ) goto P2
  **
  ** If cursor P1 is not open, jump to instruction P2. Otherwise, fall through.
  */
  case OP_IfNotOpen: {        /* jump */
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    VdbeBranchTaken(p->apCsr[pOp->p1]==0, 2);
    if( !p->apCsr[pOp->p1] ){
      goto jump_to_p2_and_check_for_interrupt;
    }
    break;
  }
  
  /* Opcode: Found P1 P2 P3 P4 *
  ** Synopsis: key=r[P3@P4]
  **
  ** If P4==0 then register P3 holds a blob constructed by MakeRecord.  If
  ** P4>0 then register P3 is the first of P4 registers that form an unpacked
  ** record.
  **
  ** Cursor P1 is on an index btree.  If the record identified by P3 and P4
  ** is a prefix of any entry in P1 then a jump is made to P2 and
  ** P1 is left pointing at the matching entry.
  **
  ** This operation leaves the cursor in a state where it can be
  ** advanced in the forward direction.  The Next instruction will work,
  ** but not the Prev instruction.
  **
  ** See also: NotFound, NoConflict, NotExists. SeekGe
  */
  /* Opcode: NotFound P1 P2 P3 P4 *
  ** Synopsis: key=r[P3@P4]
  **
  ** If P4==0 then register P3 holds a blob constructed by MakeRecord.  If
  ** P4>0 then register P3 is the first of P4 registers that form an unpacked
  ** record.
  ** 
  ** Cursor P1 is on an index btree.  If the record identified by P3 and P4
  ** is not the prefix of any entry in P1 then a jump is made to P2.  If P1 
  ** does contain an entry whose prefix matches the P3/P4 record then control
  ** falls through to the next instruction and P1 is left pointing at the
  ** matching entry.
  **
  ** This operation leaves the cursor in a state where it cannot be
  ** advanced in either direction.  In other words, the Next and Prev
  ** opcodes do not work after this operation.
  **
  ** See also: Found, NotExists, NoConflict, IfNoHope
  */
  /* Opcode: IfNoHope P1 P2 P3 P4 *
  ** Synopsis: key=r[P3@P4]
  **
  ** Register P3 is the first of P4 registers that form an unpacked
  ** record.
  **
  ** Cursor P1 is on an index btree.  If the seekHit flag is set on P1, then
  ** this opcode is a no-op.  But if the seekHit flag of P1 is clear, then
  ** check to see if there is any entry in P1 that matches the
  ** prefix identified by P3 and P4.  If no entry matches the prefix,
  ** jump to P2.  Otherwise fall through.
  **
  ** This opcode behaves like OP_NotFound if the seekHit
  ** flag is clear and it behaves like OP_Noop if the seekHit flag is set.
  **
  ** This opcode is used in IN clause processing for a multi-column key.
  ** If an IN clause is attached to an element of the key other than the
  ** left-most element, and if there are no matches on the most recent
  ** seek over the whole key, then it might be that one of the key element
  ** to the left is prohibiting a match, and hence there is "no hope" of
  ** any match regardless of how many IN clause elements are checked.
  ** In such a case, we abandon the IN clause search early, using this
  ** opcode.  The opcode name comes from the fact that the
  ** jump is taken if there is "no hope" of achieving a match.
  **
  ** See also: NotFound, SeekHit
  */
  /* Opcode: NoConflict P1 P2 P3 P4 *
  ** Synopsis: key=r[P3@P4]
  **
  ** If P4==0 then register P3 holds a blob constructed by MakeRecord.  If
  ** P4>0 then register P3 is the first of P4 registers that form an unpacked
  ** record.
  ** 
  ** Cursor P1 is on an index btree.  If the record identified by P3 and P4
  ** contains any NULL value, jump immediately to P2.  If all terms of the
  ** record are not-NULL then a check is done to determine if any row in the
  ** P1 index btree has a matching key prefix.  If there are no matches, jump
  ** immediately to P2.  If there is a match, fall through and leave the P1
  ** cursor pointing to the matching row.
  **
  ** This opcode is similar to OP_NotFound with the exceptions that the
  ** branch is always taken if any part of the search key input is NULL.
  **
  ** This operation leaves the cursor in a state where it cannot be
  ** advanced in either direction.  In other words, the Next and Prev
  ** opcodes do not work after this operation.
  **
  ** See also: NotFound, Found, NotExists
  */
  case OP_IfNoHope: {     /* jump, in3 */
    VdbeCursor *pC;
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    if( pC->seekHit ) break;
    /* Fall through into OP_NotFound */
  }
  case OP_NoConflict:     /* jump, in3 */
  case OP_NotFound:       /* jump, in3 */
  case OP_Found: {        /* jump, in3 */
    int alreadyExists;
    int takeJump;
    int ii;
    VdbeCursor *pC;
    int res;
    UnpackedRecord *pFree;
    UnpackedRecord *pIdxKey;
    UnpackedRecord r;
  
  #ifdef SQLITE_TEST
    if( pOp->opcode!=OP_NoConflict ) sqlite3_found_count++;
  #endif
  
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    assert( pOp->p4type==P4_INT32 );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
  #ifdef SQLITE_DEBUG
    pC->seekOp = pOp->opcode;
  #endif
    pIn3 = &aMem[pOp->p3];
    assert( pC->eCurType==CURTYPE_BTREE );
    assert( pC->uc.pCursor!=0 );
    assert( pC->isTable==0 );
    if( pOp->p4.i>0 ){
      r.pKeyInfo = pC->pKeyInfo;
      r.nField = (u16)pOp->p4.i;
      r.aMem = pIn3;
  #ifdef SQLITE_DEBUG
      for(ii=0; ii<r.nField; ii++){
        assert( memIsValid(&r.aMem[ii]) );
        assert( (r.aMem[ii].flags & MEM_Zero)==0 || r.aMem[ii].n==0 );
        if( ii ) REGISTER_TRACE(pOp->p3+ii, &r.aMem[ii]);
      }
  #endif
      pIdxKey = &r;
      pFree = 0;
    }else{
      assert( pIn3->flags & MEM_Blob );
      rc = ExpandBlob(pIn3);
      assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
      if( rc ) goto no_mem;
      pFree = pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo);
      if( pIdxKey==0 ) goto no_mem;
      sqlite3VdbeRecordUnpack(pC->pKeyInfo, pIn3->n, pIn3->z, pIdxKey);
    }
    pIdxKey->default_rc = 0;
    takeJump = 0;
    if( pOp->opcode==OP_NoConflict ){
      /* For the OP_NoConflict opcode, take the jump if any of the
      ** input fields are NULL, since any key with a NULL will not
      ** conflict */
      for(ii=0; ii<pIdxKey->nField; ii++){
        if( pIdxKey->aMem[ii].flags & MEM_Null ){
          takeJump = 1;
          break;
        }
      }
    }
    rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, pIdxKey, 0, 0, &res);
    if( pFree ) sqlite3DbFreeNN(db, pFree);
    if( rc!=SQLITE_OK ){
      goto abort_due_to_error;
    }
    pC->seekResult = res;
    alreadyExists = (res==0);
    pC->nullRow = 1-alreadyExists;
    pC->deferredMoveto = 0;
    pC->cacheStatus = CACHE_STALE;
    if( pOp->opcode==OP_Found ){
      VdbeBranchTaken(alreadyExists!=0,2);
      if( alreadyExists ) goto jump_to_p2;
    }else{
      VdbeBranchTaken(takeJump||alreadyExists==0,2);
      if( takeJump || !alreadyExists ) goto jump_to_p2;
    }
    break;
  }
  
  /* Opcode: SeekRowid P1 P2 P3 * *
  ** Synopsis: intkey=r[P3]
  **
  ** P1 is the index of a cursor open on an SQL table btree (with integer
  ** keys).  If register P3 does not contain an integer or if P1 does not
  ** contain a record with rowid P3 then jump immediately to P2.  
  ** Or, if P2 is 0, raise an SQLITE_CORRUPT error. If P1 does contain
  ** a record with rowid P3 then 
  ** leave the cursor pointing at that record and fall through to the next
  ** instruction.
  **
  ** The OP_NotExists opcode performs the same operation, but with OP_NotExists
  ** the P3 register must be guaranteed to contain an integer value.  With this
  ** opcode, register P3 might not contain an integer.
  **
  ** The OP_NotFound opcode performs the same operation on index btrees
  ** (with arbitrary multi-value keys).
  **
  ** This opcode leaves the cursor in a state where it cannot be advanced
  ** in either direction.  In other words, the Next and Prev opcodes will
  ** not work following this opcode.
  **
  ** See also: Found, NotFound, NoConflict, SeekRowid
  */
  /* Opcode: NotExists P1 P2 P3 * *
  ** Synopsis: intkey=r[P3]
  **
  ** P1 is the index of a cursor open on an SQL table btree (with integer
  ** keys).  P3 is an integer rowid.  If P1 does not contain a record with
  ** rowid P3 then jump immediately to P2.  Or, if P2 is 0, raise an
  ** SQLITE_CORRUPT error. If P1 does contain a record with rowid P3 then 
  ** leave the cursor pointing at that record and fall through to the next
  ** instruction.
  **
  ** The OP_SeekRowid opcode performs the same operation but also allows the
  ** P3 register to contain a non-integer value, in which case the jump is
  ** always taken.  This opcode requires that P3 always contain an integer.
  **
  ** The OP_NotFound opcode performs the same operation on index btrees
  ** (with arbitrary multi-value keys).
  **
  ** This opcode leaves the cursor in a state where it cannot be advanced
  ** in either direction.  In other words, the Next and Prev opcodes will
  ** not work following this opcode.
  **
  ** See also: Found, NotFound, NoConflict, SeekRowid
  */
  case OP_SeekRowid: {        /* jump, in3 */
    VdbeCursor *pC;
    BtCursor *pCrsr;
    int res;
    u64 iKey;
  
    pIn3 = &aMem[pOp->p3];
    testcase( pIn3->flags & MEM_Int );
    testcase( pIn3->flags & MEM_IntReal );
    testcase( pIn3->flags & MEM_Real );
    testcase( (pIn3->flags & (MEM_Str|MEM_Int))==MEM_Str );
    if( (pIn3->flags & (MEM_Int|MEM_IntReal))==0 ){
      /* If pIn3->u.i does not contain an integer, compute iKey as the
      ** integer value of pIn3.  Jump to P2 if pIn3 cannot be converted
      ** into an integer without loss of information.  Take care to avoid
      ** changing the datatype of pIn3, however, as it is used by other
      ** parts of the prepared statement. */
      Mem x = pIn3[0];
      applyAffinity(&x, SQLITE_AFF_NUMERIC, encoding);
      if( (x.flags & MEM_Int)==0 ) goto jump_to_p2;
      iKey = x.u.i;
      goto notExistsWithKey;
    }
    /* Fall through into OP_NotExists */
  case OP_NotExists:          /* jump, in3 */
    pIn3 = &aMem[pOp->p3];
    assert( (pIn3->flags & MEM_Int)!=0 || pOp->opcode==OP_SeekRowid );
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    iKey = pIn3->u.i;
  notExistsWithKey:
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
  #ifdef SQLITE_DEBUG
    if( pOp->opcode==OP_SeekRowid ) pC->seekOp = OP_SeekRowid;
  #endif
    assert( pC->isTable );
    assert( pC->eCurType==CURTYPE_BTREE );
    pCrsr = pC->uc.pCursor;
    assert( pCrsr!=0 );
    res = 0;
    rc = sqlite3BtreeMovetoUnpacked(pCrsr, 0, iKey, 0, &res);
    assert( rc==SQLITE_OK || res==0 );
    pC->movetoTarget = iKey;  /* Used by OP_Delete */
    pC->nullRow = 0;
    pC->cacheStatus = CACHE_STALE;
    pC->deferredMoveto = 0;
    VdbeBranchTaken(res!=0,2);
    pC->seekResult = res;
    if( res!=0 ){
      assert( rc==SQLITE_OK );
      if( pOp->p2==0 ){
        rc = SQLITE_CORRUPT_BKPT;
      }else{
        goto jump_to_p2;
      }
    }
    if( rc ) goto abort_due_to_error;
    break;
  }
  
  /* Opcode: Sequence P1 P2 * * *
  ** Synopsis: r[P2]=cursor[P1].ctr++
  **
  ** Find the next available sequence number for cursor P1.
  ** Write the sequence number into register P2.
  ** The sequence number on the cursor is incremented after this
  ** instruction.  
  */
  case OP_Sequence: {           /* out2 */
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    assert( p->apCsr[pOp->p1]!=0 );
    assert( p->apCsr[pOp->p1]->eCurType!=CURTYPE_VTAB );
    pOut = out2Prerelease(p, pOp);
    pOut->u.i = p->apCsr[pOp->p1]->seqCount++;
    break;
  }
  
  
  /* Opcode: NewRowid P1 P2 P3 * *
  ** Synopsis: r[P2]=rowid
  **
  ** Get a new integer record number (a.k.a "rowid") used as the key to a table.
  ** The record number is not previously used as a key in the database
  ** table that cursor P1 points to.  The new record number is written
  ** written to register P2.
  **
  ** If P3>0 then P3 is a register in the root frame of this VDBE that holds 
  ** the largest previously generated record number. No new record numbers are
  ** allowed to be less than this value. When this value reaches its maximum, 
  ** an SQLITE_FULL error is generated. The P3 register is updated with the '
  ** generated record number. This P3 mechanism is used to help implement the
  ** AUTOINCREMENT feature.
  */
  case OP_NewRowid: {           /* out2 */
    i64 v;                 /* The new rowid */
    VdbeCursor *pC;        /* Cursor of table to get the new rowid */
    int res;               /* Result of an sqlite3BtreeLast() */
    int cnt;               /* Counter to limit the number of searches */
    Mem *pMem;             /* Register holding largest rowid for AUTOINCREMENT */
    VdbeFrame *pFrame;     /* Root frame of VDBE */
  
    v = 0;
    res = 0;
    pOut = out2Prerelease(p, pOp);
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    assert( pC->isTable );
    assert( pC->eCurType==CURTYPE_BTREE );
    assert( pC->uc.pCursor!=0 );
    {
      /* The next rowid or record number (different terms for the same
      ** thing) is obtained in a two-step algorithm.
      **
      ** First we attempt to find the largest existing rowid and add one
      ** to that.  But if the largest existing rowid is already the maximum
      ** positive integer, we have to fall through to the second
      ** probabilistic algorithm
      **
      ** The second algorithm is to select a rowid at random and see if
      ** it already exists in the table.  If it does not exist, we have
      ** succeeded.  If the random rowid does exist, we select a new one
      ** and try again, up to 100 times.
      */
      assert( pC->isTable );
  
  #ifdef SQLITE_32BIT_ROWID
  #   define MAX_ROWID 0x7fffffff
  #else
      /* Some compilers complain about constants of the form 0x7fffffffffffffff.
      ** Others complain about 0x7ffffffffffffffffLL.  The following macro seems
      ** to provide the constant while making all compilers happy.
      */
  #   define MAX_ROWID  (i64)( (((u64)0x7fffffff)<<32) | (u64)0xffffffff )
  #endif
  
      if( !pC->useRandomRowid ){
        rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
        if( rc!=SQLITE_OK ){
          goto abort_due_to_error;
        }
        if( res ){
          v = 1;   /* IMP: R-61914-48074 */
        }else{
          assert( sqlite3BtreeCursorIsValid(pC->uc.pCursor) );
          v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
          if( v>=MAX_ROWID ){
            pC->useRandomRowid = 1;
          }else{
            v++;   /* IMP: R-29538-34987 */
          }
        }
      }
  
  #ifndef SQLITE_OMIT_AUTOINCREMENT
      if( pOp->p3 ){
        /* Assert that P3 is a valid memory cell. */
        assert( pOp->p3>0 );
        if( p->pFrame ){
          for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
          /* Assert that P3 is a valid memory cell. */
          assert( pOp->p3<=pFrame->nMem );
          pMem = &pFrame->aMem[pOp->p3];
        }else{
          /* Assert that P3 is a valid memory cell. */
          assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
          pMem = &aMem[pOp->p3];
          memAboutToChange(p, pMem);
        }
        assert( memIsValid(pMem) );
  
        REGISTER_TRACE(pOp->p3, pMem);
        sqlite3VdbeMemIntegerify(pMem);
        assert( (pMem->flags & MEM_Int)!=0 );  /* mem(P3) holds an integer */
        if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
          rc = SQLITE_FULL;   /* IMP: R-17817-00630 */
          goto abort_due_to_error;
        }
        if( v<pMem->u.i+1 ){
          v = pMem->u.i + 1;
        }
        pMem->u.i = v;
      }
  #endif
      if( pC->useRandomRowid ){
        /* IMPLEMENTATION-OF: R-07677-41881 If the largest ROWID is equal to the
        ** largest possible integer (9223372036854775807) then the database
        ** engine starts picking positive candidate ROWIDs at random until
        ** it finds one that is not previously used. */
        assert( pOp->p3==0 );  /* We cannot be in random rowid mode if this is
                               ** an AUTOINCREMENT table. */
        cnt = 0;
        do{
          sqlite3_randomness(sizeof(v), &v);
          v &= (MAX_ROWID>>1); v++;  /* Ensure that v is greater than zero */
        }while(  ((rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)v,
                                                   0, &res))==SQLITE_OK)
              && (res==0)
              && (++cnt<100));
        if( rc ) goto abort_due_to_error;
        if( res==0 ){
          rc = SQLITE_FULL;   /* IMP: R-38219-53002 */
          goto abort_due_to_error;
        }
        assert( v>0 );  /* EV: R-40812-03570 */
      }
      pC->deferredMoveto = 0;
      pC->cacheStatus = CACHE_STALE;
    }
    pOut->u.i = v;
    break;
  }
  
  /* Opcode: Insert P1 P2 P3 P4 P5
  ** Synopsis: intkey=r[P3] data=r[P2]
  **
  ** Write an entry into the table of cursor P1.  A new entry is
  ** created if it doesn't already exist or the data for an existing
  ** entry is overwritten.  The data is the value MEM_Blob stored in register
  ** number P2. The key is stored in register P3. The key must
  ** be a MEM_Int.
  **
  ** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is
  ** incremented (otherwise not).  If the OPFLAG_LASTROWID flag of P5 is set,
  ** then rowid is stored for subsequent return by the
  ** sqlite3_last_insert_rowid() function (otherwise it is unmodified).
  **
  ** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might
  ** run faster by avoiding an unnecessary seek on cursor P1.  However,
  ** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior
  ** seeks on the cursor or if the most recent seek used a key equal to P3.
  **
  ** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an
  ** UPDATE operation.  Otherwise (if the flag is clear) then this opcode
  ** is part of an INSERT operation.  The difference is only important to
  ** the update hook.
  **
  ** Parameter P4 may point to a Table structure, or may be NULL. If it is 
  ** not NULL, then the update-hook (sqlite3.xUpdateCallback) is invoked 
  ** following a successful insert.
  **
  ** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically
  ** allocated, then ownership of P2 is transferred to the pseudo-cursor
  ** and register P2 becomes ephemeral.  If the cursor is changed, the
  ** value of register P2 will then change.  Make sure this does not
  ** cause any problems.)
  **
  ** This instruction only works on tables.  The equivalent instruction
  ** for indices is OP_IdxInsert.
  */
  case OP_Insert: {
    Mem *pData;       /* MEM cell holding data for the record to be inserted */
    Mem *pKey;        /* MEM cell holding key  for the record */
    VdbeCursor *pC;   /* Cursor to table into which insert is written */
    int seekResult;   /* Result of prior seek or 0 if no USESEEKRESULT flag */
    const char *zDb;  /* database name - used by the update hook */
    Table *pTab;      /* Table structure - used by update and pre-update hooks */
    BtreePayload x;   /* Payload to be inserted */
  
    pData = &aMem[pOp->p2];
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    assert( memIsValid(pData) );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    assert( pC->eCurType==CURTYPE_BTREE );
    assert( pC->deferredMoveto==0 );
    assert( pC->uc.pCursor!=0 );
    assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable );
    assert( pOp->p4type==P4_TABLE || pOp->p4type>=P4_STATIC );
    REGISTER_TRACE(pOp->p2, pData);
    sqlite3VdbeIncrWriteCounter(p, pC);
  
    pKey = &aMem[pOp->p3];
    assert( pKey->flags & MEM_Int );
    assert( memIsValid(pKey) );
    REGISTER_TRACE(pOp->p3, pKey);
    x.nKey = pKey->u.i;
  
    if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){
      assert( pC->iDb>=0 );
      zDb = db->aDb[pC->iDb].zDbSName;
      pTab = pOp->p4.pTab;
      assert( (pOp->p5 & OPFLAG_ISNOOP) || HasRowid(pTab) );
    }else{
      pTab = 0;
      zDb = 0;  /* Not needed.  Silence a compiler warning. */
    }
  
  #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
    /* Invoke the pre-update hook, if any */
    if( pTab ){
      if( db->xPreUpdateCallback && !(pOp->p5 & OPFLAG_ISUPDATE) ){
        sqlite3VdbePreUpdateHook(p, pC, SQLITE_INSERT, zDb, pTab, x.nKey,pOp->p2);
      }
      if( db->xUpdateCallback==0 || pTab->aCol==0 ){
        /* Prevent post-update hook from running in cases when it should not */
        pTab = 0;
      }
    }
    if( pOp->p5 & OPFLAG_ISNOOP ) break;
  #endif
  
    if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
    if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = x.nKey;
    assert( pData->flags & (MEM_Blob|MEM_Str) );
    x.pData = pData->z;
    x.nData = pData->n;
    seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0);
    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)), 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: 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
  ** record in the table. If it is left pointing at the next record, then
  ** the next Next instruction will be a no-op. As a result, in this case
  ** it is ok to delete a record from within a Next loop. If 
  ** OPFLAG_SAVEPOSITION bit of P5 is clear, then the cursor will be
  ** left in an undefined state.
  **
  ** If the OPFLAG_AUXDELETE bit is set on P5, that indicates that this
  ** delete one of several associated with deleting a table row and all its
  ** associated index entries.  Exactly one of those deletes is the "primary"
  ** delete.  The others are all on OPFLAG_FORDELETE cursors or else are
  ** marked with the AUXDELETE flag.
  **
  ** If the OPFLAG_NCHANGE flag of P2 (NB: P2 not P5) is set, then the row
  ** change count is incremented (otherwise not).
  **
  ** P1 must not be pseudo-table.  It has to be a real table with
  ** multiple rows.
  **
  ** If P4 is not NULL then it points to a Table object. In this case either 
  ** the update or pre-update hook, or both, may be invoked. The P1 cursor must
  ** have been positioned using OP_NotFound prior to invoking this opcode in 
  ** this case. Specifically, if one is configured, the pre-update hook is 
  ** invoked if P4 is not NULL. The update-hook is invoked if one is configured, 
  ** P4 is not NULL, and the OPFLAG_NCHANGE flag is set in P2.
  **
  ** If the OPFLAG_ISUPDATE flag is set in P2, then P3 contains the address
  ** of the memory cell that contains the value that the rowid of the row will
  ** be set to by the update.
  */
  case OP_Delete: {
    VdbeCursor *pC;
    const char *zDb;
    Table *pTab;
    int opflags;
  
    opflags = pOp->p2;
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    assert( pC->eCurType==CURTYPE_BTREE );
    assert( pC->uc.pCursor!=0 );
    assert( pC->deferredMoveto==0 );
    sqlite3VdbeIncrWriteCounter(p, pC);
  
  #ifdef SQLITE_DEBUG
    if( pOp->p4type==P4_TABLE
     && HasRowid(pOp->p4.pTab)
     && pOp->p5==0
     && sqlite3BtreeCursorIsValidNN(pC->uc.pCursor)
    ){
      /* If p5 is zero, the seek operation that positioned the cursor prior to
      ** OP_Delete will have also set the pC->movetoTarget field to the rowid of
      ** the row that is being deleted */
      i64 iKey = sqlite3BtreeIntegerKey(pC->uc.pCursor);
      assert( CORRUPT_DB || pC->movetoTarget==iKey );
    }
  #endif
  
    /* If the update-hook or pre-update-hook will be invoked, set zDb to
    ** the name of the db to pass as to it. Also set local pTab to a copy
    ** of p4.pTab. Finally, if p5 is true, indicating that this cursor was
    ** last moved with OP_Next or OP_Prev, not Seek or NotFound, set 
    ** VdbeCursor.movetoTarget to the current rowid.  */
    if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){
      assert( pC->iDb>=0 );
      assert( pOp->p4.pTab!=0 );
      zDb = db->aDb[pC->iDb].zDbSName;
      pTab = pOp->p4.pTab;
      if( (pOp->p5 & OPFLAG_SAVEPOSITION)!=0 && pC->isTable ){
        pC->movetoTarget = sqlite3BtreeIntegerKey(pC->uc.pCursor);
      }
    }else{
      zDb = 0;   /* Not needed.  Silence a compiler warning. */
      pTab = 0;  /* Not needed.  Silence a compiler warning. */
    }
  
  #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
    /* Invoke the pre-update-hook if required. */
    if( db->xPreUpdateCallback && pOp->p4.pTab ){
      assert( !(opflags & OPFLAG_ISUPDATE) 
           || HasRowid(pTab)==0 
           || (aMem[pOp->p3].flags & MEM_Int) 
      );
      sqlite3VdbePreUpdateHook(p, pC,
          (opflags & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_DELETE, 
          zDb, pTab, pC->movetoTarget,
          pOp->p3
      );
    }
    if( opflags & OPFLAG_ISNOOP ) break;
  #endif
   
    /* Only flags that can be set are SAVEPOISTION and AUXDELETE */ 
    assert( (pOp->p5 & ~(OPFLAG_SAVEPOSITION|OPFLAG_AUXDELETE))==0 );
    assert( OPFLAG_SAVEPOSITION==BTREE_SAVEPOSITION );
    assert( OPFLAG_AUXDELETE==BTREE_AUXDELETE );
  
  #ifdef SQLITE_DEBUG
    if( p->pFrame==0 ){
      if( pC->isEphemeral==0
          && (pOp->p5 & OPFLAG_AUXDELETE)==0
          && (pC->wrFlag & OPFLAG_FORDELETE)==0
        ){
        nExtraDelete++;
      }
      if( pOp->p2 & OPFLAG_NCHANGE ){
        nExtraDelete--;
      }
    }
  #endif
  
    rc = sqlite3BtreeDelete(pC->uc.pCursor, pOp->p5);
    pC->cacheStatus = CACHE_STALE;
    pC->seekResult = 0;
    if( rc ) goto abort_due_to_error;
  
    /* Invoke the update-hook if required. */
    if( opflags & OPFLAG_NCHANGE ){
      p->nChange++;
      if( db->xUpdateCallback && HasRowid(pTab) ){
        db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName,
            pC->movetoTarget);
        assert( pC->iDb>=0 );
      }
    }
  
    break;
  }
  /* Opcode: ResetCount * * * * *
  **
  ** The value of the change counter is copied to the database handle
  ** change counter (returned by subsequent calls to sqlite3_changes()).
  ** Then the VMs internal change counter resets to 0.
  ** This is used by trigger programs.
  */
  case OP_ResetCount: {
    sqlite3VdbeSetChanges(db, p->nChange);
    p->nChange = 0;
    break;
  }
  
  /* Opcode: SorterCompare P1 P2 P3 P4
  ** Synopsis: if key(P1)!=trim(r[P3],P4) goto P2
  **
  ** P1 is a sorter cursor. This instruction compares a prefix of the
  ** record blob in register P3 against a prefix of the entry that 
  ** the sorter cursor currently points to.  Only the first P4 fields
  ** of r[P3] and the sorter record are compared.
  **
  ** If either P3 or the sorter contains a NULL in one of their significant
  ** fields (not counting the P4 fields at the end which are ignored) then
  ** the comparison is assumed to be equal.
  **
  ** Fall through to next instruction if the two records compare equal to
  ** each other.  Jump to P2 if they are different.
  */
  case OP_SorterCompare: {
    VdbeCursor *pC;
    int res;
    int nKeyCol;
  
    pC = p->apCsr[pOp->p1];
    assert( isSorter(pC) );
    assert( pOp->p4type==P4_INT32 );
    pIn3 = &aMem[pOp->p3];
    nKeyCol = pOp->p4.i;
    res = 0;
    rc = sqlite3VdbeSorterCompare(pC, pIn3, nKeyCol, &res);
    VdbeBranchTaken(res!=0,2);
    if( rc ) goto abort_due_to_error;
    if( res ) goto jump_to_p2;
    break;
  };
  
  /* Opcode: SorterData P1 P2 P3 * *
  ** Synopsis: r[P2]=data
  **
  ** Write into register P2 the current sorter data for sorter cursor P1.
  ** Then clear the column header cache on cursor P3.
  **
  ** This opcode is normally use to move a record out of the sorter and into
  ** a register that is the source for a pseudo-table cursor created using
  ** OpenPseudo.  That pseudo-table cursor is the one that is identified by
  ** parameter P3.  Clearing the P3 column cache as part of this opcode saves
  ** us from having to issue a separate NullRow instruction to clear that cache.
  */
  case OP_SorterData: {
    VdbeCursor *pC;
  
    pOut = &aMem[pOp->p2];
    pC = p->apCsr[pOp->p1];
    assert( isSorter(pC) );
    rc = sqlite3VdbeSorterRowkey(pC, pOut);
    assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) );
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    if( rc ) goto abort_due_to_error;
    p->apCsr[pOp->p3]->cacheStatus = CACHE_STALE;
    break;
  }
  
  /* Opcode: RowData P1 P2 P3 * *
  ** Synopsis: r[P2]=data
  **
  ** Write into register P2 the complete row content for the row at 
  ** which cursor P1 is currently pointing.
  ** There is no interpretation of the data.  
  ** It is just copied onto the P2 register exactly as 
  ** it is found in the database file.
  **
  ** If cursor P1 is an index, then the content is the key of the row.
  ** If cursor P2 is a table, then the content extracted is the data.
  **
  ** If the P1 cursor must be pointing to a valid row (not a NULL row)
  ** of a real table, not a pseudo-table.
  **
  ** If P3!=0 then this opcode is allowed to make an ephemeral pointer
  ** into the database page.  That means that the content of the output
  ** register will be invalidated as soon as the cursor moves - including
  ** moves caused by other cursors that "save" the current cursors
  ** position in order that they can write to the same table.  If P3==0
  ** then a copy of the data is made into memory.  P3!=0 is faster, but
  ** P3==0 is safer.
  **
  ** If P3!=0 then the content of the P2 register is unsuitable for use
  ** in OP_Result and any OP_Result will invalidate the P2 register content.
  ** The P2 register content is invalidated by opcodes like OP_Function or
  ** by any use of another cursor pointing to the same table.
  */
  case OP_RowData: {
    VdbeCursor *pC;
    BtCursor *pCrsr;
    u32 n;
  
    pOut = out2Prerelease(p, pOp);
  
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    assert( pC->eCurType==CURTYPE_BTREE );
    assert( isSorter(pC)==0 );
    assert( pC->nullRow==0 );
    assert( pC->uc.pCursor!=0 );
    pCrsr = pC->uc.pCursor;
  
    /* The OP_RowData opcodes always follow OP_NotExists or
    ** OP_SeekRowid or OP_Rewind/Op_Next with no intervening instructions
    ** that might invalidate the cursor.
    ** If this where not the case, on of the following assert()s
    ** would fail.  Should this ever change (because of changes in the code
    ** generator) then the fix would be to insert a call to
    ** sqlite3VdbeCursorMoveto().
    */
    assert( pC->deferredMoveto==0 );
    assert( sqlite3BtreeCursorIsValid(pCrsr) );
  #if 0  /* Not required due to the previous to assert() statements */
    rc = sqlite3VdbeCursorMoveto(pC);
    if( rc!=SQLITE_OK ) goto abort_due_to_error;
  #endif
  
    n = sqlite3BtreePayloadSize(pCrsr);
    if( n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
      goto too_big;
    }
    testcase( n==0 );
    rc = sqlite3VdbeMemFromBtreeZeroOffset(pCrsr, n, pOut);
    if( rc ) goto abort_due_to_error;
    if( !pOp->p3 ) Deephemeralize(pOut);
    UPDATE_MAX_BLOBSIZE(pOut);
    REGISTER_TRACE(pOp->p2, pOut);
    break;
  }
  
  /* Opcode: Rowid P1 P2 * * *
  ** Synopsis: r[P2]=rowid
  **
  ** Store in register P2 an integer which is the key of the table entry that
  ** P1 is currently point to.
  **
  ** P1 can be either an ordinary table or a virtual table.  There used to
  ** be a separate OP_VRowid opcode for use with virtual tables, but this
  ** one opcode now works for both table types.
  */
  case OP_Rowid: {                 /* out2 */
    VdbeCursor *pC;
    i64 v;
    sqlite3_vtab *pVtab;
    const sqlite3_module *pModule;
  
    pOut = out2Prerelease(p, pOp);
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
    if( pC->nullRow ){
      pOut->flags = MEM_Null;
      break;
    }else if( pC->deferredMoveto ){
      v = pC->movetoTarget;
  #ifndef SQLITE_OMIT_VIRTUALTABLE
    }else if( pC->eCurType==CURTYPE_VTAB ){
      assert( pC->uc.pVCur!=0 );
      pVtab = pC->uc.pVCur->pVtab;
      pModule = pVtab->pModule;
      assert( pModule->xRowid );
      rc = pModule->xRowid(pC->uc.pVCur, &v);
      sqlite3VtabImportErrmsg(p, pVtab);
      if( rc ) goto abort_due_to_error;
  #endif /* SQLITE_OMIT_VIRTUALTABLE */
    }else{
      assert( pC->eCurType==CURTYPE_BTREE );
      assert( pC->uc.pCursor!=0 );
      rc = sqlite3VdbeCursorRestore(pC);
      if( rc ) goto abort_due_to_error;
      if( pC->nullRow ){
        pOut->flags = MEM_Null;
        break;
      }
      v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
    }
    pOut->u.i = v;
    break;
  }
  
  /* Opcode: NullRow P1 * * * *
  **
  ** Move the cursor P1 to a null row.  Any OP_Column operations
  ** that occur while the cursor is on the null row will always
  ** write a NULL.
  */
  case OP_NullRow: {
    VdbeCursor *pC;
  
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    pC->nullRow = 1;
    pC->cacheStatus = CACHE_STALE;
    if( pC->eCurType==CURTYPE_BTREE ){
      assert( pC->uc.pCursor!=0 );
      sqlite3BtreeClearCursor(pC->uc.pCursor);
    }
  #ifdef SQLITE_DEBUG
    if( pC->seekOp==0 ) pC->seekOp = OP_NullRow;
  #endif
    break;
  }
  
  /* Opcode: SeekEnd P1 * * * *
  **
  ** Position cursor P1 at the end of the btree for the purpose of
  ** appending a new entry onto the btree.
  **
  ** It is assumed that the cursor is used only for appending and so
  ** if the cursor is valid, then the cursor must already be pointing
  ** at the end of the btree and so no changes are made to
  ** the cursor.
  */
  /* Opcode: Last P1 P2 * * *
  **
  ** The next use of the Rowid or Column or Prev instruction for P1 
  ** will refer to the last entry in the database table or index.
  ** If the table or index is empty and P2>0, then jump immediately to P2.
  ** If P2 is 0 or if the table or index is not empty, fall through
  ** to the following instruction.
  **
  ** This opcode leaves the cursor configured to move in reverse order,
  ** from the end toward the beginning.  In other words, the cursor is
  ** configured to use Prev, not Next.
  */
  case OP_SeekEnd:
  case OP_Last: {        /* jump */
    VdbeCursor *pC;
    BtCursor *pCrsr;
    int res;
  
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    assert( pC->eCurType==CURTYPE_BTREE );
    pCrsr = pC->uc.pCursor;
    res = 0;
    assert( pCrsr!=0 );
  #ifdef SQLITE_DEBUG
    pC->seekOp = pOp->opcode;
  #endif
    if( pOp->opcode==OP_SeekEnd ){
      assert( pOp->p2==0 );
      pC->seekResult = -1;
      if( sqlite3BtreeCursorIsValidNN(pCrsr) ){
        break;
      }
    }
    rc = sqlite3BtreeLast(pCrsr, &res);
    pC->nullRow = (u8)res;
    pC->deferredMoveto = 0;
    pC->cacheStatus = CACHE_STALE;
    if( rc ) goto abort_due_to_error;
    if( pOp->p2>0 ){
      VdbeBranchTaken(res!=0,2);
      if( res ) goto jump_to_p2;
    }
    break;
  }
  
  /* Opcode: IfSmaller P1 P2 P3 * *
  **
  ** Estimate the number of rows in the table P1.  Jump to P2 if that
  ** estimate is less than approximately 2**(0.1*P3).
  */
  case OP_IfSmaller: {        /* jump */
    VdbeCursor *pC;
    BtCursor *pCrsr;
    int res;
    i64 sz;
  
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    pCrsr = pC->uc.pCursor;
    assert( pCrsr );
    rc = sqlite3BtreeFirst(pCrsr, &res);
    if( rc ) goto abort_due_to_error;
    if( res==0 ){
      sz = sqlite3BtreeRowCountEst(pCrsr);
      if( ALWAYS(sz>=0) && sqlite3LogEst((u64)sz)<pOp->p3 ) res = 1;
    }
    VdbeBranchTaken(res!=0,2);
    if( res ) goto jump_to_p2;
    break;
  }
  
  
  /* Opcode: SorterSort P1 P2 * * *
  **
  ** After all records have been inserted into the Sorter object
  ** identified by P1, invoke this opcode to actually do the sorting.
  ** Jump to P2 if there are no records to be sorted.
  **
  ** This opcode is an alias for OP_Sort and OP_Rewind that is used
  ** for Sorter objects.
  */
  /* Opcode: Sort P1 P2 * * *
  **
  ** This opcode does exactly the same thing as OP_Rewind except that
  ** it increments an undocumented global variable used for testing.
  **
  ** Sorting is accomplished by writing records into a sorting index,
  ** then rewinding that index and playing it back from beginning to
  ** end.  We use the OP_Sort opcode instead of OP_Rewind to do the
  ** rewinding so that the global variable will be incremented and
  ** regression tests can determine whether or not the optimizer is
  ** correctly optimizing out sorts.
  */
  case OP_SorterSort:    /* jump */
  case OP_Sort: {        /* jump */
  #ifdef SQLITE_TEST
    sqlite3_sort_count++;
    sqlite3_search_count--;
  #endif
    p->aCounter[SQLITE_STMTSTATUS_SORT]++;
    /* Fall through into OP_Rewind */
  }
  /* Opcode: Rewind P1 P2 * * *
  **
  ** The next use of the Rowid or Column or Next instruction for P1 
  ** will refer to the first entry in the database table or index.
  ** If the table or index is empty, jump immediately to P2.
  ** If the table or index is not empty, fall through to the following 
  ** instruction.
  **
  ** This opcode leaves the cursor configured to move in forward order,
  ** from the beginning toward the end.  In other words, the cursor is
  ** configured to use Next, not Prev.
  */
  case OP_Rewind: {        /* jump */
    VdbeCursor *pC;
    BtCursor *pCrsr;
    int res;
  
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    assert( pOp->p5==0 );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );
    res = 1;
  #ifdef SQLITE_DEBUG
    pC->seekOp = OP_Rewind;
  #endif
    if( isSorter(pC) ){
      rc = sqlite3VdbeSorterRewind(pC, &res);
    }else{
      assert( pC->eCurType==CURTYPE_BTREE );
      pCrsr = pC->uc.pCursor;
      assert( pCrsr );
      rc = sqlite3BtreeFirst(pCrsr, &res);
      pC->deferredMoveto = 0;
      pC->cacheStatus = CACHE_STALE;
    }
    if( rc ) goto abort_due_to_error;
    pC->nullRow = (u8)res;
    assert( pOp->p2>0 && pOp->p2<p->nOp );
    VdbeBranchTaken(res!=0,2);
    if( res ) goto jump_to_p2;
    break;
  }
  
  /* Opcode: Next P1 P2 P3 P4 P5
  **
  ** Advance cursor P1 so that it points to the next key/data pair in its
  ** table or index.  If there are no more key/value pairs then fall through
  ** to the following instruction.  But if the cursor advance was successful,
  ** jump immediately to P2.
  **
  ** The Next opcode is only valid following an SeekGT, SeekGE, or
  ** OP_Rewind opcode used to position the cursor.  Next is not allowed
  ** to follow SeekLT, SeekLE, or OP_Last.
  **
  ** The P1 cursor must be for a real table, not a pseudo-table.  P1 must have
  ** been opened prior to this opcode or the program will segfault.
  **
  ** The P3 value is a hint to the btree implementation. If P3==1, that
  ** means P1 is an SQL index and that this instruction could have been
  ** omitted if that index had been unique.  P3 is usually 0.  P3 is
  ** always either 0 or 1.
  **
  ** P4 is always of type P4_ADVANCE. The function pointer points to
  ** sqlite3BtreeNext().
  **
  ** If P5 is positive and the jump is taken, then event counter
  ** number P5-1 in the prepared statement is incremented.
  **
  ** See also: Prev
  */
  /* Opcode: Prev P1 P2 P3 P4 P5
  **
  ** Back up cursor P1 so that it points to the previous key/data pair in its
  ** table or index.  If there is no previous key/value pairs then fall through
  ** to the following instruction.  But if the cursor backup was successful,
  ** jump immediately to P2.
  **
  **
  ** The Prev opcode is only valid following an SeekLT, SeekLE, or
  ** OP_Last opcode used to position the cursor.  Prev is not allowed
  ** to follow SeekGT, SeekGE, or OP_Rewind.
  **
  ** The P1 cursor must be for a real table, not a pseudo-table.  If P1 is
  ** not open then the behavior is undefined.
  **
  ** The P3 value is a hint to the btree implementation. If P3==1, that
  ** means P1 is an SQL index and that this instruction could have been
  ** omitted if that index had been unique.  P3 is usually 0.  P3 is
  ** always either 0 or 1.
  **
  ** P4 is always of type P4_ADVANCE. The function pointer points to
  ** sqlite3BtreePrevious().
  **
  ** If P5 is positive and the jump is taken, then event counter
  ** number P5-1 in the prepared statement is incremented.
  */
  /* Opcode: SorterNext P1 P2 * * P5
  **
  ** This opcode works just like OP_Next except that P1 must be a
  ** sorter object for which the OP_SorterSort opcode has been
  ** invoked.  This opcode advances the cursor to the next sorted
  ** record, or jumps to P2 if there are no more sorted records.
  */
  case OP_SorterNext: {  /* jump */
    VdbeCursor *pC;
  
    pC = p->apCsr[pOp->p1];
    assert( isSorter(pC) );
    rc = sqlite3VdbeSorterNext(db, pC);
    goto next_tail;
  case OP_Prev:          /* jump */
  case OP_Next:          /* jump */
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    assert( pOp->p5<ArraySize(p->aCounter) );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    assert( pC->deferredMoveto==0 );
    assert( pC->eCurType==CURTYPE_BTREE );
    assert( pOp->opcode!=OP_Next || pOp->p4.xAdvance==sqlite3BtreeNext );
    assert( pOp->opcode!=OP_Prev || pOp->p4.xAdvance==sqlite3BtreePrevious );
  
    /* The Next opcode is only used after SeekGT, SeekGE, Rewind, and Found.
    ** The Prev opcode is only used after SeekLT, SeekLE, and Last. */
    assert( pOp->opcode!=OP_Next
         || pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE
         || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found
         || pC->seekOp==OP_NullRow|| pC->seekOp==OP_SeekRowid
         || pC->seekOp==OP_IfNoHope);
    assert( pOp->opcode!=OP_Prev
         || pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE
         || pC->seekOp==OP_Last   || pC->seekOp==OP_IfNoHope
         || pC->seekOp==OP_NullRow);
  
    rc = pOp->p4.xAdvance(pC->uc.pCursor, pOp->p3);
  next_tail:
    pC->cacheStatus = CACHE_STALE;
    VdbeBranchTaken(rc==SQLITE_OK,2);
    if( rc==SQLITE_OK ){
      pC->nullRow = 0;
      p->aCounter[pOp->p5]++;
  #ifdef SQLITE_TEST
      sqlite3_search_count++;
  #endif
      goto jump_to_p2_and_check_for_interrupt;
    }
    if( rc!=SQLITE_DONE ) goto abort_due_to_error;
    rc = SQLITE_OK;
    pC->nullRow = 1;
    goto check_for_interrupt;
  }
  
  /* Opcode: IdxInsert P1 P2 P3 P4 P5
  ** Synopsis: key=r[P2]
  **
  ** Register P2 holds an SQL index key made using the
  ** MakeRecord instructions.  This opcode writes that key
  ** into the index P1.  Data for the entry is nil.
  **
  ** If P4 is not zero, then it is the number of values in the unpacked
  ** key of reg(P2).  In that case, P3 is the index of the first register
  ** for the unpacked key.  The availability of the unpacked key can sometimes
  ** be an optimization.
  **
  ** If P5 has the OPFLAG_APPEND bit set, that is a hint to the b-tree layer
  ** that this insert is likely to be an append.
  **
  ** If P5 has the OPFLAG_NCHANGE bit set, then the change counter is
  ** incremented by this instruction.  If the OPFLAG_NCHANGE bit is clear,
  ** then the change counter is unchanged.
  **
  ** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might
  ** run faster by avoiding an unnecessary seek on cursor P1.  However,
  ** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior
  ** seeks on the cursor or if the most recent seek used a key equivalent
  ** to P2. 
  **
  ** This instruction only works for indices.  The equivalent instruction
  ** for tables is OP_Insert.
  */
  case OP_IdxInsert: {        /* in2 */
    VdbeCursor *pC;
    BtreePayload x;
  
    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 );
    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)), 
        ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
        );
    assert( pC->deferredMoveto==0 );
    pC->cacheStatus = CACHE_STALE;
    if( rc) goto abort_due_to_error;
    break;
  }
  
  /* Opcode: SorterInsert P1 P2 * * *
  ** Synopsis: key=r[P2]
  **
  ** Register P2 holds an SQL index key made using the
  ** MakeRecord instructions.  This opcode writes that key
  ** into the sorter P1.  Data for the entry is nil.
  */
  case OP_SorterInsert: {     /* in2 */
    VdbeCursor *pC;
  
    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 );
    assert( pC->isTable==0 );
    rc = ExpandBlob(pIn2);
    if( rc ) goto abort_due_to_error;
    rc = sqlite3VdbeSorterWrite(pC, pIn2);
    if( rc) goto abort_due_to_error;
    break;
  }
  
  /* Opcode: IdxDelete P1 P2 P3 * P5
  ** Synopsis: key=r[P2@P3]
  **
  ** The content of P3 registers starting at register P2 form
  ** an unpacked index key. This opcode removes that entry from the 
  ** index opened by cursor P1.
  **
  ** If P5 is not zero, then raise an SQLITE_CORRUPT_INDEX error
  ** if no matching index entry is found.  This happens when running
  ** an UPDATE or DELETE statement and the index entry to be updated
  ** or deleted is not found.  For some uses of IdxDelete
  ** (example:  the EXCEPT operator) it does not matter that no matching
  ** entry is found.  For those cases, P5 is zero.
  */
  case OP_IdxDelete: {
    VdbeCursor *pC;
    BtCursor *pCrsr;
    int res;
    UnpackedRecord r;
  
    assert( pOp->p3>0 );
    assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem+1 - p->nCursor)+1 );
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    assert( pC->eCurType==CURTYPE_BTREE );
    sqlite3VdbeIncrWriteCounter(p, pC);
    pCrsr = pC->uc.pCursor;
    assert( pCrsr!=0 );
    r.pKeyInfo = pC->pKeyInfo;
    r.nField = (u16)pOp->p3;
    r.default_rc = 0;
    r.aMem = &aMem[pOp->p2];
    rc = sqlite3BtreeMovetoUnpacked(pCrsr, &r, 0, 0, &res);
    if( rc ) goto abort_due_to_error;
    if( res==0 ){
      rc = sqlite3BtreeDelete(pCrsr, BTREE_AUXDELETE);
      if( rc ) goto abort_due_to_error;
    }else if( pOp->p5 ){
      rc = SQLITE_CORRUPT_INDEX;
      goto abort_due_to_error;
    }
    assert( pC->deferredMoveto==0 );
    pC->cacheStatus = CACHE_STALE;
    pC->seekResult = 0;
    break;
  }
  
  /* Opcode: DeferredSeek P1 * P3 P4 *
  ** Synopsis: Move P3 to P1.rowid if needed
  **
  ** P1 is an open index cursor and P3 is a cursor on the corresponding
  ** table.  This opcode does a deferred seek of the P3 table cursor
  ** to the row that corresponds to the current row of P1.
  **
  ** This is a deferred seek.  Nothing actually happens until
  ** the cursor is used to read a record.  That way, if no reads
  ** occur, no unnecessary I/O happens.
  **
  ** P4 may be an array of integers (type P4_INTARRAY) containing
  ** one entry for each column in the P3 table.  If array entry a(i)
  ** is non-zero, then reading column a(i)-1 from cursor P3 is 
  ** equivalent to performing the deferred seek and then reading column i 
  ** from P1.  This information is stored in P3 and used to redirect
  ** reads against P3 over to P1, thus possibly avoiding the need to
  ** seek and read cursor P3.
  */
  /* Opcode: IdxRowid P1 P2 * * *
  ** Synopsis: r[P2]=rowid
  **
  ** Write into register P2 an integer which is the last entry in the record at
  ** the end of the index key pointed to by cursor P1.  This integer should be
  ** the rowid of the table entry to which this index entry points.
  **
  ** See also: Rowid, MakeRecord.
  */
  case OP_DeferredSeek:
  case OP_IdxRowid: {           /* out2 */
    VdbeCursor *pC;             /* The P1 index cursor */
    VdbeCursor *pTabCur;        /* The P2 table cursor (OP_DeferredSeek only) */
    i64 rowid;                  /* Rowid that P1 current points to */
  
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    assert( pC->eCurType==CURTYPE_BTREE );
    assert( pC->uc.pCursor!=0 );
    assert( pC->isTable==0 );
    assert( pC->deferredMoveto==0 );
    assert( !pC->nullRow || pOp->opcode==OP_IdxRowid );
  
    /* The IdxRowid and Seek opcodes are combined because of the commonality
    ** of sqlite3VdbeCursorRestore() and sqlite3VdbeIdxRowid(). */
    rc = sqlite3VdbeCursorRestore(pC);
  
    /* sqlite3VbeCursorRestore() can only fail if the record has been deleted
    ** out from under the cursor.  That will never happens for an IdxRowid
    ** or Seek opcode */
    if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error;
  
    if( !pC->nullRow ){
      rowid = 0;  /* Not needed.  Only used to silence a warning. */
      rc = sqlite3VdbeIdxRowid(db, pC->uc.pCursor, &rowid);
      if( rc!=SQLITE_OK ){
        goto abort_due_to_error;
      }
      if( pOp->opcode==OP_DeferredSeek ){
        assert( pOp->p3>=0 && pOp->p3<p->nCursor );
        pTabCur = p->apCsr[pOp->p3];
        assert( pTabCur!=0 );
        assert( pTabCur->eCurType==CURTYPE_BTREE );
        assert( pTabCur->uc.pCursor!=0 );
        assert( pTabCur->isTable );
        pTabCur->nullRow = 0;
        pTabCur->movetoTarget = rowid;
        pTabCur->deferredMoveto = 1;
        assert( pOp->p4type==P4_INTARRAY || pOp->p4.ai==0 );
        pTabCur->aAltMap = pOp->p4.ai;
        pTabCur->pAltCursor = pC;
      }else{
        pOut = out2Prerelease(p, pOp);
        pOut->u.i = rowid;
      }
    }else{
      assert( pOp->opcode==OP_IdxRowid );
      sqlite3VdbeMemSetNull(&aMem[pOp->p2]);
    }
    break;
  }
  
  /* Opcode: FinishSeek P1 * * * *
  ** 
  ** If cursor P1 was previously moved via OP_DeferredSeek, complete that
  ** seek operation now, without further delay.  If the cursor seek has
  ** already occurred, this instruction is a no-op.
  */
  case OP_FinishSeek: {
    VdbeCursor *pC;             /* The P1 index cursor */
  
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    if( pC->deferredMoveto ){
      rc = sqlite3VdbeFinishMoveto(pC);
      if( rc ) goto abort_due_to_error;
    }
    break;
  }
  
  /* Opcode: IdxGE P1 P2 P3 P4 P5
  ** Synopsis: key=r[P3@P4]
  **
  ** The P4 register values beginning with P3 form an unpacked index 
  ** key that omits the PRIMARY KEY.  Compare this key value against the index 
  ** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID 
  ** fields at the end.
  **
  ** If the P1 index entry is greater than or equal to the key value
  ** then jump to P2.  Otherwise fall through to the next instruction.
  */
  /* Opcode: IdxGT P1 P2 P3 P4 P5
  ** Synopsis: key=r[P3@P4]
  **
  ** The P4 register values beginning with P3 form an unpacked index 
  ** key that omits the PRIMARY KEY.  Compare this key value against the index 
  ** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID 
  ** fields at the end.
  **
  ** If the P1 index entry is greater than the key value
  ** then jump to P2.  Otherwise fall through to the next instruction.
  */
  /* Opcode: IdxLT P1 P2 P3 P4 P5
  ** Synopsis: key=r[P3@P4]
  **
  ** The P4 register values beginning with P3 form an unpacked index 
  ** key that omits the PRIMARY KEY or ROWID.  Compare this key value against
  ** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or
  ** ROWID on the P1 index.
  **
  ** If the P1 index entry is less than the key value then jump to P2.
  ** Otherwise fall through to the next instruction.
  */
  /* Opcode: IdxLE P1 P2 P3 P4 P5
  ** Synopsis: key=r[P3@P4]
  **
  ** The P4 register values beginning with P3 form an unpacked index 
  ** key that omits the PRIMARY KEY or ROWID.  Compare this key value against
  ** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or
  ** ROWID on the P1 index.
  **
  ** If the P1 index entry is less than or equal to the key value then jump
  ** to P2. Otherwise fall through to the next instruction.
  */
  case OP_IdxLE:          /* jump */
  case OP_IdxGT:          /* jump */
  case OP_IdxLT:          /* jump */
  case OP_IdxGE:  {       /* jump */
    VdbeCursor *pC;
    int res;
    UnpackedRecord r;
  
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    assert( pC->isOrdered );
    assert( pC->eCurType==CURTYPE_BTREE );
    assert( pC->uc.pCursor!=0);
    assert( pC->deferredMoveto==0 );
    assert( pOp->p5==0 || pOp->p5==1 );
    assert( pOp->p4type==P4_INT32 );
    r.pKeyInfo = pC->pKeyInfo;
    r.nField = (u16)pOp->p4.i;
    if( pOp->opcode<OP_IdxLT ){
      assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxGT );
      r.default_rc = -1;
    }else{
      assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxLT );
      r.default_rc = 0;
    }
    r.aMem = &aMem[pOp->p3];
  #ifdef SQLITE_DEBUG
    {
      int i;
      for(i=0; i<r.nField; i++){
        assert( memIsValid(&r.aMem[i]) );
        REGISTER_TRACE(pOp->p3+i, &aMem[pOp->p3+i]);
      }
    }
  #endif
    res = 0;  /* Not needed.  Only used to silence a warning. */
    rc = sqlite3VdbeIdxKeyCompare(db, pC, &r, &res);
    assert( (OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1) );
    if( (pOp->opcode&1)==(OP_IdxLT&1) ){
      assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT );
      res = -res;
    }else{
      assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxGT );
      res++;
    }
    VdbeBranchTaken(res>0,2);
    if( rc ) goto abort_due_to_error;
    if( res>0 ) goto jump_to_p2;
    break;
  }
  
  /* Opcode: Destroy P1 P2 P3 * *
  **
  ** Delete an entire database table or index whose root page in the database
  ** file is given by P1.
  **
  ** The table being destroyed is in the main database file if P3==0.  If
  ** P3==1 then the table to be clear is in the auxiliary database file
  ** that is used to store tables create using CREATE TEMPORARY TABLE.
  **
  ** If AUTOVACUUM is enabled then it is possible that another root page
  ** might be moved into the newly deleted root page in order to keep all
  ** root pages contiguous at the beginning of the database.  The former
  ** value of the root page that moved - its value before the move occurred -
  ** is stored in register P2. If no page movement was required (because the
  ** table being dropped was already the last one in the database) then a 
  ** zero is stored in register P2.  If AUTOVACUUM is disabled then a zero 
  ** is stored in register P2.
  **
  ** This opcode throws an error if there are any active reader VMs when
  ** it is invoked. This is done to avoid the difficulty associated with 
  ** updating existing cursors when a root page is moved in an AUTOVACUUM 
  ** database. This error is thrown even if the database is not an AUTOVACUUM 
  ** db in order to avoid introducing an incompatibility between autovacuum 
  ** and non-autovacuum modes.
  **
  ** See also: Clear
  */
  case OP_Destroy: {     /* out2 */
    int iMoved;
    int iDb;
  
    sqlite3VdbeIncrWriteCounter(p, 0);
    assert( p->readOnly==0 );
    assert( pOp->p1>1 );
    pOut = out2Prerelease(p, pOp);
    pOut->flags = MEM_Null;
    if( db->nVdbeRead > db->nVDestroy+1 ){
      rc = SQLITE_LOCKED;
      p->errorAction = OE_Abort;
      goto abort_due_to_error;
    }else{
      iDb = pOp->p3;
      assert( DbMaskTest(p->btreeMask, iDb) );
      iMoved = 0;  /* Not needed.  Only to silence a warning. */
      rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
      pOut->flags = MEM_Int;
      pOut->u.i = iMoved;
      if( rc ) goto abort_due_to_error;
  #ifndef SQLITE_OMIT_AUTOVACUUM
      if( iMoved!=0 ){
        sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1);
        /* All OP_Destroy operations occur on the same btree */
        assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 );
        resetSchemaOnFault = iDb+1;
      }
  #endif
    }
    break;
  }
  
  /* Opcode: Clear P1 P2 P3
  **
  ** Delete all contents of the database table or index whose root page
  ** in the database file is given by P1.  But, unlike Destroy, do not
  ** remove the table or index from the database file.
  **
  ** The table being clear is in the main database file if P2==0.  If
  ** P2==1 then the table to be clear is in the auxiliary database file
  ** that is used to store tables create using CREATE TEMPORARY TABLE.
  **
  ** If the P3 value is non-zero, then the table referred to must be an
  ** intkey table (an SQL table, not an index). In this case the row change 
  ** count is incremented by the number of rows in the table being cleared. 
  ** If P3 is greater than zero, then the value stored in register P3 is
  ** also incremented by the number of rows in the table being cleared.
  **
  ** See also: Destroy
  */
  case OP_Clear: {
    int nChange;
   
    sqlite3VdbeIncrWriteCounter(p, 0);
    nChange = 0;
    assert( p->readOnly==0 );
    assert( DbMaskTest(p->btreeMask, pOp->p2) );
    rc = sqlite3BtreeClearTable(
        db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &nChange : 0)
    );
    if( pOp->p3 ){
      p->nChange += nChange;
      if( pOp->p3>0 ){
        assert( memIsValid(&aMem[pOp->p3]) );
        memAboutToChange(p, &aMem[pOp->p3]);
        aMem[pOp->p3].u.i += nChange;
      }
    }
    if( rc ) goto abort_due_to_error;
    break;
  }
  
  /* Opcode: ResetSorter P1 * * * *
  **
  ** Delete all contents from the ephemeral table or sorter
  ** that is open on cursor P1.
  **
  ** This opcode only works for cursors used for sorting and
  ** opened with OP_OpenEphemeral or OP_SorterOpen.
  */
  case OP_ResetSorter: {
    VdbeCursor *pC;
   
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    if( isSorter(pC) ){
      sqlite3VdbeSorterReset(db, pC->uc.pSorter);
    }else{
      assert( pC->eCurType==CURTYPE_BTREE );
      assert( pC->isEphemeral );
      rc = sqlite3BtreeClearTableOfCursor(pC->uc.pCursor);
      if( rc ) goto abort_due_to_error;
    }
    break;
  }
  
  /* Opcode: CreateBtree P1 P2 P3 * *
  ** Synopsis: r[P2]=root iDb=P1 flags=P3
  **
  ** Allocate a new b-tree in the main database file if P1==0 or in the
  ** TEMP database file if P1==1 or in an attached database if
  ** P1>1.  The P3 argument must be 1 (BTREE_INTKEY) for a rowid table
  ** it must be 2 (BTREE_BLOBKEY) for an index or WITHOUT ROWID table.
  ** The root page number of the new b-tree is stored in register P2.
  */
  case OP_CreateBtree: {          /* out2 */
    int pgno;
    Db *pDb;
  
    sqlite3VdbeIncrWriteCounter(p, 0);
    pOut = out2Prerelease(p, pOp);
    pgno = 0;
    assert( pOp->p3==BTREE_INTKEY || pOp->p3==BTREE_BLOBKEY );
    assert( pOp->p1>=0 && pOp->p1<db->nDb );
    assert( DbMaskTest(p->btreeMask, pOp->p1) );
    assert( p->readOnly==0 );
    pDb = &db->aDb[pOp->p1];
    assert( pDb->pBt!=0 );
    rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, pOp->p3);
    if( rc ) goto abort_due_to_error;
    pOut->u.i = pgno;
    break;
  }
  
  /* Opcode: SqlExec * * * P4 *
  **
  ** Run the SQL statement or statements specified in the P4 string.
  */
  case OP_SqlExec: {
    sqlite3VdbeIncrWriteCounter(p, 0);
    db->nSqlExec++;
    rc = sqlite3_exec(db, pOp->p4.z, 0, 0, 0);
    db->nSqlExec--;
    if( rc ) goto abort_due_to_error;
    break;
  }
  
  /* Opcode: ParseSchema P1 * * P4 *
  **
  ** Read and parse all entries from the SQLITE_MASTER table of database P1
  ** that match the WHERE clause P4.  If P4 is a NULL pointer, then the
  ** entire schema for P1 is reparsed.
  **
  ** This opcode invokes the parser to create a new virtual machine,
  ** then runs the new virtual machine.  It is thus a re-entrant opcode.
  */
  case OP_ParseSchema: {
    int iDb;
    const char *zMaster;
    char *zSql;
    InitData initData;
  
    /* Any prepared statement that invokes this opcode will hold mutexes
    ** on every btree.  This is a prerequisite for invoking 
    ** sqlite3InitCallback().
    */
  #ifdef SQLITE_DEBUG
    for(iDb=0; iDb<db->nDb; iDb++){
      assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
    }
  #endif
  
    iDb = pOp->p1;
    assert( iDb>=0 && iDb<db->nDb );
    assert( DbHasProperty(db, iDb, DB_SchemaLoaded) );
  
  #ifndef SQLITE_OMIT_ALTERTABLE
    if( pOp->p4.z==0 ){
      sqlite3SchemaClear(db->aDb[iDb].pSchema);
      db->mDbFlags &= ~DBFLAG_SchemaKnownOk;
      rc = sqlite3InitOne(db, iDb, &p->zErrMsg, INITFLAG_AlterTable);
      db->mDbFlags |= DBFLAG_SchemaChange;
      p->expired = 0;
    }else
  #endif
    {
      zMaster = MASTER_NAME;
      initData.db = db;
      initData.iDb = iDb;
      initData.pzErrMsg = &p->zErrMsg;
      initData.mInitFlags = 0;
      zSql = sqlite3MPrintf(db,
         "SELECT*FROM\"%w\".%s WHERE %s ORDER BY rowid",
         db->aDb[iDb].zDbSName, zMaster, pOp->p4.z);
      if( zSql==0 ){
        rc = SQLITE_NOMEM_BKPT;
      }else{
        assert( db->init.busy==0 );
        db->init.busy = 1;
        initData.rc = SQLITE_OK;
        initData.nInitRow = 0;
        assert( !db->mallocFailed );
        rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
        if( rc==SQLITE_OK ) rc = initData.rc;
        if( rc==SQLITE_OK && initData.nInitRow==0 ){
          /* The OP_ParseSchema opcode with a non-NULL P4 argument should parse
          ** at least one SQL statement. Any less than that indicates that
          ** the sqlite_master table is corrupt. */
          rc = SQLITE_CORRUPT_BKPT;
        }
        sqlite3DbFreeNN(db, zSql);
        db->init.busy = 0;
      }
    }
    if( rc ){
      sqlite3ResetAllSchemasOfConnection(db);
      if( rc==SQLITE_NOMEM ){
        goto no_mem;
      }
      goto abort_due_to_error;
    }
    break;  
  }
  
  #if !defined(SQLITE_OMIT_ANALYZE)
  /* Opcode: LoadAnalysis P1 * * * *
  **
  ** Read the sqlite_stat1 table for database P1 and load the content
  ** of that table into the internal index hash table.  This will cause
  ** the analysis to be used when preparing all subsequent queries.
  */
  case OP_LoadAnalysis: {
    assert( pOp->p1>=0 && pOp->p1<db->nDb );
    rc = sqlite3AnalysisLoad(db, pOp->p1);
    if( rc ) goto abort_due_to_error;
    break;  
  }
  #endif /* !defined(SQLITE_OMIT_ANALYZE) */
  
  /* Opcode: DropTable P1 * * P4 *
  **
  ** Remove the internal (in-memory) data structures that describe
  ** the table named P4 in database P1.  This is called after a table
  ** is dropped from disk (using the Destroy opcode) in order to keep 
  ** the internal representation of the
  ** schema consistent with what is on disk.
  */
  case OP_DropTable: {
    sqlite3VdbeIncrWriteCounter(p, 0);
    sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z);
    break;
  }
  
  /* Opcode: DropIndex P1 * * P4 *
  **
  ** Remove the internal (in-memory) data structures that describe
  ** the index named P4 in database P1.  This is called after an index
  ** is dropped from disk (using the Destroy opcode)
  ** in order to keep the internal representation of the
  ** schema consistent with what is on disk.
  */
  case OP_DropIndex: {
    sqlite3VdbeIncrWriteCounter(p, 0);
    sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z);
    break;
  }
  
  /* Opcode: DropTrigger P1 * * P4 *
  **
  ** Remove the internal (in-memory) data structures that describe
  ** the trigger named P4 in database P1.  This is called after a trigger
  ** is dropped from disk (using the Destroy opcode) in order to keep 
  ** the internal representation of the
  ** schema consistent with what is on disk.
  */
  case OP_DropTrigger: {
    sqlite3VdbeIncrWriteCounter(p, 0);
    sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z);
    break;
  }
  
  
  #ifndef SQLITE_OMIT_INTEGRITY_CHECK
  /* Opcode: IntegrityCk P1 P2 P3 P4 P5
  **
  ** Do an analysis of the currently open database.  Store in
  ** register P1 the text of an error message describing any problems.
  ** If no problems are found, store a NULL in register P1.
  **
  ** The register P3 contains one less than the maximum number of allowed errors.
  ** At most reg(P3) errors will be reported.
  ** In other words, the analysis stops as soon as reg(P1) errors are 
  ** seen.  Reg(P1) is updated with the number of errors remaining.
  **
  ** The root page numbers of all tables in the database are integers
  ** stored in P4_INTARRAY argument.
  **
  ** If P5 is not zero, the check is done on the auxiliary database
  ** file, not the main database file.
  **
  ** This opcode is used to implement the integrity_check pragma.
  */
  case OP_IntegrityCk: {
    int nRoot;      /* Number of tables to check.  (Number of root pages.) */
    int *aRoot;     /* Array of rootpage numbers for tables to be checked */
    int nErr;       /* Number of errors reported */
    char *z;        /* Text of the error report */
    Mem *pnErr;     /* Register keeping track of errors remaining */
  
    assert( p->bIsReader );
    nRoot = pOp->p2;
    aRoot = pOp->p4.ai;
    assert( nRoot>0 );
    assert( aRoot[0]==nRoot );
    assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
    pnErr = &aMem[pOp->p3];
    assert( (pnErr->flags & MEM_Int)!=0 );
    assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 );
    pIn1 = &aMem[pOp->p1];
    assert( pOp->p5<db->nDb );
    assert( DbMaskTest(p->btreeMask, pOp->p5) );
    z = sqlite3BtreeIntegrityCheck(db, db->aDb[pOp->p5].pBt, &aRoot[1], nRoot,
                                   (int)pnErr->u.i+1, &nErr);
    sqlite3VdbeMemSetNull(pIn1);
    if( nErr==0 ){
      assert( z==0 );
    }else if( z==0 ){
      goto no_mem;
    }else{
      pnErr->u.i -= nErr-1;
      sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free);
    }
    UPDATE_MAX_BLOBSIZE(pIn1);
    sqlite3VdbeChangeEncoding(pIn1, encoding);
    goto check_for_interrupt;
  }
  #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
  
  /* Opcode: RowSetAdd P1 P2 * * *
  ** Synopsis: rowset(P1)=r[P2]
  **
  ** Insert the integer value held by register P2 into a RowSet object
  ** held in register P1.
  **
  ** An assertion fails if P2 is not an integer.
  */
  case OP_RowSetAdd: {       /* in1, in2 */
    pIn1 = &aMem[pOp->p1];
    pIn2 = &aMem[pOp->p2];
    assert( (pIn2->flags & MEM_Int)!=0 );
    if( (pIn1->flags & MEM_Blob)==0 ){
      if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem;
    }
    assert( sqlite3VdbeMemIsRowSet(pIn1) );
    sqlite3RowSetInsert((RowSet*)pIn1->z, pIn2->u.i);
    break;
  }
  
  /* Opcode: RowSetRead P1 P2 P3 * *
  ** Synopsis: r[P3]=rowset(P1)
  **
  ** Extract the smallest value from the RowSet object in P1
  ** and put that value into register P3.
  ** Or, if RowSet object P1 is initially empty, leave P3
  ** unchanged and jump to instruction P2.
  */
  case OP_RowSetRead: {       /* jump, in1, out3 */
    i64 val;
  
    pIn1 = &aMem[pOp->p1];
    assert( (pIn1->flags & MEM_Blob)==0 || sqlite3VdbeMemIsRowSet(pIn1) );
    if( (pIn1->flags & MEM_Blob)==0 
     || sqlite3RowSetNext((RowSet*)pIn1->z, &val)==0
    ){
      /* The boolean index is empty */
      sqlite3VdbeMemSetNull(pIn1);
      VdbeBranchTaken(1,2);
      goto jump_to_p2_and_check_for_interrupt;
    }else{
      /* A value was pulled from the index */
      VdbeBranchTaken(0,2);
      sqlite3VdbeMemSetInt64(&aMem[pOp->p3], val);
    }
    goto check_for_interrupt;
  }
  
  /* Opcode: RowSetTest P1 P2 P3 P4
  ** Synopsis: if r[P3] in rowset(P1) goto P2
  **
  ** Register P3 is assumed to hold a 64-bit integer value. If register P1
  ** contains a RowSet object and that RowSet object contains
  ** the value held in P3, jump to register P2. Otherwise, insert the
  ** integer in P3 into the RowSet and continue on to the
  ** next opcode.
  **
  ** The RowSet object is optimized for the case where sets of integers
  ** are inserted in distinct phases, which each set contains no duplicates.
  ** Each set is identified by a unique P4 value. The first set
  ** must have P4==0, the final set must have P4==-1, and for all other sets
  ** must have P4>0.
  **
  ** This allows optimizations: (a) when P4==0 there is no need to test
  ** the RowSet object for P3, as it is guaranteed not to contain it,
  ** (b) when P4==-1 there is no need to insert the value, as it will
  ** never be tested for, and (c) when a value that is part of set X is
  ** inserted, there is no need to search to see if the same value was
  ** previously inserted as part of set X (only if it was previously
  ** inserted as part of some other set).
  */
  case OP_RowSetTest: {                     /* jump, in1, in3 */
    int iSet;
    int exists;
  
    pIn1 = &aMem[pOp->p1];
    pIn3 = &aMem[pOp->p3];
    iSet = pOp->p4.i;
    assert( pIn3->flags&MEM_Int );
  
    /* If there is anything other than a rowset object in memory cell P1,
    ** delete it now and initialize P1 with an empty rowset
    */
    if( (pIn1->flags & MEM_Blob)==0 ){
      if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem;
    }
    assert( sqlite3VdbeMemIsRowSet(pIn1) );
    assert( pOp->p4type==P4_INT32 );
    assert( iSet==-1 || iSet>=0 );
    if( iSet ){
      exists = sqlite3RowSetTest((RowSet*)pIn1->z, iSet, pIn3->u.i);
      VdbeBranchTaken(exists!=0,2);
      if( exists ) goto jump_to_p2;
    }
    if( iSet>=0 ){
      sqlite3RowSetInsert((RowSet*)pIn1->z, pIn3->u.i);
    }
    break;
  }
  
  
  #ifndef SQLITE_OMIT_TRIGGER
  
  /* Opcode: Program P1 P2 P3 P4 P5
  **
  ** Execute the trigger program passed as P4 (type P4_SUBPROGRAM). 
  **
  ** P1 contains the address of the memory cell that contains the first memory 
  ** cell in an array of values used as arguments to the sub-program. P2 
  ** contains the address to jump to if the sub-program throws an IGNORE 
  ** exception using the RAISE() function. Register P3 contains the address 
  ** of a memory cell in this (the parent) VM that is used to allocate the 
  ** memory required by the sub-vdbe at runtime.
  **
  ** P4 is a pointer to the VM containing the trigger program.
  **
  ** If P5 is non-zero, then recursive program invocation is enabled.
  */
  case OP_Program: {        /* jump */
    int nMem;               /* Number of memory registers for sub-program */
    int nByte;              /* Bytes of runtime space required for sub-program */
    Mem *pRt;               /* Register to allocate runtime space */
    Mem *pMem;              /* Used to iterate through memory cells */
    Mem *pEnd;              /* Last memory cell in new array */
    VdbeFrame *pFrame;      /* New vdbe frame to execute in */
    SubProgram *pProgram;   /* Sub-program to execute */
    void *t;                /* Token identifying trigger */
  
    pProgram = pOp->p4.pProgram;
    pRt = &aMem[pOp->p3];
    assert( pProgram->nOp>0 );
    
    /* If the p5 flag is clear, then recursive invocation of triggers is 
    ** disabled for backwards compatibility (p5 is set if this sub-program
    ** is really a trigger, not a foreign key action, and the flag set
    ** and cleared by the "PRAGMA recursive_triggers" command is clear).
    ** 
    ** It is recursive invocation of triggers, at the SQL level, that is 
    ** disabled. In some cases a single trigger may generate more than one 
    ** SubProgram (if the trigger may be executed with more than one different 
    ** ON CONFLICT algorithm). SubProgram structures associated with a
    ** single trigger all have the same value for the SubProgram.token 
    ** variable.  */
    if( pOp->p5 ){
      t = pProgram->token;
      for(pFrame=p->pFrame; pFrame && pFrame->token!=t; pFrame=pFrame->pParent);
      if( pFrame ) break;
    }
  
    if( p->nFrame>=db->aLimit[SQLITE_LIMIT_TRIGGER_DEPTH] ){
      rc = SQLITE_ERROR;
      sqlite3VdbeError(p, "too many levels of trigger recursion");
      goto abort_due_to_error;
    }
  
    /* Register pRt is used to store the memory required to save the state
    ** of the current program, and the memory required at runtime to execute
    ** the trigger program. If this trigger has been fired before, then pRt 
    ** is already allocated. Otherwise, it must be initialized.  */
    if( (pRt->flags&MEM_Blob)==0 ){
      /* SubProgram.nMem is set to the number of memory cells used by the 
      ** program stored in SubProgram.aOp. As well as these, one memory
      ** cell is required for each cursor used by the program. Set local
      ** variable nMem (and later, VdbeFrame.nChildMem) to this value.
      */
      nMem = pProgram->nMem + pProgram->nCsr;
      assert( nMem>0 );
      if( pProgram->nCsr==0 ) nMem++;
      nByte = ROUND8(sizeof(VdbeFrame))
                + nMem * sizeof(Mem)
                + pProgram->nCsr * sizeof(VdbeCursor*)
                + (pProgram->nOp + 7)/8;
      pFrame = sqlite3DbMallocZero(db, nByte);
      if( !pFrame ){
        goto no_mem;
      }
      sqlite3VdbeMemRelease(pRt);
      pRt->flags = MEM_Blob|MEM_Dyn;
      pRt->z = (char*)pFrame;
      pRt->n = nByte;
      pRt->xDel = sqlite3VdbeFrameMemDel;
  
      pFrame->v = p;
      pFrame->nChildMem = nMem;
      pFrame->nChildCsr = pProgram->nCsr;
      pFrame->pc = (int)(pOp - aOp);
      pFrame->aMem = p->aMem;
      pFrame->nMem = p->nMem;
      pFrame->apCsr = p->apCsr;
      pFrame->nCursor = p->nCursor;
      pFrame->aOp = p->aOp;
      pFrame->nOp = p->nOp;
      pFrame->token = pProgram->token;
  #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
      pFrame->anExec = p->anExec;
  #endif
  #ifdef SQLITE_DEBUG
      pFrame->iFrameMagic = SQLITE_FRAME_MAGIC;
  #endif
  
      pEnd = &VdbeFrameMem(pFrame)[pFrame->nChildMem];
      for(pMem=VdbeFrameMem(pFrame); pMem!=pEnd; pMem++){
        pMem->flags = MEM_Undefined;
        pMem->db = db;
      }
    }else{
      pFrame = (VdbeFrame*)pRt->z;
      assert( pRt->xDel==sqlite3VdbeFrameMemDel );
      assert( pProgram->nMem+pProgram->nCsr==pFrame->nChildMem 
          || (pProgram->nCsr==0 && pProgram->nMem+1==pFrame->nChildMem) );
      assert( pProgram->nCsr==pFrame->nChildCsr );
      assert( (int)(pOp - aOp)==pFrame->pc );
    }
  
    p->nFrame++;
    pFrame->pParent = p->pFrame;
    pFrame->lastRowid = db->lastRowid;
    pFrame->nChange = p->nChange;
    pFrame->nDbChange = p->db->nChange;
    assert( pFrame->pAuxData==0 );
    pFrame->pAuxData = p->pAuxData;
    p->pAuxData = 0;
    p->nChange = 0;
    p->pFrame = pFrame;
    p->aMem = aMem = VdbeFrameMem(pFrame);
    p->nMem = pFrame->nChildMem;
    p->nCursor = (u16)pFrame->nChildCsr;
    p->apCsr = (VdbeCursor **)&aMem[p->nMem];
    pFrame->aOnce = (u8*)&p->apCsr[pProgram->nCsr];
    memset(pFrame->aOnce, 0, (pProgram->nOp + 7)/8);
    p->aOp = aOp = pProgram->aOp;
    p->nOp = pProgram->nOp;
  #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
    p->anExec = 0;
  #endif
  #ifdef SQLITE_DEBUG
    /* Verify that second and subsequent executions of the same trigger do not
    ** try to reuse register values from the first use. */
    {
      int i;
      for(i=0; i<p->nMem; i++){
        aMem[i].pScopyFrom = 0;  /* Prevent false-positive AboutToChange() errs */
        MemSetTypeFlag(&aMem[i], MEM_Undefined); /* Fault if this reg is reused */
      }
    }
  #endif
    pOp = &aOp[-1];
    goto check_for_interrupt;
  }
  
  /* Opcode: Param P1 P2 * * *
  **
  ** This opcode is only ever present in sub-programs called via the 
  ** OP_Program instruction. Copy a value currently stored in a memory 
  ** cell of the calling (parent) frame to cell P2 in the current frames 
  ** address space. This is used by trigger programs to access the new.* 
  ** and old.* values.
  **
  ** The address of the cell in the parent frame is determined by adding
  ** the value of the P1 argument to the value of the P1 argument to the
  ** calling OP_Program instruction.
  */
  case OP_Param: {           /* out2 */
    VdbeFrame *pFrame;
    Mem *pIn;
    pOut = out2Prerelease(p, pOp);
    pFrame = p->pFrame;
    pIn = &pFrame->aMem[pOp->p1 + pFrame->aOp[pFrame->pc].p1];   
    sqlite3VdbeMemShallowCopy(pOut, pIn, MEM_Ephem);
    break;
  }
  
  #endif /* #ifndef SQLITE_OMIT_TRIGGER */
  
  #ifndef SQLITE_OMIT_FOREIGN_KEY
  /* Opcode: FkCounter P1 P2 * * *
  ** Synopsis: fkctr[P1]+=P2
  **
  ** Increment a "constraint counter" by P2 (P2 may be negative or positive).
  ** If P1 is non-zero, the database constraint counter is incremented 
  ** (deferred foreign key constraints). Otherwise, if P1 is zero, the 
  ** statement counter is incremented (immediate foreign key constraints).
  */
  case OP_FkCounter: {
    if( db->flags & SQLITE_DeferFKs ){
      db->nDeferredImmCons += pOp->p2;
    }else if( pOp->p1 ){
      db->nDeferredCons += pOp->p2;
    }else{
      p->nFkConstraint += pOp->p2;
    }
    break;
  }
  
  /* Opcode: FkIfZero P1 P2 * * *
  ** Synopsis: if fkctr[P1]==0 goto P2
  **
  ** This opcode tests if a foreign key constraint-counter is currently zero.
  ** If so, jump to instruction P2. Otherwise, fall through to the next 
  ** instruction.
  **
  ** If P1 is non-zero, then the jump is taken if the database constraint-counter
  ** is zero (the one that counts deferred constraint violations). If P1 is
  ** zero, the jump is taken if the statement constraint-counter is zero
  ** (immediate foreign key constraint violations).
  */
  case OP_FkIfZero: {         /* jump */
    if( pOp->p1 ){
      VdbeBranchTaken(db->nDeferredCons==0 && db->nDeferredImmCons==0, 2);
      if( db->nDeferredCons==0 && db->nDeferredImmCons==0 ) goto jump_to_p2;
    }else{
      VdbeBranchTaken(p->nFkConstraint==0 && db->nDeferredImmCons==0, 2);
      if( p->nFkConstraint==0 && db->nDeferredImmCons==0 ) goto jump_to_p2;
    }
    break;
  }
  #endif /* #ifndef SQLITE_OMIT_FOREIGN_KEY */
  
  #ifndef SQLITE_OMIT_AUTOINCREMENT
  /* Opcode: MemMax P1 P2 * * *
  ** Synopsis: r[P1]=max(r[P1],r[P2])
  **
  ** P1 is a register in the root frame of this VM (the root frame is
  ** different from the current frame if this instruction is being executed
  ** within a sub-program). Set the value of register P1 to the maximum of 
  ** its current value and the value in register P2.
  **
  ** This instruction throws an error if the memory cell is not initially
  ** an integer.
  */
  case OP_MemMax: {        /* in2 */
    VdbeFrame *pFrame;
    if( p->pFrame ){
      for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
      pIn1 = &pFrame->aMem[pOp->p1];
    }else{
      pIn1 = &aMem[pOp->p1];
    }
    assert( memIsValid(pIn1) );
    sqlite3VdbeMemIntegerify(pIn1);
    pIn2 = &aMem[pOp->p2];
    sqlite3VdbeMemIntegerify(pIn2);
    if( pIn1->u.i<pIn2->u.i){
      pIn1->u.i = pIn2->u.i;
    }
    break;
  }
  #endif /* SQLITE_OMIT_AUTOINCREMENT */
  
  /* Opcode: IfPos P1 P2 P3 * *
  ** Synopsis: if r[P1]>0 then r[P1]-=P3, goto P2
  **
  ** Register P1 must contain an integer.
  ** If the value of register P1 is 1 or greater, subtract P3 from the
  ** value in P1 and jump to P2.
  **
  ** If the initial value of register P1 is less than 1, then the
  ** value is unchanged and control passes through to the next instruction.
  */
  case OP_IfPos: {        /* jump, in1 */
    pIn1 = &aMem[pOp->p1];
    assert( pIn1->flags&MEM_Int );
    VdbeBranchTaken( pIn1->u.i>0, 2);
    if( pIn1->u.i>0 ){
      pIn1->u.i -= pOp->p3;
      goto jump_to_p2;
    }
    break;
  }
  
  /* Opcode: OffsetLimit P1 P2 P3 * *
  ** Synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)
  **
  ** This opcode performs a commonly used computation associated with
  ** LIMIT and OFFSET process.  r[P1] holds the limit counter.  r[P3]
  ** holds the offset counter.  The opcode computes the combined value
  ** of the LIMIT and OFFSET and stores that value in r[P2].  The r[P2]
  ** value computed is the total number of rows that will need to be
  ** visited in order to complete the query.
  **
  ** If r[P3] is zero or negative, that means there is no OFFSET
  ** and r[P2] is set to be the value of the LIMIT, r[P1].
  **
  ** if r[P1] is zero or negative, that means there is no LIMIT
  ** and r[P2] is set to -1. 
  **
  ** Otherwise, r[P2] is set to the sum of r[P1] and r[P3].
  */
  case OP_OffsetLimit: {    /* in1, out2, in3 */
    i64 x;
    pIn1 = &aMem[pOp->p1];
    pIn3 = &aMem[pOp->p3];
    pOut = out2Prerelease(p, pOp);
    assert( pIn1->flags & MEM_Int );
    assert( pIn3->flags & MEM_Int );
    x = pIn1->u.i;
    if( x<=0 || sqlite3AddInt64(&x, pIn3->u.i>0?pIn3->u.i:0) ){
      /* If the LIMIT is less than or equal to zero, loop forever.  This
      ** is documented.  But also, if the LIMIT+OFFSET exceeds 2^63 then
      ** also loop forever.  This is undocumented.  In fact, one could argue
      ** that the loop should terminate.  But assuming 1 billion iterations
      ** per second (far exceeding the capabilities of any current hardware)
      ** it would take nearly 300 years to actually reach the limit.  So
      ** looping forever is a reasonable approximation. */
      pOut->u.i = -1;
    }else{
      pOut->u.i = x;
    }
    break;
  }
  
  /* Opcode: IfNotZero P1 P2 * * *
  ** Synopsis: if r[P1]!=0 then r[P1]--, goto P2
  **
  ** Register P1 must contain an integer.  If the content of register P1 is
  ** initially greater than zero, then decrement the value in register P1.
  ** If it is non-zero (negative or positive) and then also jump to P2.  
  ** If register P1 is initially zero, leave it unchanged and fall through.
  */
  case OP_IfNotZero: {        /* jump, in1 */
    pIn1 = &aMem[pOp->p1];
    assert( pIn1->flags&MEM_Int );
    VdbeBranchTaken(pIn1->u.i<0, 2);
    if( pIn1->u.i ){
       if( pIn1->u.i>0 ) pIn1->u.i--;
       goto jump_to_p2;
    }
    break;
  }
  
  /* Opcode: DecrJumpZero P1 P2 * * *
  ** Synopsis: if (--r[P1])==0 goto P2
  **
  ** Register P1 must hold an integer.  Decrement the value in P1
  ** and jump to P2 if the new value is exactly zero.
  */
  case OP_DecrJumpZero: {      /* jump, in1 */
    pIn1 = &aMem[pOp->p1];
    assert( pIn1->flags&MEM_Int );
    if( pIn1->u.i>SMALLEST_INT64 ) pIn1->u.i--;
    VdbeBranchTaken(pIn1->u.i==0, 2);
    if( pIn1->u.i==0 ) goto jump_to_p2;
    break;
  }
  
  
  /* Opcode: AggStep * P2 P3 P4 P5
  ** Synopsis: accum=r[P3] step(r[P2@P5])
  **
  ** Execute the xStep function for an aggregate.
  ** The function has P5 arguments.  P4 is a pointer to the 
  ** FuncDef structure that specifies the function.  Register P3 is the
  ** accumulator.
  **
  ** The P5 arguments are taken from register P2 and its
  ** successors.
  */
  /* Opcode: AggInverse * P2 P3 P4 P5
  ** Synopsis: accum=r[P3] inverse(r[P2@P5])
  **
  ** Execute the xInverse function for an aggregate.
  ** The function has P5 arguments.  P4 is a pointer to the 
  ** FuncDef structure that specifies the function.  Register P3 is the
  ** accumulator.
  **
  ** The P5 arguments are taken from register P2 and its
  ** successors.
  */
  /* Opcode: AggStep1 P1 P2 P3 P4 P5
  ** Synopsis: accum=r[P3] step(r[P2@P5])
  **
  ** Execute the xStep (if P1==0) or xInverse (if P1!=0) function for an
  ** aggregate.  The function has P5 arguments.  P4 is a pointer to the 
  ** FuncDef structure that specifies the function.  Register P3 is the
  ** accumulator.
  **
  ** The P5 arguments are taken from register P2 and its
  ** successors.
  **
  ** This opcode is initially coded as OP_AggStep0.  On first evaluation,
  ** the FuncDef stored in P4 is converted into an sqlite3_context and
  ** the opcode is changed.  In this way, the initialization of the
  ** sqlite3_context only happens once, instead of on each call to the
  ** step function.
  */
  case OP_AggInverse:
  case OP_AggStep: {
    int n;
    sqlite3_context *pCtx;
  
    assert( pOp->p4type==P4_FUNCDEF );
    n = pOp->p5;
    assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
    assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) );
    assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
    pCtx = sqlite3DbMallocRawNN(db, n*sizeof(sqlite3_value*) +
                 (sizeof(pCtx[0]) + sizeof(Mem) - sizeof(sqlite3_value*)));
    if( pCtx==0 ) goto no_mem;
    pCtx->pMem = 0;
    pCtx->pOut = (Mem*)&(pCtx->argv[n]);
    sqlite3VdbeMemInit(pCtx->pOut, db, MEM_Null);
    pCtx->pFunc = pOp->p4.pFunc;
    pCtx->iOp = (int)(pOp - aOp);
    pCtx->pVdbe = p;
    pCtx->skipFlag = 0;
    pCtx->isError = 0;
    pCtx->argc = n;
    pOp->p4type = P4_FUNCCTX;
    pOp->p4.pCtx = pCtx;
  
    /* OP_AggInverse must have P1==1 and OP_AggStep must have P1==0 */
    assert( pOp->p1==(pOp->opcode==OP_AggInverse) );
  
    pOp->opcode = OP_AggStep1;
    /* Fall through into OP_AggStep */
  }
  case OP_AggStep1: {
    int i;
    sqlite3_context *pCtx;
    Mem *pMem;
  
    assert( pOp->p4type==P4_FUNCCTX );
    pCtx = pOp->p4.pCtx;
    pMem = &aMem[pOp->p3];
  
  #ifdef SQLITE_DEBUG
    if( pOp->p1 ){
      /* This is an OP_AggInverse call.  Verify that xStep has always
      ** been called at least once prior to any xInverse call. */
      assert( pMem->uTemp==0x1122e0e3 );
    }else{
      /* This is an OP_AggStep call.  Mark it as such. */
      pMem->uTemp = 0x1122e0e3;
    }
  #endif
  
    /* If this function is inside of a trigger, the register array in aMem[]
    ** might change from one evaluation to the next.  The next block of code
    ** checks to see if the register array has changed, and if so it
    ** reinitializes the relavant parts of the sqlite3_context object */
    if( pCtx->pMem != pMem ){
      pCtx->pMem = pMem;
      for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
    }
  
  #ifdef SQLITE_DEBUG
    for(i=0; i<pCtx->argc; i++){
      assert( memIsValid(pCtx->argv[i]) );
      REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
    }
  #endif
  
    pMem->n++;
    assert( pCtx->pOut->flags==MEM_Null );
    assert( pCtx->isError==0 );
    assert( pCtx->skipFlag==0 );
  #ifndef SQLITE_OMIT_WINDOWFUNC
    if( pOp->p1 ){
      (pCtx->pFunc->xInverse)(pCtx,pCtx->argc,pCtx->argv);
    }else
  #endif
    (pCtx->pFunc->xSFunc)(pCtx,pCtx->argc,pCtx->argv); /* IMP: R-24505-23230 */
  
    if( pCtx->isError ){
      if( pCtx->isError>0 ){
        sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut));
        rc = pCtx->isError;
      }
      if( pCtx->skipFlag ){
        assert( pOp[-1].opcode==OP_CollSeq );
        i = pOp[-1].p1;
        if( i ) sqlite3VdbeMemSetInt64(&aMem[i], 1);
        pCtx->skipFlag = 0;
      }
      sqlite3VdbeMemRelease(pCtx->pOut);
      pCtx->pOut->flags = MEM_Null;
      pCtx->isError = 0;
      if( rc ) goto abort_due_to_error;
    }
    assert( pCtx->pOut->flags==MEM_Null );
    assert( pCtx->skipFlag==0 );
    break;
  }
  
  /* Opcode: AggFinal P1 P2 * P4 *
  ** Synopsis: accum=r[P1] N=P2
  **
  ** P1 is the memory location that is the accumulator for an aggregate
  ** or window function.  Execute the finalizer function 
  ** for an aggregate and store the result in P1.
  **
  ** P2 is the number of arguments that the step function takes and
  ** P4 is a pointer to the FuncDef for this function.  The P2
  ** argument is not used by this opcode.  It is only there to disambiguate
  ** functions that can take varying numbers of arguments.  The
  ** P4 argument is only needed for the case where
  ** the step function was not previously called.
  */
  /* Opcode: AggValue * P2 P3 P4 *
  ** Synopsis: r[P3]=value N=P2
  **
  ** Invoke the xValue() function and store the result in register P3.
  **
  ** P2 is the number of arguments that the step function takes and
  ** P4 is a pointer to the FuncDef for this function.  The P2
  ** argument is not used by this opcode.  It is only there to disambiguate
  ** functions that can take varying numbers of arguments.  The
  ** P4 argument is only needed for the case where
  ** the step function was not previously called.
  */
  case OP_AggValue:
  case OP_AggFinal: {
    Mem *pMem;
    assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
    assert( pOp->p3==0 || pOp->opcode==OP_AggValue );
    pMem = &aMem[pOp->p1];
    assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
  #ifndef SQLITE_OMIT_WINDOWFUNC
    if( pOp->p3 ){
      memAboutToChange(p, &aMem[pOp->p3]);
      rc = sqlite3VdbeMemAggValue(pMem, &aMem[pOp->p3], pOp->p4.pFunc);
      pMem = &aMem[pOp->p3];
    }else
  #endif
    {
      rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc);
    }
    
    if( rc ){
      sqlite3VdbeError(p, "%s", sqlite3_value_text(pMem));
      goto abort_due_to_error;
    }
    sqlite3VdbeChangeEncoding(pMem, encoding);
    UPDATE_MAX_BLOBSIZE(pMem);
    if( sqlite3VdbeMemTooBig(pMem) ){
      goto too_big;
    }
    break;
  }
  
  #ifndef SQLITE_OMIT_WAL
  /* Opcode: Checkpoint P1 P2 P3 * *
  **
  ** Checkpoint database P1. This is a no-op if P1 is not currently in
  ** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL,
  ** RESTART, or TRUNCATE.  Write 1 or 0 into mem[P3] if the checkpoint returns
  ** SQLITE_BUSY or not, respectively.  Write the number of pages in the
  ** WAL after the checkpoint into mem[P3+1] and the number of pages
  ** in the WAL that have been checkpointed after the checkpoint
  ** completes into mem[P3+2].  However on an error, mem[P3+1] and
  ** mem[P3+2] are initialized to -1.
  */
  case OP_Checkpoint: {
    int i;                          /* Loop counter */
    int aRes[3];                    /* Results */
    Mem *pMem;                      /* Write results here */
  
    assert( p->readOnly==0 );
    aRes[0] = 0;
    aRes[1] = aRes[2] = -1;
    assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
         || pOp->p2==SQLITE_CHECKPOINT_FULL
         || pOp->p2==SQLITE_CHECKPOINT_RESTART
         || pOp->p2==SQLITE_CHECKPOINT_TRUNCATE
    );
    rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &aRes[1], &aRes[2]);
    if( rc ){
      if( rc!=SQLITE_BUSY ) goto abort_due_to_error;
      rc = SQLITE_OK;
      aRes[0] = 1;
    }
    for(i=0, pMem = &aMem[pOp->p3]; i<3; i++, pMem++){
      sqlite3VdbeMemSetInt64(pMem, (i64)aRes[i]);
    }    
    break;
  };  
  #endif
  
  #ifndef SQLITE_OMIT_PRAGMA
  /* Opcode: JournalMode P1 P2 P3 * *
  **
  ** Change the journal mode of database P1 to P3. P3 must be one of the
  ** PAGER_JOURNALMODE_XXX values. If changing between the various rollback
  ** modes (delete, truncate, persist, off and memory), this is a simple
  ** operation. No IO is required.
  **
  ** If changing into or out of WAL mode the procedure is more complicated.
  **
  ** Write a string containing the final journal-mode to register P2.
  */
  case OP_JournalMode: {    /* out2 */
    Btree *pBt;                     /* Btree to change journal mode of */
    Pager *pPager;                  /* Pager associated with pBt */
    int eNew;                       /* New journal mode */
    int eOld;                       /* The old journal mode */
  #ifndef SQLITE_OMIT_WAL
    const char *zFilename;          /* Name of database file for pPager */
  #endif
  
    pOut = out2Prerelease(p, pOp);
    eNew = pOp->p3;
    assert( eNew==PAGER_JOURNALMODE_DELETE 
         || eNew==PAGER_JOURNALMODE_TRUNCATE 
         || eNew==PAGER_JOURNALMODE_PERSIST 
         || eNew==PAGER_JOURNALMODE_OFF
         || eNew==PAGER_JOURNALMODE_MEMORY
         || eNew==PAGER_JOURNALMODE_WAL
         || eNew==PAGER_JOURNALMODE_QUERY
    );
    assert( pOp->p1>=0 && pOp->p1<db->nDb );
    assert( p->readOnly==0 );
  
    pBt = db->aDb[pOp->p1].pBt;
    pPager = sqlite3BtreePager(pBt);
    eOld = sqlite3PagerGetJournalMode(pPager);
    if( eNew==PAGER_JOURNALMODE_QUERY ) eNew = eOld;
    if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld;
  
  #ifndef SQLITE_OMIT_WAL
    zFilename = sqlite3PagerFilename(pPager, 1);
  
    /* Do not allow a transition to journal_mode=WAL for a database
    ** in temporary storage or if the VFS does not support shared memory 
    */
    if( eNew==PAGER_JOURNALMODE_WAL
     && (sqlite3Strlen30(zFilename)==0           /* Temp file */
         || !sqlite3PagerWalSupported(pPager))   /* No shared-memory support */
    ){
      eNew = eOld;
    }
  
    if( (eNew!=eOld)
     && (eOld==PAGER_JOURNALMODE_WAL || eNew==PAGER_JOURNALMODE_WAL)
    ){
      if( !db->autoCommit || db->nVdbeRead>1 ){
        rc = SQLITE_ERROR;
        sqlite3VdbeError(p,
            "cannot change %s wal mode from within a transaction",
            (eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of")
        );
        goto abort_due_to_error;
      }else{
   
        if( eOld==PAGER_JOURNALMODE_WAL ){
          /* If leaving WAL mode, close the log file. If successful, the call
          ** to PagerCloseWal() checkpoints and deletes the write-ahead-log 
          ** file. An EXCLUSIVE lock may still be held on the database file 
          ** after a successful return. 
          */
          rc = sqlite3PagerCloseWal(pPager, db);
          if( rc==SQLITE_OK ){
            sqlite3PagerSetJournalMode(pPager, eNew);
          }
        }else if( eOld==PAGER_JOURNALMODE_MEMORY ){
          /* Cannot transition directly from MEMORY to WAL.  Use mode OFF
          ** as an intermediate */
          sqlite3PagerSetJournalMode(pPager, PAGER_JOURNALMODE_OFF);
        }
    
        /* Open a transaction on the database file. Regardless of the journal
        ** mode, this transaction always uses a rollback journal.
        */
        assert( sqlite3BtreeIsInTrans(pBt)==0 );
        if( rc==SQLITE_OK ){
          rc = sqlite3BtreeSetVersion(pBt, (eNew==PAGER_JOURNALMODE_WAL ? 2 : 1));
        }
      }
    }
  #endif /* ifndef SQLITE_OMIT_WAL */
  
    if( rc ) eNew = eOld;
    eNew = sqlite3PagerSetJournalMode(pPager, eNew);
  
    pOut->flags = MEM_Str|MEM_Static|MEM_Term;
    pOut->z = (char *)sqlite3JournalModename(eNew);
    pOut->n = sqlite3Strlen30(pOut->z);
    pOut->enc = SQLITE_UTF8;
    sqlite3VdbeChangeEncoding(pOut, encoding);
    if( rc ) goto abort_due_to_error;
    break;
  };
  #endif /* SQLITE_OMIT_PRAGMA */
  
  #if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH)
  /* Opcode: Vacuum P1 P2 * * *
  **
  ** Vacuum the entire database P1.  P1 is 0 for "main", and 2 or more
  ** for an attached database.  The "temp" database may not be vacuumed.
  **
  ** If P2 is not zero, then it is a register holding a string which is
  ** the file into which the result of vacuum should be written.  When
  ** P2 is zero, the vacuum overwrites the original database.
  */
  case OP_Vacuum: {
    assert( p->readOnly==0 );
    rc = sqlite3RunVacuum(&p->zErrMsg, db, pOp->p1,
                          pOp->p2 ? &aMem[pOp->p2] : 0);
    if( rc ) goto abort_due_to_error;
    break;
  }
  #endif
  
  #if !defined(SQLITE_OMIT_AUTOVACUUM)
  /* Opcode: IncrVacuum P1 P2 * * *
  **
  ** Perform a single step of the incremental vacuum procedure on
  ** the P1 database. If the vacuum has finished, jump to instruction
  ** P2. Otherwise, fall through to the next instruction.
  */
  case OP_IncrVacuum: {        /* jump */
    Btree *pBt;
  
    assert( pOp->p1>=0 && pOp->p1<db->nDb );
    assert( DbMaskTest(p->btreeMask, pOp->p1) );
    assert( p->readOnly==0 );
    pBt = db->aDb[pOp->p1].pBt;
    rc = sqlite3BtreeIncrVacuum(pBt);
    VdbeBranchTaken(rc==SQLITE_DONE,2);
    if( rc ){
      if( rc!=SQLITE_DONE ) goto abort_due_to_error;
      rc = SQLITE_OK;
      goto jump_to_p2;
    }
    break;
  }
  #endif
  
  /* Opcode: Expire P1 P2 * * *
  **
  ** Cause precompiled statements to expire.  When an expired statement
  ** is executed using sqlite3_step() it will either automatically
  ** reprepare itself (if it was originally created using sqlite3_prepare_v2())
  ** or it will fail with SQLITE_SCHEMA.
  ** 
  ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
  ** then only the currently executing statement is expired.
  **
  ** If P2 is 0, then SQL statements are expired immediately.  If P2 is 1,
  ** then running SQL statements are allowed to continue to run to completion.
  ** The P2==1 case occurs when a CREATE INDEX or similar schema change happens
  ** that might help the statement run faster but which does not affect the
  ** correctness of operation.
  */
  case OP_Expire: {
    assert( pOp->p2==0 || pOp->p2==1 );
    if( !pOp->p1 ){
      sqlite3ExpirePreparedStatements(db, pOp->p2);
    }else{
      p->expired = pOp->p2+1;
    }
    break;
  }
  
  /* Opcode: CursorLock P1 * * * *
  **
  ** Lock the btree to which cursor P1 is pointing so that the btree cannot be
  ** written by an other cursor.
  */
  case OP_CursorLock: {
    VdbeCursor *pC;
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    assert( pC->eCurType==CURTYPE_BTREE );
    sqlite3BtreeCursorPin(pC->uc.pCursor);
    break;
  }
  
  /* Opcode: CursorUnlock P1 * * * *
  **
  ** Unlock the btree to which cursor P1 is pointing so that it can be
  ** written by other cursors.
  */
  case OP_CursorUnlock: {
    VdbeCursor *pC;
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    pC = p->apCsr[pOp->p1];
    assert( pC!=0 );
    assert( pC->eCurType==CURTYPE_BTREE );
    sqlite3BtreeCursorUnpin(pC->uc.pCursor);
    break;
  }
  
  #ifndef SQLITE_OMIT_SHARED_CACHE
  /* Opcode: TableLock P1 P2 P3 P4 *
  ** Synopsis: iDb=P1 root=P2 write=P3
  **
  ** Obtain a lock on a particular table. This instruction is only used when
  ** the shared-cache feature is enabled. 
  **
  ** P1 is the index of the database in sqlite3.aDb[] of the database
  ** on which the lock is acquired.  A readlock is obtained if P3==0 or
  ** a write lock if P3==1.
  **
  ** P2 contains the root-page of the table to lock.
  **
  ** P4 contains a pointer to the name of the table being locked. This is only
  ** used to generate an error message if the lock cannot be obtained.
  */
  case OP_TableLock: {
    u8 isWriteLock = (u8)pOp->p3;
    if( isWriteLock || 0==(db->flags&SQLITE_ReadUncommit) ){
      int p1 = pOp->p1; 
      assert( p1>=0 && p1<db->nDb );
      assert( DbMaskTest(p->btreeMask, p1) );
      assert( isWriteLock==0 || isWriteLock==1 );
      rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
      if( rc ){
        if( (rc&0xFF)==SQLITE_LOCKED ){
          const char *z = pOp->p4.z;
          sqlite3VdbeError(p, "database table is locked: %s", z);
        }
        goto abort_due_to_error;
      }
    }
    break;
  }
  #endif /* SQLITE_OMIT_SHARED_CACHE */
  
  #ifndef SQLITE_OMIT_VIRTUALTABLE
  /* Opcode: VBegin * * * P4 *
  **
  ** P4 may be a pointer to an sqlite3_vtab structure. If so, call the 
  ** xBegin method for that table.
  **
  ** Also, whether or not P4 is set, check that this is not being called from
  ** within a callback to a virtual table xSync() method. If it is, the error
  ** code will be set to SQLITE_LOCKED.
  */
  case OP_VBegin: {
    VTable *pVTab;
    pVTab = pOp->p4.pVtab;
    rc = sqlite3VtabBegin(db, pVTab);
    if( pVTab ) sqlite3VtabImportErrmsg(p, pVTab->pVtab);
    if( rc ) goto abort_due_to_error;
    break;
  }
  #endif /* SQLITE_OMIT_VIRTUALTABLE */
  
  #ifndef SQLITE_OMIT_VIRTUALTABLE
  /* Opcode: VCreate P1 P2 * * *
  **
  ** P2 is a register that holds the name of a virtual table in database 
  ** P1. Call the xCreate method for that table.
  */
  case OP_VCreate: {
    Mem sMem;          /* For storing the record being decoded */
    const char *zTab;  /* Name of the virtual table */
  
    memset(&sMem, 0, sizeof(sMem));
    sMem.db = db;
    /* Because P2 is always a static string, it is impossible for the
    ** sqlite3VdbeMemCopy() to fail */
    assert( (aMem[pOp->p2].flags & MEM_Str)!=0 );
    assert( (aMem[pOp->p2].flags & MEM_Static)!=0 );
    rc = sqlite3VdbeMemCopy(&sMem, &aMem[pOp->p2]);
    assert( rc==SQLITE_OK );
    zTab = (const char*)sqlite3_value_text(&sMem);
    assert( zTab || db->mallocFailed );
    if( zTab ){
      rc = sqlite3VtabCallCreate(db, pOp->p1, zTab, &p->zErrMsg);
    }
    sqlite3VdbeMemRelease(&sMem);
    if( rc ) goto abort_due_to_error;
    break;
  }
  #endif /* SQLITE_OMIT_VIRTUALTABLE */
  
  #ifndef SQLITE_OMIT_VIRTUALTABLE
  /* Opcode: VDestroy P1 * * P4 *
  **
  ** P4 is the name of a virtual table in database P1.  Call the xDestroy method
  ** of that table.
  */
  case OP_VDestroy: {
    db->nVDestroy++;
    rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z);
    db->nVDestroy--;
    assert( p->errorAction==OE_Abort && p->usesStmtJournal );
    if( rc ) goto abort_due_to_error;
    break;
  }
  #endif /* SQLITE_OMIT_VIRTUALTABLE */
  
  #ifndef SQLITE_OMIT_VIRTUALTABLE
  /* Opcode: VOpen P1 * * P4 *
  **
  ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
  ** P1 is a cursor number.  This opcode opens a cursor to the virtual
  ** table and stores that cursor in P1.
  */
  case OP_VOpen: {
    VdbeCursor *pCur;
    sqlite3_vtab_cursor *pVCur;
    sqlite3_vtab *pVtab;
    const sqlite3_module *pModule;
  
    assert( p->bIsReader );
    pCur = 0;
    pVCur = 0;
    pVtab = pOp->p4.pVtab->pVtab;
    if( pVtab==0 || NEVER(pVtab->pModule==0) ){
      rc = SQLITE_LOCKED;
      goto abort_due_to_error;
    }
    pModule = pVtab->pModule;
    rc = pModule->xOpen(pVtab, &pVCur);
    sqlite3VtabImportErrmsg(p, pVtab);
    if( rc ) goto abort_due_to_error;
  
    /* Initialize sqlite3_vtab_cursor base class */
    pVCur->pVtab = pVtab;
  
    /* Initialize vdbe cursor object */
    pCur = allocateCursor(p, pOp->p1, 0, -1, CURTYPE_VTAB);
    if( pCur ){
      pCur->uc.pVCur = pVCur;
      pVtab->nRef++;
    }else{
      assert( db->mallocFailed );
      pModule->xClose(pVCur);
      goto no_mem;
    }
    break;
  }
  #endif /* SQLITE_OMIT_VIRTUALTABLE */
  
  #ifndef SQLITE_OMIT_VIRTUALTABLE
  /* Opcode: VFilter P1 P2 P3 P4 *
  ** Synopsis: iplan=r[P3] zplan='P4'
  **
  ** P1 is a cursor opened using VOpen.  P2 is an address to jump to if
  ** the filtered result set is empty.
  **
  ** P4 is either NULL or a string that was generated by the xBestIndex
  ** method of the module.  The interpretation of the P4 string is left
  ** to the module implementation.
  **
  ** This opcode invokes the xFilter method on the virtual table specified
  ** by P1.  The integer query plan parameter to xFilter is stored in register
  ** P3. Register P3+1 stores the argc parameter to be passed to the
  ** xFilter method. Registers P3+2..P3+1+argc are the argc
  ** additional parameters which are passed to
  ** xFilter as argv. Register P3+2 becomes argv[0] when passed to xFilter.
  **
  ** A jump is made to P2 if the result set after filtering would be empty.
  */
  case OP_VFilter: {   /* jump */
    int nArg;
    int iQuery;
    const sqlite3_module *pModule;
    Mem *pQuery;
    Mem *pArgc;
    sqlite3_vtab_cursor *pVCur;
    sqlite3_vtab *pVtab;
    VdbeCursor *pCur;
    int res;
    int i;
    Mem **apArg;
  
    pQuery = &aMem[pOp->p3];
    pArgc = &pQuery[1];
    pCur = p->apCsr[pOp->p1];
    assert( memIsValid(pQuery) );
    REGISTER_TRACE(pOp->p3, pQuery);
    assert( pCur->eCurType==CURTYPE_VTAB );
    pVCur = pCur->uc.pVCur;
    pVtab = pVCur->pVtab;
    pModule = pVtab->pModule;
  
    /* Grab the index number and argc parameters */
    assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int );
    nArg = (int)pArgc->u.i;
    iQuery = (int)pQuery->u.i;
  
    /* Invoke the xFilter method */
    res = 0;
    apArg = p->apArg;
    for(i = 0; i<nArg; i++){
      apArg[i] = &pArgc[i+1];
    }
    rc = pModule->xFilter(pVCur, iQuery, pOp->p4.z, nArg, apArg);
    sqlite3VtabImportErrmsg(p, pVtab);
    if( rc ) goto abort_due_to_error;
    res = pModule->xEof(pVCur);
    pCur->nullRow = 0;
    VdbeBranchTaken(res!=0,2);
    if( res ) goto jump_to_p2;
    break;
  }
  #endif /* SQLITE_OMIT_VIRTUALTABLE */
  
  #ifndef SQLITE_OMIT_VIRTUALTABLE
  /* Opcode: VColumn P1 P2 P3 * P5
  ** Synopsis: r[P3]=vcolumn(P2)
  **
  ** Store in register P3 the value of the P2-th column of
  ** the current row of the virtual-table of cursor P1.
  **
  ** If the VColumn opcode is being used to fetch the value of
  ** an unchanging column during an UPDATE operation, then the P5
  ** value is OPFLAG_NOCHNG.  This will cause the sqlite3_vtab_nochange()
  ** function to return true inside the xColumn method of the virtual
  ** table implementation.  The P5 column might also contain other
  ** bits (OPFLAG_LENGTHARG or OPFLAG_TYPEOFARG) but those bits are
  ** unused by OP_VColumn.
  */
  case OP_VColumn: {
    sqlite3_vtab *pVtab;
    const sqlite3_module *pModule;
    Mem *pDest;
    sqlite3_context sContext;
  
    VdbeCursor *pCur = p->apCsr[pOp->p1];
    assert( pCur->eCurType==CURTYPE_VTAB );
    assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
    pDest = &aMem[pOp->p3];
    memAboutToChange(p, pDest);
    if( pCur->nullRow ){
      sqlite3VdbeMemSetNull(pDest);
      break;
    }
    pVtab = pCur->uc.pVCur->pVtab;
    pModule = pVtab->pModule;
    assert( pModule->xColumn );
    memset(&sContext, 0, sizeof(sContext));
    sContext.pOut = pDest;
    assert( pOp->p5==OPFLAG_NOCHNG || pOp->p5==0 );
    if( pOp->p5 & OPFLAG_NOCHNG ){
      sqlite3VdbeMemSetNull(pDest);
      pDest->flags = MEM_Null|MEM_Zero;
      pDest->u.nZero = 0;
    }else{
      MemSetTypeFlag(pDest, MEM_Null);
    }
    rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2);
    sqlite3VtabImportErrmsg(p, pVtab);
    if( sContext.isError>0 ){
      sqlite3VdbeError(p, "%s", sqlite3_value_text(pDest));
      rc = sContext.isError;
    }
    sqlite3VdbeChangeEncoding(pDest, encoding);
    REGISTER_TRACE(pOp->p3, pDest);
    UPDATE_MAX_BLOBSIZE(pDest);
  
    if( sqlite3VdbeMemTooBig(pDest) ){
      goto too_big;
    }
    if( rc ) goto abort_due_to_error;
    break;
  }
  #endif /* SQLITE_OMIT_VIRTUALTABLE */
  
  #ifndef SQLITE_OMIT_VIRTUALTABLE
  /* Opcode: VNext P1 P2 * * *
  **
  ** Advance virtual table P1 to the next row in its result set and
  ** jump to instruction P2.  Or, if the virtual table has reached
  ** the end of its result set, then fall through to the next instruction.
  */
  case OP_VNext: {   /* jump */
    sqlite3_vtab *pVtab;
    const sqlite3_module *pModule;
    int res;
    VdbeCursor *pCur;
  
    res = 0;
    pCur = p->apCsr[pOp->p1];
    assert( pCur->eCurType==CURTYPE_VTAB );
    if( pCur->nullRow ){
      break;
    }
    pVtab = pCur->uc.pVCur->pVtab;
    pModule = pVtab->pModule;
    assert( pModule->xNext );
  
    /* Invoke the xNext() method of the module. There is no way for the
    ** underlying implementation to return an error if one occurs during
    ** xNext(). Instead, if an error occurs, true is returned (indicating that 
    ** data is available) and the error code returned when xColumn or
    ** some other method is next invoked on the save virtual table cursor.
    */
    rc = pModule->xNext(pCur->uc.pVCur);
    sqlite3VtabImportErrmsg(p, pVtab);
    if( rc ) goto abort_due_to_error;
    res = pModule->xEof(pCur->uc.pVCur);
    VdbeBranchTaken(!res,2);
    if( !res ){
      /* If there is data, jump to P2 */
      goto jump_to_p2_and_check_for_interrupt;
    }
    goto check_for_interrupt;
  }
  #endif /* SQLITE_OMIT_VIRTUALTABLE */
  
  #ifndef SQLITE_OMIT_VIRTUALTABLE
  /* Opcode: VRename P1 * * P4 *
  **
  ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
  ** This opcode invokes the corresponding xRename method. The value
  ** in register P1 is passed as the zName argument to the xRename method.
  */
  case OP_VRename: {
    sqlite3_vtab *pVtab;
    Mem *pName;
    int isLegacy;
    
    isLegacy = (db->flags & SQLITE_LegacyAlter);
    db->flags |= SQLITE_LegacyAlter;
    pVtab = pOp->p4.pVtab->pVtab;
    pName = &aMem[pOp->p1];
    assert( pVtab->pModule->xRename );
    assert( memIsValid(pName) );
    assert( p->readOnly==0 );
    REGISTER_TRACE(pOp->p1, pName);
    assert( pName->flags & MEM_Str );
    testcase( pName->enc==SQLITE_UTF8 );
    testcase( pName->enc==SQLITE_UTF16BE );
    testcase( pName->enc==SQLITE_UTF16LE );
    rc = sqlite3VdbeChangeEncoding(pName, SQLITE_UTF8);
    if( rc ) goto abort_due_to_error;
    rc = pVtab->pModule->xRename(pVtab, pName->z);
    if( isLegacy==0 ) db->flags &= ~(u64)SQLITE_LegacyAlter;
    sqlite3VtabImportErrmsg(p, pVtab);
    p->expired = 0;
    if( rc ) goto abort_due_to_error;
    break;
  }
  #endif
  
  #ifndef SQLITE_OMIT_VIRTUALTABLE
  /* Opcode: VUpdate P1 P2 P3 P4 P5
  ** Synopsis: data=r[P3@P2]
  **
  ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
  ** This opcode invokes the corresponding xUpdate method. P2 values
  ** are contiguous memory cells starting at P3 to pass to the xUpdate 
  ** invocation. The value in register (P3+P2-1) corresponds to the 
  ** p2th element of the argv array passed to xUpdate.
  **
  ** The xUpdate method will do a DELETE or an INSERT or both.
  ** The argv[0] element (which corresponds to memory cell P3)
  ** is the rowid of a row to delete.  If argv[0] is NULL then no 
  ** deletion occurs.  The argv[1] element is the rowid of the new 
  ** row.  This can be NULL to have the virtual table select the new 
  ** rowid for itself.  The subsequent elements in the array are 
  ** the values of columns in the new row.
  **
  ** If P2==1 then no insert is performed.  argv[0] is the rowid of
  ** a row to delete.
  **
  ** P1 is a boolean flag. If it is set to true and the xUpdate call
  ** is successful, then the value returned by sqlite3_last_insert_rowid() 
  ** is set to the value of the rowid for the row just inserted.
  **
  ** P5 is the error actions (OE_Replace, OE_Fail, OE_Ignore, etc) to
  ** apply in the case of a constraint failure on an insert or update.
  */
  case OP_VUpdate: {
    sqlite3_vtab *pVtab;
    const sqlite3_module *pModule;
    int nArg;
    int i;
    sqlite_int64 rowid;
    Mem **apArg;
    Mem *pX;
  
    assert( pOp->p2==1        || pOp->p5==OE_Fail   || pOp->p5==OE_Rollback 
         || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace
    );
    assert( p->readOnly==0 );
    if( db->mallocFailed ) goto no_mem;
    sqlite3VdbeIncrWriteCounter(p, 0);
    pVtab = pOp->p4.pVtab->pVtab;
    if( pVtab==0 || NEVER(pVtab->pModule==0) ){
      rc = SQLITE_LOCKED;
      goto abort_due_to_error;
    }
    pModule = pVtab->pModule;
    nArg = pOp->p2;
    assert( pOp->p4type==P4_VTAB );
    if( ALWAYS(pModule->xUpdate) ){
      u8 vtabOnConflict = db->vtabOnConflict;
      apArg = p->apArg;
      pX = &aMem[pOp->p3];
      for(i=0; i<nArg; i++){
        assert( memIsValid(pX) );
        memAboutToChange(p, pX);
        apArg[i] = pX;
        pX++;
      }
      db->vtabOnConflict = pOp->p5;
      rc = pModule->xUpdate(pVtab, nArg, apArg, &rowid);
      db->vtabOnConflict = vtabOnConflict;
      sqlite3VtabImportErrmsg(p, pVtab);
      if( rc==SQLITE_OK && pOp->p1 ){
        assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) );
        db->lastRowid = rowid;
      }
      if( (rc&0xff)==SQLITE_CONSTRAINT && pOp->p4.pVtab->bConstraint ){
        if( pOp->p5==OE_Ignore ){
          rc = SQLITE_OK;
        }else{
          p->errorAction = ((pOp->p5==OE_Replace) ? OE_Abort : pOp->p5);
        }
      }else{
        p->nChange++;
      }
      if( rc ) goto abort_due_to_error;
    }
    break;
  }
  #endif /* SQLITE_OMIT_VIRTUALTABLE */
  
  #ifndef  SQLITE_OMIT_PAGER_PRAGMAS
  /* Opcode: Pagecount P1 P2 * * *
  **
  ** Write the current number of pages in database P1 to memory cell P2.
  */
  case OP_Pagecount: {            /* out2 */
    pOut = out2Prerelease(p, pOp);
    pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt);
    break;
  }
  #endif
  
  
  #ifndef  SQLITE_OMIT_PAGER_PRAGMAS
  /* Opcode: MaxPgcnt P1 P2 P3 * *
  **
  ** Try to set the maximum page count for database P1 to the value in P3.
  ** Do not let the maximum page count fall below the current page count and
  ** do not change the maximum page count value if P3==0.
  **
  ** Store the maximum page count after the change in register P2.
  */
  case OP_MaxPgcnt: {            /* out2 */
    unsigned int newMax;
    Btree *pBt;
  
    pOut = out2Prerelease(p, pOp);
    pBt = db->aDb[pOp->p1].pBt;
    newMax = 0;
    if( pOp->p3 ){
      newMax = sqlite3BtreeLastPage(pBt);
      if( newMax < (unsigned)pOp->p3 ) newMax = (unsigned)pOp->p3;
    }
    pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax);
    break;
  }
  #endif
  
  /* Opcode: Function P1 P2 P3 P4 *
  ** Synopsis: r[P3]=func(r[P2@NP])
  **
  ** Invoke a user function (P4 is a pointer to an sqlite3_context object that
  ** contains a pointer to the function to be run) with arguments taken
  ** from register P2 and successors.  The number of arguments is in
  ** the sqlite3_context object that P4 points to.
  ** The result of the function is stored
  ** in register P3.  Register P3 must not be one of the function inputs.
  **
  ** P1 is a 32-bit bitmask indicating whether or not each argument to the 
  ** function was determined to be constant at compile time. If the first
  ** argument was constant then bit 0 of P1 is set. This is used to determine
  ** whether meta data associated with a user function argument using the
  ** sqlite3_set_auxdata() API may be safely retained until the next
  ** invocation of this opcode.
  **
  ** See also: AggStep, AggFinal, PureFunc
  */
  /* Opcode: PureFunc P1 P2 P3 P4 *
  ** Synopsis: r[P3]=func(r[P2@NP])
  **
  ** Invoke a user function (P4 is a pointer to an sqlite3_context object that
  ** contains a pointer to the function to be run) with arguments taken
  ** from register P2 and successors.  The number of arguments is in
  ** the sqlite3_context object that P4 points to.
  ** The result of the function is stored
  ** in register P3.  Register P3 must not be one of the function inputs.
  **
  ** P1 is a 32-bit bitmask indicating whether or not each argument to the 
  ** function was determined to be constant at compile time. If the first
  ** argument was constant then bit 0 of P1 is set. This is used to determine
  ** whether meta data associated with a user function argument using the
  ** sqlite3_set_auxdata() API may be safely retained until the next
  ** invocation of this opcode.
  **
  ** This opcode works exactly like OP_Function.  The only difference is in
  ** its name.  This opcode is used in places where the function must be
  ** purely non-deterministic.  Some built-in date/time functions can be
  ** either determinitic of non-deterministic, depending on their arguments.
  ** When those function are used in a non-deterministic way, they will check
  ** to see if they were called using OP_PureFunc instead of OP_Function, and
  ** if they were, they throw an error.
  **
  ** See also: AggStep, AggFinal, Function
  */
  case OP_PureFunc:              /* group */
  case OP_Function: {            /* group */
    int i;
    sqlite3_context *pCtx;
  
    assert( pOp->p4type==P4_FUNCCTX );
    pCtx = pOp->p4.pCtx;
  
    /* If this function is inside of a trigger, the register array in aMem[]
    ** might change from one evaluation to the next.  The next block of code
    ** checks to see if the register array has changed, and if so it
    ** reinitializes the relavant parts of the sqlite3_context object */
    pOut = &aMem[pOp->p3];
    if( pCtx->pOut != pOut ){
      pCtx->pVdbe = p;
      pCtx->pOut = pOut;
      for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
    }
    assert( pCtx->pVdbe==p );
  
    memAboutToChange(p, pOut);
  #ifdef SQLITE_DEBUG
    for(i=0; i<pCtx->argc; i++){
      assert( memIsValid(pCtx->argv[i]) );
      REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
    }
  #endif
    MemSetTypeFlag(pOut, MEM_Null);
    assert( pCtx->isError==0 );
    (*pCtx->pFunc->xSFunc)(pCtx, pCtx->argc, pCtx->argv);/* IMP: R-24505-23230 */
  
    /* If the function returned an error, throw an exception */
    if( pCtx->isError ){
      if( pCtx->isError>0 ){
        sqlite3VdbeError(p, "%s", sqlite3_value_text(pOut));
        rc = pCtx->isError;
      }
      sqlite3VdbeDeleteAuxData(db, &p->pAuxData, pCtx->iOp, pOp->p1);
      pCtx->isError = 0;
      if( rc ) goto abort_due_to_error;
    }
  
    /* Copy the result of the function into register P3 */
    if( pOut->flags & (MEM_Str|MEM_Blob) ){
      sqlite3VdbeChangeEncoding(pOut, encoding);
      if( sqlite3VdbeMemTooBig(pOut) ) goto too_big;
    }
  
    REGISTER_TRACE(pOp->p3, pOut);
    UPDATE_MAX_BLOBSIZE(pOut);
    break;
  }
  
  /* Opcode: Trace P1 P2 * P4 *
  **
  ** Write P4 on the statement trace output if statement tracing is
  ** enabled.
  **
  ** Operand P1 must be 0x7fffffff and P2 must positive.
  */
  /* Opcode: Init P1 P2 P3 P4 *
  ** Synopsis: Start at P2
  **
  ** Programs contain a single instance of this opcode as the very first
  ** opcode.
  **
  ** If tracing is enabled (by the sqlite3_trace()) interface, then
  ** the UTF-8 string contained in P4 is emitted on the trace callback.
  ** Or if P4 is blank, use the string returned by sqlite3_sql().
  **
  ** If P2 is not zero, jump to instruction P2.
  **
  ** Increment the value of P1 so that OP_Once opcodes will jump the
  ** first time they are evaluated for this run.
  **
  ** If P3 is not zero, then it is an address to jump to if an SQLITE_CORRUPT
  ** error is encountered.
  */
  case OP_Trace:
  case OP_Init: {          /* jump */
    int i;
  #ifndef SQLITE_OMIT_TRACE
    char *zTrace;
  #endif
  
    /* If the P4 argument is not NULL, then it must be an SQL comment string.
    ** The "--" string is broken up to prevent false-positives with srcck1.c.
    **
    ** This assert() provides evidence for:
    ** EVIDENCE-OF: R-50676-09860 The callback can compute the same text that
    ** would have been returned by the legacy sqlite3_trace() interface by
    ** using the X argument when X begins with "--" and invoking
    ** sqlite3_expanded_sql(P) otherwise.
    */
    assert( pOp->p4.z==0 || strncmp(pOp->p4.z, "-" "- ", 3)==0 );
  
    /* OP_Init is always instruction 0 */
    assert( pOp==p->aOp || pOp->opcode==OP_Trace );
  
  #ifndef SQLITE_OMIT_TRACE
    if( (db->mTrace & (SQLITE_TRACE_STMT|SQLITE_TRACE_LEGACY))!=0
     && !p->doingRerun
     && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
    ){
  #ifndef SQLITE_OMIT_DEPRECATED
      if( db->mTrace & SQLITE_TRACE_LEGACY ){
        void (*x)(void*,const char*) = (void(*)(void*,const char*))db->xTrace;
        char *z = sqlite3VdbeExpandSql(p, zTrace);
        x(db->pTraceArg, z);
        sqlite3_free(z);
      }else
  #endif
      if( db->nVdbeExec>1 ){
        char *z = sqlite3MPrintf(db, "-- %s", zTrace);
        (void)db->xTrace(SQLITE_TRACE_STMT, db->pTraceArg, p, z);
        sqlite3DbFree(db, z);
      }else{
        (void)db->xTrace(SQLITE_TRACE_STMT, db->pTraceArg, p, zTrace);
      }
    }
  #ifdef SQLITE_USE_FCNTL_TRACE
    zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql);
    if( zTrace ){
      int j;
      for(j=0; j<db->nDb; j++){
        if( DbMaskTest(p->btreeMask, j)==0 ) continue;
        sqlite3_file_control(db, db->aDb[j].zDbSName, SQLITE_FCNTL_TRACE, zTrace);
      }
    }
  #endif /* SQLITE_USE_FCNTL_TRACE */
  #ifdef SQLITE_DEBUG
    if( (db->flags & SQLITE_SqlTrace)!=0
     && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
    ){
      sqlite3DebugPrintf("SQL-trace: %s\n", zTrace);
    }
  #endif /* SQLITE_DEBUG */
  #endif /* SQLITE_OMIT_TRACE */
    assert( pOp->p2>0 );
    if( pOp->p1>=sqlite3GlobalConfig.iOnceResetThreshold ){
      if( pOp->opcode==OP_Trace ) break;
      for(i=1; i<p->nOp; i++){
        if( p->aOp[i].opcode==OP_Once ) p->aOp[i].p1 = 0;
      }
      pOp->p1 = 0;
    }
    pOp->p1++;
    p->aCounter[SQLITE_STMTSTATUS_RUN]++;
    goto jump_to_p2;
  }
  
  #ifdef SQLITE_ENABLE_CURSOR_HINTS
  /* Opcode: CursorHint P1 * * P4 *
  **
  ** Provide a hint to cursor P1 that it only needs to return rows that
  ** satisfy the Expr in P4.  TK_REGISTER terms in the P4 expression refer
  ** to values currently held in registers.  TK_COLUMN terms in the P4
  ** expression refer to columns in the b-tree to which cursor P1 is pointing.
  */
  case OP_CursorHint: {
    VdbeCursor *pC;
  
    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
    assert( pOp->p4type==P4_EXPR );
    pC = p->apCsr[pOp->p1];
    if( pC ){
      assert( pC->eCurType==CURTYPE_BTREE );
      sqlite3BtreeCursorHint(pC->uc.pCursor, BTREE_HINT_RANGE,
                             pOp->p4.pExpr, aMem);
    }
    break;
  }
  #endif /* SQLITE_ENABLE_CURSOR_HINTS */
  
  #ifdef SQLITE_DEBUG
  /* Opcode:  Abortable   * * * * *
  **
  ** Verify that an Abort can happen.  Assert if an Abort at this point
  ** might cause database corruption.  This opcode only appears in debugging
  ** builds.
  **
  ** An Abort is safe if either there have been no writes, or if there is
  ** an active statement journal.
  */
  case OP_Abortable: {
    sqlite3VdbeAssertAbortable(p);
    break;
  }
  #endif
  
  #ifdef SQLITE_DEBUG
  /* Opcode:  ReleaseReg   P1 P2 P3 * P5
  ** Synopsis: release r[P1@P2] mask P3
  **
  ** Release registers from service.  Any content that was in the
  ** the registers is unreliable after this opcode completes.
  **
  ** The registers released will be the P2 registers starting at P1,
  ** except if bit ii of P3 set, then do not release register P1+ii.
  ** In other words, P3 is a mask of registers to preserve.
  **
  ** Releasing a register clears the Mem.pScopyFrom pointer.  That means
  ** that if the content of the released register was set using OP_SCopy,
  ** a change to the value of the source register for the OP_SCopy will no longer
  ** generate an assertion fault in sqlite3VdbeMemAboutToChange().
  **
  ** If P5 is set, then all released registers have their type set
  ** to MEM_Undefined so that any subsequent attempt to read the released
  ** register (before it is reinitialized) will generate an assertion fault.
  **
  ** P5 ought to be set on every call to this opcode.
  ** However, there are places in the code generator will release registers
  ** before their are used, under the (valid) assumption that the registers
  ** will not be reallocated for some other purpose before they are used and
  ** hence are safe to release.
  **
  ** This opcode is only available in testing and debugging builds.  It is
  ** not generated for release builds.  The purpose of this opcode is to help
  ** validate the generated bytecode.  This opcode does not actually contribute
  ** to computing an answer.
  */
  case OP_ReleaseReg: {
    Mem *pMem;
    int i;
    u32 constMask;
    assert( pOp->p1>0 );
    assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );
    pMem = &aMem[pOp->p1];
    constMask = pOp->p3;
    for(i=0; i<pOp->p2; i++, pMem++){
      if( i>=32 || (constMask & MASKBIT32(i))==0 ){
        pMem->pScopyFrom = 0;
        if( i<32 && pOp->p5 ) MemSetTypeFlag(pMem, MEM_Undefined);
      }
    }
    break;
  }
  #endif
  
  /* Opcode: Noop * * * * *
  **
  ** Do nothing.  This instruction is often useful as a jump
  ** destination.
  */
  /*
  ** The magic Explain opcode are only inserted when explain==2 (which
  ** is to say when the EXPLAIN QUERY PLAN syntax is used.)
  ** This opcode records information from the optimizer.  It is the
  ** the same as a no-op.  This opcodesnever appears in a real VM program.
  */
  default: {          /* This is really OP_Noop, OP_Explain */
    assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain );
  
    break;
  }
  
  /*****************************************************************************
  ** The cases of the switch statement above this line should all be indented
  ** by 6 spaces.  But the left-most 6 spaces have been removed to improve the
  ** readability.  From this point on down, the normal indentation rules are
  ** restored.
  *****************************************************************************/
      }
  
  #ifdef VDBE_PROFILE
      {
        u64 endTime = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime();
        if( endTime>start ) pOrigOp->cycles += endTime - start;
        pOrigOp->cnt++;
      }
  #endif
  
      /* The following code adds nothing to the actual functionality
      ** of the program.  It is only here for testing and debugging.
      ** On the other hand, it does burn CPU cycles every time through
      ** the evaluator loop.  So we can leave it out when NDEBUG is defined.
      */
  #ifndef NDEBUG
      assert( pOp>=&aOp[-1] && pOp<&aOp[p->nOp-1] );
  
  #ifdef SQLITE_DEBUG
      if( db->flags & SQLITE_VdbeTrace ){
        u8 opProperty = sqlite3OpcodeProperty[pOrigOp->opcode];
        if( rc!=0 ) printf("rc=%d\n",rc);
        if( opProperty & (OPFLG_OUT2) ){
          registerTrace(pOrigOp->p2, &aMem[pOrigOp->p2]);
        }
        if( opProperty & OPFLG_OUT3 ){
          registerTrace(pOrigOp->p3, &aMem[pOrigOp->p3]);
        }
        if( opProperty==0xff ){
          /* Never happens.  This code exists to avoid a harmless linkage
          ** warning aboud sqlite3VdbeRegisterDump() being defined but not
          ** used. */
          sqlite3VdbeRegisterDump(p);
        }
      }
  #endif  /* SQLITE_DEBUG */
  #endif  /* NDEBUG */
    }  /* The end of the for(;;) loop the loops through opcodes */
  
    /* If we reach this point, it means that execution is finished with
    ** an error of some kind.
    */
  abort_due_to_error:
    if( db->mallocFailed ) rc = SQLITE_NOMEM_BKPT;
    assert( rc );
    if( p->zErrMsg==0 && rc!=SQLITE_IOERR_NOMEM ){
      sqlite3VdbeError(p, "%s", sqlite3ErrStr(rc));
    }
    p->rc = rc;
    sqlite3SystemError(db, rc);
    testcase( sqlite3GlobalConfig.xLog!=0 );
    sqlite3_log(rc, "statement aborts at %d: [%s] %s", 
                     (int)(pOp - aOp), p->zSql, p->zErrMsg);
    sqlite3VdbeHalt(p);
    if( rc==SQLITE_IOERR_NOMEM ) sqlite3OomFault(db);
    rc = SQLITE_ERROR;
    if( resetSchemaOnFault>0 ){
      sqlite3ResetOneSchema(db, resetSchemaOnFault-1);
    }
  
    /* This is the only way out of this procedure.  We have to
    ** release the mutexes on btrees that were acquired at the
    ** top. */
  vdbe_return:
  #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
    while( nVmStep>=nProgressLimit && db->xProgress!=0 ){
      nProgressLimit += db->nProgressOps;
      if( db->xProgress(db->pProgressArg) ){
        nProgressLimit = 0xffffffff;
        rc = SQLITE_INTERRUPT;
        goto abort_due_to_error;
      }
    }
  #endif
    p->aCounter[SQLITE_STMTSTATUS_VM_STEP] += (int)nVmStep;
    sqlite3VdbeLeave(p);
    assert( rc!=SQLITE_OK || nExtraDelete==0 
         || sqlite3_strlike("DELETE%",p->zSql,0)!=0 
    );
    return rc;
  
    /* Jump to here if a string or blob larger than SQLITE_MAX_LENGTH
    ** is encountered.
    */
  too_big:
    sqlite3VdbeError(p, "string or blob too big");
    rc = SQLITE_TOOBIG;
    goto abort_due_to_error;
  
    /* Jump to here if a malloc() fails.
    */
  no_mem:
    sqlite3OomFault(db);
    sqlite3VdbeError(p, "out of memory");
    rc = SQLITE_NOMEM_BKPT;
    goto abort_due_to_error;
  
    /* Jump to here if the sqlite3_interrupt() API sets the interrupt
    ** flag.
    */
  abort_due_to_interrupt:
    assert( AtomicLoad(&db->u1.isInterrupted) );
    rc = db->mallocFailed ? SQLITE_NOMEM_BKPT : SQLITE_INTERRUPT;
    p->rc = rc;
    sqlite3VdbeError(p, "%s", sqlite3ErrStr(rc));
    goto abort_due_to_error;
  }
  