Rename 'digikam' folder to 'src'

Signed-off-by: Michele Calgaro <[email protected]>

1 files changed, 4921 insertions, 0 deletions

diff --git a/src/libs/sqlite2/vdbe.c b/src/libs/sqlite2/vdbe.c
new file mode 100644
index 00000000..1838691c
--- /dev/null
+++ b/src/libs/sqlite2/vdbe.c
@@ -0,0 +1,4921 @@
+/*
+** 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 execution method of the 
+** Virtual Database Engine (VDBE).  A separate file ("vdbeaux.c")
+** handles housekeeping details such as creating and deleting
+** VDBE instances.  This file is solely interested in executing
+** the VDBE program.
+**
+** In the external interface, an "sqlite_vm*" is an opaque pointer
+** to a VDBE.
+**
+** The SQL parser generates a program which is then executed by
+** the VDBE to do the work of the SQL statement.  VDBE programs are 
+** similar in form to assembly language.  The program consists of
+** a linear sequence of operations.  Each operation has an opcode 
+** and 3 operands.  Operands P1 and P2 are integers.  Operand P3 
+** is a null-terminated string.   The P2 operand must be non-negative.
+** Opcodes will typically ignore one or more operands.  Many opcodes
+** ignore all three operands.
+**
+** Computation results are stored on a stack.  Each entry on the
+** stack is either an integer, a null-terminated string, a floating point
+** number, or the SQL "NULL" value.  An inplicit conversion from one
+** type to the other occurs as necessary.
+** 
+** Most of the code in this file is taken up by the sqliteVdbeExec()
+** function which does the work of interpreting a VDBE program.
+** But other routines are also provided to help in building up
+** a program instruction by instruction.
+**
+** 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.
+**
+** $Id: vdbe.c 875429 2008-10-24 12:20:41Z cgilles $
+*/
+#include "sqliteInt.h"
+#include "os.h"
+#include <ctype.h>
+#include "vdbeInt.h"
+
+/*
+** The following global variable is incremented every time a cursor
+** moves, either by the OP_MoveTo or the OP_Next opcode.  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.
+*/
+int sqlite_search_count = 0;
+
+/*
+** When this global variable is positive, it gets decremented once before
+** each instruction in the VDBE.  When reaches zero, the SQLITE_Interrupt
+** of the db.flags field is set in order to simulate an interrupt.
+**
+** This facility is used for testing purposes only.  It does not function
+** in an ordinary build.
+*/
+int sqlite_interrupt_count = 0;
+
+/*
+** Advance the virtual machine to the next output row.
+**
+** The return vale will be either SQLITE_BUSY, SQLITE_DONE, 
+** SQLITE_ROW, SQLITE_ERROR, or SQLITE_MISUSE.
+**
+** SQLITE_BUSY means that the virtual machine attempted to open
+** a locked database and there is no busy callback registered.
+** Call sqlite_step() again to retry the open.  *pN is set to 0
+** and *pazColName and *pazValue are both set to NULL.
+**
+** SQLITE_DONE means that the virtual machine has finished
+** executing.  sqlite_step() should not be called again on this
+** virtual machine.  *pN and *pazColName are set appropriately
+** but *pazValue is set to NULL.
+**
+** SQLITE_ROW means that the virtual machine has generated another
+** row of the result set.  *pN is set to the number of columns in
+** the row.  *pazColName is set to the names of the columns followed
+** by the column datatypes.  *pazValue is set to the values of each
+** column in the row.  The value of the i-th column is (*pazValue)[i].
+** The name of the i-th column is (*pazColName)[i] and the datatype
+** of the i-th column is (*pazColName)[i+*pN].
+**
+** SQLITE_ERROR means that a run-time error (such as a constraint
+** violation) has occurred.  The details of the error will be returned
+** by the next call to sqlite_finalize().  sqlite_step() should not
+** be called again on the VM.
+**
+** SQLITE_MISUSE means that the this routine was called inappropriately.
+** Perhaps it was called on a virtual machine that had already been
+** finalized or on one that had previously returned SQLITE_ERROR or
+** SQLITE_DONE.  Or it could be the case the the same database connection
+** is being used simulataneously by two or more threads.
+*/
+int sqlite_step(
+  sqlite_vm *pVm,              /* The virtual machine to execute */
+  int *pN,                     /* OUT: Number of columns in result */
+  const char ***pazValue,      /* OUT: Column data */
+  const char ***pazColName     /* OUT: Column names and datatypes */
+){
+  Vdbe *p = (Vdbe*)pVm;
+  sqlite *db;
+  int rc;
+
+  if( p->magic!=VDBE_MAGIC_RUN ){
+    return SQLITE_MISUSE;
+  }
+  db = p->db;
+  if( sqliteSafetyOn(db) ){
+    p->rc = SQLITE_MISUSE;
+    return SQLITE_MISUSE;
+  }
+  if( p->explain ){
+    rc = sqliteVdbeList(p);
+  }else{
+    rc = sqliteVdbeExec(p);
+  }
+  if( rc==SQLITE_DONE || rc==SQLITE_ROW ){
+    if( pazColName ) *pazColName = (const char**)p->azColName;
+    if( pN ) *pN = p->nResColumn;
+  }else{
+    if( pazColName) *pazColName = 0;
+    if( pN ) *pN = 0;
+  }
+  if( pazValue ){
+    if( rc==SQLITE_ROW ){
+      *pazValue = (const char**)p->azResColumn;
+    }else{
+      *pazValue = 0;
+    }
+  }
+  if( sqliteSafetyOff(db) ){
+    return SQLITE_MISUSE;
+  }
+  return rc;
+}
+
+/*
+** Insert a new aggregate element and make it the element that
+** has focus.
+**
+** Return 0 on success and 1 if memory is exhausted.
+*/
+static int AggInsert(Agg *p, char *zKey, int nKey){
+  AggElem *pElem, *pOld;
+  int i;
+  Mem *pMem;
+  pElem = sqliteMalloc( sizeof(AggElem) + nKey +
+                        (p->nMem-1)*sizeof(pElem->aMem[0]) );
+  if( pElem==0 ) return 1;
+  pElem->zKey = (char*)&pElem->aMem[p->nMem];
+  memcpy(pElem->zKey, zKey, nKey);
+  pElem->nKey = nKey;
+  pOld = sqliteHashInsert(&p->hash, pElem->zKey, pElem->nKey, pElem);
+  if( pOld!=0 ){
+    assert( pOld==pElem );  /* Malloc failed on insert */
+    sqliteFree(pOld);
+    return 0;
+  }
+  for(i=0, pMem=pElem->aMem; i<p->nMem; i++, pMem++){
+    pMem->flags = MEM_Null;
+  }
+  p->pCurrent = pElem;
+  return 0;
+}
+
+/*
+** Get the AggElem currently in focus
+*/
+#define AggInFocus(P)   ((P).pCurrent ? (P).pCurrent : _AggInFocus(&(P)))
+static AggElem *_AggInFocus(Agg *p){
+  HashElem *pElem = sqliteHashFirst(&p->hash);
+  if( pElem==0 ){
+    AggInsert(p,"",1);
+    pElem = sqliteHashFirst(&p->hash);
+  }
+  return pElem ? sqliteHashData(pElem) : 0;
+}
+
+/*
+** Convert the given stack entity into a string if it isn't one
+** already.
+*/
+#define Stringify(P) if(((P)->flags & MEM_Str)==0){hardStringify(P);}
+static int hardStringify(Mem *pStack){
+  int fg = pStack->flags;
+  if( fg & MEM_Real ){
+    sqlite_snprintf(sizeof(pStack->zShort),pStack->zShort,"%.15g",pStack->r);
+  }else if( fg & MEM_Int ){
+    sqlite_snprintf(sizeof(pStack->zShort),pStack->zShort,"%d",pStack->i);
+  }else{
+    pStack->zShort[0] = 0;
+  }
+  pStack->z = pStack->zShort;
+  pStack->n = strlen(pStack->zShort)+1;
+  pStack->flags = MEM_Str | MEM_Short;
+  return 0;
+}
+
+/*
+** Convert the given stack entity into a string that has been obtained
+** from sqliteMalloc().  This is different from Stringify() above in that
+** Stringify() will use the NBFS bytes of static string space if the string
+** will fit but this routine always mallocs for space.
+** Return non-zero if we run out of memory.
+*/
+#define Dynamicify(P) (((P)->flags & MEM_Dyn)==0 ? hardDynamicify(P):0)
+static int hardDynamicify(Mem *pStack){
+  int fg = pStack->flags;
+  char *z;
+  if( (fg & MEM_Str)==0 ){
+    hardStringify(pStack);
+  }
+  assert( (fg & MEM_Dyn)==0 );
+  z = sqliteMallocRaw( pStack->n );
+  if( z==0 ) return 1;
+  memcpy(z, pStack->z, pStack->n);
+  pStack->z = z;
+  pStack->flags |= MEM_Dyn;
+  return 0;
+}
+
+/*
+** 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 stack entry
+** does not control the string, it might be deleted without the stack
+** entry knowing it.
+**
+** This routine converts an ephemeral string into a dynamically allocated
+** string that the stack entry itself controls.  In other words, it
+** converts an MEM_Ephem string into an MEM_Dyn string.
+*/
+#define Deephemeralize(P) \
+   if( ((P)->flags&MEM_Ephem)!=0 && hardDeephem(P) ){ goto no_mem;}
+static int hardDeephem(Mem *pStack){
+  char *z;
+  assert( (pStack->flags & MEM_Ephem)!=0 );
+  z = sqliteMallocRaw( pStack->n );
+  if( z==0 ) return 1;
+  memcpy(z, pStack->z, pStack->n);
+  pStack->z = z;
+  pStack->flags &= ~MEM_Ephem;
+  pStack->flags |= MEM_Dyn;
+  return 0;
+}
+
+/*
+** Release the memory associated with the given stack level.  This
+** leaves the Mem.flags field in an inconsistent state.
+*/
+#define Release(P) if((P)->flags&MEM_Dyn){ sqliteFree((P)->z); }
+
+/*
+** Pop the stack N times.
+*/
+static void popStack(Mem **ppTos, int N){
+  Mem *pTos = *ppTos;
+  while( N>0 ){
+    N--;
+    Release(pTos);
+    pTos--;
+  }
+  *ppTos = pTos;
+}
+
+/*
+** Return TRUE if zNum is a 32-bit signed integer and write
+** the value of the integer into *pNum.  If zNum is not an integer
+** or is an integer that is too large to be expressed with just 32
+** bits, then return false.
+**
+** Under Linux (RedHat 7.2) this routine is much faster than atoi()
+** for converting strings into integers.
+*/
+static int toInt(const char *zNum, int *pNum){
+  int v = 0;
+  int neg;
+  int i, c;
+  if( *zNum=='-' ){
+    neg = 1;
+    zNum++;
+  }else if( *zNum=='+' ){
+    neg = 0;
+    zNum++;
+  }else{
+    neg = 0;
+  }
+  for(i=0; (c=zNum[i])>='0' && c<='9'; i++){
+    v = v*10 + c - '0';
+  }
+  *pNum = neg ? -v : v;
+  return c==0 && i>0 && (i<10 || (i==10 && memcmp(zNum,"2147483647",10)<=0));
+}
+
+/*
+** Convert the given stack entity into a integer if it isn't one
+** already.
+**
+** Any prior string or real representation is invalidated.  
+** NULLs are converted into 0.
+*/
+#define Integerify(P) if(((P)->flags&MEM_Int)==0){ hardIntegerify(P); }
+static void hardIntegerify(Mem *pStack){
+  if( pStack->flags & MEM_Real ){
+    pStack->i = (int)pStack->r;
+    Release(pStack);
+  }else if( pStack->flags & MEM_Str ){
+    toInt(pStack->z, &pStack->i);
+    Release(pStack);
+  }else{
+    pStack->i = 0;
+  }
+  pStack->flags = MEM_Int;
+}
+
+/*
+** Get a valid Real representation for the given stack element.
+**
+** Any prior string or integer representation is retained.
+** NULLs are converted into 0.0.
+*/
+#define Realify(P) if(((P)->flags&MEM_Real)==0){ hardRealify(P); }
+static void hardRealify(Mem *pStack){
+  if( pStack->flags & MEM_Str ){
+    pStack->r = sqliteAtoF(pStack->z, 0);
+  }else if( pStack->flags & MEM_Int ){
+    pStack->r = pStack->i;
+  }else{
+    pStack->r = 0.0;
+  }
+  pStack->flags |= MEM_Real;
+}
+
+/*
+** The parameters are pointers to the head of two sorted lists
+** of Sorter structures.  Merge these two lists together and return
+** a single sorted list.  This routine forms the core of the merge-sort
+** algorithm.
+**
+** In the case of a tie, left sorts in front of right.
+*/
+static Sorter *Merge(Sorter *pLeft, Sorter *pRight){
+  Sorter sHead;
+  Sorter *pTail;
+  pTail = &sHead;
+  pTail->pNext = 0;
+  while( pLeft && pRight ){
+    int c = sqliteSortCompare(pLeft->zKey, pRight->zKey);
+    if( c<=0 ){
+      pTail->pNext = pLeft;
+      pLeft = pLeft->pNext;
+    }else{
+      pTail->pNext = pRight;
+      pRight = pRight->pNext;
+    }
+    pTail = pTail->pNext;
+  }
+  if( pLeft ){
+    pTail->pNext = pLeft;
+  }else if( pRight ){
+    pTail->pNext = pRight;
+  }
+  return sHead.pNext;
+}
+
+/*
+** The following routine works like a replacement for the standard
+** library routine fgets().  The difference is in how end-of-line (EOL)
+** is handled.  Standard fgets() uses LF for EOL under unix, CRLF
+** under windows, and CR under mac.  This routine accepts any of these
+** character sequences as an EOL mark.  The EOL mark is replaced by
+** a single LF character in zBuf.
+*/
+static char *vdbe_fgets(char *zBuf, int nBuf, FILE *in){
+  int i, c;
+  for(i=0; i<nBuf-1 && (c=getc(in))!=EOF; i++){
+    zBuf[i] = c;
+    if( c=='\r' || c=='\n' ){
+      if( c=='\r' ){
+        zBuf[i] = '\n';
+        c = getc(in);
+        if( c!=EOF && c!='\n' ) ungetc(c, in);
+      }
+      i++;
+      break;
+    }
+  }
+  zBuf[i]  = 0;
+  return i>0 ? zBuf : 0;
+}
+
+/*
+** Make sure there is space in the Vdbe structure to hold at least
+** mxCursor cursors.  If there is not currently enough space, then
+** allocate more.
+**
+** If a memory allocation error occurs, return 1.  Return 0 if
+** everything works.
+*/
+static int expandCursorArraySize(Vdbe *p, int mxCursor){
+  if( mxCursor>=p->nCursor ){
+    Cursor *aCsr = sqliteRealloc( p->aCsr, (mxCursor+1)*sizeof(Cursor) );
+    if( aCsr==0 ) return 1;
+    p->aCsr = aCsr;
+    memset(&p->aCsr[p->nCursor], 0, sizeof(Cursor)*(mxCursor+1-p->nCursor));
+    p->nCursor = mxCursor+1;
+  }
+  return 0;
+}
+
+#ifdef VDBE_PROFILE
+/*
+** The following routine only works on pentium-class processors.
+** It uses the RDTSC opcode to read cycle count value out of the
+** processor and returns that value.  This can be used for high-res
+** profiling.
+*/
+__inline__ unsigned long long int hwtime(void){
+  unsigned long long int x;
+  __asm__("rdtsc\n\t"
+          "mov %%edx, %%ecx\n\t"
+          :"=A" (x));
+  return x;
+}
+#endif
+
+/*
+** The CHECK_FOR_INTERRUPT macro defined here looks to see if the
+** sqlite_interrupt() routine has been called.  If it has been, then
+** processing of the VDBE program is interrupted.
+**
+** This macro added to every instruction that does a jump in order to
+** implement a loop.  This test used to be on every single instruction,
+** but that meant we more testing that we needed.  By only testing the
+** flag on jump instructions, we get a (small) speed improvement.
+*/
+#define CHECK_FOR_INTERRUPT \
+   if( db->flags & SQLITE_Interrupt ) goto abort_due_to_interrupt;
+
+
+/*
+** Execute as much of a VDBE program as we can then return.
+**
+** sqliteVdbeMakeReady() must be called before this routine in order to
+** close the program with a final OP_Halt and to set up the callbacks
+** and the error message pointer.
+**
+** Whenever a row or result data is available, this routine will either
+** invoke the result callback (if there is one) or return with
+** SQLITE_ROW.
+**
+** If an attempt is made to open a locked database, then this routine
+** will either invoke the busy callback (if there is one) or it will
+** return SQLITE_BUSY.
+**
+** If an error occurs, an error message is written to memory obtained
+** from sqliteMalloc() and p->zErrMsg is made to point to that memory.
+** The error code is stored in p->rc and this routine returns SQLITE_ERROR.
+**
+** If the callback ever returns non-zero, then the program exits
+** immediately.  There will be no error message but the p->rc field is
+** set to SQLITE_ABORT and this routine will return SQLITE_ERROR.
+**
+** A memory allocation error causes p->rc to be set to SQLITE_NOMEM and this
+** routine to return SQLITE_ERROR.
+**
+** Other fatal errors return SQLITE_ERROR.
+**
+** After this routine has finished, sqliteVdbeFinalize() should be
+** used to clean up the mess that was left behind.
+*/
+int sqliteVdbeExec(
+  Vdbe *p                    /* The VDBE */
+){
+  int pc;                    /* The program counter */
+  Op *pOp;                   /* Current operation */
+  int rc = SQLITE_OK;        /* Value to return */
+  sqlite *db = p->db;        /* The database */
+  Mem *pTos;                 /* Top entry in the operand stack */
+  char zBuf[100];            /* Space to sprintf() an integer */
+#ifdef VDBE_PROFILE
+  unsigned long long start;  /* CPU clock count at start of opcode */
+  int origPc;                /* Program counter at start of opcode */
+#endif
+#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
+  int nProgressOps = 0;      /* Opcodes executed since progress callback. */
+#endif
+
+  if( p->magic!=VDBE_MAGIC_RUN ) return SQLITE_MISUSE;
+  assert( db->magic==SQLITE_MAGIC_BUSY );
+  assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY );
+  p->rc = SQLITE_OK;
+  assert( p->explain==0 );
+  if( sqlite_malloc_failed ) goto no_mem;
+  pTos = p->pTos;
+  if( p->popStack ){
+    popStack(&pTos, p->popStack);
+    p->popStack = 0;
+  }
+  CHECK_FOR_INTERRUPT;
+  for(pc=p->pc; rc==SQLITE_OK; pc++){
+    assert( pc>=0 && pc<p->nOp );
+    assert( pTos<=&p->aStack[pc] );
+#ifdef VDBE_PROFILE
+    origPc = pc;
+    start = hwtime();
+#endif
+    pOp = &p->aOp[pc];
+
+    /* Only allow tracing if NDEBUG is not defined.
+    */
+#ifndef NDEBUG
+    if( p->trace ){
+      sqliteVdbePrintOp(p->trace, pc, pOp);
+    }
+#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( sqlite_interrupt_count>0 ){
+      sqlite_interrupt_count--;
+      if( sqlite_interrupt_count==0 ){
+        sqlite_interrupt(db);
+      }
+    }
+#endif
+
+#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
+    ** sqliteVdbeExec() 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.
+    */
+    if( db->xProgress ){
+      if( db->nProgressOps==nProgressOps ){
+        if( db->xProgress(db->pProgressArg)!=0 ){
+          rc = SQLITE_ABORT;
+          continue; /* skip to the next iteration of the for loop */
+        }
+        nProgressOps = 0;
+      }
+      nProgressOps++;
+    }
+#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.
+**
+** 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.
+*/
+case OP_Goto: {
+  CHECK_FOR_INTERRUPT;
+  pc = pOp->p2 - 1;
+  break;
+}
+
+/* Opcode:  Gosub * P2 *
+**
+** Push the current address plus 1 onto the return address stack
+** and then jump to address P2.
+**
+** The return address stack is of limited depth.  If too many
+** OP_Gosub operations occur without intervening OP_Returns, then
+** the return address stack will fill up and processing will abort
+** with a fatal error.
+*/
+case OP_Gosub: {
+  if( p->returnDepth>=sizeof(p->returnStack)/sizeof(p->returnStack[0]) ){
+    sqliteSetString(&p->zErrMsg, "return address stack overflow", (char*)0);
+    p->rc = SQLITE_INTERNAL;
+    return SQLITE_ERROR;
+  }
+  p->returnStack[p->returnDepth++] = pc+1;
+  pc = pOp->p2 - 1;
+  break;
+}
+
+/* Opcode:  Return * * *
+**
+** Jump immediately to the next instruction after the last unreturned
+** OP_Gosub.  If an OP_Return has occurred for all OP_Gosubs, then
+** processing aborts with a fatal error.
+*/
+case OP_Return: {
+  if( p->returnDepth<=0 ){
+    sqliteSetString(&p->zErrMsg, "return address stack underflow", (char*)0);
+    p->rc = SQLITE_INTERNAL;
+    return SQLITE_ERROR;
+  }
+  p->returnDepth--;
+  pc = p->returnStack[p->returnDepth] - 1;
+  break;
+}
+
+/* Opcode:  Halt P1 P2 *
+**
+** Exit immediately.  All open cursors, Lists, Sorts, etc are closed
+** automatically.
+**
+** P1 is the result code returned by sqlite_exec().  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. 
+**
+** 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: {
+  p->magic = VDBE_MAGIC_HALT;
+  p->pTos = pTos;
+  if( pOp->p1!=SQLITE_OK ){
+    p->rc = pOp->p1;
+    p->errorAction = pOp->p2;
+    if( pOp->p3 ){
+      sqliteSetString(&p->zErrMsg, pOp->p3, (char*)0);
+    }
+    return SQLITE_ERROR;
+  }else{
+    p->rc = SQLITE_OK;
+    return SQLITE_DONE;
+  }
+}
+
+/* Opcode: Integer P1 * P3
+**
+** The integer value P1 is pushed onto the stack.  If P3 is not zero
+** then it is assumed to be a string representation of the same integer.
+*/
+case OP_Integer: {
+  pTos++;
+  pTos->i = pOp->p1;
+  pTos->flags = MEM_Int;
+  if( pOp->p3 ){
+    pTos->z = pOp->p3;
+    pTos->flags |= MEM_Str | MEM_Static;
+    pTos->n = strlen(pOp->p3)+1;
+  }
+  break;
+}
+
+/* Opcode: String * * P3
+**
+** The string value P3 is pushed onto the stack.  If P3==0 then a
+** NULL is pushed onto the stack.
+*/
+case OP_String: {
+  char *z = pOp->p3;
+  pTos++;
+  if( z==0 ){
+    pTos->flags = MEM_Null;
+  }else{
+    pTos->z = z;
+    pTos->n = strlen(z) + 1;
+    pTos->flags = MEM_Str | MEM_Static;
+  }
+  break;
+}
+
+/* Opcode: Variable P1 * *
+**
+** Push the value of variable P1 onto the stack.  A variable is
+** an unknown in the original SQL string as handed to sqlite_compile().
+** Any occurance of the '?' character in the original SQL is considered
+** a variable.  Variables in the SQL string are number from left to
+** right beginning with 1.  The values of variables are set using the
+** sqlite_bind() API.
+*/
+case OP_Variable: {
+  int j = pOp->p1 - 1;
+  pTos++;
+  if( j>=0 && j<p->nVar && p->azVar[j]!=0 ){
+    pTos->z = p->azVar[j];
+    pTos->n = p->anVar[j];
+    pTos->flags = MEM_Str | MEM_Static;
+  }else{
+    pTos->flags = MEM_Null;
+  }
+  break;
+}
+
+/* Opcode: Pop P1 * *
+**
+** P1 elements are popped off of the top of stack and discarded.
+*/
+case OP_Pop: {
+  assert( pOp->p1>=0 );
+  popStack(&pTos, pOp->p1);
+  assert( pTos>=&p->aStack[-1] );
+  break;
+}
+
+/* Opcode: Dup P1 P2 *
+**
+** A copy of the P1-th element of the stack 
+** is made and pushed onto the top of the stack.
+** The top of the stack is element 0.  So the
+** instruction "Dup 0 0 0" will make a copy of the
+** top of the stack.
+**
+** If the content of the P1-th element is a dynamically
+** allocated string, then a new copy of that string
+** is made if P2==0.  If P2!=0, then just a pointer
+** to the string is copied.
+**
+** Also see the Pull instruction.
+*/
+case OP_Dup: {
+  Mem *pFrom = &pTos[-pOp->p1];
+  assert( pFrom<=pTos && pFrom>=p->aStack );
+  pTos++;
+  memcpy(pTos, pFrom, sizeof(*pFrom)-NBFS);
+  if( pTos->flags & MEM_Str ){
+    if( pOp->p2 && (pTos->flags & (MEM_Dyn|MEM_Ephem)) ){
+      pTos->flags &= ~MEM_Dyn;
+      pTos->flags |= MEM_Ephem;
+    }else if( pTos->flags & MEM_Short ){
+      memcpy(pTos->zShort, pFrom->zShort, pTos->n);
+      pTos->z = pTos->zShort;
+    }else if( (pTos->flags & MEM_Static)==0 ){
+      pTos->z = sqliteMallocRaw(pFrom->n);
+      if( sqlite_malloc_failed ) goto no_mem;
+      memcpy(pTos->z, pFrom->z, pFrom->n);
+      pTos->flags &= ~(MEM_Static|MEM_Ephem|MEM_Short);
+      pTos->flags |= MEM_Dyn;
+    }
+  }
+  break;
+}
+
+/* Opcode: Pull P1 * *
+**
+** The P1-th element is removed from its current location on 
+** the stack and pushed back on top of the stack.  The
+** top of the stack is element 0, so "Pull 0 0 0" is
+** a no-op.  "Pull 1 0 0" swaps the top two elements of
+** the stack.
+**
+** See also the Dup instruction.
+*/
+case OP_Pull: {
+  Mem *pFrom = &pTos[-pOp->p1];
+  int i;
+  Mem ts;
+
+  ts = *pFrom;
+  Deephemeralize(pTos);
+  for(i=0; i<pOp->p1; i++, pFrom++){
+    Deephemeralize(&pFrom[1]);
+    *pFrom = pFrom[1];
+    assert( (pFrom->flags & MEM_Ephem)==0 );
+    if( pFrom->flags & MEM_Short ){
+      assert( pFrom->flags & MEM_Str );
+      assert( pFrom->z==pFrom[1].zShort );
+      pFrom->z = pFrom->zShort;
+    }
+  }
+  *pTos = ts;
+  if( pTos->flags & MEM_Short ){
+    assert( pTos->flags & MEM_Str );
+    assert( pTos->z==pTos[-pOp->p1].zShort );
+    pTos->z = pTos->zShort;
+  }
+  break;
+}
+
+/* Opcode: Push P1 * *
+**
+** Overwrite the value of the P1-th element down on the
+** stack (P1==0 is the top of the stack) with the value
+** of the top of the stack.  Then pop the top of the stack.
+*/
+case OP_Push: {
+  Mem *pTo = &pTos[-pOp->p1];
+
+  assert( pTo>=p->aStack );
+  Deephemeralize(pTos);
+  Release(pTo);
+  *pTo = *pTos;
+  if( pTo->flags & MEM_Short ){
+    assert( pTo->z==pTos->zShort );
+    pTo->z = pTo->zShort;
+  }
+  pTos--;
+  break;
+}
+
+
+/* Opcode: ColumnName P1 P2 P3
+**
+** P3 becomes the P1-th column name (first is 0).  An array of pointers
+** to all column names is passed as the 4th parameter to the callback.
+** If P2==1 then this is the last column in the result set and thus the
+** number of columns in the result set will be P1.  There must be at least
+** one OP_ColumnName with a P2==1 before invoking OP_Callback and the
+** number of columns specified in OP_Callback must one more than the P1
+** value of the OP_ColumnName that has P2==1.
+*/
+case OP_ColumnName: {
+  assert( pOp->p1>=0 && pOp->p1<p->nOp );
+  p->azColName[pOp->p1] = pOp->p3;
+  p->nCallback = 0;
+  if( pOp->p2 ) p->nResColumn = pOp->p1+1;
+  break;
+}
+
+/* Opcode: Callback P1 * *
+**
+** Pop P1 values off the stack and form them into an array.  Then
+** invoke the callback function using the newly formed array as the
+** 3rd parameter.
+*/
+case OP_Callback: {
+  int i;
+  char **azArgv = p->zArgv;
+  Mem *pCol;
+
+  pCol = &pTos[1-pOp->p1];
+  assert( pCol>=p->aStack );
+  for(i=0; i<pOp->p1; i++, pCol++){
+    if( pCol->flags & MEM_Null ){
+      azArgv[i] = 0;
+    }else{
+      Stringify(pCol);
+      azArgv[i] = pCol->z;
+    }
+  }
+  azArgv[i] = 0;
+  p->nCallback++;
+  p->azResColumn = azArgv;
+  assert( p->nResColumn==pOp->p1 );
+  p->popStack = pOp->p1;
+  p->pc = pc + 1;
+  p->pTos = pTos;
+  return SQLITE_ROW;
+}
+
+/* Opcode: Concat P1 P2 P3
+**
+** Look at the first P1 elements of the stack.  Append them all 
+** together with the lowest element first.  Use P3 as a separator.  
+** Put the result on the top of the stack.  The original P1 elements
+** are popped from the stack if P2==0 and retained if P2==1.  If
+** any element of the stack is NULL, then the result is NULL.
+**
+** If P3 is NULL, then use no separator.  When P1==1, this routine
+** makes a copy of the top stack element into memory obtained
+** from sqliteMalloc().
+*/
+case OP_Concat: {
+  char *zNew;
+  int nByte;
+  int nField;
+  int i, j;
+  char *zSep;
+  int nSep;
+  Mem *pTerm;
+
+  nField = pOp->p1;
+  zSep = pOp->p3;
+  if( zSep==0 ) zSep = "";
+  nSep = strlen(zSep);
+  assert( &pTos[1-nField] >= p->aStack );
+  nByte = 1 - nSep;
+  pTerm = &pTos[1-nField];
+  for(i=0; i<nField; i++, pTerm++){
+    if( pTerm->flags & MEM_Null ){
+      nByte = -1;
+      break;
+    }else{
+      Stringify(pTerm);
+      nByte += pTerm->n - 1 + nSep;
+    }
+  }
+  if( nByte<0 ){
+    if( pOp->p2==0 ){
+      popStack(&pTos, nField);
+    }
+    pTos++;
+    pTos->flags = MEM_Null;
+    break;
+  }
+  zNew = sqliteMallocRaw( nByte );
+  if( zNew==0 ) goto no_mem;
+  j = 0;
+  pTerm = &pTos[1-nField];
+  for(i=j=0; i<nField; i++, pTerm++){
+    assert( pTerm->flags & MEM_Str );
+    memcpy(&zNew[j], pTerm->z, pTerm->n-1);
+    j += pTerm->n-1;
+    if( nSep>0 && i<nField-1 ){
+      memcpy(&zNew[j], zSep, nSep);
+      j += nSep;
+    }
+  }
+  zNew[j] = 0;
+  if( pOp->p2==0 ){
+    popStack(&pTos, nField);
+  }
+  pTos++;
+  pTos->n = nByte;
+  pTos->flags = MEM_Str|MEM_Dyn;
+  pTos->z = zNew;
+  break;
+}
+
+/* Opcode: Add * * *
+**
+** Pop the top two elements from the stack, add them together,
+** and push the result back onto the stack.  If either element
+** is a string then it is converted to a double using the atof()
+** function before the addition.
+** If either operand is NULL, the result is NULL.
+*/
+/* Opcode: Multiply * * *
+**
+** Pop the top two elements from the stack, multiply them together,
+** and push the result back onto the stack.  If either element
+** is a string then it is converted to a double using the atof()
+** function before the multiplication.
+** If either operand is NULL, the result is NULL.
+*/
+/* Opcode: Subtract * * *
+**
+** Pop the top two elements from the stack, subtract the
+** first (what was on top of the stack) from the second (the
+** next on stack)
+** and push the result back onto the stack.  If either element
+** is a string then it is converted to a double using the atof()
+** function before the subtraction.
+** If either operand is NULL, the result is NULL.
+*/
+/* Opcode: Divide * * *
+**
+** Pop the top two elements from the stack, divide the
+** first (what was on top of the stack) from the second (the
+** next on stack)
+** and push the result back onto the stack.  If either element
+** is a string then it is converted to a double using the atof()
+** function before the division.  Division by zero returns NULL.
+** If either operand is NULL, the result is NULL.
+*/
+/* Opcode: Remainder * * *
+**
+** Pop the top two elements from the stack, divide the
+** first (what was on top of the stack) from the second (the
+** next on stack)
+** and push the remainder after division onto the stack.  If either element
+** is a string then it is converted to a double using the atof()
+** function before the division.  Division by zero returns NULL.
+** If either operand is NULL, the result is NULL.
+*/
+case OP_Add:
+case OP_Subtract:
+case OP_Multiply:
+case OP_Divide:
+case OP_Remainder: {
+  Mem *pNos = &pTos[-1];
+  assert( pNos>=p->aStack );
+  if( ((pTos->flags | pNos->flags) & MEM_Null)!=0 ){
+    Release(pTos);
+    pTos--;
+    Release(pTos);
+    pTos->flags = MEM_Null;
+  }else if( (pTos->flags & pNos->flags & MEM_Int)==MEM_Int ){
+    int a, b;
+    a = pTos->i;
+    b = pNos->i;
+    switch( pOp->opcode ){
+      case OP_Add:         b += a;       break;
+      case OP_Subtract:    b -= a;       break;
+      case OP_Multiply:    b *= a;       break;
+      case OP_Divide: {
+        if( a==0 ) goto divide_by_zero;
+        b /= a;
+        break;
+      }
+      default: {
+        if( a==0 ) goto divide_by_zero;
+        b %= a;
+        break;
+      }
+    }
+    Release(pTos);
+    pTos--;
+    Release(pTos);
+    pTos->i = b;
+    pTos->flags = MEM_Int;
+  }else{
+    double a, b;
+    Realify(pTos);
+    Realify(pNos);
+    a = pTos->r;
+    b = pNos->r;
+    switch( pOp->opcode ){
+      case OP_Add:         b += a;       break;
+      case OP_Subtract:    b -= a;       break;
+      case OP_Multiply:    b *= a;       break;
+      case OP_Divide: {
+        if( a==0.0 ) goto divide_by_zero;
+        b /= a;
+        break;
+      }
+      default: {
+        int ia = (int)a;
+        int ib = (int)b;
+        if( ia==0.0 ) goto divide_by_zero;
+        b = ib % ia;
+        break;
+      }
+    }
+    Release(pTos);
+    pTos--;
+    Release(pTos);
+    pTos->r = b;
+    pTos->flags = MEM_Real;
+  }
+  break;
+
+divide_by_zero:
+  Release(pTos);
+  pTos--;
+  Release(pTos);
+  pTos->flags = MEM_Null;
+  break;
+}
+
+/* Opcode: Function P1 * P3
+**
+** Invoke a user function (P3 is a pointer to a Function structure that
+** defines the function) with P1 string arguments taken from the stack.
+** Pop all arguments from the stack and push back the result.
+**
+** See also: AggFunc
+*/
+case OP_Function: {
+  int n, i;
+  Mem *pArg;
+  char **azArgv;
+  sqlite_func ctx;
+
+  n = pOp->p1;
+  pArg = &pTos[1-n];
+  azArgv = p->zArgv;
+  for(i=0; i<n; i++, pArg++){
+    if( pArg->flags & MEM_Null ){
+      azArgv[i] = 0;
+    }else{
+      Stringify(pArg);
+      azArgv[i] = pArg->z;
+    }
+  }
+  ctx.pFunc = (FuncDef*)pOp->p3;
+  ctx.s.flags = MEM_Null;
+  ctx.s.z = 0;
+  ctx.isError = 0;
+  ctx.isStep = 0;
+  if( sqliteSafetyOff(db) ) goto abort_due_to_misuse;
+  (*ctx.pFunc->xFunc)(&ctx, n, (const char**)azArgv);
+  if( sqliteSafetyOn(db) ) goto abort_due_to_misuse;
+  popStack(&pTos, n);
+  pTos++;
+  *pTos = ctx.s;
+  if( pTos->flags & MEM_Short ){
+    pTos->z = pTos->zShort;
+  }
+  if( ctx.isError ){
+    sqliteSetString(&p->zErrMsg, 
+       (pTos->flags & MEM_Str)!=0 ? pTos->z : "user function error", (char*)0);
+    rc = SQLITE_ERROR;
+  }
+  break;
+}
+
+/* Opcode: BitAnd * * *
+**
+** Pop the top two elements from the stack.  Convert both elements
+** to integers.  Push back onto the stack the bit-wise AND of the
+** two elements.
+** If either operand is NULL, the result is NULL.
+*/
+/* Opcode: BitOr * * *
+**
+** Pop the top two elements from the stack.  Convert both elements
+** to integers.  Push back onto the stack the bit-wise OR of the
+** two elements.
+** If either operand is NULL, the result is NULL.
+*/
+/* Opcode: ShiftLeft * * *
+**
+** Pop the top two elements from the stack.  Convert both elements
+** to integers.  Push back onto the stack the top element shifted
+** left by N bits where N is the second element on the stack.
+** If either operand is NULL, the result is NULL.
+*/
+/* Opcode: ShiftRight * * *
+**
+** Pop the top two elements from the stack.  Convert both elements
+** to integers.  Push back onto the stack the top element shifted
+** right by N bits where N is the second element on the stack.
+** If either operand is NULL, the result is NULL.
+*/
+case OP_BitAnd:
+case OP_BitOr:
+case OP_ShiftLeft:
+case OP_ShiftRight: {
+  Mem *pNos = &pTos[-1];
+  int a, b;
+
+  assert( pNos>=p->aStack );
+  if( (pTos->flags | pNos->flags) & MEM_Null ){
+    popStack(&pTos, 2);
+    pTos++;
+    pTos->flags = MEM_Null;
+    break;
+  }
+  Integerify(pTos);
+  Integerify(pNos);
+  a = pTos->i;
+  b = pNos->i;
+  switch( pOp->opcode ){
+    case OP_BitAnd:      a &= b;     break;
+    case OP_BitOr:       a |= b;     break;
+    case OP_ShiftLeft:   a <<= b;    break;
+    case OP_ShiftRight:  a >>= b;    break;
+    default:   /* CANT HAPPEN */     break;
+  }
+  assert( (pTos->flags & MEM_Dyn)==0 );
+  assert( (pNos->flags & MEM_Dyn)==0 );
+  pTos--;
+  Release(pTos);
+  pTos->i = a;
+  pTos->flags = MEM_Int;
+  break;
+}
+
+/* Opcode: AddImm  P1 * *
+** 
+** Add the value P1 to whatever is on top of the stack.  The result
+** is always an integer.
+**
+** To force the top of the stack to be an integer, just add 0.
+*/
+case OP_AddImm: {
+  assert( pTos>=p->aStack );
+  Integerify(pTos);
+  pTos->i += pOp->p1;
+  break;
+}
+
+/* Opcode: ForceInt P1 P2 *
+**
+** Convert the top of the stack into an integer.  If the current top of
+** the stack is not numeric (meaning that is is a NULL or a string that
+** does not look like an integer or floating point number) then pop the
+** stack and jump to P2.  If the top of the stack is numeric then
+** convert it into the least integer that is greater than or equal to its
+** current value if P1==0, or to the least integer that is strictly
+** greater than its current value if P1==1.
+*/
+case OP_ForceInt: {
+  int v;
+  assert( pTos>=p->aStack );
+  if( (pTos->flags & (MEM_Int|MEM_Real))==0
+         && ((pTos->flags & MEM_Str)==0 || sqliteIsNumber(pTos->z)==0) ){
+    Release(pTos);
+    pTos--;
+    pc = pOp->p2 - 1;
+    break;
+  }
+  if( pTos->flags & MEM_Int ){
+    v = pTos->i + (pOp->p1!=0);
+  }else{
+    Realify(pTos);
+    v = (int)pTos->r;
+    if( pTos->r>(double)v ) v++;
+    if( pOp->p1 && pTos->r==(double)v ) v++;
+  }
+  Release(pTos);
+  pTos->i = v;
+  pTos->flags = MEM_Int;
+  break;
+}
+
+/* Opcode: MustBeInt P1 P2 *
+** 
+** Force the top of the stack to be an integer.  If the top of the
+** stack is not an integer and cannot be converted into an integer
+** with out data loss, then jump immediately to P2, or if P2==0
+** raise an SQLITE_MISMATCH exception.
+**
+** If the top of the stack is not an integer and P2 is not zero and
+** P1 is 1, then the stack is popped.  In all other cases, the depth
+** of the stack is unchanged.
+*/
+case OP_MustBeInt: {
+  assert( pTos>=p->aStack );
+  if( pTos->flags & MEM_Int ){
+    /* Do nothing */
+  }else if( pTos->flags & MEM_Real ){
+    int i = (int)pTos->r;
+    double r = (double)i;
+    if( r!=pTos->r ){
+      goto mismatch;
+    }
+    pTos->i = i;
+  }else if( pTos->flags & MEM_Str ){
+    int v;
+    if( !toInt(pTos->z, &v) ){
+      double r;
+      if( !sqliteIsNumber(pTos->z) ){
+        goto mismatch;
+      }
+      Realify(pTos);
+      v = (int)pTos->r;
+      r = (double)v;
+      if( r!=pTos->r ){
+        goto mismatch;
+      }
+    }
+    pTos->i = v;
+  }else{
+    goto mismatch;
+  }
+  Release(pTos);
+  pTos->flags = MEM_Int;
+  break;
+
+mismatch:
+  if( pOp->p2==0 ){
+    rc = SQLITE_MISMATCH;
+    goto abort_due_to_error;
+  }else{
+    if( pOp->p1 ) popStack(&pTos, 1);
+    pc = pOp->p2 - 1;
+  }
+  break;
+}
+
+/* Opcode: Eq P1 P2 *
+**
+** Pop the top two elements from the stack.  If they are equal, then
+** jump to instruction P2.  Otherwise, continue to the next instruction.
+**
+** If either operand is NULL (and thus if the result is unknown) then
+** take the jump if P1 is true.
+**
+** If both values are numeric, they are converted to doubles using atof()
+** and compared for equality that way.  Otherwise the strcmp() library
+** routine is used for the comparison.  For a pure text comparison
+** use OP_StrEq.
+**
+** If P2 is zero, do not jump.  Instead, push an integer 1 onto the
+** stack if the jump would have been taken, or a 0 if not.  Push a
+** NULL if either operand was NULL.
+*/
+/* Opcode: Ne P1 P2 *
+**
+** Pop the top two elements from the stack.  If they are not equal, then
+** jump to instruction P2.  Otherwise, continue to the next instruction.
+**
+** If either operand is NULL (and thus if the result is unknown) then
+** take the jump if P1 is true.
+**
+** If both values are numeric, they are converted to doubles using atof()
+** and compared in that format.  Otherwise the strcmp() library
+** routine is used for the comparison.  For a pure text comparison
+** use OP_StrNe.
+**
+** If P2 is zero, do not jump.  Instead, push an integer 1 onto the
+** stack if the jump would have been taken, or a 0 if not.  Push a
+** NULL if either operand was NULL.
+*/
+/* Opcode: Lt P1 P2 *
+**
+** Pop the top two elements from the stack.  If second element (the
+** next on stack) is less than the first (the top of stack), then
+** jump to instruction P2.  Otherwise, continue to the next instruction.
+** In other words, jump if NOS<TOS.
+**
+** If either operand is NULL (and thus if the result is unknown) then
+** take the jump if P1 is true.
+**
+** If both values are numeric, they are converted to doubles using atof()
+** and compared in that format.  Numeric values are always less than
+** non-numeric values.  If both operands are non-numeric, the strcmp() library
+** routine is used for the comparison.  For a pure text comparison
+** use OP_StrLt.
+**
+** If P2 is zero, do not jump.  Instead, push an integer 1 onto the
+** stack if the jump would have been taken, or a 0 if not.  Push a
+** NULL if either operand was NULL.
+*/
+/* Opcode: Le P1 P2 *
+**
+** Pop the top two elements from the stack.  If second element (the
+** next on stack) is less than or equal to the first (the top of stack),
+** then jump to instruction P2. In other words, jump if NOS<=TOS.
+**
+** If either operand is NULL (and thus if the result is unknown) then
+** take the jump if P1 is true.
+**
+** If both values are numeric, they are converted to doubles using atof()
+** and compared in that format.  Numeric values are always less than
+** non-numeric values.  If both operands are non-numeric, the strcmp() library
+** routine is used for the comparison.  For a pure text comparison
+** use OP_StrLe.
+**
+** If P2 is zero, do not jump.  Instead, push an integer 1 onto the
+** stack if the jump would have been taken, or a 0 if not.  Push a
+** NULL if either operand was NULL.
+*/
+/* Opcode: Gt P1 P2 *
+**
+** Pop the top two elements from the stack.  If second element (the
+** next on stack) is greater than the first (the top of stack),
+** then jump to instruction P2. In other words, jump if NOS>TOS.
+**
+** If either operand is NULL (and thus if the result is unknown) then
+** take the jump if P1 is true.
+**
+** If both values are numeric, they are converted to doubles using atof()
+** and compared in that format.  Numeric values are always less than
+** non-numeric values.  If both operands are non-numeric, the strcmp() library
+** routine is used for the comparison.  For a pure text comparison
+** use OP_StrGt.
+**
+** If P2 is zero, do not jump.  Instead, push an integer 1 onto the
+** stack if the jump would have been taken, or a 0 if not.  Push a
+** NULL if either operand was NULL.
+*/
+/* Opcode: Ge P1 P2 *
+**
+** Pop the top two elements from the stack.  If second element (the next
+** on stack) is greater than or equal to the first (the top of stack),
+** then jump to instruction P2. In other words, jump if NOS>=TOS.
+**
+** If either operand is NULL (and thus if the result is unknown) then
+** take the jump if P1 is true.
+**
+** If both values are numeric, they are converted to doubles using atof()
+** and compared in that format.  Numeric values are always less than
+** non-numeric values.  If both operands are non-numeric, the strcmp() library
+** routine is used for the comparison.  For a pure text comparison
+** use OP_StrGe.
+**
+** If P2 is zero, do not jump.  Instead, push an integer 1 onto the
+** stack if the jump would have been taken, or a 0 if not.  Push a
+** NULL if either operand was NULL.
+*/
+case OP_Eq:
+case OP_Ne:
+case OP_Lt:
+case OP_Le:
+case OP_Gt:
+case OP_Ge: {
+  Mem *pNos = &pTos[-1];
+  int c, v;
+  int ft, fn;
+  assert( pNos>=p->aStack );
+  ft = pTos->flags;
+  fn = pNos->flags;
+  if( (ft | fn) & MEM_Null ){
+    popStack(&pTos, 2);
+    if( pOp->p2 ){
+      if( pOp->p1 ) pc = pOp->p2-1;
+    }else{
+      pTos++;
+      pTos->flags = MEM_Null;
+    }
+    break;
+  }else if( (ft & fn & MEM_Int)==MEM_Int ){
+    c = pNos->i - pTos->i;
+  }else if( (ft & MEM_Int)!=0 && (fn & MEM_Str)!=0 && toInt(pNos->z,&v) ){
+    c = v - pTos->i;
+  }else if( (fn & MEM_Int)!=0 && (ft & MEM_Str)!=0 && toInt(pTos->z,&v) ){
+    c = pNos->i - v;
+  }else{
+    Stringify(pTos);
+    Stringify(pNos);
+    c = sqliteCompare(pNos->z, pTos->z);
+  }
+  switch( pOp->opcode ){
+    case OP_Eq:    c = c==0;     break;
+    case OP_Ne:    c = c!=0;     break;
+    case OP_Lt:    c = c<0;      break;
+    case OP_Le:    c = c<=0;     break;
+    case OP_Gt:    c = c>0;      break;
+    default:       c = c>=0;     break;
+  }
+  popStack(&pTos, 2);
+  if( pOp->p2 ){
+    if( c ) pc = pOp->p2-1;
+  }else{
+    pTos++;
+    pTos->i = c;
+    pTos->flags = MEM_Int;
+  }
+  break;
+}
+/* INSERT NO CODE HERE!
+**
+** The opcode numbers are extracted from this source file by doing
+**
+**    grep '^case OP_' vdbe.c | ... >opcodes.h
+**
+** The opcodes are numbered in the order that they appear in this file.
+** But in order for the expression generating code to work right, the
+** string comparison operators that follow must be numbered exactly 6
+** greater than the numeric comparison opcodes above.  So no other
+** cases can appear between the two.
+*/
+/* Opcode: StrEq P1 P2 *
+**
+** Pop the top two elements from the stack.  If they are equal, then
+** jump to instruction P2.  Otherwise, continue to the next instruction.
+**
+** If either operand is NULL (and thus if the result is unknown) then
+** take the jump if P1 is true.
+**
+** The strcmp() library routine is used for the comparison.  For a
+** numeric comparison, use OP_Eq.
+**
+** If P2 is zero, do not jump.  Instead, push an integer 1 onto the
+** stack if the jump would have been taken, or a 0 if not.  Push a
+** NULL if either operand was NULL.
+*/
+/* Opcode: StrNe P1 P2 *
+**
+** Pop the top two elements from the stack.  If they are not equal, then
+** jump to instruction P2.  Otherwise, continue to the next instruction.
+**
+** If either operand is NULL (and thus if the result is unknown) then
+** take the jump if P1 is true.
+**
+** The strcmp() library routine is used for the comparison.  For a
+** numeric comparison, use OP_Ne.
+**
+** If P2 is zero, do not jump.  Instead, push an integer 1 onto the
+** stack if the jump would have been taken, or a 0 if not.  Push a
+** NULL if either operand was NULL.
+*/
+/* Opcode: StrLt P1 P2 *
+**
+** Pop the top two elements from the stack.  If second element (the
+** next on stack) is less than the first (the top of stack), then
+** jump to instruction P2.  Otherwise, continue to the next instruction.
+** In other words, jump if NOS<TOS.
+**
+** If either operand is NULL (and thus if the result is unknown) then
+** take the jump if P1 is true.
+**
+** The strcmp() library routine is used for the comparison.  For a
+** numeric comparison, use OP_Lt.
+**
+** If P2 is zero, do not jump.  Instead, push an integer 1 onto the
+** stack if the jump would have been taken, or a 0 if not.  Push a
+** NULL if either operand was NULL.
+*/
+/* Opcode: StrLe P1 P2 *
+**
+** Pop the top two elements from the stack.  If second element (the
+** next on stack) is less than or equal to the first (the top of stack),
+** then jump to instruction P2. In other words, jump if NOS<=TOS.
+**
+** If either operand is NULL (and thus if the result is unknown) then
+** take the jump if P1 is true.
+**
+** The strcmp() library routine is used for the comparison.  For a
+** numeric comparison, use OP_Le.
+**
+** If P2 is zero, do not jump.  Instead, push an integer 1 onto the
+** stack if the jump would have been taken, or a 0 if not.  Push a
+** NULL if either operand was NULL.
+*/
+/* Opcode: StrGt P1 P2 *
+**
+** Pop the top two elements from the stack.  If second element (the
+** next on stack) is greater than the first (the top of stack),
+** then jump to instruction P2. In other words, jump if NOS>TOS.
+**
+** If either operand is NULL (and thus if the result is unknown) then
+** take the jump if P1 is true.
+**
+** The strcmp() library routine is used for the comparison.  For a
+** numeric comparison, use OP_Gt.
+**
+** If P2 is zero, do not jump.  Instead, push an integer 1 onto the
+** stack if the jump would have been taken, or a 0 if not.  Push a
+** NULL if either operand was NULL.
+*/
+/* Opcode: StrGe P1 P2 *
+**
+** Pop the top two elements from the stack.  If second element (the next
+** on stack) is greater than or equal to the first (the top of stack),
+** then jump to instruction P2. In other words, jump if NOS>=TOS.
+**
+** If either operand is NULL (and thus if the result is unknown) then
+** take the jump if P1 is true.
+**
+** The strcmp() library routine is used for the comparison.  For a
+** numeric comparison, use OP_Ge.
+**
+** If P2 is zero, do not jump.  Instead, push an integer 1 onto the
+** stack if the jump would have been taken, or a 0 if not.  Push a
+** NULL if either operand was NULL.
+*/
+case OP_StrEq:
+case OP_StrNe:
+case OP_StrLt:
+case OP_StrLe:
+case OP_StrGt:
+case OP_StrGe: {
+  Mem *pNos = &pTos[-1];
+  int c;
+  assert( pNos>=p->aStack );
+  if( (pNos->flags | pTos->flags) & MEM_Null ){
+    popStack(&pTos, 2);
+    if( pOp->p2 ){
+      if( pOp->p1 ) pc = pOp->p2-1;
+    }else{
+      pTos++;
+      pTos->flags = MEM_Null;
+    }
+    break;
+  }else{
+    Stringify(pTos);
+    Stringify(pNos);
+    c = strcmp(pNos->z, pTos->z);
+  }
+  /* The asserts on each case of the following switch are there to verify
+  ** that string comparison opcodes are always exactly 6 greater than the
+  ** corresponding numeric comparison opcodes.  The code generator depends
+  ** on this fact.
+  */
+  switch( pOp->opcode ){
+    case OP_StrEq:    c = c==0;    assert( pOp->opcode-6==OP_Eq );   break;
+    case OP_StrNe:    c = c!=0;    assert( pOp->opcode-6==OP_Ne );   break;
+    case OP_StrLt:    c = c<0;     assert( pOp->opcode-6==OP_Lt );   break;
+    case OP_StrLe:    c = c<=0;    assert( pOp->opcode-6==OP_Le );   break;
+    case OP_StrGt:    c = c>0;     assert( pOp->opcode-6==OP_Gt );   break;
+    default:          c = c>=0;    assert( pOp->opcode-6==OP_Ge );   break;
+  }
+  popStack(&pTos, 2);
+  if( pOp->p2 ){
+    if( c ) pc = pOp->p2-1;
+  }else{
+    pTos++;
+    pTos->flags = MEM_Int;
+    pTos->i = c;
+  }
+  break;
+}
+
+/* Opcode: And * * *
+**
+** Pop two values off the stack.  Take the logical AND of the
+** two values and push the resulting boolean value back onto the
+** stack. 
+*/
+/* Opcode: Or * * *
+**
+** Pop two values off the stack.  Take the logical OR of the
+** two values and push the resulting boolean value back onto the
+** stack. 
+*/
+case OP_And:
+case OP_Or: {
+  Mem *pNos = &pTos[-1];
+  int v1, v2;    /* 0==TRUE, 1==FALSE, 2==UNKNOWN or NULL */
+
+  assert( pNos>=p->aStack );
+  if( pTos->flags & MEM_Null ){
+    v1 = 2;
+  }else{
+    Integerify(pTos);
+    v1 = pTos->i==0;
+  }
+  if( pNos->flags & MEM_Null ){
+    v2 = 2;
+  }else{
+    Integerify(pNos);
+    v2 = pNos->i==0;
+  }
+  if( pOp->opcode==OP_And ){
+    static const unsigned char and_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 };
+    v1 = and_logic[v1*3+v2];
+  }else{
+    static const unsigned char or_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 };
+    v1 = or_logic[v1*3+v2];
+  }
+  popStack(&pTos, 2);
+  pTos++;
+  if( v1==2 ){
+    pTos->flags = MEM_Null;
+  }else{
+    pTos->i = v1==0;
+    pTos->flags = MEM_Int;
+  }
+  break;
+}
+
+/* Opcode: Negative * * *
+**
+** Treat the top of the stack as a numeric quantity.  Replace it
+** with its additive inverse.  If the top of the stack is NULL
+** its value is unchanged.
+*/
+/* Opcode: AbsValue * * *
+**
+** Treat the top of the stack as a numeric quantity.  Replace it
+** with its absolute value. If the top of the stack is NULL
+** its value is unchanged.
+*/
+case OP_Negative:
+case OP_AbsValue: {
+  assert( pTos>=p->aStack );
+  if( pTos->flags & MEM_Real ){
+    Release(pTos);
+    if( pOp->opcode==OP_Negative || pTos->r<0.0 ){
+      pTos->r = -pTos->r;
+    }
+    pTos->flags = MEM_Real;
+  }else if( pTos->flags & MEM_Int ){
+    Release(pTos);
+    if( pOp->opcode==OP_Negative || pTos->i<0 ){
+      pTos->i = -pTos->i;
+    }
+    pTos->flags = MEM_Int;
+  }else if( pTos->flags & MEM_Null ){
+    /* Do nothing */
+  }else{
+    Realify(pTos);
+    Release(pTos);
+    if( pOp->opcode==OP_Negative || pTos->r<0.0 ){
+      pTos->r = -pTos->r;
+    }
+    pTos->flags = MEM_Real;
+  }
+  break;
+}
+
+/* Opcode: Not * * *
+**
+** Interpret the top of the stack as a boolean value.  Replace it
+** with its complement.  If the top of the stack is NULL its value
+** is unchanged.
+*/
+case OP_Not: {
+  assert( pTos>=p->aStack );
+  if( pTos->flags & MEM_Null ) break;  /* Do nothing to NULLs */
+  Integerify(pTos);
+  Release(pTos);
+  pTos->i = !pTos->i;
+  pTos->flags = MEM_Int;
+  break;
+}
+
+/* Opcode: BitNot * * *
+**
+** Interpret the top of the stack as an value.  Replace it
+** with its ones-complement.  If the top of the stack is NULL its
+** value is unchanged.
+*/
+case OP_BitNot: {
+  assert( pTos>=p->aStack );
+  if( pTos->flags & MEM_Null ) break;  /* Do nothing to NULLs */
+  Integerify(pTos);
+  Release(pTos);
+  pTos->i = ~pTos->i;
+  pTos->flags = MEM_Int;
+  break;
+}
+
+/* Opcode: Noop * * *
+**
+** Do nothing.  This instruction is often useful as a jump
+** destination.
+*/
+case OP_Noop: {
+  break;
+}
+
+/* Opcode: If P1 P2 *
+**
+** Pop a single boolean from the stack.  If the boolean popped is
+** true, then jump to p2.  Otherwise continue to the next instruction.
+** An integer is false if zero and true otherwise.  A string is
+** false if it has zero length and true otherwise.
+**
+** If the value popped of the stack is NULL, then take the jump if P1
+** is true and fall through if P1 is false.
+*/
+/* Opcode: IfNot P1 P2 *
+**
+** Pop a single boolean from the stack.  If the boolean popped is
+** false, then jump to p2.  Otherwise continue to the next instruction.
+** An integer is false if zero and true otherwise.  A string is
+** false if it has zero length and true otherwise.
+**
+** If the value popped of the stack is NULL, then take the jump if P1
+** is true and fall through if P1 is false.
+*/
+case OP_If:
+case OP_IfNot: {
+  int c;
+  assert( pTos>=p->aStack );
+  if( pTos->flags & MEM_Null ){
+    c = pOp->p1;
+  }else{
+    Integerify(pTos);
+    c = pTos->i;
+    if( pOp->opcode==OP_IfNot ) c = !c;
+  }
+  assert( (pTos->flags & MEM_Dyn)==0 );
+  pTos--;
+  if( c ) pc = pOp->p2-1;
+  break;
+}
+
+/* Opcode: IsNull P1 P2 *
+**
+** If any of the top abs(P1) values on the stack are NULL, then jump
+** to P2.  Pop the stack P1 times if P1>0.   If P1<0 leave the stack
+** unchanged.
+*/
+case OP_IsNull: {
+  int i, cnt;
+  Mem *pTerm;
+  cnt = pOp->p1;
+  if( cnt<0 ) cnt = -cnt;
+  pTerm = &pTos[1-cnt];
+  assert( pTerm>=p->aStack );
+  for(i=0; i<cnt; i++, pTerm++){
+    if( pTerm->flags & MEM_Null ){
+      pc = pOp->p2-1;
+      break;
+    }
+  }
+  if( pOp->p1>0 ) popStack(&pTos, cnt);
+  break;
+}
+
+/* Opcode: NotNull P1 P2 *
+**
+** Jump to P2 if the top P1 values on the stack are all not NULL.  Pop the
+** stack if P1 times if P1 is greater than zero.  If P1 is less than
+** zero then leave the stack unchanged.
+*/
+case OP_NotNull: {
+  int i, cnt;
+  cnt = pOp->p1;
+  if( cnt<0 ) cnt = -cnt;
+  assert( &pTos[1-cnt] >= p->aStack );
+  for(i=0; i<cnt && (pTos[1+i-cnt].flags & MEM_Null)==0; i++){}
+  if( i>=cnt ) pc = pOp->p2-1;
+  if( pOp->p1>0 ) popStack(&pTos, cnt);
+  break;
+}
+
+/* Opcode: MakeRecord P1 P2 *
+**
+** Convert the top P1 entries of the stack into a single entry
+** suitable for use as a data record in a database table.  The
+** details of the format are irrelavant as long as the OP_Column
+** opcode can decode the record later.  Refer to source code
+** comments for the details of the record format.
+**
+** If P2 is true (non-zero) and one or more of the P1 entries
+** that go into building the record is NULL, then add some extra
+** bytes to the record to make it distinct for other entries created
+** during the same run of the VDBE.  The extra bytes added are a
+** counter that is reset with each run of the VDBE, so records
+** created this way will not necessarily be distinct across runs.
+** But they should be distinct for transient tables (created using
+** OP_OpenTemp) which is what they are intended for.
+**
+** (Later:) The P2==1 option was intended to make NULLs distinct
+** for the UNION operator.  But I have since discovered that NULLs
+** are indistinct for UNION.  So this option is never used.
+*/
+case OP_MakeRecord: {
+  char *zNewRecord;
+  int nByte;
+  int nField;
+  int i, j;
+  int idxWidth;
+  u32 addr;
+  Mem *pRec;
+  int addUnique = 0;   /* True to cause bytes to be added to make the
+                       ** generated record distinct */
+  char zTemp[NBFS];    /* Temp space for small records */
+
+  /* Assuming the record contains N fields, the record format looks
+  ** like this:
+  **
+  **   -------------------------------------------------------------------
+  **   | idx0 | idx1 | ... | idx(N-1) | idx(N) | data0 | ... | data(N-1) |
+  **   -------------------------------------------------------------------
+  **
+  ** All data fields are converted to strings before being stored and
+  ** are stored with their null terminators.  NULL entries omit the
+  ** null terminator.  Thus an empty string uses 1 byte and a NULL uses
+  ** zero bytes.  Data(0) is taken from the lowest element of the stack
+  ** and data(N-1) is the top of the stack.
+  **
+  ** Each of the idx() entries is either 1, 2, or 3 bytes depending on
+  ** how big the total record is.  Idx(0) contains the offset to the start
+  ** of data(0).  Idx(k) contains the offset to the start of data(k).
+  ** Idx(N) contains the total number of bytes in the record.
+  */
+  nField = pOp->p1;
+  pRec = &pTos[1-nField];
+  assert( pRec>=p->aStack );
+  nByte = 0;
+  for(i=0; i<nField; i++, pRec++){
+    if( pRec->flags & MEM_Null ){
+      addUnique = pOp->p2;
+    }else{
+      Stringify(pRec);
+      nByte += pRec->n;
+    }
+  }
+  if( addUnique ) nByte += sizeof(p->uniqueCnt);
+  if( nByte + nField + 1 < 256 ){
+    idxWidth = 1;
+  }else if( nByte + 2*nField + 2 < 65536 ){
+    idxWidth = 2;
+  }else{
+    idxWidth = 3;
+  }
+  nByte += idxWidth*(nField + 1);
+  if( nByte>MAX_BYTES_PER_ROW ){
+    rc = SQLITE_TOOBIG;
+    goto abort_due_to_error;
+  }
+  if( nByte<=NBFS ){
+    zNewRecord = zTemp;
+  }else{
+    zNewRecord = sqliteMallocRaw( nByte );
+    if( zNewRecord==0 ) goto no_mem;
+  }
+  j = 0;
+  addr = idxWidth*(nField+1) + addUnique*sizeof(p->uniqueCnt);
+  for(i=0, pRec=&pTos[1-nField]; i<nField; i++, pRec++){
+    zNewRecord[j++] = addr & 0xff;
+    if( idxWidth>1 ){
+      zNewRecord[j++] = (addr>>8)&0xff;
+      if( idxWidth>2 ){
+        zNewRecord[j++] = (addr>>16)&0xff;
+      }
+    }
+    if( (pRec->flags & MEM_Null)==0 ){
+      addr += pRec->n;
+    }
+  }
+  zNewRecord[j++] = addr & 0xff;
+  if( idxWidth>1 ){
+    zNewRecord[j++] = (addr>>8)&0xff;
+    if( idxWidth>2 ){
+      zNewRecord[j++] = (addr>>16)&0xff;
+    }
+  }
+  if( addUnique ){
+    memcpy(&zNewRecord[j], &p->uniqueCnt, sizeof(p->uniqueCnt));
+    p->uniqueCnt++;
+    j += sizeof(p->uniqueCnt);
+  }
+  for(i=0, pRec=&pTos[1-nField]; i<nField; i++, pRec++){
+    if( (pRec->flags & MEM_Null)==0 ){
+      memcpy(&zNewRecord[j], pRec->z, pRec->n);
+      j += pRec->n;
+    }
+  }
+  popStack(&pTos, nField);
+  pTos++;
+  pTos->n = nByte;
+  if( nByte<=NBFS ){
+    assert( zNewRecord==zTemp );
+    memcpy(pTos->zShort, zTemp, nByte);
+    pTos->z = pTos->zShort;
+    pTos->flags = MEM_Str | MEM_Short;
+  }else{
+    assert( zNewRecord!=zTemp );
+    pTos->z = zNewRecord;
+    pTos->flags = MEM_Str | MEM_Dyn;
+  }
+  break;
+}
+
+/* Opcode: MakeKey P1 P2 P3
+**
+** Convert the top P1 entries of the stack into a single entry suitable
+** for use as the key in an index.  The top P1 records are
+** converted to strings and merged.  The null-terminators 
+** are retained and used as separators.
+** The lowest entry in the stack is the first field and the top of the
+** stack becomes the last.
+**
+** If P2 is not zero, then the original entries remain on the stack
+** and the new key is pushed on top.  If P2 is zero, the original
+** data is popped off the stack first then the new key is pushed
+** back in its place.
+**
+** P3 is a string that is P1 characters long.  Each character is either
+** an 'n' or a 't' to indicates if the argument should be intepreted as
+** numeric or text type.  The first character of P3 corresponds to the
+** lowest element on the stack.  If P3 is NULL then all arguments are
+** assumed to be of the numeric type.
+**
+** The type makes a difference in that text-type fields may not be 
+** introduced by 'b' (as described in the next paragraph).  The
+** first character of a text-type field must be either 'a' (if it is NULL)
+** or 'c'.  Numeric fields will be introduced by 'b' if their content
+** looks like a well-formed number.  Otherwise the 'a' or 'c' will be
+** used.
+**
+** The key is a concatenation of fields.  Each field is terminated by
+** a single 0x00 character.  A NULL field is introduced by an 'a' and
+** is followed immediately by its 0x00 terminator.  A numeric field is
+** introduced by a single character 'b' and is followed by a sequence
+** of characters that represent the number such that a comparison of
+** the character string using memcpy() sorts the numbers in numerical
+** order.  The character strings for numbers are generated using the
+** sqliteRealToSortable() function.  A text field is introduced by a
+** 'c' character and is followed by the exact text of the field.  The
+** use of an 'a', 'b', or 'c' character at the beginning of each field
+** guarantees that NULLs sort before numbers and that numbers sort
+** before text.  0x00 characters do not occur except as separators
+** between fields.
+**
+** See also: MakeIdxKey, SortMakeKey
+*/
+/* Opcode: MakeIdxKey P1 P2 P3
+**
+** Convert the top P1 entries of the stack into a single entry suitable
+** for use as the key in an index.  In addition, take one additional integer
+** off of the stack, treat that integer as a four-byte record number, and
+** append the four bytes to the key.  Thus a total of P1+1 entries are
+** popped from the stack for this instruction and a single entry is pushed
+** back.  The first P1 entries that are popped are strings and the last
+** entry (the lowest on the stack) is an integer record number.
+**
+** The converstion of the first P1 string entries occurs just like in
+** MakeKey.  Each entry is separated from the others by a null.
+** The entire concatenation is null-terminated.  The lowest entry
+** in the stack is the first field and the top of the stack becomes the
+** last.
+**
+** If P2 is not zero and one or more of the P1 entries that go into the
+** generated key is NULL, then jump to P2 after the new key has been
+** pushed on the stack.  In other words, jump to P2 if the key is
+** guaranteed to be unique.  This jump can be used to skip a subsequent
+** uniqueness test.
+**
+** P3 is a string that is P1 characters long.  Each character is either
+** an 'n' or a 't' to indicates if the argument should be numeric or
+** text.  The first character corresponds to the lowest element on the
+** stack.  If P3 is null then all arguments are assumed to be numeric.
+**
+** See also:  MakeKey, SortMakeKey
+*/
+case OP_MakeIdxKey:
+case OP_MakeKey: {
+  char *zNewKey;
+  int nByte;
+  int nField;
+  int addRowid;
+  int i, j;
+  int containsNull = 0;
+  Mem *pRec;
+  char zTemp[NBFS];
+
+  addRowid = pOp->opcode==OP_MakeIdxKey;
+  nField = pOp->p1;
+  pRec = &pTos[1-nField];
+  assert( pRec>=p->aStack );
+  nByte = 0;
+  for(j=0, i=0; i<nField; i++, j++, pRec++){
+    int flags = pRec->flags;
+    int len;
+    char *z;
+    if( flags & MEM_Null ){
+      nByte += 2;
+      containsNull = 1;
+    }else if( pOp->p3 && pOp->p3[j]=='t' ){
+      Stringify(pRec);
+      pRec->flags &= ~(MEM_Int|MEM_Real);
+      nByte += pRec->n+1;
+    }else if( (flags & (MEM_Real|MEM_Int))!=0 || sqliteIsNumber(pRec->z) ){
+      if( (flags & (MEM_Real|MEM_Int))==MEM_Int ){
+        pRec->r = pRec->i;
+      }else if( (flags & (MEM_Real|MEM_Int))==0 ){
+        pRec->r = sqliteAtoF(pRec->z, 0);
+      }
+      Release(pRec);
+      z = pRec->zShort;
+      sqliteRealToSortable(pRec->r, z);
+      len = strlen(z);
+      pRec->z = 0;
+      pRec->flags = MEM_Real;
+      pRec->n = len+1;
+      nByte += pRec->n+1;
+    }else{
+      nByte += pRec->n+1;
+    }
+  }
+  if( nByte+sizeof(u32)>MAX_BYTES_PER_ROW ){
+    rc = SQLITE_TOOBIG;
+    goto abort_due_to_error;
+  }
+  if( addRowid ) nByte += sizeof(u32);
+  if( nByte<=NBFS ){
+    zNewKey = zTemp;
+  }else{
+    zNewKey = sqliteMallocRaw( nByte );
+    if( zNewKey==0 ) goto no_mem;
+  }
+  j = 0;
+  pRec = &pTos[1-nField];
+  for(i=0; i<nField; i++, pRec++){
+    if( pRec->flags & MEM_Null ){
+      zNewKey[j++] = 'a';
+      zNewKey[j++] = 0;
+    }else if( pRec->flags==MEM_Real ){
+      zNewKey[j++] = 'b';
+      memcpy(&zNewKey[j], pRec->zShort, pRec->n);
+      j += pRec->n;
+    }else{
+      assert( pRec->flags & MEM_Str );
+      zNewKey[j++] = 'c';
+      memcpy(&zNewKey[j], pRec->z, pRec->n);
+      j += pRec->n;
+    }
+  }
+  if( addRowid ){
+    u32 iKey;
+    pRec = &pTos[-nField];
+    assert( pRec>=p->aStack );
+    Integerify(pRec);
+    iKey = intToKey(pRec->i);
+    memcpy(&zNewKey[j], &iKey, sizeof(u32));
+    popStack(&pTos, nField+1);
+    if( pOp->p2 && containsNull ) pc = pOp->p2 - 1;
+  }else{
+    if( pOp->p2==0 ) popStack(&pTos, nField);
+  }
+  pTos++;
+  pTos->n = nByte;
+  if( nByte<=NBFS ){
+    assert( zNewKey==zTemp );
+    pTos->z = pTos->zShort;
+    memcpy(pTos->zShort, zTemp, nByte);
+    pTos->flags = MEM_Str | MEM_Short;
+  }else{
+    pTos->z = zNewKey;
+    pTos->flags = MEM_Str | MEM_Dyn;
+  }
+  break;
+}
+
+/* Opcode: IncrKey * * *
+**
+** The top of the stack should contain an index key generated by
+** The MakeKey opcode.  This routine increases the least significant
+** byte of that key by one.  This is used so that the MoveTo opcode
+** will move to the first entry greater than the key rather than to
+** the key itself.
+*/
+case OP_IncrKey: {
+  assert( pTos>=p->aStack );
+  /* The IncrKey opcode is only applied to keys generated by
+  ** MakeKey or MakeIdxKey and the results of those operands
+  ** are always dynamic strings or zShort[] strings.  So we
+  ** are always free to modify the string in place.
+  */
+  assert( pTos->flags & (MEM_Dyn|MEM_Short) );
+  pTos->z[pTos->n-1]++;
+  break;
+}
+
+/* Opcode: Checkpoint P1 * *
+**
+** Begin a checkpoint.  A checkpoint is the beginning of a operation that
+** is part of a larger transaction but which might need to be rolled back
+** itself without effecting the containing transaction.  A checkpoint will
+** be automatically committed or rollback when the VDBE halts.
+**
+** The checkpoint is begun on the database file with index P1.  The main
+** database file has an index of 0 and the file used for temporary tables
+** has an index of 1.
+*/
+case OP_Checkpoint: {
+  int i = pOp->p1;
+  if( i>=0 && i<db->nDb && db->aDb[i].pBt && db->aDb[i].inTrans==1 ){
+    rc = sqliteBtreeBeginCkpt(db->aDb[i].pBt);
+    if( rc==SQLITE_OK ) db->aDb[i].inTrans = 2;
+  }
+  break;
+}
+
+/* Opcode: Transaction P1 * *
+**
+** Begin a transaction.  The transaction ends when a Commit or Rollback
+** opcode is encountered.  Depending on the ON CONFLICT setting, the
+** transaction might also be rolled back if an error is encountered.
+**
+** 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.
+**
+** A write lock is obtained on the database file when a transaction is
+** started.  No other process can read or write the file while the
+** transaction is underway.  Starting a transaction also creates a
+** rollback journal.  A transaction must be started before any changes
+** can be made to the database.
+*/
+case OP_Transaction: {
+  int busy = 1;
+  int i = pOp->p1;
+  assert( i>=0 && i<db->nDb );
+  if( db->aDb[i].inTrans ) break;
+  while( db->aDb[i].pBt!=0 && busy ){
+    rc = sqliteBtreeBeginTrans(db->aDb[i].pBt);
+    switch( rc ){
+      case SQLITE_BUSY: {
+        if( db->xBusyCallback==0 ){
+          p->pc = pc;
+          p->undoTransOnError = 1;
+          p->rc = SQLITE_BUSY;
+          p->pTos = pTos;
+          return SQLITE_BUSY;
+        }else if( (*db->xBusyCallback)(db->pBusyArg, "", busy++)==0 ){
+          sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);
+          busy = 0;
+        }
+        break;
+      }
+      case SQLITE_READONLY: {
+        rc = SQLITE_OK;
+        /* Fall thru into the next case */
+      }
+      case SQLITE_OK: {
+        p->inTempTrans = 0;
+        busy = 0;
+        break;
+      }
+      default: {
+        goto abort_due_to_error;
+      }
+    }
+  }
+  db->aDb[i].inTrans = 1;
+  p->undoTransOnError = 1;
+  break;
+}
+
+/* Opcode: Commit * * *
+**
+** Cause all modifications to the database that have been made since the
+** last Transaction to actually take effect.  No additional modifications
+** are allowed until another transaction is started.  The Commit instruction
+** deletes the journal file and releases the write lock on the database.
+** A read lock continues to be held if there are still cursors open.
+*/
+case OP_Commit: {
+  int i;
+  if( db->xCommitCallback!=0 ){
+    if( sqliteSafetyOff(db) ) goto abort_due_to_misuse; 
+    if( db->xCommitCallback(db->pCommitArg)!=0 ){
+      rc = SQLITE_CONSTRAINT;
+    }
+    if( sqliteSafetyOn(db) ) goto abort_due_to_misuse;
+  }
+  for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
+    if( db->aDb[i].inTrans ){
+      rc = sqliteBtreeCommit(db->aDb[i].pBt);
+      db->aDb[i].inTrans = 0;
+    }
+  }
+  if( rc==SQLITE_OK ){
+    sqliteCommitInternalChanges(db);
+  }else{
+    sqliteRollbackAll(db);
+  }
+  break;
+}
+
+/* Opcode: Rollback P1 * *
+**
+** Cause all modifications to the database that have been made since the
+** last Transaction to be undone. The database is restored to its state
+** before the Transaction opcode was executed.  No additional modifications
+** are allowed until another transaction is started.
+**
+** P1 is the index of the database file that is committed.  An index of 0
+** is used for the main database and an index of 1 is used for the file used
+** to hold temporary tables.
+**
+** This instruction automatically closes all cursors and releases both
+** the read and write locks on the indicated database.
+*/
+case OP_Rollback: {
+  sqliteRollbackAll(db);
+  break;
+}
+
+/* Opcode: ReadCookie P1 P2 *
+**
+** Read cookie number P2 from database P1 and push it onto the stack.
+** P2==0 is the schema version.  P2==1 is the database format.
+** P2==2 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: {
+  int aMeta[SQLITE_N_BTREE_META];
+  assert( pOp->p2<SQLITE_N_BTREE_META );
+  assert( pOp->p1>=0 && pOp->p1<db->nDb );
+  assert( db->aDb[pOp->p1].pBt!=0 );
+  rc = sqliteBtreeGetMeta(db->aDb[pOp->p1].pBt, aMeta);
+  pTos++;
+  pTos->i = aMeta[1+pOp->p2];
+  pTos->flags = MEM_Int;
+  break;
+}
+
+/* Opcode: SetCookie P1 P2 *
+**
+** Write the top of the stack into cookie number P2 of database P1.
+** P2==0 is the schema version.  P2==1 is the database format.
+** P2==2 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: {
+  int aMeta[SQLITE_N_BTREE_META];
+  assert( pOp->p2<SQLITE_N_BTREE_META );
+  assert( pOp->p1>=0 && pOp->p1<db->nDb );
+  assert( db->aDb[pOp->p1].pBt!=0 );
+  assert( pTos>=p->aStack );
+  Integerify(pTos)
+  rc = sqliteBtreeGetMeta(db->aDb[pOp->p1].pBt, aMeta);
+  if( rc==SQLITE_OK ){
+    aMeta[1+pOp->p2] = pTos->i;
+    rc = sqliteBtreeUpdateMeta(db->aDb[pOp->p1].pBt, aMeta);
+  }
+  Release(pTos);
+  pTos--;
+  break;
+}
+
+/* Opcode: VerifyCookie P1 P2 *
+**
+** Check the value of global database parameter number 0 (the
+** schema version) and make sure it is equal to P2.  
+** P1 is the database number which is 0 for the main database file
+** and 1 for the file holding temporary tables and some higher number
+** for auxiliary databases.
+**
+** 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.
+**
+** Either a transaction needs to have been started or an OP_Open needs
+** to be executed (to establish a read lock) before this opcode is
+** invoked.
+*/
+case OP_VerifyCookie: {
+  int aMeta[SQLITE_N_BTREE_META];
+  assert( pOp->p1>=0 && pOp->p1<db->nDb );
+  rc = sqliteBtreeGetMeta(db->aDb[pOp->p1].pBt, aMeta);
+  if( rc==SQLITE_OK && aMeta[1]!=pOp->p2 ){
+    sqliteSetString(&p->zErrMsg, "database schema has changed", (char*)0);
+    rc = SQLITE_SCHEMA;
+  }
+  break;
+}
+
+/* Opcode: OpenRead P1 P2 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 an 
+** integer from the top of the stack.  0 means the main database and
+** 1 means the database used for temporary tables.  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.
+**
+** If P2==0 then take the root page number from the next of the stack.
+**
+** There will be a read lock on the database whenever there is an
+** open cursor.  If the database was unlocked prior to this instruction
+** then a read lock is acquired as part of this instruction.  A read
+** lock allows other processes to read the database but prohibits
+** any other process from modifying the database.  The read lock is
+** released when all cursors are closed.  If this instruction attempts
+** to get a read lock but fails, the script terminates with an
+** SQLITE_BUSY error code.
+**
+** The P3 value is the name of the table or index being opened.
+** The P3 value is not actually used by this opcode and may be
+** omitted.  But the code generator usually inserts the index or
+** table name into P3 to make the code easier to read.
+**
+** See also OpenWrite.
+*/
+/* Opcode: OpenWrite P1 P2 P3
+**
+** Open a read/write cursor named P1 on the table or index whose root
+** page is P2.  If P2==0 then take the root page number from the stack.
+**
+** The P3 value is the name of the table or index being opened.
+** The P3 value is not actually used by this opcode and may be
+** omitted.  But the code generator usually inserts the index or
+** table name into P3 to make the code easier to read.
+**
+** This instruction works just like OpenRead except that it opens the cursor
+** in read/write mode.  For a given table, there can be one or more read-only
+** cursors or a single read/write cursor but not both.
+**
+** See also OpenRead.
+*/
+case OP_OpenRead:
+case OP_OpenWrite: {
+  int busy = 0;
+  int i = pOp->p1;
+  int p2 = pOp->p2;
+  int wrFlag;
+  Btree *pX;
+  int iDb;
+  
+  assert( pTos>=p->aStack );
+  Integerify(pTos);
+  iDb = pTos->i;
+  pTos--;
+  assert( iDb>=0 && iDb<db->nDb );
+  pX = db->aDb[iDb].pBt;
+  assert( pX!=0 );
+  wrFlag = pOp->opcode==OP_OpenWrite;
+  if( p2<=0 ){
+    assert( pTos>=p->aStack );
+    Integerify(pTos);
+    p2 = pTos->i;
+    pTos--;
+    if( p2<2 ){
+      sqliteSetString(&p->zErrMsg, "root page number less than 2", (char*)0);
+      rc = SQLITE_INTERNAL;
+      break;
+    }
+  }
+  assert( i>=0 );
+  if( expandCursorArraySize(p, i) ) goto no_mem;
+  sqliteVdbeCleanupCursor(&p->aCsr[i]);
+  memset(&p->aCsr[i], 0, sizeof(Cursor));
+  p->aCsr[i].nullRow = 1;
+  if( pX==0 ) break;
+  do{
+    rc = sqliteBtreeCursor(pX, p2, wrFlag, &p->aCsr[i].pCursor);
+    switch( rc ){
+      case SQLITE_BUSY: {
+        if( db->xBusyCallback==0 ){
+          p->pc = pc;
+          p->rc = SQLITE_BUSY;
+          p->pTos = &pTos[1 + (pOp->p2<=0)]; /* Operands must remain on stack */
+          return SQLITE_BUSY;
+        }else if( (*db->xBusyCallback)(db->pBusyArg, pOp->p3, ++busy)==0 ){
+          sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);
+          busy = 0;
+        }
+        break;
+      }
+      case SQLITE_OK: {
+        busy = 0;
+        break;
+      }
+      default: {
+        goto abort_due_to_error;
+      }
+    }
+  }while( busy );
+  break;
+}
+
+/* Opcode: OpenTemp P1 P2 *
+**
+** Open a new cursor to a transient table.
+** The transient cursor is always opened read/write even if 
+** the main database is read-only.  The transient table is deleted
+** automatically when the cursor is closed.
+**
+** The cursor points to a BTree table if P2==0 and to a BTree index
+** if P2==1.  A BTree table must have an integer key and can have arbitrary
+** data.  A BTree index has no data but can have an arbitrary key.
+**
+** This opcode is used for tables that exist for the duration of a single
+** SQL statement only.  Tables created using CREATE TEMPORARY TABLE
+** are opened using OP_OpenRead or OP_OpenWrite.  "Temporary" in the
+** context of this opcode means for the duration of a single SQL statement
+** whereas "Temporary" in the context of CREATE TABLE means for the duration
+** of the connection to the database.  Same word; different meanings.
+*/
+case OP_OpenTemp: {
+  int i = pOp->p1;
+  Cursor *pCx;
+  assert( i>=0 );
+  if( expandCursorArraySize(p, i) ) goto no_mem;
+  pCx = &p->aCsr[i];
+  sqliteVdbeCleanupCursor(pCx);
+  memset(pCx, 0, sizeof(*pCx));
+  pCx->nullRow = 1;
+  rc = sqliteBtreeFactory(db, 0, 1, TEMP_PAGES, &pCx->pBt);
+
+  if( rc==SQLITE_OK ){
+    rc = sqliteBtreeBeginTrans(pCx->pBt);
+  }
+  if( rc==SQLITE_OK ){
+    if( pOp->p2 ){
+      int pgno;
+      rc = sqliteBtreeCreateIndex(pCx->pBt, &pgno);
+      if( rc==SQLITE_OK ){
+        rc = sqliteBtreeCursor(pCx->pBt, pgno, 1, &pCx->pCursor);
+      }
+    }else{
+      rc = sqliteBtreeCursor(pCx->pBt, 2, 1, &pCx->pCursor);
+    }
+  }
+  break;
+}
+
+/* Opcode: OpenPseudo P1 * *
+**
+** Open a new cursor that points to a fake table that contains a single
+** row of data.  Any attempt to write a second row of data causes the
+** first row to be deleted.  All data is deleted when the cursor is
+** closed.
+**
+** A pseudo-table created by this opcode is useful for holding the
+** NEW or OLD tables in a trigger.
+*/
+case OP_OpenPseudo: {
+  int i = pOp->p1;
+  Cursor *pCx;
+  assert( i>=0 );
+  if( expandCursorArraySize(p, i) ) goto no_mem;
+  pCx = &p->aCsr[i];
+  sqliteVdbeCleanupCursor(pCx);
+  memset(pCx, 0, sizeof(*pCx));
+  pCx->nullRow = 1;
+  pCx->pseudoTable = 1;
+  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: {
+  int i = pOp->p1;
+  if( i>=0 && i<p->nCursor ){
+    sqliteVdbeCleanupCursor(&p->aCsr[i]);
+  }
+  break;
+}
+
+/* Opcode: MoveTo P1 P2 *
+**
+** Pop the top of the stack and use its value as a key.  Reposition
+** cursor P1 so that it points to an entry with a matching key.  If
+** the table contains no record with a matching key, then the cursor
+** is left pointing at the first record that is greater than the key.
+** If there are no records greater than the key and P2 is not zero,
+** then an immediate jump to P2 is made.
+**
+** See also: Found, NotFound, Distinct, MoveLt
+*/
+/* Opcode: MoveLt P1 P2 *
+**
+** Pop the top of the stack and use its value as a key.  Reposition
+** cursor P1 so that it points to the entry with the largest key that is
+** less than the key popped from the stack.
+** If there are no records less than than the key and P2
+** is not zero then an immediate jump to P2 is made.
+**
+** See also: MoveTo
+*/
+case OP_MoveLt:
+case OP_MoveTo: {
+  int i = pOp->p1;
+  Cursor *pC;
+
+  assert( pTos>=p->aStack );
+  assert( i>=0 && i<p->nCursor );
+  pC = &p->aCsr[i];
+  if( pC->pCursor!=0 ){
+    int res, oc;
+    pC->nullRow = 0;
+    if( pTos->flags & MEM_Int ){
+      int iKey = intToKey(pTos->i);
+      if( pOp->p2==0 && pOp->opcode==OP_MoveTo ){
+        pC->movetoTarget = iKey;
+        pC->deferredMoveto = 1;
+        Release(pTos);
+        pTos--;
+        break;
+      }
+      sqliteBtreeMoveto(pC->pCursor, (char*)&iKey, sizeof(int), &res);
+      pC->lastRecno = pTos->i;
+      pC->recnoIsValid = res==0;
+    }else{
+      Stringify(pTos);
+      sqliteBtreeMoveto(pC->pCursor, pTos->z, pTos->n, &res);
+      pC->recnoIsValid = 0;
+    }
+    pC->deferredMoveto = 0;
+    sqlite_search_count++;
+    oc = pOp->opcode;
+    if( oc==OP_MoveTo && res<0 ){
+      sqliteBtreeNext(pC->pCursor, &res);
+      pC->recnoIsValid = 0;
+      if( res && pOp->p2>0 ){
+        pc = pOp->p2 - 1;
+      }
+    }else if( oc==OP_MoveLt ){
+      if( res>=0 ){
+        sqliteBtreePrevious(pC->pCursor, &res);
+        pC->recnoIsValid = 0;
+      }else{
+        /* res might be negative because the table is empty.  Check to
+        ** see if this is the case.
+        */
+        int keysize;
+        res = sqliteBtreeKeySize(pC->pCursor,&keysize)!=0 || keysize==0;
+      }
+      if( res && pOp->p2>0 ){
+        pc = pOp->p2 - 1;
+      }
+    }
+  }
+  Release(pTos);
+  pTos--;
+  break;
+}
+
+/* Opcode: Distinct P1 P2 *
+**
+** Use the top of the stack as a string key.  If a record with that key does
+** not exist in the table of cursor P1, then jump to P2.  If the record
+** does already exist, then fall thru.  The cursor is left pointing
+** at the record if it exists. The key is not popped from the stack.
+**
+** This operation is similar to NotFound except that this operation
+** does not pop the key from the stack.
+**
+** See also: Found, NotFound, MoveTo, IsUnique, NotExists
+*/
+/* Opcode: Found P1 P2 *
+**
+** Use the top of the stack as a string key.  If a record with that key
+** does exist in table of P1, then jump to P2.  If the record
+** does not exist, then fall thru.  The cursor is left pointing
+** to the record if it exists.  The key is popped from the stack.
+**
+** See also: Distinct, NotFound, MoveTo, IsUnique, NotExists
+*/
+/* Opcode: NotFound P1 P2 *
+**
+** Use the top of the stack as a string key.  If a record with that key
+** does not exist in table of P1, then jump to P2.  If the record
+** does exist, then fall thru.  The cursor is left pointing to the
+** record if it exists.  The key is popped from the stack.
+**
+** The difference between this operation and Distinct is that
+** Distinct does not pop the key from the stack.
+**
+** See also: Distinct, Found, MoveTo, NotExists, IsUnique
+*/
+case OP_Distinct:
+case OP_NotFound:
+case OP_Found: {
+  int i = pOp->p1;
+  int alreadyExists = 0;
+  Cursor *pC;
+  assert( pTos>=p->aStack );
+  assert( i>=0 && i<p->nCursor );
+  if( (pC = &p->aCsr[i])->pCursor!=0 ){
+    int res, rx;
+    Stringify(pTos);
+    rx = sqliteBtreeMoveto(pC->pCursor, pTos->z, pTos->n, &res);
+    alreadyExists = rx==SQLITE_OK && res==0;
+    pC->deferredMoveto = 0;
+  }
+  if( pOp->opcode==OP_Found ){
+    if( alreadyExists ) pc = pOp->p2 - 1;
+  }else{
+    if( !alreadyExists ) pc = pOp->p2 - 1;
+  }
+  if( pOp->opcode!=OP_Distinct ){
+    Release(pTos);
+    pTos--;
+  }
+  break;
+}
+
+/* Opcode: IsUnique P1 P2 *
+**
+** The top of the stack is an integer record number.  Call this
+** record number R.  The next on the stack is an index key created
+** using MakeIdxKey.  Call it K.  This instruction pops R from the
+** stack but it leaves K unchanged.
+**
+** P1 is an index.  So all but the last four bytes of K are an
+** index string.  The last four bytes of K are a record number.
+**
+** This instruction asks if there is an entry in P1 where the
+** index string matches K but the record number is different
+** from R.  If there is no such entry, then there is an immediate
+** jump to P2.  If any entry does exist where the index string
+** matches K but the record number is not R, then the record
+** number for that entry is pushed onto the stack and control
+** falls through to the next instruction.
+**
+** See also: Distinct, NotFound, NotExists, Found
+*/
+case OP_IsUnique: {
+  int i = pOp->p1;
+  Mem *pNos = &pTos[-1];
+  BtCursor *pCrsr;
+  int R;
+
+  /* Pop the value R off the top of the stack
+  */
+  assert( pNos>=p->aStack );
+  Integerify(pTos);
+  R = pTos->i;
+  pTos--;
+  assert( i>=0 && i<=p->nCursor );
+  if( (pCrsr = p->aCsr[i].pCursor)!=0 ){
+    int res, rc;
+    int v;         /* The record number on the P1 entry that matches K */
+    char *zKey;    /* The value of K */
+    int nKey;      /* Number of bytes in K */
+
+    /* Make sure K is a string and make zKey point to K
+    */
+    Stringify(pNos);
+    zKey = pNos->z;
+    nKey = pNos->n;
+    assert( nKey >= 4 );
+
+    /* Search for an entry in P1 where all but the last four bytes match K.
+    ** If there is no such entry, jump immediately to P2.
+    */
+    assert( p->aCsr[i].deferredMoveto==0 );
+    rc = sqliteBtreeMoveto(pCrsr, zKey, nKey-4, &res);
+    if( rc!=SQLITE_OK ) goto abort_due_to_error;
+    if( res<0 ){
+      rc = sqliteBtreeNext(pCrsr, &res);
+      if( res ){
+        pc = pOp->p2 - 1;
+        break;
+      }
+    }
+    rc = sqliteBtreeKeyCompare(pCrsr, zKey, nKey-4, 4, &res);
+    if( rc!=SQLITE_OK ) goto abort_due_to_error;
+    if( res>0 ){
+      pc = pOp->p2 - 1;
+      break;
+    }
+
+    /* At this point, pCrsr is pointing to an entry in P1 where all but
+    ** the last for bytes of the key match K.  Check to see if the last
+    ** four bytes of the key are different from R.  If the last four
+    ** bytes equal R then jump immediately to P2.
+    */
+    sqliteBtreeKey(pCrsr, nKey - 4, 4, (char*)&v);
+    v = keyToInt(v);
+    if( v==R ){
+      pc = pOp->p2 - 1;
+      break;
+    }
+
+    /* The last four bytes of the key are different from R.  Convert the
+    ** last four bytes of the key into an integer and push it onto the
+    ** stack.  (These bytes are the record number of an entry that
+    ** violates a UNIQUE constraint.)
+    */
+    pTos++;
+    pTos->i = v;
+    pTos->flags = MEM_Int;
+  }
+  break;
+}
+
+/* Opcode: NotExists P1 P2 *
+**
+** Use the top of the stack as a integer key.  If a record with that key
+** does not exist in table of P1, then jump to P2.  If the record
+** does exist, then fall thru.  The cursor is left pointing to the
+** record if it exists.  The integer key is popped from the stack.
+**
+** The difference between this operation and NotFound is that this
+** operation assumes the key is an integer and NotFound assumes it
+** is a string.
+**
+** See also: Distinct, Found, MoveTo, NotFound, IsUnique
+*/
+case OP_NotExists: {
+  int i = pOp->p1;
+  BtCursor *pCrsr;
+  assert( pTos>=p->aStack );
+  assert( i>=0 && i<p->nCursor );
+  if( (pCrsr = p->aCsr[i].pCursor)!=0 ){
+    int res, rx, iKey;
+    assert( pTos->flags & MEM_Int );
+    iKey = intToKey(pTos->i);
+    rx = sqliteBtreeMoveto(pCrsr, (char*)&iKey, sizeof(int), &res);
+    p->aCsr[i].lastRecno = pTos->i;
+    p->aCsr[i].recnoIsValid = res==0;
+    p->aCsr[i].nullRow = 0;
+    if( rx!=SQLITE_OK || res!=0 ){
+      pc = pOp->p2 - 1;
+      p->aCsr[i].recnoIsValid = 0;
+    }
+  }
+  Release(pTos);
+  pTos--;
+  break;
+}
+
+/* Opcode: NewRecno P1 * *
+**
+** Get a new integer record number 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 pushed 
+** onto the stack.
+*/
+case OP_NewRecno: {
+  int i = pOp->p1;
+  int v = 0;
+  Cursor *pC;
+  assert( i>=0 && i<p->nCursor );
+  if( (pC = &p->aCsr[i])->pCursor==0 ){
+    v = 0;
+  }else{
+    /* 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 1000 times.
+    **
+    ** For a table with less than 2 billion entries, the probability
+    ** of not finding a unused rowid is about 1.0e-300.  This is a 
+    ** non-zero probability, but it is still vanishingly small and should
+    ** never cause a problem.  You are much, much more likely to have a
+    ** hardware failure than for this algorithm to fail.
+    **
+    ** The analysis in the previous paragraph assumes that you have a good
+    ** source of random numbers.  Is a library function like lrand48()
+    ** good enough?  Maybe. Maybe not. It's hard to know whether there
+    ** might be subtle bugs is some implementations of lrand48() that
+    ** could cause problems. To avoid uncertainty, SQLite uses its own 
+    ** random number generator based on the RC4 algorithm.
+    **
+    ** To promote locality of reference for repetitive inserts, the
+    ** first few attempts at chosing a random rowid pick values just a little
+    ** larger than the previous rowid.  This has been shown experimentally
+    ** to double the speed of the COPY operation.
+    */
+    int res, rx, cnt, x;
+    cnt = 0;
+    if( !pC->useRandomRowid ){
+      if( pC->nextRowidValid ){
+        v = pC->nextRowid;
+      }else{
+        rx = sqliteBtreeLast(pC->pCursor, &res);
+        if( res ){
+          v = 1;
+        }else{
+          sqliteBtreeKey(pC->pCursor, 0, sizeof(v), (void*)&v);
+          v = keyToInt(v);
+          if( v==0x7fffffff ){
+            pC->useRandomRowid = 1;
+          }else{
+            v++;
+          }
+        }
+      }
+      if( v<0x7fffffff ){
+        pC->nextRowidValid = 1;
+        pC->nextRowid = v+1;
+      }else{
+        pC->nextRowidValid = 0;
+      }
+    }
+    if( pC->useRandomRowid ){
+      v = db->priorNewRowid;
+      cnt = 0;
+      do{
+        if( v==0 || cnt>2 ){
+          sqliteRandomness(sizeof(v), &v);
+          if( cnt<5 ) v &= 0xffffff;
+        }else{
+          unsigned char r;
+          sqliteRandomness(1, &r);
+          v += r + 1;
+        }
+        if( v==0 ) continue;
+        x = intToKey(v);
+        rx = sqliteBtreeMoveto(pC->pCursor, &x, sizeof(int), &res);
+        cnt++;
+      }while( cnt<1000 && rx==SQLITE_OK && res==0 );
+      db->priorNewRowid = v;
+      if( rx==SQLITE_OK && res==0 ){
+        rc = SQLITE_FULL;
+        goto abort_due_to_error;
+      }
+    }
+    pC->recnoIsValid = 0;
+    pC->deferredMoveto = 0;
+  }
+  pTos++;
+  pTos->i = v;
+  pTos->flags = MEM_Int;
+  break;
+}
+
+/* Opcode: PutIntKey P1 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 on the top of the
+** stack.  The key is the next value down on the stack.  The key must
+** be an integer.  The stack is popped twice by this instruction.
+**
+** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is
+** incremented (otherwise not).  If the OPFLAG_CSCHANGE flag is set,
+** then the current statement change count is incremented (otherwise not).
+** If the OPFLAG_LASTROWID flag of P2 is set, then rowid is
+** stored for subsequent return by the sqlite_last_insert_rowid() function
+** (otherwise it's unmodified).
+*/
+/* Opcode: PutStrKey P1 * *
+**
+** 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 on the top of the
+** stack.  The key is the next value down on the stack.  The key must
+** be a string.  The stack is popped twice by this instruction.
+**
+** P1 may not be a pseudo-table opened using the OpenPseudo opcode.
+*/
+case OP_PutIntKey:
+case OP_PutStrKey: {
+  Mem *pNos = &pTos[-1];
+  int i = pOp->p1;
+  Cursor *pC;
+  assert( pNos>=p->aStack );
+  assert( i>=0 && i<p->nCursor );
+  if( ((pC = &p->aCsr[i])->pCursor!=0 || pC->pseudoTable) ){
+    char *zKey;
+    int nKey, iKey;
+    if( pOp->opcode==OP_PutStrKey ){
+      Stringify(pNos);
+      nKey = pNos->n;
+      zKey = pNos->z;
+    }else{
+      assert( pNos->flags & MEM_Int );
+      nKey = sizeof(int);
+      iKey = intToKey(pNos->i);
+      zKey = (char*)&iKey;
+      if( pOp->p2 & OPFLAG_NCHANGE ) db->nChange++;
+      if( pOp->p2 & OPFLAG_LASTROWID ) db->lastRowid = pNos->i;
+      if( pOp->p2 & OPFLAG_CSCHANGE ) db->csChange++;
+      if( pC->nextRowidValid && pTos->i>=pC->nextRowid ){
+        pC->nextRowidValid = 0;
+      }
+    }
+    if( pTos->flags & MEM_Null ){
+      pTos->z = 0;
+      pTos->n = 0;
+    }else{
+      assert( pTos->flags & MEM_Str );
+    }
+    if( pC->pseudoTable ){
+      /* PutStrKey does not work for pseudo-tables.
+      ** The following assert makes sure we are not trying to use
+      ** PutStrKey on a pseudo-table
+      */
+      assert( pOp->opcode==OP_PutIntKey );
+      sqliteFree(pC->pData);
+      pC->iKey = iKey;
+      pC->nData = pTos->n;
+      if( pTos->flags & MEM_Dyn ){
+        pC->pData = pTos->z;
+        pTos->flags = MEM_Null;
+      }else{
+        pC->pData = sqliteMallocRaw( pC->nData );
+        if( pC->pData ){
+          memcpy(pC->pData, pTos->z, pC->nData);
+        }
+      }
+      pC->nullRow = 0;
+    }else{
+      rc = sqliteBtreeInsert(pC->pCursor, zKey, nKey, pTos->z, pTos->n);
+    }
+    pC->recnoIsValid = 0;
+    pC->deferredMoveto = 0;
+  }
+  popStack(&pTos, 2);
+  break;
+}
+
+/* Opcode: Delete P1 P2 *
+**
+** Delete the record at which the P1 cursor is currently pointing.
+**
+** 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.  Hence it is OK to delete
+** a record from within an Next loop.
+**
+** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is
+** incremented (otherwise not).  If OPFLAG_CSCHANGE flag is set,
+** then the current statement change count is incremented (otherwise not).
+**
+** If P1 is a pseudo-table, then this instruction is a no-op.
+*/
+case OP_Delete: {
+  int i = pOp->p1;
+  Cursor *pC;
+  assert( i>=0 && i<p->nCursor );
+  pC = &p->aCsr[i];
+  if( pC->pCursor!=0 ){
+    sqliteVdbeCursorMoveto(pC);
+    rc = sqliteBtreeDelete(pC->pCursor);
+    pC->nextRowidValid = 0;
+  }
+  if( pOp->p2 & OPFLAG_NCHANGE ) db->nChange++;
+  if( pOp->p2 & OPFLAG_CSCHANGE ) db->csChange++;
+  break;
+}
+
+/* Opcode: SetCounts * * *
+**
+** Called at end of statement.  Updates lsChange (last statement change count)
+** and resets csChange (current statement change count) to 0.
+*/
+case OP_SetCounts: {
+  db->lsChange=db->csChange;
+  db->csChange=0;
+  break;
+}
+
+/* Opcode: KeyAsData P1 P2 *
+**
+** Turn the key-as-data mode for cursor P1 either on (if P2==1) or
+** off (if P2==0).  In key-as-data mode, the OP_Column opcode pulls
+** data off of the key rather than the data.  This is used for
+** processing compound selects.
+*/
+case OP_KeyAsData: {
+  int i = pOp->p1;
+  assert( i>=0 && i<p->nCursor );
+  p->aCsr[i].keyAsData = pOp->p2;
+  break;
+}
+
+/* Opcode: RowData P1 * *
+**
+** Push onto the stack the complete row data for cursor P1.
+** There is no interpretation of the data.  It is just copied
+** onto the stack exactly as it is found in the database file.
+**
+** If the cursor is not pointing to a valid row, a NULL is pushed
+** onto the stack.
+*/
+/* Opcode: RowKey P1 * *
+**
+** Push onto the stack the complete row key for cursor P1.
+** There is no interpretation of the key.  It is just copied
+** onto the stack exactly as it is found in the database file.
+**
+** If the cursor is not pointing to a valid row, a NULL is pushed
+** onto the stack.
+*/
+case OP_RowKey:
+case OP_RowData: {
+  int i = pOp->p1;
+  Cursor *pC;
+  int n;
+
+  pTos++;
+  assert( i>=0 && i<p->nCursor );
+  pC = &p->aCsr[i];
+  if( pC->nullRow ){
+    pTos->flags = MEM_Null;
+  }else if( pC->pCursor!=0 ){
+    BtCursor *pCrsr = pC->pCursor;
+    sqliteVdbeCursorMoveto(pC);
+    if( pC->nullRow ){
+      pTos->flags = MEM_Null;
+      break;
+    }else if( pC->keyAsData || pOp->opcode==OP_RowKey ){
+      sqliteBtreeKeySize(pCrsr, &n);
+    }else{
+      sqliteBtreeDataSize(pCrsr, &n);
+    }
+    pTos->n = n;
+    if( n<=NBFS ){
+      pTos->flags = MEM_Str | MEM_Short;
+      pTos->z = pTos->zShort;
+    }else{
+      char *z = sqliteMallocRaw( n );
+      if( z==0 ) goto no_mem;
+      pTos->flags = MEM_Str | MEM_Dyn;
+      pTos->z = z;
+    }
+    if( pC->keyAsData || pOp->opcode==OP_RowKey ){
+      sqliteBtreeKey(pCrsr, 0, n, pTos->z);
+    }else{
+      sqliteBtreeData(pCrsr, 0, n, pTos->z);
+    }
+  }else if( pC->pseudoTable ){
+    pTos->n = pC->nData;
+    pTos->z = pC->pData;
+    pTos->flags = MEM_Str|MEM_Ephem;
+  }else{
+    pTos->flags = MEM_Null;
+  }
+  break;
+}
+
+/* Opcode: Column P1 P2 *
+**
+** 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.)
+** Push onto the stack the value of the P2-th column contained
+** in the data.
+**
+** If the KeyAsData opcode has previously executed on this cursor,
+** then the field might be extracted from the key rather than the
+** data.
+**
+** If P1 is negative, then the record is stored on the stack rather
+** than in a table.  For P1==-1, the top of the stack is used.
+** For P1==-2, the next on the stack is used.  And so forth.  The
+** value pushed is always just a pointer into the record which is
+** stored further down on the stack.  The column value is not copied.
+*/
+case OP_Column: {
+  int amt, offset, end, payloadSize;
+  int i = pOp->p1;
+  int p2 = pOp->p2;
+  Cursor *pC;
+  char *zRec;
+  BtCursor *pCrsr;
+  int idxWidth;
+  unsigned char aHdr[10];
+
+  assert( i<p->nCursor );
+  pTos++;
+  if( i<0 ){
+    assert( &pTos[i]>=p->aStack );
+    assert( pTos[i].flags & MEM_Str );
+    zRec = pTos[i].z;
+    payloadSize = pTos[i].n;
+  }else if( (pC = &p->aCsr[i])->pCursor!=0 ){
+    sqliteVdbeCursorMoveto(pC);
+    zRec = 0;
+    pCrsr = pC->pCursor;
+    if( pC->nullRow ){
+      payloadSize = 0;
+    }else if( pC->keyAsData ){
+      sqliteBtreeKeySize(pCrsr, &payloadSize);
+    }else{
+      sqliteBtreeDataSize(pCrsr, &payloadSize);
+    }
+  }else if( pC->pseudoTable ){
+    payloadSize = pC->nData;
+    zRec = pC->pData;
+    assert( payloadSize==0 || zRec!=0 );
+  }else{
+    payloadSize = 0;
+  }
+
+  /* Figure out how many bytes in the column data and where the column
+  ** data begins.
+  */
+  if( payloadSize==0 ){
+    pTos->flags = MEM_Null;
+    break;
+  }else if( payloadSize<256 ){
+    idxWidth = 1;
+  }else if( payloadSize<65536 ){
+    idxWidth = 2;
+  }else{
+    idxWidth = 3;
+  }
+
+  /* Figure out where the requested column is stored and how big it is.
+  */
+  if( payloadSize < idxWidth*(p2+1) ){
+    rc = SQLITE_CORRUPT;
+    goto abort_due_to_error;
+  }
+  if( zRec ){
+    memcpy(aHdr, &zRec[idxWidth*p2], idxWidth*2);
+  }else if( pC->keyAsData ){
+    sqliteBtreeKey(pCrsr, idxWidth*p2, idxWidth*2, (char*)aHdr);
+  }else{
+    sqliteBtreeData(pCrsr, idxWidth*p2, idxWidth*2, (char*)aHdr);
+  }
+  offset = aHdr[0];
+  end = aHdr[idxWidth];
+  if( idxWidth>1 ){
+    offset |= aHdr[1]<<8;
+    end |= aHdr[idxWidth+1]<<8;
+    if( idxWidth>2 ){
+      offset |= aHdr[2]<<16;
+      end |= aHdr[idxWidth+2]<<16;
+    }
+  }
+  amt = end - offset;
+  if( amt<0 || offset<0 || end>payloadSize ){
+    rc = SQLITE_CORRUPT;
+    goto abort_due_to_error;
+  }
+
+  /* amt and offset now hold the offset to the start of data and the
+  ** amount of data.  Go get the data and put it on the stack.
+  */
+  pTos->n = amt;
+  if( amt==0 ){
+    pTos->flags = MEM_Null;
+  }else if( zRec ){
+    pTos->flags = MEM_Str | MEM_Ephem;
+    pTos->z = &zRec[offset];
+  }else{
+    if( amt<=NBFS ){
+      pTos->flags = MEM_Str | MEM_Short;
+      pTos->z = pTos->zShort;
+    }else{
+      char *z = sqliteMallocRaw( amt );
+      if( z==0 ) goto no_mem;
+      pTos->flags = MEM_Str | MEM_Dyn;
+      pTos->z = z;
+    }
+    if( pC->keyAsData ){
+      sqliteBtreeKey(pCrsr, offset, amt, pTos->z);
+    }else{
+      sqliteBtreeData(pCrsr, offset, amt, pTos->z);
+    }
+  }
+  break;
+}
+
+/* Opcode: Recno P1 * *
+**
+** Push onto the stack an integer which is the first 4 bytes of the
+** the key to the current entry in a sequential scan of the database
+** file P1.  The sequential scan should have been started using the 
+** Next opcode.
+*/
+case OP_Recno: {
+  int i = pOp->p1;
+  Cursor *pC;
+  int v;
+
+  assert( i>=0 && i<p->nCursor );
+  pC = &p->aCsr[i];
+  sqliteVdbeCursorMoveto(pC);
+  pTos++;
+  if( pC->recnoIsValid ){
+    v = pC->lastRecno;
+  }else if( pC->pseudoTable ){
+    v = keyToInt(pC->iKey);
+  }else if( pC->nullRow || pC->pCursor==0 ){
+    pTos->flags = MEM_Null;
+    break;
+  }else{
+    assert( pC->pCursor!=0 );
+    sqliteBtreeKey(pC->pCursor, 0, sizeof(u32), (char*)&v);
+    v = keyToInt(v);
+  }
+  pTos->i = v;
+  pTos->flags = MEM_Int;
+  break;
+}
+
+/* Opcode: FullKey P1 * *
+**
+** Extract the complete key from the record that cursor P1 is currently
+** pointing to and push the key onto the stack as a string.
+**
+** Compare this opcode to Recno.  The Recno opcode extracts the first
+** 4 bytes of the key and pushes those bytes onto the stack as an
+** integer.  This instruction pushes the entire key as a string.
+**
+** This opcode may not be used on a pseudo-table.
+*/
+case OP_FullKey: {
+  int i = pOp->p1;
+  BtCursor *pCrsr;
+
+  assert( p->aCsr[i].keyAsData );
+  assert( !p->aCsr[i].pseudoTable );
+  assert( i>=0 && i<p->nCursor );
+  pTos++;
+  if( (pCrsr = p->aCsr[i].pCursor)!=0 ){
+    int amt;
+    char *z;
+
+    sqliteVdbeCursorMoveto(&p->aCsr[i]);
+    sqliteBtreeKeySize(pCrsr, &amt);
+    if( amt<=0 ){
+      rc = SQLITE_CORRUPT;
+      goto abort_due_to_error;
+    }
+    if( amt>NBFS ){
+      z = sqliteMallocRaw( amt );
+      if( z==0 ) goto no_mem;
+      pTos->flags = MEM_Str | MEM_Dyn;
+    }else{
+      z = pTos->zShort;
+      pTos->flags = MEM_Str | MEM_Short;
+    }
+    sqliteBtreeKey(pCrsr, 0, amt, z);
+    pTos->z = z;
+    pTos->n = amt;
+  }
+  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 push 
+** a NULL onto the stack.
+*/
+case OP_NullRow: {
+  int i = pOp->p1;
+
+  assert( i>=0 && i<p->nCursor );
+  p->aCsr[i].nullRow = 1;
+  p->aCsr[i].recnoIsValid = 0;
+  break;
+}
+
+/* Opcode: Last P1 P2 *
+**
+** The next use of the Recno or Column or Next 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.
+*/
+case OP_Last: {
+  int i = pOp->p1;
+  Cursor *pC;
+  BtCursor *pCrsr;
+
+  assert( i>=0 && i<p->nCursor );
+  pC = &p->aCsr[i];
+  if( (pCrsr = pC->pCursor)!=0 ){
+    int res;
+    rc = sqliteBtreeLast(pCrsr, &res);
+    pC->nullRow = res;
+    pC->deferredMoveto = 0;
+    if( res && pOp->p2>0 ){
+      pc = pOp->p2 - 1;
+    }
+  }else{
+    pC->nullRow = 0;
+  }
+  break;
+}
+
+/* Opcode: Rewind P1 P2 *
+**
+** The next use of the Recno 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 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.
+*/
+case OP_Rewind: {
+  int i = pOp->p1;
+  Cursor *pC;
+  BtCursor *pCrsr;
+
+  assert( i>=0 && i<p->nCursor );
+  pC = &p->aCsr[i];
+  if( (pCrsr = pC->pCursor)!=0 ){
+    int res;
+    rc = sqliteBtreeFirst(pCrsr, &res);
+    pC->atFirst = res==0;
+    pC->nullRow = res;
+    pC->deferredMoveto = 0;
+    if( res && pOp->p2>0 ){
+      pc = pOp->p2 - 1;
+    }
+  }else{
+    pC->nullRow = 0;
+  }
+  break;
+}
+
+/* Opcode: Next P1 P2 *
+**
+** 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.
+**
+** See also: Prev
+*/
+/* Opcode: Prev P1 P2 *
+**
+** 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.
+*/
+case OP_Prev:
+case OP_Next: {
+  Cursor *pC;
+  BtCursor *pCrsr;
+
+  CHECK_FOR_INTERRUPT;
+  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
+  pC = &p->aCsr[pOp->p1];
+  if( (pCrsr = pC->pCursor)!=0 ){
+    int res;
+    if( pC->nullRow ){
+      res = 1;
+    }else{
+      assert( pC->deferredMoveto==0 );
+      rc = pOp->opcode==OP_Next ? sqliteBtreeNext(pCrsr, &res) :
+                                  sqliteBtreePrevious(pCrsr, &res);
+      pC->nullRow = res;
+    }
+    if( res==0 ){
+      pc = pOp->p2 - 1;
+      sqlite_search_count++;
+    }
+  }else{
+    pC->nullRow = 1;
+  }
+  pC->recnoIsValid = 0;
+  break;
+}
+
+/* Opcode: IdxPut P1 P2 P3
+**
+** The top of the stack holds a SQL index key made using the
+** MakeIdxKey instruction.  This opcode writes that key into the
+** index P1.  Data for the entry is nil.
+**
+** If P2==1, then the key must be unique.  If the key is not unique,
+** the program aborts with a SQLITE_CONSTRAINT error and the database
+** is rolled back.  If P3 is not null, then it becomes part of the
+** error message returned with the SQLITE_CONSTRAINT.
+*/
+case OP_IdxPut: {
+  int i = pOp->p1;
+  BtCursor *pCrsr;
+  assert( pTos>=p->aStack );
+  assert( i>=0 && i<p->nCursor );
+  assert( pTos->flags & MEM_Str );
+  if( (pCrsr = p->aCsr[i].pCursor)!=0 ){
+    int nKey = pTos->n;
+    const char *zKey = pTos->z;
+    if( pOp->p2 ){
+      int res, n;
+      assert( nKey >= 4 );
+      rc = sqliteBtreeMoveto(pCrsr, zKey, nKey-4, &res);
+      if( rc!=SQLITE_OK ) goto abort_due_to_error;
+      while( res!=0 ){
+        int c;
+        sqliteBtreeKeySize(pCrsr, &n);
+        if( n==nKey
+           && sqliteBtreeKeyCompare(pCrsr, zKey, nKey-4, 4, &c)==SQLITE_OK
+           && c==0
+        ){
+          rc = SQLITE_CONSTRAINT;
+          if( pOp->p3 && pOp->p3[0] ){
+            sqliteSetString(&p->zErrMsg, pOp->p3, (char*)0);
+          }
+          goto abort_due_to_error;
+        }
+        if( res<0 ){
+          sqliteBtreeNext(pCrsr, &res);
+          res = +1;
+        }else{
+          break;
+        }
+      }
+    }
+    rc = sqliteBtreeInsert(pCrsr, zKey, nKey, "", 0);
+    assert( p->aCsr[i].deferredMoveto==0 );
+  }
+  Release(pTos);
+  pTos--;
+  break;
+}
+
+/* Opcode: IdxDelete P1 * *
+**
+** The top of the stack is an index key built using the MakeIdxKey opcode.
+** This opcode removes that entry from the index.
+*/
+case OP_IdxDelete: {
+  int i = pOp->p1;
+  BtCursor *pCrsr;
+  assert( pTos>=p->aStack );
+  assert( pTos->flags & MEM_Str );
+  assert( i>=0 && i<p->nCursor );
+  if( (pCrsr = p->aCsr[i].pCursor)!=0 ){
+    int rx, res;
+    rx = sqliteBtreeMoveto(pCrsr, pTos->z, pTos->n, &res);
+    if( rx==SQLITE_OK && res==0 ){
+      rc = sqliteBtreeDelete(pCrsr);
+    }
+    assert( p->aCsr[i].deferredMoveto==0 );
+  }
+  Release(pTos);
+  pTos--;
+  break;
+}
+
+/* Opcode: IdxRecno P1 * *
+**
+** Push onto the stack an integer which is the last 4 bytes of the
+** the key to the current entry in index P1.  These 4 bytes should
+** be the record number of the table entry to which this index entry
+** points.
+**
+** See also: Recno, MakeIdxKey.
+*/
+case OP_IdxRecno: {
+  int i = pOp->p1;
+  BtCursor *pCrsr;
+
+  assert( i>=0 && i<p->nCursor );
+  pTos++;
+  if( (pCrsr = p->aCsr[i].pCursor)!=0 ){
+    int v;
+    int sz;
+    assert( p->aCsr[i].deferredMoveto==0 );
+    sqliteBtreeKeySize(pCrsr, &sz);
+    if( sz<sizeof(u32) ){
+      pTos->flags = MEM_Null;
+    }else{
+      sqliteBtreeKey(pCrsr, sz - sizeof(u32), sizeof(u32), (char*)&v);
+      v = keyToInt(v);
+      pTos->i = v;
+      pTos->flags = MEM_Int;
+    }
+  }else{
+    pTos->flags = MEM_Null;
+  }
+  break;
+}
+
+/* Opcode: IdxGT P1 P2 *
+**
+** Compare the top of the stack against the key on the index entry that
+** cursor P1 is currently pointing to.  Ignore the last 4 bytes of the
+** index entry.  If the index entry is greater than the top of the stack
+** then jump to P2.  Otherwise fall through to the next instruction.
+** In either case, the stack is popped once.
+*/
+/* Opcode: IdxGE P1 P2 *
+**
+** Compare the top of the stack against the key on the index entry that
+** cursor P1 is currently pointing to.  Ignore the last 4 bytes of the
+** index entry.  If the index entry is greater than or equal to 
+** the top of the stack
+** then jump to P2.  Otherwise fall through to the next instruction.
+** In either case, the stack is popped once.
+*/
+/* Opcode: IdxLT P1 P2 *
+**
+** Compare the top of the stack against the key on the index entry that
+** cursor P1 is currently pointing to.  Ignore the last 4 bytes of the
+** index entry.  If the index entry is less than the top of the stack
+** then jump to P2.  Otherwise fall through to the next instruction.
+** In either case, the stack is popped once.
+*/
+case OP_IdxLT:
+case OP_IdxGT:
+case OP_IdxGE: {
+  int i= pOp->p1;
+  BtCursor *pCrsr;
+
+  assert( i>=0 && i<p->nCursor );
+  assert( pTos>=p->aStack );
+  if( (pCrsr = p->aCsr[i].pCursor)!=0 ){
+    int res, rc;
+ 
+    Stringify(pTos);
+    assert( p->aCsr[i].deferredMoveto==0 );
+    rc = sqliteBtreeKeyCompare(pCrsr, pTos->z, pTos->n, 4, &res);
+    if( rc!=SQLITE_OK ){
+      break;
+    }
+    if( pOp->opcode==OP_IdxLT ){
+      res = -res;
+    }else if( pOp->opcode==OP_IdxGE ){
+      res++;
+    }
+    if( res>0 ){
+      pc = pOp->p2 - 1 ;
+    }
+  }
+  Release(pTos);
+  pTos--;
+  break;
+}
+
+/* Opcode: IdxIsNull P1 P2 *
+**
+** The top of the stack contains an index entry such as might be generated
+** by the MakeIdxKey opcode.  This routine looks at the first P1 fields of
+** that key.  If any of the first P1 fields are NULL, then a jump is made
+** to address P2.  Otherwise we fall straight through.
+**
+** The index entry is always popped from the stack.
+*/
+case OP_IdxIsNull: {
+  int i = pOp->p1;
+  int k, n;
+  const char *z;
+
+  assert( pTos>=p->aStack );
+  assert( pTos->flags & MEM_Str );
+  z = pTos->z;
+  n = pTos->n;
+  for(k=0; k<n && i>0; i--){
+    if( z[k]=='a' ){
+      pc = pOp->p2-1;
+      break;
+    }
+    while( k<n && z[k] ){ k++; }
+    k++;
+  }
+  Release(pTos);
+  pTos--;
+  break;
+}
+
+/* Opcode: Destroy P1 P2 *
+**
+** 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 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.
+**
+** See also: Clear
+*/
+case OP_Destroy: {
+  rc = sqliteBtreeDropTable(db->aDb[pOp->p2].pBt, pOp->p1);
+  break;
+}
+
+/* Opcode: Clear P1 P2 *
+**
+** 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.
+**
+** See also: Destroy
+*/
+case OP_Clear: {
+  rc = sqliteBtreeClearTable(db->aDb[pOp->p2].pBt, pOp->p1);
+  break;
+}
+
+/* Opcode: CreateTable * P2 P3
+**
+** Allocate a new table in the main database file if P2==0 or in the
+** auxiliary database file if P2==1.  Push the page number
+** for the root page of the new table onto the stack.
+**
+** The root page number is also written to a memory location that P3
+** points to.  This is the mechanism is used to write the root page
+** number into the parser's internal data structures that describe the
+** new table.
+**
+** The difference between a table and an index is this:  A table must
+** have a 4-byte integer key and can have arbitrary data.  An index
+** has an arbitrary key but no data.
+**
+** See also: CreateIndex
+*/
+/* Opcode: CreateIndex * P2 P3
+**
+** Allocate a new index in the main database file if P2==0 or in the
+** auxiliary database file if P2==1.  Push the page number of the
+** root page of the new index onto the stack.
+**
+** See documentation on OP_CreateTable for additional information.
+*/
+case OP_CreateIndex:
+case OP_CreateTable: {
+  int pgno;
+  assert( pOp->p3!=0 && pOp->p3type==P3_POINTER );
+  assert( pOp->p2>=0 && pOp->p2<db->nDb );
+  assert( db->aDb[pOp->p2].pBt!=0 );
+  if( pOp->opcode==OP_CreateTable ){
+    rc = sqliteBtreeCreateTable(db->aDb[pOp->p2].pBt, &pgno);
+  }else{
+    rc = sqliteBtreeCreateIndex(db->aDb[pOp->p2].pBt, &pgno);
+  }
+  pTos++;
+  if( rc==SQLITE_OK ){
+    pTos->i = pgno;
+    pTos->flags = MEM_Int;
+    *(u32*)pOp->p3 = pgno;
+    pOp->p3 = 0;
+  }else{
+    pTos->flags = MEM_Null;
+  }
+  break;
+}
+
+/* Opcode: IntegrityCk P1 P2 *
+**
+** Do an analysis of the currently open database.  Push onto the
+** stack the text of an error message describing any problems.
+** If there are no errors, push a "ok" onto the stack.
+**
+** P1 is the index of a set that contains the root page numbers
+** for all tables and indices in the main database file.  The set
+** is cleared by this opcode.  In other words, after this opcode
+** has executed, the set will be empty.
+**
+** If P2 is not zero, the check is done on the auxiliary database
+** file, not the main database file.
+**
+** This opcode is used for testing purposes only.
+*/
+case OP_IntegrityCk: {
+  int nRoot;
+  int *aRoot;
+  int iSet = pOp->p1;
+  Set *pSet;
+  int j;
+  HashElem *i;
+  char *z;
+
+  assert( iSet>=0 && iSet<p->nSet );
+  pTos++;
+  pSet = &p->aSet[iSet];
+  nRoot = sqliteHashCount(&pSet->hash);
+  aRoot = sqliteMallocRaw( sizeof(int)*(nRoot+1) );
+  if( aRoot==0 ) goto no_mem;
+  for(j=0, i=sqliteHashFirst(&pSet->hash); i; i=sqliteHashNext(i), j++){
+    toInt((char*)sqliteHashKey(i), &aRoot[j]);
+  }
+  aRoot[j] = 0;
+  sqliteHashClear(&pSet->hash);
+  pSet->prev = 0;
+  z = sqliteBtreeIntegrityCheck(db->aDb[pOp->p2].pBt, aRoot, nRoot);
+  if( z==0 || z[0]==0 ){
+    if( z ) sqliteFree(z);
+    pTos->z = "ok";
+    pTos->n = 3;
+    pTos->flags = MEM_Str | MEM_Static;
+  }else{
+    pTos->z = z;
+    pTos->n = strlen(z) + 1;
+    pTos->flags = MEM_Str | MEM_Dyn;
+  }
+  sqliteFree(aRoot);
+  break;
+}
+
+/* Opcode: ListWrite * * *
+**
+** Write the integer on the top of the stack
+** into the temporary storage list.
+*/
+case OP_ListWrite: {
+  Keylist *pKeylist;
+  assert( pTos>=p->aStack );
+  pKeylist = p->pList;
+  if( pKeylist==0 || pKeylist->nUsed>=pKeylist->nKey ){
+    pKeylist = sqliteMallocRaw( sizeof(Keylist)+999*sizeof(pKeylist->aKey[0]) );
+    if( pKeylist==0 ) goto no_mem;
+    pKeylist->nKey = 1000;
+    pKeylist->nRead = 0;
+    pKeylist->nUsed = 0;
+    pKeylist->pNext = p->pList;
+    p->pList = pKeylist;
+  }
+  Integerify(pTos);
+  pKeylist->aKey[pKeylist->nUsed++] = pTos->i;
+  Release(pTos);
+  pTos--;
+  break;
+}
+
+/* Opcode: ListRewind * * *
+**
+** Rewind the temporary buffer back to the beginning.
+*/
+case OP_ListRewind: {
+  /* What this opcode codes, really, is reverse the order of the
+  ** linked list of Keylist structures so that they are read out
+  ** in the same order that they were read in. */
+  Keylist *pRev, *pTop;
+  pRev = 0;
+  while( p->pList ){
+    pTop = p->pList;
+    p->pList = pTop->pNext;
+    pTop->pNext = pRev;
+    pRev = pTop;
+  }
+  p->pList = pRev;
+  break;
+}
+
+/* Opcode: ListRead * P2 *
+**
+** Attempt to read an integer from the temporary storage buffer
+** and push it onto the stack.  If the storage buffer is empty, 
+** push nothing but instead jump to P2.
+*/
+case OP_ListRead: {
+  Keylist *pKeylist;
+  CHECK_FOR_INTERRUPT;
+  pKeylist = p->pList;
+  if( pKeylist!=0 ){
+    assert( pKeylist->nRead>=0 );
+    assert( pKeylist->nRead<pKeylist->nUsed );
+    assert( pKeylist->nRead<pKeylist->nKey );
+    pTos++;
+    pTos->i = pKeylist->aKey[pKeylist->nRead++];
+    pTos->flags = MEM_Int;
+    if( pKeylist->nRead>=pKeylist->nUsed ){
+      p->pList = pKeylist->pNext;
+      sqliteFree(pKeylist);
+    }
+  }else{
+    pc = pOp->p2 - 1;
+  }
+  break;
+}
+
+/* Opcode: ListReset * * *
+**
+** Reset the temporary storage buffer so that it holds nothing.
+*/
+case OP_ListReset: {
+  if( p->pList ){
+    sqliteVdbeKeylistFree(p->pList);
+    p->pList = 0;
+  }
+  break;
+}
+
+/* Opcode: ListPush * * * 
+**
+** Save the current Vdbe list such that it can be restored by a ListPop
+** opcode. The list is empty after this is executed.
+*/
+case OP_ListPush: {
+  p->keylistStackDepth++;
+  assert(p->keylistStackDepth > 0);
+  p->keylistStack = sqliteRealloc(p->keylistStack, 
+          sizeof(Keylist *) * p->keylistStackDepth);
+  if( p->keylistStack==0 ) goto no_mem;
+  p->keylistStack[p->keylistStackDepth - 1] = p->pList;
+  p->pList = 0;
+  break;
+}
+
+/* Opcode: ListPop * * * 
+**
+** Restore the Vdbe list to the state it was in when ListPush was last
+** executed.
+*/
+case OP_ListPop: {
+  assert(p->keylistStackDepth > 0);
+  p->keylistStackDepth--;
+  sqliteVdbeKeylistFree(p->pList);
+  p->pList = p->keylistStack[p->keylistStackDepth];
+  p->keylistStack[p->keylistStackDepth] = 0;
+  if( p->keylistStackDepth == 0 ){
+    sqliteFree(p->keylistStack);
+    p->keylistStack = 0;
+  }
+  break;
+}
+
+/* Opcode: ContextPush * * * 
+**
+** Save the current Vdbe context such that it can be restored by a ContextPop
+** opcode. The context stores the last insert row id, the last statement change
+** count, and the current statement change count.
+*/
+case OP_ContextPush: {
+  p->contextStackDepth++;
+  assert(p->contextStackDepth > 0);
+  p->contextStack = sqliteRealloc(p->contextStack, 
+          sizeof(Context) * p->contextStackDepth);
+  if( p->contextStack==0 ) goto no_mem;
+  p->contextStack[p->contextStackDepth - 1].lastRowid = p->db->lastRowid;
+  p->contextStack[p->contextStackDepth - 1].lsChange = p->db->lsChange;
+  p->contextStack[p->contextStackDepth - 1].csChange = p->db->csChange;
+  break;
+}
+
+/* Opcode: ContextPop * * * 
+**
+** Restore the Vdbe context to the state it was in when contextPush was last
+** executed. The context stores the last insert row id, the last statement
+** change count, and the current statement change count.
+*/
+case OP_ContextPop: {
+  assert(p->contextStackDepth > 0);
+  p->contextStackDepth--;
+  p->db->lastRowid = p->contextStack[p->contextStackDepth].lastRowid;
+  p->db->lsChange = p->contextStack[p->contextStackDepth].lsChange;
+  p->db->csChange = p->contextStack[p->contextStackDepth].csChange;
+  if( p->contextStackDepth == 0 ){
+    sqliteFree(p->contextStack);
+    p->contextStack = 0;
+  }
+  break;
+}
+
+/* Opcode: SortPut * * *
+**
+** The TOS is the key and the NOS is the data.  Pop both from the stack
+** and put them on the sorter.  The key and data should have been
+** made using SortMakeKey and SortMakeRec, respectively.
+*/
+case OP_SortPut: {
+  Mem *pNos = &pTos[-1];
+  Sorter *pSorter;
+  assert( pNos>=p->aStack );
+  if( Dynamicify(pTos) || Dynamicify(pNos) ) goto no_mem;
+  pSorter = sqliteMallocRaw( sizeof(Sorter) );
+  if( pSorter==0 ) goto no_mem;
+  pSorter->pNext = p->pSort;
+  p->pSort = pSorter;
+  assert( pTos->flags & MEM_Dyn );
+  pSorter->nKey = pTos->n;
+  pSorter->zKey = pTos->z;
+  assert( pNos->flags & MEM_Dyn );
+  pSorter->nData = pNos->n;
+  pSorter->pData = pNos->z;
+  pTos -= 2;
+  break;
+}
+
+/* Opcode: SortMakeRec P1 * *
+**
+** The top P1 elements are the arguments to a callback.  Form these
+** elements into a single data entry that can be stored on a sorter
+** using SortPut and later fed to a callback using SortCallback.
+*/
+case OP_SortMakeRec: {
+  char *z;
+  char **azArg;
+  int nByte;
+  int nField;
+  int i;
+  Mem *pRec;
+
+  nField = pOp->p1;
+  pRec = &pTos[1-nField];
+  assert( pRec>=p->aStack );
+  nByte = 0;
+  for(i=0; i<nField; i++, pRec++){
+    if( (pRec->flags & MEM_Null)==0 ){
+      Stringify(pRec);
+      nByte += pRec->n;
+    }
+  }
+  nByte += sizeof(char*)*(nField+1);
+  azArg = sqliteMallocRaw( nByte );
+  if( azArg==0 ) goto no_mem;
+  z = (char*)&azArg[nField+1];
+  for(pRec=&pTos[1-nField], i=0; i<nField; i++, pRec++){
+    if( pRec->flags & MEM_Null ){
+      azArg[i] = 0;
+    }else{
+      azArg[i] = z;
+      memcpy(z, pRec->z, pRec->n);
+      z += pRec->n;
+    }
+  }
+  popStack(&pTos, nField);
+  pTos++;
+  pTos->n = nByte;
+  pTos->z = (char*)azArg;
+  pTos->flags = MEM_Str | MEM_Dyn;
+  break;
+}
+
+/* Opcode: SortMakeKey * * P3
+**
+** Convert the top few entries of the stack into a sort key.  The
+** number of stack entries consumed is the number of characters in 
+** the string P3.  One character from P3 is prepended to each entry.
+** The first character of P3 is prepended to the element lowest in
+** the stack and the last character of P3 is prepended to the top of
+** the stack.  All stack entries are separated by a \000 character
+** in the result.  The whole key is terminated by two \000 characters
+** in a row.
+**
+** "N" is substituted in place of the P3 character for NULL values.
+**
+** See also the MakeKey and MakeIdxKey opcodes.
+*/
+case OP_SortMakeKey: {
+  char *zNewKey;
+  int nByte;
+  int nField;
+  int i, j, k;
+  Mem *pRec;
+
+  nField = strlen(pOp->p3);
+  pRec = &pTos[1-nField];
+  nByte = 1;
+  for(i=0; i<nField; i++, pRec++){
+    if( pRec->flags & MEM_Null ){
+      nByte += 2;
+    }else{
+      Stringify(pRec);
+      nByte += pRec->n+2;
+    }
+  }
+  zNewKey = sqliteMallocRaw( nByte );
+  if( zNewKey==0 ) goto no_mem;
+  j = 0;
+  k = 0;
+  for(pRec=&pTos[1-nField], i=0; i<nField; i++, pRec++){
+    if( pRec->flags & MEM_Null ){
+      zNewKey[j++] = 'N';
+      zNewKey[j++] = 0;
+      k++;
+    }else{
+      zNewKey[j++] = pOp->p3[k++];
+      memcpy(&zNewKey[j], pRec->z, pRec->n-1);
+      j += pRec->n-1;
+      zNewKey[j++] = 0;
+    }
+  }
+  zNewKey[j] = 0;
+  assert( j<nByte );
+  popStack(&pTos, nField);
+  pTos++;
+  pTos->n = nByte;
+  pTos->flags = MEM_Str|MEM_Dyn;
+  pTos->z = zNewKey;
+  break;
+}
+
+/* Opcode: Sort * * *
+**
+** Sort all elements on the sorter.  The algorithm is a
+** mergesort.
+*/
+case OP_Sort: {
+  int i;
+  Sorter *pElem;
+  Sorter *apSorter[NSORT];
+  for(i=0; i<NSORT; i++){
+    apSorter[i] = 0;
+  }
+  while( p->pSort ){
+    pElem = p->pSort;
+    p->pSort = pElem->pNext;
+    pElem->pNext = 0;
+    for(i=0; i<NSORT-1; i++){
+    if( apSorter[i]==0 ){
+        apSorter[i] = pElem;
+        break;
+      }else{
+        pElem = Merge(apSorter[i], pElem);
+        apSorter[i] = 0;
+      }
+    }
+    if( i>=NSORT-1 ){
+      apSorter[NSORT-1] = Merge(apSorter[NSORT-1],pElem);
+    }
+  }
+  pElem = 0;
+  for(i=0; i<NSORT; i++){
+    pElem = Merge(apSorter[i], pElem);
+  }
+  p->pSort = pElem;
+  break;
+}
+
+/* Opcode: SortNext * P2 *
+**
+** Push the data for the topmost element in the sorter onto the
+** stack, then remove the element from the sorter.  If the sorter
+** is empty, push nothing on the stack and instead jump immediately 
+** to instruction P2.
+*/
+case OP_SortNext: {
+  Sorter *pSorter = p->pSort;
+  CHECK_FOR_INTERRUPT;
+  if( pSorter!=0 ){
+    p->pSort = pSorter->pNext;
+    pTos++;
+    pTos->z = pSorter->pData;
+    pTos->n = pSorter->nData;
+    pTos->flags = MEM_Str|MEM_Dyn;
+    sqliteFree(pSorter->zKey);
+    sqliteFree(pSorter);
+  }else{
+    pc = pOp->p2 - 1;
+  }
+  break;
+}
+
+/* Opcode: SortCallback P1 * *
+**
+** The top of the stack contains a callback record built using
+** the SortMakeRec operation with the same P1 value as this
+** instruction.  Pop this record from the stack and invoke the
+** callback on it.
+*/
+case OP_SortCallback: {
+  assert( pTos>=p->aStack );
+  assert( pTos->flags & MEM_Str );
+  p->nCallback++;
+  p->pc = pc+1;
+  p->azResColumn = (char**)pTos->z;
+  assert( p->nResColumn==pOp->p1 );
+  p->popStack = 1;
+  p->pTos = pTos;
+  return SQLITE_ROW;
+}
+
+/* Opcode: SortReset * * *
+**
+** Remove any elements that remain on the sorter.
+*/
+case OP_SortReset: {
+  sqliteVdbeSorterReset(p);
+  break;
+}
+
+/* Opcode: FileOpen * * P3
+**
+** Open the file named by P3 for reading using the FileRead opcode.
+** If P3 is "stdin" then open standard input for reading.
+*/
+case OP_FileOpen: {
+  assert( pOp->p3!=0 );
+  if( p->pFile ){
+    if( p->pFile!=stdin ) fclose(p->pFile);
+    p->pFile = 0;
+  }
+  if( sqliteStrICmp(pOp->p3,"stdin")==0 ){
+    p->pFile = stdin;
+  }else{
+    p->pFile = fopen(pOp->p3, "r");
+  }
+  if( p->pFile==0 ){
+    sqliteSetString(&p->zErrMsg,"unable to open file: ", pOp->p3, (char*)0);
+    rc = SQLITE_ERROR;
+  }
+  break;
+}
+
+/* Opcode: FileRead P1 P2 P3
+**
+** Read a single line of input from the open file (the file opened using
+** FileOpen).  If we reach end-of-file, jump immediately to P2.  If
+** we are able to get another line, split the line apart using P3 as
+** a delimiter.  There should be P1 fields.  If the input line contains
+** more than P1 fields, ignore the excess.  If the input line contains
+** fewer than P1 fields, assume the remaining fields contain NULLs.
+**
+** Input ends if a line consists of just "\.".  A field containing only
+** "\N" is a null field.  The backslash \ character can be used be used
+** to escape newlines or the delimiter.
+*/
+case OP_FileRead: {
+  int n, eol, nField, i, c, nDelim;
+  char *zDelim, *z;
+  CHECK_FOR_INTERRUPT;
+  if( p->pFile==0 ) goto fileread_jump;
+  nField = pOp->p1;
+  if( nField<=0 ) goto fileread_jump;
+  if( nField!=p->nField || p->azField==0 ){
+    char **azField = sqliteRealloc(p->azField, sizeof(char*)*nField+1);
+    if( azField==0 ){ goto no_mem; }
+    p->azField = azField;
+    p->nField = nField;
+  }
+  n = 0;
+  eol = 0;
+  while( eol==0 ){
+    if( p->zLine==0 || n+200>p->nLineAlloc ){
+      char *zLine;
+      p->nLineAlloc = p->nLineAlloc*2 + 300;
+      zLine = sqliteRealloc(p->zLine, p->nLineAlloc);
+      if( zLine==0 ){
+        p->nLineAlloc = 0;
+        sqliteFree(p->zLine);
+        p->zLine = 0;
+        goto no_mem;
+      }
+      p->zLine = zLine;
+    }
+    if( vdbe_fgets(&p->zLine[n], p->nLineAlloc-n, p->pFile)==0 ){
+      eol = 1;
+      p->zLine[n] = 0;
+    }else{
+      int c;
+      while( (c = p->zLine[n])!=0 ){
+        if( c=='\\' ){
+          if( p->zLine[n+1]==0 ) break;
+          n += 2;
+        }else if( c=='\n' ){
+          p->zLine[n] = 0;
+          eol = 1;
+          break;
+        }else{
+          n++;
+        }
+      }
+    }
+  }
+  if( n==0 ) goto fileread_jump;
+  z = p->zLine;
+  if( z[0]=='\\' && z[1]=='.' && z[2]==0 ){
+    goto fileread_jump;
+  }
+  zDelim = pOp->p3;
+  if( zDelim==0 ) zDelim = "\t";
+  c = zDelim[0];
+  nDelim = strlen(zDelim);
+  p->azField[0] = z;
+  for(i=1; *z!=0 && i<=nField; i++){
+    int from, to;
+    from = to = 0;
+    if( z[0]=='\\' && z[1]=='N' 
+       && (z[2]==0 || strncmp(&z[2],zDelim,nDelim)==0) ){
+      if( i<=nField ) p->azField[i-1] = 0;
+      z += 2 + nDelim;
+      if( i<nField ) p->azField[i] = z;
+      continue;
+    }
+    while( z[from] ){
+      if( z[from]=='\\' && z[from+1]!=0 ){
+        int tx = z[from+1];
+        switch( tx ){
+          case 'b':  tx = '\b'; break;
+          case 'f':  tx = '\f'; break;
+          case 'n':  tx = '\n'; break;
+          case 'r':  tx = '\r'; break;
+          case 't':  tx = '\t'; break;
+          case 'v':  tx = '\v'; break;
+          default:   break;
+        }
+        z[to++] = tx;
+        from += 2;
+        continue;
+      }
+      if( z[from]==c && strncmp(&z[from],zDelim,nDelim)==0 ) break;
+      z[to++] = z[from++];
+    }
+    if( z[from] ){
+      z[to] = 0;
+      z += from + nDelim;
+      if( i<nField ) p->azField[i] = z;
+    }else{
+      z[to] = 0;
+      z = "";
+    }
+  }
+  while( i<nField ){
+    p->azField[i++] = 0;
+  }
+  break;
+
+  /* If we reach end-of-file, or if anything goes wrong, jump here.
+  ** This code will cause a jump to P2 */
+fileread_jump:
+  pc = pOp->p2 - 1;
+  break;
+}
+
+/* Opcode: FileColumn P1 * *
+**
+** Push onto the stack the P1-th column of the most recently read line
+** from the input file.
+*/
+case OP_FileColumn: {
+  int i = pOp->p1;
+  char *z;
+  assert( i>=0 && i<p->nField );
+  if( p->azField ){
+    z = p->azField[i];
+  }else{
+    z = 0;
+  }
+  pTos++;
+  if( z ){
+    pTos->n = strlen(z) + 1;
+    pTos->z = z;
+    pTos->flags = MEM_Str | MEM_Ephem;
+  }else{
+    pTos->flags = MEM_Null;
+  }
+  break;
+}
+
+/* Opcode: MemStore P1 P2 *
+**
+** Write the top of the stack into memory location P1.
+** P1 should be a small integer since space is allocated
+** for all memory locations between 0 and P1 inclusive.
+**
+** After the data is stored in the memory location, the
+** stack is popped once if P2 is 1.  If P2 is zero, then
+** the original data remains on the stack.
+*/
+case OP_MemStore: {
+  int i = pOp->p1;
+  Mem *pMem;
+  assert( pTos>=p->aStack );
+  if( i>=p->nMem ){
+    int nOld = p->nMem;
+    Mem *aMem;
+    p->nMem = i + 5;
+    aMem = sqliteRealloc(p->aMem, p->nMem*sizeof(p->aMem[0]));
+    if( aMem==0 ) goto no_mem;
+    if( aMem!=p->aMem ){
+      int j;
+      for(j=0; j<nOld; j++){
+        if( aMem[j].flags & MEM_Short ){
+          aMem[j].z = aMem[j].zShort;
+        }
+      }
+    }
+    p->aMem = aMem;
+    if( nOld<p->nMem ){
+      memset(&p->aMem[nOld], 0, sizeof(p->aMem[0])*(p->nMem-nOld));
+    }
+  }
+  Deephemeralize(pTos);
+  pMem = &p->aMem[i];
+  Release(pMem);
+  *pMem = *pTos;
+  if( pMem->flags & MEM_Dyn ){
+    if( pOp->p2 ){
+      pTos->flags = MEM_Null;
+    }else{
+      pMem->z = sqliteMallocRaw( pMem->n );
+      if( pMem->z==0 ) goto no_mem;
+      memcpy(pMem->z, pTos->z, pMem->n);
+    }
+  }else if( pMem->flags & MEM_Short ){
+    pMem->z = pMem->zShort;
+  }
+  if( pOp->p2 ){
+    Release(pTos);
+    pTos--;
+  }
+  break;
+}
+
+/* Opcode: MemLoad P1 * *
+**
+** Push a copy of the value in memory location P1 onto the stack.
+**
+** If the value is a string, then the value pushed is a pointer to
+** the string that is stored in the memory location.  If the memory
+** location is subsequently changed (using OP_MemStore) then the
+** value pushed onto the stack will change too.
+*/
+case OP_MemLoad: {
+  int i = pOp->p1;
+  assert( i>=0 && i<p->nMem );
+  pTos++;
+  memcpy(pTos, &p->aMem[i], sizeof(pTos[0])-NBFS);;
+  if( pTos->flags & MEM_Str ){
+    pTos->flags |= MEM_Ephem;
+    pTos->flags &= ~(MEM_Dyn|MEM_Static|MEM_Short);
+  }
+  break;
+}
+
+/* Opcode: MemIncr P1 P2 *
+**
+** Increment the integer valued memory cell P1 by 1.  If P2 is not zero
+** and the result after the increment is greater than zero, then jump
+** to P2.
+**
+** This instruction throws an error if the memory cell is not initially
+** an integer.
+*/
+case OP_MemIncr: {
+  int i = pOp->p1;
+  Mem *pMem;
+  assert( i>=0 && i<p->nMem );
+  pMem = &p->aMem[i];
+  assert( pMem->flags==MEM_Int );
+  pMem->i++;
+  if( pOp->p2>0 && pMem->i>0 ){
+     pc = pOp->p2 - 1;
+  }
+  break;
+}
+
+/* Opcode: AggReset * P2 *
+**
+** Reset the aggregator so that it no longer contains any data.
+** Future aggregator elements will contain P2 values each.
+*/
+case OP_AggReset: {
+  sqliteVdbeAggReset(&p->agg);
+  p->agg.nMem = pOp->p2;
+  p->agg.apFunc = sqliteMalloc( p->agg.nMem*sizeof(p->agg.apFunc[0]) );
+  if( p->agg.apFunc==0 ) goto no_mem;
+  break;
+}
+
+/* Opcode: AggInit * P2 P3
+**
+** Initialize the function parameters for an aggregate function.
+** The aggregate will operate out of aggregate column P2.
+** P3 is a pointer to the FuncDef structure for the function.
+*/
+case OP_AggInit: {
+  int i = pOp->p2;
+  assert( i>=0 && i<p->agg.nMem );
+  p->agg.apFunc[i] = (FuncDef*)pOp->p3;
+  break;
+}
+
+/* Opcode: AggFunc * P2 P3
+**
+** Execute the step function for an aggregate.  The
+** function has P2 arguments.  P3 is a pointer to the FuncDef
+** structure that specifies the function.
+**
+** The top of the stack must be an integer which is the index of
+** the aggregate column that corresponds to this aggregate function.
+** Ideally, this index would be another parameter, but there are
+** no free parameters left.  The integer is popped from the stack.
+*/
+case OP_AggFunc: {
+  int n = pOp->p2;
+  int i;
+  Mem *pMem, *pRec;
+  char **azArgv = p->zArgv;
+  sqlite_func ctx;
+
+  assert( n>=0 );
+  assert( pTos->flags==MEM_Int );
+  pRec = &pTos[-n];
+  assert( pRec>=p->aStack );
+  for(i=0; i<n; i++, pRec++){
+    if( pRec->flags & MEM_Null ){
+      azArgv[i] = 0;
+    }else{
+      Stringify(pRec);
+      azArgv[i] = pRec->z;
+    }
+  }
+  i = pTos->i;
+  assert( i>=0 && i<p->agg.nMem );
+  ctx.pFunc = (FuncDef*)pOp->p3;
+  pMem = &p->agg.pCurrent->aMem[i];
+  ctx.s.z = pMem->zShort;  /* Space used for small aggregate contexts */
+  ctx.pAgg = pMem->z;
+  ctx.cnt = ++pMem->i;
+  ctx.isError = 0;
+  ctx.isStep = 1;
+  (ctx.pFunc->xStep)(&ctx, n, (const char**)azArgv);
+  pMem->z = ctx.pAgg;
+  pMem->flags = MEM_AggCtx;
+  popStack(&pTos, n+1);
+  if( ctx.isError ){
+    rc = SQLITE_ERROR;
+  }
+  break;
+}
+
+/* Opcode: AggFocus * P2 *
+**
+** Pop the top of the stack and use that as an aggregator key.  If
+** an aggregator with that same key already exists, then make the
+** aggregator the current aggregator and jump to P2.  If no aggregator
+** with the given key exists, create one and make it current but
+** do not jump.
+**
+** The order of aggregator opcodes is important.  The order is:
+** AggReset AggFocus AggNext.  In other words, you must execute
+** AggReset first, then zero or more AggFocus operations, then
+** zero or more AggNext operations.  You must not execute an AggFocus
+** in between an AggNext and an AggReset.
+*/
+case OP_AggFocus: {
+  AggElem *pElem;
+  char *zKey;
+  int nKey;
+
+  assert( pTos>=p->aStack );
+  Stringify(pTos);
+  zKey = pTos->z;
+  nKey = pTos->n;
+  pElem = sqliteHashFind(&p->agg.hash, zKey, nKey);
+  if( pElem ){
+    p->agg.pCurrent = pElem;
+    pc = pOp->p2 - 1;
+  }else{
+    AggInsert(&p->agg, zKey, nKey);
+    if( sqlite_malloc_failed ) goto no_mem;
+  }
+  Release(pTos);
+  pTos--;
+  break; 
+}
+
+/* Opcode: AggSet * P2 *
+**
+** Move the top of the stack into the P2-th field of the current
+** aggregate.  String values are duplicated into new memory.
+*/
+case OP_AggSet: {
+  AggElem *pFocus = AggInFocus(p->agg);
+  Mem *pMem;
+  int i = pOp->p2;
+  assert( pTos>=p->aStack );
+  if( pFocus==0 ) goto no_mem;
+  assert( i>=0 && i<p->agg.nMem );
+  Deephemeralize(pTos);
+  pMem = &pFocus->aMem[i];
+  Release(pMem);
+  *pMem = *pTos;
+  if( pMem->flags & MEM_Dyn ){
+    pTos->flags = MEM_Null;
+  }else if( pMem->flags & MEM_Short ){
+    pMem->z = pMem->zShort;
+  }
+  Release(pTos);
+  pTos--;
+  break;
+}
+
+/* Opcode: AggGet * P2 *
+**
+** Push a new entry onto the stack which is a copy of the P2-th field
+** of the current aggregate.  Strings are not duplicated so
+** string values will be ephemeral.
+*/
+case OP_AggGet: {
+  AggElem *pFocus = AggInFocus(p->agg);
+  Mem *pMem;
+  int i = pOp->p2;
+  if( pFocus==0 ) goto no_mem;
+  assert( i>=0 && i<p->agg.nMem );
+  pTos++;
+  pMem = &pFocus->aMem[i];
+  *pTos = *pMem;
+  if( pTos->flags & MEM_Str ){
+    pTos->flags &= ~(MEM_Dyn|MEM_Static|MEM_Short);
+    pTos->flags |= MEM_Ephem;
+  }
+  if( pTos->flags & MEM_AggCtx ){
+    Release(pTos);
+    pTos->flags = MEM_Null;
+  }
+  break;
+}
+
+/* Opcode: AggNext * P2 *
+**
+** Make the next aggregate value the current aggregate.  The prior
+** aggregate is deleted.  If all aggregate values have been consumed,
+** jump to P2.
+**
+** The order of aggregator opcodes is important.  The order is:
+** AggReset AggFocus AggNext.  In other words, you must execute
+** AggReset first, then zero or more AggFocus operations, then
+** zero or more AggNext operations.  You must not execute an AggFocus
+** in between an AggNext and an AggReset.
+*/
+case OP_AggNext: {
+  CHECK_FOR_INTERRUPT;
+  if( p->agg.pSearch==0 ){
+    p->agg.pSearch = sqliteHashFirst(&p->agg.hash);
+  }else{
+    p->agg.pSearch = sqliteHashNext(p->agg.pSearch);
+  }
+  if( p->agg.pSearch==0 ){
+    pc = pOp->p2 - 1;
+  } else {
+    int i;
+    sqlite_func ctx;
+    Mem *aMem;
+    p->agg.pCurrent = sqliteHashData(p->agg.pSearch);
+    aMem = p->agg.pCurrent->aMem;
+    for(i=0; i<p->agg.nMem; i++){
+      int freeCtx;
+      if( p->agg.apFunc[i]==0 ) continue;
+      if( p->agg.apFunc[i]->xFinalize==0 ) continue;
+      ctx.s.flags = MEM_Null;
+      ctx.s.z = aMem[i].zShort;
+      ctx.pAgg = (void*)aMem[i].z;
+      freeCtx = aMem[i].z && aMem[i].z!=aMem[i].zShort;
+      ctx.cnt = aMem[i].i;
+      ctx.isStep = 0;
+      ctx.pFunc = p->agg.apFunc[i];
+      (*p->agg.apFunc[i]->xFinalize)(&ctx);
+      if( freeCtx ){
+        sqliteFree( aMem[i].z );
+      }
+      aMem[i] = ctx.s;
+      if( aMem[i].flags & MEM_Short ){
+        aMem[i].z = aMem[i].zShort;
+      }
+    }
+  }
+  break;
+}
+
+/* Opcode: SetInsert P1 * P3
+**
+** If Set P1 does not exist then create it.  Then insert value
+** P3 into that set.  If P3 is NULL, then insert the top of the
+** stack into the set.
+*/
+case OP_SetInsert: {
+  int i = pOp->p1;
+  if( p->nSet<=i ){
+    int k;
+    Set *aSet = sqliteRealloc(p->aSet, (i+1)*sizeof(p->aSet[0]) );
+    if( aSet==0 ) goto no_mem;
+    p->aSet = aSet;
+    for(k=p->nSet; k<=i; k++){
+      sqliteHashInit(&p->aSet[k].hash, SQLITE_HASH_BINARY, 1);
+    }
+    p->nSet = i+1;
+  }
+  if( pOp->p3 ){
+    sqliteHashInsert(&p->aSet[i].hash, pOp->p3, strlen(pOp->p3)+1, p);
+  }else{
+    assert( pTos>=p->aStack );
+    Stringify(pTos);
+    sqliteHashInsert(&p->aSet[i].hash, pTos->z, pTos->n, p);
+    Release(pTos);
+    pTos--;
+  }
+  if( sqlite_malloc_failed ) goto no_mem;
+  break;
+}
+
+/* Opcode: SetFound P1 P2 *
+**
+** Pop the stack once and compare the value popped off with the
+** contents of set P1.  If the element popped exists in set P1,
+** then jump to P2.  Otherwise fall through.
+*/
+case OP_SetFound: {
+  int i = pOp->p1;
+  assert( pTos>=p->aStack );
+  Stringify(pTos);
+  if( i>=0 && i<p->nSet && sqliteHashFind(&p->aSet[i].hash, pTos->z, pTos->n)){
+    pc = pOp->p2 - 1;
+  }
+  Release(pTos);
+  pTos--;
+  break;
+}
+
+/* Opcode: SetNotFound P1 P2 *
+**
+** Pop the stack once and compare the value popped off with the
+** contents of set P1.  If the element popped does not exists in 
+** set P1, then jump to P2.  Otherwise fall through.
+*/
+case OP_SetNotFound: {
+  int i = pOp->p1;
+  assert( pTos>=p->aStack );
+  Stringify(pTos);
+  if( i<0 || i>=p->nSet ||
+       sqliteHashFind(&p->aSet[i].hash, pTos->z, pTos->n)==0 ){
+    pc = pOp->p2 - 1;
+  }
+  Release(pTos);
+  pTos--;
+  break;
+}
+
+/* Opcode: SetFirst P1 P2 *
+**
+** Read the first element from set P1 and push it onto the stack.  If the
+** set is empty, push nothing and jump immediately to P2.  This opcode is
+** used in combination with OP_SetNext to loop over all elements of a set.
+*/
+/* Opcode: SetNext P1 P2 *
+**
+** Read the next element from set P1 and push it onto the stack.  If there
+** are no more elements in the set, do not do the push and fall through.
+** Otherwise, jump to P2 after pushing the next set element.
+*/
+case OP_SetFirst: 
+case OP_SetNext: {
+  Set *pSet;
+  CHECK_FOR_INTERRUPT;
+  if( pOp->p1<0 || pOp->p1>=p->nSet ){
+    if( pOp->opcode==OP_SetFirst ) pc = pOp->p2 - 1;
+    break;
+  }
+  pSet = &p->aSet[pOp->p1];
+  if( pOp->opcode==OP_SetFirst ){
+    pSet->prev = sqliteHashFirst(&pSet->hash);
+    if( pSet->prev==0 ){
+      pc = pOp->p2 - 1;
+      break;
+    }
+  }else{
+    if( pSet->prev ){
+      pSet->prev = sqliteHashNext(pSet->prev);
+    }
+    if( pSet->prev==0 ){
+      break;
+    }else{
+      pc = pOp->p2 - 1;
+    }
+  }
+  pTos++;
+  pTos->z = sqliteHashKey(pSet->prev);
+  pTos->n = sqliteHashKeysize(pSet->prev);
+  pTos->flags = MEM_Str | MEM_Ephem;
+  break;
+}
+
+/* Opcode: Vacuum * * *
+**
+** Vacuum the entire database.  This opcode will cause other virtual
+** machines to be created and run.  It may not be called from within
+** a transaction.
+*/
+case OP_Vacuum: {
+  if( sqliteSafetyOff(db) ) goto abort_due_to_misuse; 
+  rc = sqliteRunVacuum(&p->zErrMsg, db);
+  if( sqliteSafetyOn(db) ) goto abort_due_to_misuse;
+  break;
+}
+
+/* Opcode: StackDepth * * *
+**
+** Push an integer onto the stack which is the depth of the stack prior
+** to that integer being pushed.
+*/
+case OP_StackDepth: {
+  int depth = (&pTos[1]) - p->aStack;
+  pTos++;
+  pTos->i = depth;
+  pTos->flags = MEM_Int;
+  break;
+}
+
+/* Opcode: StackReset * * *
+**
+** Pop a single integer off of the stack.  Then pop the stack
+** as many times as necessary to get the depth of the stack down
+** to the value of the integer that was popped.
+*/
+case OP_StackReset: {
+  int depth, goal;
+  assert( pTos>=p->aStack );
+  Integerify(pTos);
+  goal = pTos->i;
+  depth = (&pTos[1]) - p->aStack;
+  assert( goal<depth );
+  popStack(&pTos, depth-goal);
+  break;
+}
+
+/* An other opcode is illegal...
+*/
+default: {
+  sqlite_snprintf(sizeof(zBuf),zBuf,"%d",pOp->opcode);
+  sqliteSetString(&p->zErrMsg, "unknown opcode ", zBuf, (char*)0);
+  rc = SQLITE_INTERNAL;
+  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
+    {
+      long long elapse = hwtime() - start;
+      pOp->cycles += elapse;
+      pOp->cnt++;
+#if 0
+        fprintf(stdout, "%10lld ", elapse);
+        sqliteVdbePrintOp(stdout, origPc, &p->aOp[origPc]);
+#endif
+    }
+#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
+    /* Sanity checking on the top element of the stack */
+    if( pTos>=p->aStack ){
+      assert( pTos->flags!=0 );  /* Must define some type */
+      if( pTos->flags & MEM_Str ){
+        int x = pTos->flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short);
+        assert( x!=0 );            /* Strings must define a string subtype */
+        assert( (x & (x-1))==0 );  /* Only one string subtype can be defined */
+        assert( pTos->z!=0 );      /* Strings must have a value */
+        /* Mem.z points to Mem.zShort iff the subtype is MEM_Short */
+        assert( (pTos->flags & MEM_Short)==0 || pTos->z==pTos->zShort );
+        assert( (pTos->flags & MEM_Short)!=0 || pTos->z!=pTos->zShort );
+      }else{
+        /* Cannot define a string subtype for non-string objects */
+        assert( (pTos->flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short))==0 );
+      }
+      /* MEM_Null excludes all other types */
+      assert( pTos->flags==MEM_Null || (pTos->flags&MEM_Null)==0 );
+    }
+    if( pc<-1 || pc>=p->nOp ){
+      sqliteSetString(&p->zErrMsg, "jump destination out of range", (char*)0);
+      rc = SQLITE_INTERNAL;
+    }
+    if( p->trace && pTos>=p->aStack ){
+      int i;
+      fprintf(p->trace, "Stack:");
+      for(i=0; i>-5 && &pTos[i]>=p->aStack; i--){
+        if( pTos[i].flags & MEM_Null ){
+          fprintf(p->trace, " NULL");
+        }else if( (pTos[i].flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){
+          fprintf(p->trace, " si:%d", pTos[i].i);
+        }else if( pTos[i].flags & MEM_Int ){
+          fprintf(p->trace, " i:%d", pTos[i].i);
+        }else if( pTos[i].flags & MEM_Real ){
+          fprintf(p->trace, " r:%g", pTos[i].r);
+        }else if( pTos[i].flags & MEM_Str ){
+          int j, k;
+          char zBuf[100];
+          zBuf[0] = ' ';
+          if( pTos[i].flags & MEM_Dyn ){
+            zBuf[1] = 'z';
+            assert( (pTos[i].flags & (MEM_Static|MEM_Ephem))==0 );
+          }else if( pTos[i].flags & MEM_Static ){
+            zBuf[1] = 't';
+            assert( (pTos[i].flags & (MEM_Dyn|MEM_Ephem))==0 );
+          }else if( pTos[i].flags & MEM_Ephem ){
+            zBuf[1] = 'e';
+            assert( (pTos[i].flags & (MEM_Static|MEM_Dyn))==0 );
+          }else{
+            zBuf[1] = 's';
+          }
+          zBuf[2] = '[';
+          k = 3;
+          for(j=0; j<20 && j<pTos[i].n; j++){
+            int c = pTos[i].z[j];
+            if( c==0 && j==pTos[i].n-1 ) break;
+            if( isprint(c) && !isspace(c) ){
+              zBuf[k++] = c;
+            }else{
+              zBuf[k++] = '.';
+            }
+          }
+          zBuf[k++] = ']';
+          zBuf[k++] = 0;
+          fprintf(p->trace, "%s", zBuf);
+        }else{
+          fprintf(p->trace, " ???");
+        }
+      }
+      if( rc!=0 ) fprintf(p->trace," rc=%d",rc);
+      fprintf(p->trace,"\n");
+    }
+#endif
+  }  /* The end of the for(;;) loop the loops through opcodes */
+
+  /* If we reach this point, it means that execution is finished.
+  */
+vdbe_halt:
+  CHECK_FOR_INTERRUPT
+  if( rc ){
+    p->rc = rc;
+    rc = SQLITE_ERROR;
+  }else{
+    rc = SQLITE_DONE;
+  }
+  p->magic = VDBE_MAGIC_HALT;
+  p->pTos = pTos;
+  return rc;
+
+  /* Jump to here if a malloc() fails.  It's hard to get a malloc()
+  ** to fail on a modern VM computer, so this code is untested.
+  */
+no_mem:
+  sqliteSetString(&p->zErrMsg, "out of memory", (char*)0);
+  rc = SQLITE_NOMEM;
+  goto vdbe_halt;
+
+  /* Jump to here for an SQLITE_MISUSE error.
+  */
+abort_due_to_misuse:
+  rc = SQLITE_MISUSE;
+  /* Fall thru into abort_due_to_error */
+
+  /* Jump to here for any other kind of fatal error.  The "rc" variable
+  ** should hold the error number.
+  */
+abort_due_to_error:
+  if( p->zErrMsg==0 ){
+    if( sqlite_malloc_failed ) rc = SQLITE_NOMEM;
+    sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);
+  }
+  goto vdbe_halt;
+
+  /* Jump to here if the sqlite_interrupt() API sets the interrupt
+  ** flag.
+  */
+abort_due_to_interrupt:
+  assert( db->flags & SQLITE_Interrupt );
+  db->flags &= ~SQLITE_Interrupt;
+  if( db->magic!=SQLITE_MAGIC_BUSY ){
+    rc = SQLITE_MISUSE;
+  }else{
+    rc = SQLITE_INTERRUPT;
+  }
+  sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);
+  goto vdbe_halt;
+}