diff --git a/Makefile.in b/Makefile.in
index 7fef9f575b..567f31215f 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -1187,6 +1187,22 @@ sqlite3_analyzer.c: sqlite3.c $(TOP)/src/tclsqlite.c $(TOP)/tool/spaceanal.tcl $
 sqlite3_analyzer$(TEXE): sqlite3_analyzer.c
 	$(LTLINK) sqlite3_analyzer.c -o $@ $(LIBTCL) $(TLIBS)
 
+CHECKER_DEPS =\
+  $(TOP)/tool/mkccode.tcl \
+  sqlite3.c \
+  $(TOP)/src/tclsqlite.c \
+  $(TOP)/ext/repair/sqlite3_checker.tcl \
+  $(TOP)/ext/repair/checkindex.c \
+  $(TOP)/ext/repair/checkfreelist.c \
+  $(TOP)/ext/misc/btreeinfo.c \
+  $(TOP)/ext/repair/sqlite3_checker.c.in
+
+sqlite3_checker.c:	$(CHECKER_DEPS)
+	$(TCLSH_CMD) $(TOP)/tool/mkccode.tcl $(TOP)/ext/repair/sqlite3_checker.c.in >$@
+
+sqlite3_checker$(TEXE):	sqlite3_checker.c
+	$(LTLINK) sqlite3_checker.c -o $@ $(LIBTCL) $(TLIBS)
+
 dbdump$(TEXE): $(TOP)/ext/misc/dbdump.c sqlite3.lo
 	$(LTLINK) -DDBDUMP_STANDALONE -o $@ \
            $(TOP)/ext/misc/dbdump.c sqlite3.lo $(TLIBS)
diff --git a/Makefile.msc b/Makefile.msc
index d663b753bf..9c834931d7 100644
--- a/Makefile.msc
+++ b/Makefile.msc
@@ -1491,6 +1491,7 @@ TESTPROGS = \
   testfixture.exe \
   $(SQLITE3EXE) \
   sqlite3_analyzer.exe \
+  sqlite3_checker.exe \
   sqldiff.exe \
   dbhash.exe
 
@@ -2197,6 +2198,23 @@ sqlite3_analyzer.exe:	sqlite3_analyzer.c $(LIBRESOBJS)
 	$(LTLINK) $(NO_WARN) -DBUILD_sqlite -I$(TCLINCDIR) sqlite3_analyzer.c \
 		/link $(LDFLAGS) $(LTLINKOPTS) $(LTLIBPATHS) $(LIBRESOBJS) $(LTLIBS) $(TLIBS)
 
+CHECKER_DEPS =\
+  $(TOP)/tool/mkccode.tcl \
+  sqlite3.c \
+  $(TOP)/src/tclsqlite.c \
+  $(TOP)/ext/repair/sqlite3_checker.tcl \
+  $(TOP)/ext/repair/checkindex.c \
+  $(TOP)/ext/repair/checkfreelist.c \
+  $(TOP)/ext/misc/btreeinfo.c \
+  $(TOP)/ext/repair/sqlite3_checker.c.in
+
+sqlite3_checker.c:	$(CHECKER_DEPS)
+	$(TCLSH_CMD) $(TOP)\tool\mkccode.tcl $(TOP)\ext\repair\sqlite3_checker.c.in > $@
+
+sqlite3_checker.exe:	sqlite3_checker.c $(LIBRESOBJS)
+	$(LTLINK) $(NO_WARN) -DBUILD_sqlite -I$(TCLINCDIR) sqlite3_checker.c \
+		/link $(LDFLAGS) $(LTLINKOPTS) $(LTLIBPATHS) $(LIBRESOBJS) $(LTLIBS) $(TLIBS)
+
 dbdump.exe:	$(TOP)\ext\misc\dbdump.c $(SQLITE3C) $(SQLITE3H)
 	$(LTLINK) $(NO_WARN) -DDBDUMP_STANDALONE $(TOP)\ext\misc\dbdump.c $(SQLITE3C) \
 		/link $(LDFLAGS) $(LTLINKOPTS) $(LTLIBPATHS) $(LIBRESOBJS) $(LTLIBS)
diff --git a/ext/misc/btreeinfo.c b/ext/misc/btreeinfo.c
index 131c63e835..d75f06277f 100644
--- a/ext/misc/btreeinfo.c
+++ b/ext/misc/btreeinfo.c
@@ -61,7 +61,9 @@
 **      SELECT name FROM sqlite_btreeinfo
 **       WHERE type='table' AND NOT hasRowid;
 */
-#include <sqlite3ext.h>
+#if !defined(SQLITEINT_H)
+#include "sqlite3ext.h"
+#endif
 SQLITE_EXTENSION_INIT1
 #include <string.h>
 #include <assert.h>
diff --git a/ext/misc/spellfix.c b/ext/misc/spellfix.c
index 1ac1712f4e..4f17b88e1d 100644
--- a/ext/misc/spellfix.c
+++ b/ext/misc/spellfix.c
@@ -1122,15 +1122,17 @@ static int editDist3Install(sqlite3 *db){
   if( pConfig==0 ) return SQLITE_NOMEM;
   memset(pConfig, 0, sizeof(*pConfig));
   rc = sqlite3_create_function_v2(db, "editdist3",
-              2, SQLITE_UTF8, pConfig, editDist3SqlFunc, 0, 0, 0);
+              2, SQLITE_UTF8|SQLITE_DETERMINISTIC, pConfig,
+              editDist3SqlFunc, 0, 0, 0);
   if( rc==SQLITE_OK ){
     rc = sqlite3_create_function_v2(db, "editdist3",
-                3, SQLITE_UTF8, pConfig, editDist3SqlFunc, 0, 0, 0);
+                3, SQLITE_UTF8|SQLITE_DETERMINISTIC, pConfig,
+                editDist3SqlFunc, 0, 0, 0);
   }
   if( rc==SQLITE_OK ){
     rc = sqlite3_create_function_v2(db, "editdist3",
-                1, SQLITE_UTF8, pConfig, editDist3SqlFunc, 0, 0,
-                editDist3ConfigDelete);
+                1, SQLITE_UTF8|SQLITE_DETERMINISTIC, pConfig,
+                editDist3SqlFunc, 0, 0, editDist3ConfigDelete);
   }else{
     sqlite3_free(pConfig);
   }
@@ -2895,18 +2897,22 @@ static sqlite3_module spellfix1Module = {
 static int spellfix1Register(sqlite3 *db){
   int rc = SQLITE_OK;
   int i;
-  rc = sqlite3_create_function(db, "spellfix1_translit", 1, SQLITE_UTF8, 0,
-                                  transliterateSqlFunc, 0, 0);
+  rc = sqlite3_create_function(db, "spellfix1_translit", 1,
+                               SQLITE_UTF8|SQLITE_DETERMINISTIC, 0,
+                                transliterateSqlFunc, 0, 0);
   if( rc==SQLITE_OK ){
-    rc = sqlite3_create_function(db, "spellfix1_editdist", 2, SQLITE_UTF8, 0,
+    rc = sqlite3_create_function(db, "spellfix1_editdist", 2,
+                                 SQLITE_UTF8|SQLITE_DETERMINISTIC, 0,
                                   editdistSqlFunc, 0, 0);
   }
   if( rc==SQLITE_OK ){
-    rc = sqlite3_create_function(db, "spellfix1_phonehash", 1, SQLITE_UTF8, 0,
+    rc = sqlite3_create_function(db, "spellfix1_phonehash", 1,
+                                 SQLITE_UTF8|SQLITE_DETERMINISTIC, 0,
                                   phoneticHashSqlFunc, 0, 0);
   }
   if( rc==SQLITE_OK ){
-    rc = sqlite3_create_function(db, "spellfix1_scriptcode", 1, SQLITE_UTF8, 0,
+    rc = sqlite3_create_function(db, "spellfix1_scriptcode", 1,
+                                  SQLITE_UTF8|SQLITE_DETERMINISTIC, 0,
                                   scriptCodeSqlFunc, 0, 0);
   }
   if( rc==SQLITE_OK ){
diff --git a/ext/repair/checkfreelist.c b/ext/repair/checkfreelist.c
index cd2801e040..990be4afa7 100644
--- a/ext/repair/checkfreelist.c
+++ b/ext/repair/checkfreelist.c
@@ -166,7 +166,7 @@ static int checkFreelist(
     u32 i;
     u32 iTrunk = (u32)sqlite3_column_int(pTrunk, 0);
     const u8 *aData = (const u8*)sqlite3_column_blob(pTrunk, 1);
-    int nData = sqlite3_column_bytes(pTrunk, 1);
+    u32 nData = (u32)sqlite3_column_bytes(pTrunk, 1);
     u32 iNext = get4byte(&aData[0]);
     u32 nLeaf = get4byte(&aData[4]);
 
diff --git a/ext/repair/checkindex.c b/ext/repair/checkindex.c
new file mode 100644
index 0000000000..fa8c713f7c
--- /dev/null
+++ b/ext/repair/checkindex.c
@@ -0,0 +1,828 @@
+/*
+** 2017 October 27
+**
+** 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.
+**
+*************************************************************************
+*/
+
+#include "sqlite3ext.h"
+SQLITE_EXTENSION_INIT1
+
+#ifndef SQLITE_AMALGAMATION
+# include <string.h>
+# include <stdio.h>
+# include <stdlib.h>
+# include <assert.h>
+# define ALWAYS(X)  1
+# define NEVER(X)   0
+  typedef unsigned char u8;
+  typedef unsigned short u16;
+  typedef unsigned int u32;
+#define get4byte(x) (        \
+    ((u32)((x)[0])<<24) +    \
+    ((u32)((x)[1])<<16) +    \
+    ((u32)((x)[2])<<8) +     \
+    ((u32)((x)[3]))          \
+)
+#endif
+
+typedef struct CidxTable CidxTable;
+typedef struct CidxCursor CidxCursor;
+
+struct CidxTable {
+  sqlite3_vtab base;              /* Base class.  Must be first */
+  sqlite3 *db;
+};
+
+struct CidxCursor {
+  sqlite3_vtab_cursor base;       /* Base class.  Must be first */
+  sqlite3_int64 iRowid;
+  sqlite3_stmt *pStmt;
+};
+
+typedef struct CidxColumn CidxColumn;
+struct CidxColumn {
+  char *zExpr;                    /* Text for indexed expression */
+  int bDesc;                      /* True for DESC columns, otherwise false */
+  int bKey;                       /* Part of index, not PK */
+};
+
+typedef struct CidxIndex CidxIndex;
+struct CidxIndex {
+  int nCol;                       /* Elements in aCol[] array */
+  CidxColumn aCol[1];             /* Array of indexed columns */
+};
+
+static void *cidxMalloc(int *pRc, int n){
+  void *pRet = 0;
+  assert( n!=0 );
+  if( *pRc==SQLITE_OK ){
+    pRet = sqlite3_malloc(n);
+    if( pRet ){
+      memset(pRet, 0, n);
+    }else{
+      *pRc = SQLITE_NOMEM;
+    }
+  }
+  return pRet;
+}
+
+static void cidxCursorError(CidxCursor *pCsr, const char *zFmt, ...){
+  va_list ap;
+  va_start(ap, zFmt);
+  assert( pCsr->base.pVtab->zErrMsg==0 );
+  pCsr->base.pVtab->zErrMsg = sqlite3_vmprintf(zFmt, ap);
+  va_end(ap);
+}
+
+/*
+** Connect to then incremental_index_check virtual table.
+*/
+static int cidxConnect(
+  sqlite3 *db,
+  void *pAux,
+  int argc, const char *const*argv,
+  sqlite3_vtab **ppVtab,
+  char **pzErr
+){
+  int rc = SQLITE_OK;
+  CidxTable *pRet;
+
+#define IIC_ERRMSG        0
+#define IIC_CURRENT_KEY   1
+#define IIC_INDEX_NAME    2
+#define IIC_AFTER_KEY     3
+  rc = sqlite3_declare_vtab(db,
+      "CREATE TABLE xyz("
+      " errmsg TEXT, current_key TEXT,"
+      " index_name HIDDEN, after_key HIDDEN"
+      ")"
+  );
+  pRet = cidxMalloc(&rc, sizeof(CidxTable));
+  if( pRet ){
+    pRet->db = db;
+  }
+
+  *ppVtab = (sqlite3_vtab*)pRet;
+  return rc;
+}
+
+/*
+** Disconnect from or destroy an incremental_index_check virtual table.
+*/
+static int cidxDisconnect(sqlite3_vtab *pVtab){
+  CidxTable *pTab = (CidxTable*)pVtab;
+  sqlite3_free(pTab);
+  return SQLITE_OK;
+}
+
+/*
+** xBestIndex method.
+*/
+static int cidxBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pInfo){
+  int iIdxName = -1;
+  int iAfterKey = -1;
+  int i;
+
+  for(i=0; i<pInfo->nConstraint; i++){
+    struct sqlite3_index_constraint *p = &pInfo->aConstraint[i];
+    if( p->usable==0 ) continue;
+    if( p->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
+
+    if( p->iColumn==IIC_INDEX_NAME ){
+      iIdxName = i;
+    }
+    if( p->iColumn==IIC_AFTER_KEY ){
+      iAfterKey = i;
+    }
+  }
+
+  if( iIdxName<0 ){
+    pInfo->estimatedCost = 1000000000.0;
+  }else{
+    pInfo->aConstraintUsage[iIdxName].argvIndex = 1;
+    pInfo->aConstraintUsage[iIdxName].omit = 1;
+    if( iAfterKey<0 ){
+      pInfo->estimatedCost = 1000000.0;
+    }else{
+      pInfo->aConstraintUsage[iAfterKey].argvIndex = 2;
+      pInfo->aConstraintUsage[iAfterKey].omit = 1;
+      pInfo->estimatedCost = 1000.0;
+    }
+  }
+
+  return SQLITE_OK;
+}
+
+/*
+** Open a new btreeinfo cursor.
+*/
+static int cidxOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
+  CidxCursor *pRet;
+  int rc = SQLITE_OK;
+
+  pRet = cidxMalloc(&rc, sizeof(CidxCursor));
+
+  *ppCursor = (sqlite3_vtab_cursor*)pRet;
+  return rc;
+}
+
+/*
+** Close a btreeinfo cursor.
+*/
+static int cidxClose(sqlite3_vtab_cursor *pCursor){
+  CidxCursor *pCsr = (CidxCursor*)pCursor;
+  sqlite3_finalize(pCsr->pStmt);
+  pCsr->pStmt = 0;
+  sqlite3_free(pCsr);
+  return SQLITE_OK;
+}
+
+/*
+** Move a btreeinfo cursor to the next entry in the file.
+*/
+static int cidxNext(sqlite3_vtab_cursor *pCursor){
+  CidxCursor *pCsr = (CidxCursor*)pCursor;
+  int rc = sqlite3_step(pCsr->pStmt);
+  if( rc!=SQLITE_ROW ){
+    rc = sqlite3_finalize(pCsr->pStmt);
+    pCsr->pStmt = 0;
+    if( rc!=SQLITE_OK ){
+      sqlite3 *db = ((CidxTable*)pCsr->base.pVtab)->db;
+      cidxCursorError(pCsr, "Cursor error: %s", sqlite3_errmsg(db));
+    }
+  }else{
+    pCsr->iRowid++;
+    rc = SQLITE_OK;
+  }
+  return rc;
+}
+
+/* We have reached EOF if previous sqlite3_step() returned
+** anything other than SQLITE_ROW;
+*/
+static int cidxEof(sqlite3_vtab_cursor *pCursor){
+  CidxCursor *pCsr = (CidxCursor*)pCursor;
+  return pCsr->pStmt==0;
+}
+
+static char *cidxMprintf(int *pRc, const char *zFmt, ...){
+  char *zRet = 0;
+  va_list ap;
+  va_start(ap, zFmt);
+  zRet = sqlite3_vmprintf(zFmt, ap);
+  if( *pRc==SQLITE_OK ){
+    if( zRet==0 ){
+      *pRc = SQLITE_NOMEM;
+    }
+  }else{
+    sqlite3_free(zRet);
+    zRet = 0;
+  }
+  va_end(ap);
+  return zRet;
+}
+
+static sqlite3_stmt *cidxPrepare(
+  int *pRc, CidxCursor *pCsr, const char *zFmt, ...
+){
+  sqlite3_stmt *pRet = 0;
+  char *zSql;
+  va_list ap;                     /* ... printf arguments */
+  va_start(ap, zFmt);
+
+  zSql = sqlite3_vmprintf(zFmt, ap);
+  if( *pRc==SQLITE_OK ){
+    if( zSql==0 ){
+      *pRc = SQLITE_NOMEM;
+    }else{
+      sqlite3 *db = ((CidxTable*)pCsr->base.pVtab)->db;
+      *pRc = sqlite3_prepare_v2(db, zSql, -1, &pRet, 0);
+      if( *pRc!=SQLITE_OK ){
+        cidxCursorError(pCsr, "SQL error: %s", sqlite3_errmsg(db));
+      }
+    }
+  }
+  sqlite3_free(zSql);
+  va_end(ap);
+
+  return pRet;
+}
+
+static void cidxFinalize(int *pRc, sqlite3_stmt *pStmt){
+  int rc = sqlite3_finalize(pStmt);
+  if( *pRc==SQLITE_OK ) *pRc = rc;
+}
+
+char *cidxStrdup(int *pRc, const char *zStr){
+  char *zRet = 0;
+  if( *pRc==SQLITE_OK ){
+    int n = (int)strlen(zStr);
+    zRet = cidxMalloc(pRc, n+1);
+    if( zRet ) memcpy(zRet, zStr, n+1);
+  }
+  return zRet;
+}
+
+static void cidxFreeIndex(CidxIndex *pIdx){
+  if( pIdx ){
+    int i;
+    for(i=0; i<pIdx->nCol; i++){
+      sqlite3_free(pIdx->aCol[i].zExpr);
+    }
+    sqlite3_free(pIdx);
+  }
+}
+
+static int cidx_isspace(char c){
+  return c==' ' || c=='\t' || c=='\r' || c=='\n';
+}
+
+static int cidx_isident(char c){
+  return c<0 
+    || (c>='0' && c<='9') || (c>='a' && c<='z') 
+    || (c>='A' && c<='Z') || c=='_';
+}
+
+#define CIDX_PARSE_EOF   0
+#define CIDX_PARSE_COMMA 1      /*  "," */
+#define CIDX_PARSE_OPEN  2      /*  "(" */
+#define CIDX_PARSE_CLOSE 3      /*  ")" */
+
+static int cidxFindNext(
+  const char *zIn, 
+  const char **pzOut,
+  int *pbDoNotTrim                /* OUT: True if prev is -- comment */
+){
+  const char *z = zIn;
+
+  while( 1 ){
+    if( z[0]=='-' && z[1]=='-' ){
+      z += 2;
+      while( z[0]!='\n' ){
+        if( z[0]=='\0' ) return CIDX_PARSE_EOF;
+        z++;
+      }
+      while( cidx_isspace(*z) ) z++;
+      *pbDoNotTrim = 1;
+    }else{
+      *pzOut = z;
+      switch( *z ){
+        case '\0':
+          return CIDX_PARSE_EOF;
+        case '(':
+          return CIDX_PARSE_OPEN;
+        case ')':
+          return CIDX_PARSE_CLOSE;
+        case ',':
+          return CIDX_PARSE_COMMA;
+  
+        case '"': 
+        case '\'': 
+        case '`': {
+          char q = *z;
+          z++;
+          while( *z ){
+            if( *z==q ){
+              z++;
+              if( *z!=q ) break;
+            }
+            z++;
+          }
+          break;
+        }
+  
+        case '[':
+          while( *z++!=']' );
+          break;
+  
+        case '/':
+          if( z[1]=='*' ){
+            z += 2;
+            while( z[0]!='*' || z[1]!='/' ){
+              if( z[1]=='\0' ) return CIDX_PARSE_EOF;
+              z++;
+            }
+            z += 2;
+            break;
+          }
+  
+        default:
+          z++;
+          break;
+      }
+      *pbDoNotTrim = 0;
+    }
+  }
+
+  assert( 0 );
+  return -1;
+}
+
+static int cidxParseSQL(CidxCursor *pCsr, CidxIndex *pIdx, const char *zSql){
+  const char *z = zSql;
+  const char *z1;
+  int e;
+  int rc = SQLITE_OK;
+  int nParen = 1;
+  int bDoNotTrim = 0;
+  CidxColumn *pCol = pIdx->aCol;
+
+  e = cidxFindNext(z, &z, &bDoNotTrim);
+  if( e!=CIDX_PARSE_OPEN ) goto parse_error;
+  z1 = z+1;
+  z++;
+  while( nParen>0 ){
+    e = cidxFindNext(z, &z, &bDoNotTrim);
+    if( e==CIDX_PARSE_EOF ) goto parse_error;
+    if( (e==CIDX_PARSE_COMMA || e==CIDX_PARSE_CLOSE) && nParen==1 ){
+      const char *z2 = z;
+      if( pCol->zExpr ) goto parse_error;
+
+      if( bDoNotTrim==0 ){
+        while( cidx_isspace(z[-1]) ) z--;
+        if( !sqlite3_strnicmp(&z[-3], "asc", 3) && 0==cidx_isident(z[-4]) ){
+          z -= 3;
+          while( cidx_isspace(z[-1]) ) z--;
+        }else
+          if( !sqlite3_strnicmp(&z[-4], "desc", 4) && 0==cidx_isident(z[-5]) ){
+            z -= 4;
+            while( cidx_isspace(z[-1]) ) z--;
+          }
+        while( cidx_isspace(z1[0]) ) z1++;
+      }
+
+      pCol->zExpr = cidxMprintf(&rc, "%.*s", z-z1, z1);
+      pCol++;
+      z = z1 = z2+1;
+    }
+    if( e==CIDX_PARSE_OPEN ) nParen++;
+    if( e==CIDX_PARSE_CLOSE ) nParen--;
+    z++;
+  }
+
+  return rc;
+
+ parse_error:
+  cidxCursorError(pCsr, "Parse error in: %s", zSql);
+  return SQLITE_ERROR;
+}
+
+static int cidxLookupIndex(
+  CidxCursor *pCsr,               /* Cursor object */
+  const char *zIdx,               /* Name of index to look up */
+  CidxIndex **ppIdx,              /* OUT: Description of columns */
+  char **pzTab                    /* OUT: Table name */
+){
+  int rc = SQLITE_OK;
+  char *zTab = 0;
+  CidxIndex *pIdx = 0;
+
+  sqlite3_stmt *pFindTab = 0;
+  sqlite3_stmt *pInfo = 0;
+    
+  /* Find the table for this index. */
+  pFindTab = cidxPrepare(&rc, pCsr, 
+      "SELECT tbl_name, sql FROM sqlite_master WHERE name=%Q AND type='index'",
+      zIdx
+  );
+  if( rc==SQLITE_OK && sqlite3_step(pFindTab)==SQLITE_ROW ){
+    const char *zSql = (const char*)sqlite3_column_text(pFindTab, 1);
+    zTab = cidxStrdup(&rc, (const char*)sqlite3_column_text(pFindTab, 0));
+
+    pInfo = cidxPrepare(&rc, pCsr, "PRAGMA index_xinfo(%Q)", zIdx);
+    if( rc==SQLITE_OK ){
+      int nAlloc = 0;
+      int iCol = 0;
+
+      while( sqlite3_step(pInfo)==SQLITE_ROW ){
+        const char *zName = (const char*)sqlite3_column_text(pInfo, 2);
+        const char *zColl = (const char*)sqlite3_column_text(pInfo, 4);
+        CidxColumn *p;
+        if( zName==0 ) zName = "rowid";
+        if( iCol==nAlloc ){
+          int nByte = sizeof(CidxIndex) + sizeof(CidxColumn)*(nAlloc+8);
+          pIdx = (CidxIndex*)sqlite3_realloc(pIdx, nByte);
+          nAlloc += 8;
+        }
+        p = &pIdx->aCol[iCol++];
+        p->bDesc = sqlite3_column_int(pInfo, 3);
+        p->bKey = sqlite3_column_int(pInfo, 5);
+        if( zSql==0 || p->bKey==0 ){
+          p->zExpr = cidxMprintf(&rc, "\"%w\" COLLATE %s",zName,zColl);
+        }else{
+          p->zExpr = 0;
+        }
+        pIdx->nCol = iCol;
+      }
+      cidxFinalize(&rc, pInfo);
+    }
+
+    if( rc==SQLITE_OK && zSql ){
+      rc = cidxParseSQL(pCsr, pIdx, zSql);
+    }
+  }
+
+  cidxFinalize(&rc, pFindTab);
+  if( rc==SQLITE_OK && zTab==0 ){
+    rc = SQLITE_ERROR;
+  }
+  
+  if( rc!=SQLITE_OK ){
+    sqlite3_free(zTab);
+    cidxFreeIndex(pIdx);
+  }else{
+    *pzTab = zTab;
+    *ppIdx = pIdx;
+  }
+
+  return rc;
+}
+
+static int cidxDecodeAfter(
+  CidxCursor *pCsr, 
+  int nCol, 
+  const char *zAfterKey, 
+  char ***pazAfter
+){
+  char **azAfter;
+  int rc = SQLITE_OK;
+  int nAfterKey = (int)strlen(zAfterKey);
+
+  azAfter = cidxMalloc(&rc, sizeof(char*)*nCol + nAfterKey+1);
+  if( rc==SQLITE_OK ){
+    int i;
+    char *zCopy = (char*)&azAfter[nCol];
+    char *p = zCopy;
+    memcpy(zCopy, zAfterKey, nAfterKey+1);
+    for(i=0; i<nCol; i++){
+      while( *p==' ' ) p++;
+
+      /* Check NULL values */
+      if( *p=='N' ){
+        if( memcmp(p, "NULL", 4) ) goto parse_error;
+        p += 4;
+      }
+
+      /* Check strings and blob literals */
+      else if( *p=='X' || *p=='\'' ){
+        azAfter[i] = p;
+        if( *p=='X' ) p++;
+        if( *p!='\'' ) goto parse_error;
+        p++;
+        while( 1 ){
+          if( *p=='\0' ) goto parse_error;
+          if( *p=='\'' ){
+            p++;
+            if( *p!='\'' ) break;
+          }
+          p++;
+        }
+      }
+
+      /* Check numbers */
+      else{
+        azAfter[i] = p;
+        while( (*p>='0' && *p<='9') 
+            || *p=='.' || *p=='+' || *p=='-' || *p=='e' || *p=='E'
+        ){
+          p++;
+        }
+      }
+
+      while( *p==' ' ) p++;
+      if( *p!=(i==(nCol-1) ? '\0' : ',') ){
+        goto parse_error;
+      }
+      *p++ = '\0';
+    }
+  }
+
+  *pazAfter = azAfter;
+  return rc;
+
+ parse_error:
+  sqlite3_free(azAfter);
+  *pazAfter = 0;
+  cidxCursorError(pCsr, "%s", "error parsing after value");
+  return SQLITE_ERROR;
+}
+
+static char *cidxWhere(
+  int *pRc, CidxColumn *aCol, char **azAfter, int iGt, int bLastIsNull
+){
+  char *zRet = 0;
+  const char *zSep = "";
+  int i;
+
+  for(i=0; i<iGt; i++){
+    zRet = cidxMprintf(pRc, "%z%s(%s) IS %s", zRet, 
+        zSep, aCol[i].zExpr, (azAfter[i] ? azAfter[i] : "NULL")
+    );
+    zSep = " AND ";
+  }
+
+  if( bLastIsNull ){
+    zRet = cidxMprintf(pRc, "%z%s(%s) IS NULL", zRet, zSep, aCol[iGt].zExpr);
+  }
+  else if( azAfter[iGt] ){
+    zRet = cidxMprintf(pRc, "%z%s(%s) %s %s", zRet, 
+        zSep, aCol[iGt].zExpr, (aCol[iGt].bDesc ? "<" : ">"), 
+        azAfter[iGt]
+    );
+  }else{
+    zRet = cidxMprintf(pRc, "%z%s(%s) IS NOT NULL", zRet, zSep,aCol[iGt].zExpr);
+  }
+
+  return zRet;
+}
+
+#define CIDX_CLIST_ALL         0
+#define CIDX_CLIST_ORDERBY     1
+#define CIDX_CLIST_CURRENT_KEY 2
+#define CIDX_CLIST_SUBWHERE    3
+#define CIDX_CLIST_SUBEXPR     4
+
+/*
+** This function returns various strings based on the contents of the
+** CidxIndex structure and the eType parameter.
+*/
+static char *cidxColumnList(
+  int *pRc,                       /* IN/OUT: Error code */
+  const char *zIdx,
+  CidxIndex *pIdx,                /* Indexed columns */
+  int eType                       /* True to include ASC/DESC */
+){
+  char *zRet = 0;
+  if( *pRc==SQLITE_OK ){
+    const char *aDir[2] = {"", " DESC"};
+    int i;
+    const char *zSep = "";
+
+    for(i=0; i<pIdx->nCol; i++){
+      CidxColumn *p = &pIdx->aCol[i];
+      assert( pIdx->aCol[i].bDesc==0 || pIdx->aCol[i].bDesc==1 );
+      switch( eType ){
+
+        case CIDX_CLIST_ORDERBY:
+          zRet = cidxMprintf(pRc, "%z%s%d%s", zRet, zSep, i+1, aDir[p->bDesc]);
+          zSep = ",";
+          break;
+
+        case CIDX_CLIST_CURRENT_KEY:
+          zRet = cidxMprintf(pRc, "%z%squote(i%d)", zRet, zSep, i);
+          zSep = "||','||";
+          break;
+
+        case CIDX_CLIST_SUBWHERE:
+          if( p->bKey==0 ){
+            zRet = cidxMprintf(pRc, "%z%s%s IS i.i%d", zRet, 
+                zSep, p->zExpr, i
+            );
+            zSep = " AND ";
+          }
+          break;
+
+        case CIDX_CLIST_SUBEXPR:
+          if( p->bKey==1 ){
+            zRet = cidxMprintf(pRc, "%z%s%s IS i.i%d", zRet, 
+                zSep, p->zExpr, i
+            );
+            zSep = " AND ";
+          }
+          break;
+
+        default:
+          assert( eType==CIDX_CLIST_ALL );
+          zRet = cidxMprintf(pRc, "%z%s(%s) AS i%d", zRet, zSep, p->zExpr, i);
+          zSep = ", ";
+          break;
+      }
+    }
+  }
+
+  return zRet;
+}
+
+/* 
+** Position a cursor back to the beginning.
+*/
+static int cidxFilter(
+  sqlite3_vtab_cursor *pCursor, 
+  int idxNum, const char *idxStr,
+  int argc, sqlite3_value **argv
+){
+  int rc = SQLITE_OK;
+  CidxCursor *pCsr = (CidxCursor*)pCursor;
+  const char *zIdxName = 0;
+  const char *zAfterKey = 0;
+
+  if( argc>0 ){
+    zIdxName = (const char*)sqlite3_value_text(argv[0]);
+    if( argc>1 ){
+      zAfterKey = (const char*)sqlite3_value_text(argv[1]);
+    }
+  }
+
+  if( zIdxName ){
+    char *zTab = 0;
+    char *zCurrentKey = 0;
+    char *zOrderBy = 0;
+    char *zSubWhere = 0;
+    char *zSubExpr = 0;
+    char *zSrcList = 0;
+
+    char **azAfter = 0;
+    CidxIndex *pIdx = 0;
+
+    rc = cidxLookupIndex(pCsr, zIdxName, &pIdx, &zTab);
+
+    zOrderBy = cidxColumnList(&rc, zIdxName, pIdx, CIDX_CLIST_ORDERBY);
+    zCurrentKey = cidxColumnList(&rc, zIdxName, pIdx, CIDX_CLIST_CURRENT_KEY);
+    zSubWhere = cidxColumnList(&rc, zIdxName, pIdx, CIDX_CLIST_SUBWHERE);
+    zSubExpr = cidxColumnList(&rc, zIdxName, pIdx, CIDX_CLIST_SUBEXPR);
+    zSrcList = cidxColumnList(&rc, zIdxName, pIdx, CIDX_CLIST_ALL);
+
+    if( rc==SQLITE_OK && zAfterKey ){
+      rc = cidxDecodeAfter(pCsr, pIdx->nCol, zAfterKey, &azAfter);
+    }
+
+    if( rc || zAfterKey==0 ){
+      pCsr->pStmt = cidxPrepare(&rc, pCsr, 
+          "SELECT (SELECT %s FROM %Q AS t WHERE %s), %s "
+          "FROM (SELECT %s FROM %Q ORDER BY %s) AS i",
+          zSubExpr, zTab, zSubWhere, zCurrentKey, 
+          zSrcList, zTab, zOrderBy
+      );
+      /* printf("SQL: %s\n", sqlite3_sql(pCsr->pStmt)); */
+    }else{
+      const char *zSep = "";
+      char *zSql;
+      int i;
+
+      zSql = cidxMprintf(&rc, 
+          "SELECT (SELECT %s FROM %Q WHERE %s), %s FROM (",
+          zSubExpr, zTab, zSubWhere, zCurrentKey
+      );
+      for(i=pIdx->nCol-1; i>=0; i--){
+        int j;
+        if( pIdx->aCol[i].bDesc && azAfter[i]==0 ) continue;
+        for(j=0; j<2; j++){
+          char *zWhere = cidxWhere(&rc, pIdx->aCol, azAfter, i, j);
+          zSql = cidxMprintf(&rc, "%z"
+              "%sSELECT * FROM (SELECT %s FROM %Q WHERE %z ORDER BY %s)",
+              zSql, zSep, zSrcList, zTab, zWhere, zOrderBy
+          );
+          zSep = " UNION ALL ";
+          if( pIdx->aCol[i].bDesc==0 ) break;
+        }
+      }
+      zSql = cidxMprintf(&rc, "%z) AS i", zSql);
+
+      /* printf("SQL: %s\n", zSql); */
+      pCsr->pStmt = cidxPrepare(&rc, pCsr, "%z", zSql);
+    }
+
+    sqlite3_free(zTab);
+    sqlite3_free(zCurrentKey);
+    sqlite3_free(zOrderBy);
+    sqlite3_free(zSubWhere);
+    sqlite3_free(zSubExpr);
+    sqlite3_free(zSrcList);
+    cidxFreeIndex(pIdx);
+    sqlite3_free(azAfter);
+  }
+
+  if( pCsr->pStmt ){
+    assert( rc==SQLITE_OK );
+    rc = cidxNext(pCursor);
+  }
+  pCsr->iRowid = 1;
+  return rc;
+}
+
+/* 
+** Return a column value.
+*/
+static int cidxColumn(
+  sqlite3_vtab_cursor *pCursor, 
+  sqlite3_context *ctx, 
+  int iCol
+){
+  CidxCursor *pCsr = (CidxCursor*)pCursor;
+  assert( iCol>=IIC_ERRMSG && iCol<=IIC_AFTER_KEY );
+  if( iCol==IIC_ERRMSG ){
+    const char *zVal = 0;
+    if( sqlite3_column_type(pCsr->pStmt, 0)==SQLITE_INTEGER ){
+      if( sqlite3_column_int(pCsr->pStmt, 0)==0 ){
+        zVal = "row data mismatch";
+      }
+    }else{
+      zVal = "row missing";
+    }
+    sqlite3_result_text(ctx, zVal, -1, SQLITE_STATIC);
+  }else if( iCol==IIC_CURRENT_KEY ){
+    sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pStmt, 1));
+  }
+  return SQLITE_OK;
+}
+
+/* Return the ROWID for the sqlite_btreeinfo table */
+static int cidxRowid(sqlite3_vtab_cursor *pCursor, sqlite_int64 *pRowid){
+  *pRowid = 0;
+  return SQLITE_OK;
+}
+
+/*
+** Register the virtual table modules with the database handle passed
+** as the only argument.
+*/
+static int ciInit(sqlite3 *db){
+  static sqlite3_module cidx_module = {
+    0,                            /* iVersion */
+    0,                            /* xCreate */
+    cidxConnect,                  /* xConnect */
+    cidxBestIndex,                /* xBestIndex */
+    cidxDisconnect,               /* xDisconnect */
+    0,                            /* xDestroy */
+    cidxOpen,                     /* xOpen - open a cursor */
+    cidxClose,                    /* xClose - close a cursor */
+    cidxFilter,                   /* xFilter - configure scan constraints */
+    cidxNext,                     /* xNext - advance a cursor */
+    cidxEof,                      /* xEof - check for end of scan */
+    cidxColumn,                   /* xColumn - read data */
+    cidxRowid,                    /* xRowid - read data */
+    0,                            /* xUpdate */
+    0,                            /* xBegin */
+    0,                            /* xSync */
+    0,                            /* xCommit */
+    0,                            /* xRollback */
+    0,                            /* xFindMethod */
+    0,                            /* xRename */
+    0,                            /* xSavepoint */
+    0,                            /* xRelease */
+    0,                            /* xRollbackTo */
+  };
+  return sqlite3_create_module(db, "incremental_index_check", &cidx_module, 0);
+}
+
+/*
+** Extension load function.
+*/
+#ifdef _WIN32
+__declspec(dllexport)
+#endif
+int sqlite3_checkindex_init(
+  sqlite3 *db, 
+  char **pzErrMsg, 
+  const sqlite3_api_routines *pApi
+){
+  SQLITE_EXTENSION_INIT2(pApi);
+  return ciInit(db);
+}
diff --git a/ext/repair/sqlite3_checker.c.in b/ext/repair/sqlite3_checker.c.in
new file mode 100644
index 0000000000..76e9708787
--- /dev/null
+++ b/ext/repair/sqlite3_checker.c.in
@@ -0,0 +1,86 @@
+/*
+** Read an SQLite database file and analyze its space utilization.  Generate
+** text on standard output.
+*/
+#define TCLSH_INIT_PROC sqlite3_checker_init_proc
+#define SQLITE_ENABLE_DBPAGE_VTAB 1
+#define SQLITE_ENABLE_JSON1 1
+#undef SQLITE_THREADSAFE
+#define SQLITE_THREADSAFE 0
+#undef SQLITE_ENABLE_COLUMN_METADATA
+#define SQLITE_OMIT_DECLTYPE 1
+#define SQLITE_OMIT_DEPRECATED 1
+#define SQLITE_OMIT_PROGRESS_CALLBACK 1
+#define SQLITE_OMIT_SHARED_CACHE 1
+#define SQLITE_DEFAULT_MEMSTATUS 0
+#define SQLITE_MAX_EXPR_DEPTH 0
+INCLUDE sqlite3.c
+INCLUDE $ROOT/src/tclsqlite.c
+INCLUDE $ROOT/ext/misc/btreeinfo.c
+INCLUDE $ROOT/ext/repair/checkindex.c
+INCLUDE $ROOT/ext/repair/checkfreelist.c
+
+/*
+** Decode a pointer to an sqlite3 object.
+*/
+int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb){
+  struct SqliteDb *p;
+  Tcl_CmdInfo cmdInfo;
+  if( Tcl_GetCommandInfo(interp, zA, &cmdInfo) ){
+    p = (struct SqliteDb*)cmdInfo.objClientData;
+    *ppDb = p->db;
+    return TCL_OK;
+  }else{
+    *ppDb = 0;
+    return TCL_ERROR;
+  }
+  return TCL_OK;
+}
+
+/*
+**   sqlite3_imposter db main rootpage {CREATE TABLE...}  ;# setup an imposter
+**   sqlite3_imposter db main                             ;# rm all imposters
+*/
+static int sqlite3_imposter(
+  void *clientData,
+  Tcl_Interp *interp,
+  int objc,
+  Tcl_Obj *CONST objv[]
+){
+  sqlite3 *db;
+  const char *zSchema;
+  int iRoot;
+  const char *zSql;
+
+  if( objc!=3 && objc!=5 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB SCHEMA [ROOTPAGE SQL]");
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
+  zSchema = Tcl_GetString(objv[2]);
+  if( objc==3 ){
+    sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, zSchema, 0, 1);
+  }else{
+    if( Tcl_GetIntFromObj(interp, objv[3], &iRoot) ) return TCL_ERROR;
+    zSql = Tcl_GetString(objv[4]);
+    sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, zSchema, 1, iRoot);
+    sqlite3_exec(db, zSql, 0, 0, 0);
+    sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, zSchema, 0, 0);
+  }
+  return TCL_OK;
+}
+
+#include <stdio.h>
+
+const char *sqlite3_checker_init_proc(Tcl_Interp *interp){
+  Tcl_CreateObjCommand(interp, "sqlite3_imposter", 
+                       (Tcl_ObjCmdProc*)sqlite3_imposter, 0, 0);
+  sqlite3_auto_extension((void(*)(void))sqlite3_btreeinfo_init);
+  sqlite3_auto_extension((void(*)(void))sqlite3_checkindex_init);
+  sqlite3_auto_extension((void(*)(void))sqlite3_checkfreelist_init);
+  return
+BEGIN_STRING
+INCLUDE $ROOT/ext/repair/sqlite3_checker.tcl
+END_STRING
+;
+}
diff --git a/ext/repair/sqlite3_checker.tcl b/ext/repair/sqlite3_checker.tcl
new file mode 100644
index 0000000000..ab8d05e600
--- /dev/null
+++ b/ext/repair/sqlite3_checker.tcl
@@ -0,0 +1,243 @@
+# This TCL script is the main driver script for the sqlite3_checker utility
+# program.
+#
+
+# Special case:
+#
+#      sqlite3_checker --test FILENAME ARGS
+#
+# uses FILENAME in place of this script.
+#
+if {[lindex $argv 0]=="--test" && [llength $argv]>1} {
+  set ::argv0 [lindex $argv 1]
+  set argv [lrange $argv 2 end]
+  source $argv0
+  exit 0
+}
+
+# Emulate a TCL shell
+#
+proc tclsh {} {
+  set line {}
+  while {![eof stdin]} {
+    if {$line!=""} {
+      puts -nonewline "> "
+    } else {
+      puts -nonewline "% "
+    }
+    flush stdout
+    append line [gets stdin]
+    if {[info complete $line]} {
+      if {[catch {uplevel #0 $line} result]} {
+        puts stderr "Error: $result"
+      } elseif {$result!=""} {
+        puts $result
+      }
+      set line {}
+    } else {
+      append line \n
+    }
+  }
+}
+
+# Do an incremental integrity check of a single index
+#
+proc check_index {idxname batchsize} {
+  set i 0
+  set more 1
+  set nerr 0
+  set pct 00.0
+  set max [db one {SELECT nEntry FROM sqlite_btreeinfo('main')
+                    WHERE name=$idxname}]
+  puts -nonewline "$idxname: $i of $max rows ($pct%)\r"
+  flush stdout
+  while {$more} {
+    set more 0
+    db eval {SELECT errmsg, current_key AS key
+               FROM incremental_index_check($idxname)
+              WHERE after_key=$key
+              LIMIT $batchsize} {
+      set more 1
+      if {$errmsg!=""} {
+        incr nerr
+        puts "$idxname: key($key): $errmsg"
+      }
+      incr i
+    }
+    set x [format {%.1f} [expr {($i*100.0)/$max}]]
+    if {$x!=$pct} {
+      puts -nonewline "$idxname: $i of $max rows ($pct%)\r"
+      flush stdout
+      set pct $x
+    }
+  }
+  puts "$idxname: $nerr errors out of $i entries"
+}
+
+# Print a usage message on standard error, then quit.
+#
+proc usage {} {
+  set argv0 [file rootname [file tail [info nameofexecutable]]]
+  puts stderr "Usage: $argv0 OPTIONS database-filename"
+  puts stderr {
+Do sanity checking on a live SQLite3 database file specified by the
+"database-filename" argument.
+
+Options:
+
+   --batchsize N     Number of rows to check per transaction
+
+   --freelist        Perform a freelist check
+
+   --index NAME      Run a check of the index NAME
+
+   --summary         Print summary information about the database
+
+   --table NAME      Run a check of all indexes for table NAME
+
+   --tclsh           Run the built-in TCL interpreter (for debugging)
+
+   --version         Show the version number of SQLite
+}
+  exit 1
+}
+
+set file_to_analyze {}
+append argv {}
+set bFreelistCheck 0
+set bSummary 0
+set zIndex {}
+set zTable {}
+set batchsize 1000
+set bAll 1
+set argc [llength $argv]
+for {set i 0} {$i<$argc} {incr i} {
+  set arg [lindex $argv $i]
+  if {[regexp {^-+tclsh$} $arg]} {
+    tclsh
+    exit 0
+  }
+  if {[regexp {^-+version$} $arg]} {
+    sqlite3 mem :memory:
+    puts [mem one {SELECT sqlite_version()||' '||sqlite_source_id()}]
+    mem close
+    exit 0
+  }
+  if {[regexp {^-+freelist$} $arg]} {
+    set bFreelistCheck 1
+    set bAll 0
+    continue
+  }
+  if {[regexp {^-+summary$} $arg]} {
+    set bSummary 1
+    set bAll 0
+    continue
+  }
+  if {[regexp {^-+batchsize$} $arg]} {
+    incr i
+    if {$i>=$argc} {
+      puts stderr "missing argument on $arg"
+      exit 1
+    }
+    set batchsize [lindex $argv $i]
+    continue
+  }
+  if {[regexp {^-+index$} $arg]} {
+    incr i
+    if {$i>=$argc} {
+      puts stderr "missing argument on $arg"
+      exit 1
+    }
+    set zIndex [lindex $argv $i]
+    set bAll 0
+    continue
+  }
+  if {[regexp {^-+table$} $arg]} {
+    incr i
+    if {$i>=$argc} {
+      puts stderr "missing argument on $arg"
+      exit 1
+    }
+    set zTable [lindex $argv $i]
+    set bAll 0
+    continue
+  }
+  if {[regexp {^-} $arg]} {
+    puts stderr "Unknown option: $arg"
+    usage
+  }
+  if {$file_to_analyze!=""} {
+    usage
+  } else {
+    set file_to_analyze $arg
+  }
+}
+if {$file_to_analyze==""} usage
+
+# If a TCL script is specified on the command-line, then run that
+# script.
+#
+if {[file extension $file_to_analyze]==".tcl"} {
+  source $file_to_analyze
+  exit 0
+}
+
+set root_filename $file_to_analyze
+regexp {^file:(//)?([^?]*)} $file_to_analyze all x1 root_filename
+if {![file exists $root_filename]} {
+  puts stderr "No such file: $root_filename"
+  exit 1
+}
+if {![file readable $root_filename]} {
+  puts stderr "File is not readable: $root_filename"
+  exit 1
+}
+
+if {[catch {sqlite3 db $file_to_analyze} res]} {
+  puts stderr "Cannot open datababase $root_filename: $res"
+  exit 1
+}
+
+if {$bFreelistCheck || $bAll} {
+  puts -nonewline "freelist-check: "
+  flush stdout
+  puts [db one {SELECT checkfreelist('main')}]
+}
+if {$bSummary} {
+  set scale 0
+  set pgsz [db one {PRAGMA page_size}]
+  db eval {SELECT nPage*$pgsz AS sz, name, tbl_name
+             FROM sqlite_btreeinfo
+            WHERE type='index'
+            ORDER BY 1 DESC, name} {
+    if {$scale==0} {
+      if {$sz>10000000} {
+        set scale 1000000.0
+        set unit MB
+      } else {
+        set scale 1000.0
+        set unit KB
+      }
+    }
+    puts [format {%7.1f %s index %s of table %s} \
+            [expr {$sz/$scale}] $unit $name $tbl_name]
+  }
+}
+if {$zIndex!=""} {
+  check_index $zIndex $batchsize
+}
+if {$zTable!=""} {
+  foreach idx [db eval {SELECT name FROM sqlite_master
+                         WHERE type='index' AND rootpage>0
+                           AND tbl_name=$zTable}] {
+    check_index $idx $batchsize
+  }
+}
+if {$bAll} {
+  set allidx [db eval {SELECT name FROM sqlite_btreeinfo('main')
+                        WHERE type='index' AND rootpage>0
+                        ORDER BY nEntry}]
+  foreach idx $allidx {
+    check_index $idx $batchsize
+  }
+}
diff --git a/ext/repair/test/README.md b/ext/repair/test/README.md
new file mode 100644
index 0000000000..8cc954adf5
--- /dev/null
+++ b/ext/repair/test/README.md
@@ -0,0 +1,13 @@
+To run these tests, first build sqlite3_checker:
+
+
+>     make sqlite3_checker
+
+
+Then run the "test.tcl" script using:
+
+
+>     ./sqlite3_checker --test $path/test.tcl
+
+
+Optionally add the full pathnames of individual *.test modules
diff --git a/test/checkfreelist.test b/ext/repair/test/checkfreelist01.test
similarity index 64%
rename from test/checkfreelist.test
rename to ext/repair/test/checkfreelist01.test
index 93e4ecc234..7e2dd51c37 100644
--- a/test/checkfreelist.test
+++ b/ext/repair/test/checkfreelist01.test
@@ -1,40 +1,12 @@
 # 2017-10-11
-#
-# The author disclaims copyright to this source code.  In place of
-# a legal notice, here is a blessing:
-#
-#    May you do good and not evil.
-#    May you find forgiveness for yourself and forgive others.
-#    May you share freely, never taking more than you give.
-#
-#***********************************************************************
-# This file implements regression tests for SQLite library.  The
-# focus of this file is testing the checkfreelist extension.
-#
 
-set testdir [file dirname $argv0]
-source $testdir/tester.tcl
 set testprefix checkfreelist
 
-ifcapable !vtab||!compound {
-  finish_test
-  return
-}
-
-if {[file exists ../checkfreelist.so]==0} {
-  finish_test
-  return
-}
-
 do_execsql_test 1.0 {
+  PRAGMA page_size=1024;
   CREATE TABLE t1(a, b);
 }
 
-db enable_load_extension 1
-do_execsql_test 1.1 {
-  SELECT load_extension('../checkfreelist.so');
-} {{}}
-
 do_execsql_test 1.2 { SELECT checkfreelist('main') } {ok}
 do_execsql_test 1.3 {
   WITH s(i) AS (
@@ -55,8 +27,8 @@ do_execsql_test 1.5 {
   )
   SELECT i FROM freelist_trunk WHERE i!=1;
 } {
-  10010 9716 9344 8970 8596 8223 7848 7475 7103 6728 6355 5983 5609 5235
-  4861 4488 4113 3741 3368 2993 2620 2248 1873 1500 1126 753 378 5
+  10009 9715 9343 8969 8595 8222 7847 7474 7102 6727 6354 5982 5608 5234
+  4860 4487 4112 3740 3367 2992 2619 2247 1872 1499 1125 752 377 5
 }
 
 do_execsql_test 1.6 { SELECT checkfreelist('main') } {ok}
@@ -78,7 +50,7 @@ do_execsql_test 1.7 {
   BEGIN;
     UPDATE sqlite_dbpage 
       SET data = set_int(data, 1, get_int(data, 1)-1) 
-      WHERE pgno=4861;
+      WHERE pgno=4860;
     SELECT checkfreelist('main');
   ROLLBACK;
 } {{free-list count mismatch: actual=6725 header=6726}}
@@ -87,19 +59,19 @@ do_execsql_test 1.8 {
   BEGIN;
     UPDATE sqlite_dbpage 
       SET data = set_int(data, 5, (SELECT * FROM pragma_page_count)+1)
-      WHERE pgno=4861;
+      WHERE pgno=4860;
     SELECT checkfreelist('main');
   ROLLBACK;
-} {{leaf page 10093 is out of range (child 3 of trunk page 4861)}}
+} {{leaf page 10092 is out of range (child 3 of trunk page 4860)}}
 
 do_execsql_test 1.9 {
   BEGIN;
     UPDATE sqlite_dbpage 
       SET data = set_int(data, 5, 0)
-      WHERE pgno=4861;
+      WHERE pgno=4860;
     SELECT checkfreelist('main');
   ROLLBACK;
-} {{leaf page 0 is out of range (child 3 of trunk page 4861)}}
+} {{leaf page 0 is out of range (child 3 of trunk page 4860)}}
 
 do_execsql_test 1.10 {
   BEGIN;
@@ -118,6 +90,3 @@ do_execsql_test 1.11 {
     SELECT checkfreelist('main');
   ROLLBACK;
 } {{leaf count out of range (249) on trunk page 5}}
-
-finish_test
-
diff --git a/ext/repair/test/checkindex01.test b/ext/repair/test/checkindex01.test
new file mode 100644
index 0000000000..744a21c69e
--- /dev/null
+++ b/ext/repair/test/checkindex01.test
@@ -0,0 +1,311 @@
+# 2017-10-11
+#
+set testprefix checkindex
+
+do_execsql_test 1.0 {
+  CREATE TABLE t1(a, b);
+  CREATE INDEX i1 ON t1(a);
+  INSERT INTO t1 VALUES('one', 2);
+  INSERT INTO t1 VALUES('two', 4);
+  INSERT INTO t1 VALUES('three', 6);
+  INSERT INTO t1 VALUES('four', 8);
+  INSERT INTO t1 VALUES('five', 10);
+
+  CREATE INDEX i2 ON t1(a DESC);
+} {}
+
+proc incr_index_check {idx nStep} {
+  set Q {
+    SELECT errmsg, current_key FROM incremental_index_check($idx, $after)
+    LIMIT $nStep
+  }
+
+  set res [list]
+  while {1} {
+    unset -nocomplain current_key
+    set res1 [db eval $Q]
+    if {[llength $res1]==0} break
+    set res [concat $res $res1]
+    set after [lindex $res end]
+  }
+
+  return $res
+}
+
+proc do_index_check_test {tn idx res} {
+  uplevel [list do_execsql_test $tn.1 "
+    SELECT errmsg, current_key FROM incremental_index_check('$idx');
+  " $res]
+
+  uplevel [list do_test $tn.2 "incr_index_check $idx 1" [list {*}$res]]
+  uplevel [list do_test $tn.3 "incr_index_check $idx 2" [list {*}$res]]
+  uplevel [list do_test $tn.4 "incr_index_check $idx 5" [list {*}$res]]
+}
+
+
+do_execsql_test 1.2 {
+  SELECT errmsg IS NULL, current_key FROM incremental_index_check('i1');
+} {
+  1 'five',5
+  1 'four',4
+  1 'one',1
+  1 'three',3
+  1 'two',2
+}
+
+do_index_check_test 1.3 i1 {
+  {} 'five',5
+  {} 'four',4
+  {} 'one',1
+  {} 'three',3
+  {} 'two',2
+}
+
+do_index_check_test 1.4 i2 {
+  {} 'two',2
+  {} 'three',3
+  {} 'one',1
+  {} 'four',4
+  {} 'five',5
+}
+
+do_test 1.5 {
+  set tblroot [db one { SELECT rootpage FROM sqlite_master WHERE name='t1' }]
+  sqlite3_imposter db main $tblroot {CREATE TABLE xt1(a,b)}
+  db eval {
+    UPDATE xt1 SET a='six' WHERE rowid=3;
+    DELETE FROM xt1 WHERE rowid = 5;
+  }
+  sqlite3_imposter db main
+} {}
+
+do_index_check_test 1.6 i1 {
+  {row missing} 'five',5
+  {} 'four',4
+  {} 'one',1
+  {row data mismatch} 'three',3
+  {} 'two',2
+}
+
+do_index_check_test 1.7 i2 {
+  {} 'two',2
+  {row data mismatch} 'three',3
+  {} 'one',1
+  {} 'four',4
+  {row missing} 'five',5
+}
+
+#--------------------------------------------------------------------------
+do_execsql_test 2.0 {
+
+  CREATE TABLE t2(a INTEGER PRIMARY KEY, b, c, d);
+
+  INSERT INTO t2 VALUES(1, NULL, 1, 1);
+  INSERT INTO t2 VALUES(2, 1, NULL, 1);
+  INSERT INTO t2 VALUES(3, 1, 1, NULL);
+
+  INSERT INTO t2 VALUES(4, 2, 2, 1);
+  INSERT INTO t2 VALUES(5, 2, 2, 2);
+  INSERT INTO t2 VALUES(6, 2, 2, 3);
+
+  INSERT INTO t2 VALUES(7, 2, 2, 1);
+  INSERT INTO t2 VALUES(8, 2, 2, 2);
+  INSERT INTO t2 VALUES(9, 2, 2, 3);
+
+  CREATE INDEX i3 ON t2(b, c, d);
+  CREATE INDEX i4 ON t2(b DESC, c DESC, d DESC);
+  CREATE INDEX i5 ON t2(d, c DESC, b);
+} {}
+
+do_index_check_test 2.1 i3 {
+  {} NULL,1,1,1 
+  {} 1,NULL,1,2 
+  {} 1,1,NULL,3 
+  {} 2,2,1,4 
+  {} 2,2,1,7 
+  {} 2,2,2,5
+  {} 2,2,2,8 
+  {} 2,2,3,6 
+  {} 2,2,3,9
+}
+
+do_index_check_test 2.2 i4 {
+  {} 2,2,3,6 
+  {} 2,2,3,9
+  {} 2,2,2,5
+  {} 2,2,2,8 
+  {} 2,2,1,4 
+  {} 2,2,1,7 
+  {} 1,1,NULL,3 
+  {} 1,NULL,1,2 
+  {} NULL,1,1,1 
+}
+
+do_index_check_test 2.3 i5 {
+  {} NULL,1,1,3 
+  {} 1,2,2,4 
+  {} 1,2,2,7 
+  {} 1,1,NULL,1 
+  {} 1,NULL,1,2 
+  {} 2,2,2,5 
+  {} 2,2,2,8 
+  {} 3,2,2,6 
+  {} 3,2,2,9
+}
+
+#--------------------------------------------------------------------------
+do_execsql_test 3.0 {
+
+  CREATE TABLE t3(w, x, y, z PRIMARY KEY) WITHOUT ROWID;
+  CREATE INDEX t3wxy ON t3(w, x, y);
+  CREATE INDEX t3wxy2 ON t3(w DESC, x DESC, y DESC);
+
+  INSERT INTO t3 VALUES(NULL, NULL, NULL, 1);
+  INSERT INTO t3 VALUES(NULL, NULL, NULL, 2);
+  INSERT INTO t3 VALUES(NULL, NULL, NULL, 3);
+
+  INSERT INTO t3 VALUES('a', NULL, NULL, 4);
+  INSERT INTO t3 VALUES('a', NULL, NULL, 5);
+  INSERT INTO t3 VALUES('a', NULL, NULL, 6);
+
+  INSERT INTO t3 VALUES('a', 'b', NULL, 7);
+  INSERT INTO t3 VALUES('a', 'b', NULL, 8);
+  INSERT INTO t3 VALUES('a', 'b', NULL, 9);
+
+} {}
+
+do_index_check_test 3.1 t3wxy {
+  {} NULL,NULL,NULL,1 {} NULL,NULL,NULL,2 {} NULL,NULL,NULL,3 
+  {} 'a',NULL,NULL,4  {} 'a',NULL,NULL,5  {} 'a',NULL,NULL,6 
+  {} 'a','b',NULL,7   {} 'a','b',NULL,8   {} 'a','b',NULL,9 
+}
+do_index_check_test 3.2 t3wxy2 {
+  {} 'a','b',NULL,7   {} 'a','b',NULL,8   {} 'a','b',NULL,9 
+  {} 'a',NULL,NULL,4  {} 'a',NULL,NULL,5  {} 'a',NULL,NULL,6 
+  {} NULL,NULL,NULL,1 {} NULL,NULL,NULL,2 {} NULL,NULL,NULL,3 
+}
+
+#--------------------------------------------------------------------------
+# Test with an index that uses non-default collation sequences.
+#
+do_execsql_test 4.0 {
+  CREATE TABLE t4(a INTEGER PRIMARY KEY, c1 TEXT, c2 TEXT);
+  INSERT INTO t4 VALUES(1, 'aaa', 'bbb');
+  INSERT INTO t4 VALUES(2, 'AAA', 'CCC');
+  INSERT INTO t4 VALUES(3, 'aab', 'ddd');
+  INSERT INTO t4 VALUES(4, 'AAB', 'EEE');
+
+  CREATE INDEX t4cc ON t4(c1 COLLATE nocase, c2 COLLATE nocase);
+}
+
+do_index_check_test 4.1 t4cc {
+  {} 'aaa','bbb',1 
+  {} 'AAA','CCC',2 
+  {} 'aab','ddd',3 
+  {} 'AAB','EEE',4
+}
+
+do_test 4.2 {
+  set tblroot [db one { SELECT rootpage FROM sqlite_master WHERE name='t4' }]
+  sqlite3_imposter db main $tblroot \
+     {CREATE TABLE xt4(a INTEGER PRIMARY KEY, c1 TEXT, c2 TEXT)}
+
+  db eval {
+    UPDATE xt4 SET c1='hello' WHERE rowid=2;
+    DELETE FROM xt4 WHERE rowid = 3;
+  }
+  sqlite3_imposter db main
+} {}
+
+do_index_check_test 4.3 t4cc {
+  {} 'aaa','bbb',1 
+  {row data mismatch} 'AAA','CCC',2 
+  {row missing} 'aab','ddd',3 
+  {} 'AAB','EEE',4
+}
+
+#--------------------------------------------------------------------------
+# Test an index on an expression.
+#
+do_execsql_test 5.0 {
+  CREATE TABLE t5(x INTEGER PRIMARY KEY, y TEXT, UNIQUE(y));
+  INSERT INTO t5 VALUES(1, '{"x":1, "y":1}');
+  INSERT INTO t5 VALUES(2, '{"x":2, "y":2}');
+  INSERT INTO t5 VALUES(3, '{"x":3, "y":3}');
+  INSERT INTO t5 VALUES(4, '{"w":4, "z":4}');
+  INSERT INTO t5 VALUES(5, '{"x":5, "y":5}');
+
+  CREATE INDEX t5x ON t5( json_extract(y, '$.x') );
+  CREATE INDEX t5y ON t5( json_extract(y, '$.y') DESC );
+}
+
+do_index_check_test 5.1.1 t5x {
+  {} NULL,4 {} 1,1 {} 2,2 {} 3,3 {} 5,5
+}
+
+do_index_check_test 5.1.2 t5y {
+  {} 5,5 {} 3,3 {} 2,2 {} 1,1 {} NULL,4
+}
+
+do_index_check_test 5.1.3 sqlite_autoindex_t5_1 {
+  {} {'{"w":4, "z":4}',4} 
+  {} {'{"x":1, "y":1}',1} 
+  {} {'{"x":2, "y":2}',2} 
+  {} {'{"x":3, "y":3}',3} 
+  {} {'{"x":5, "y":5}',5}
+}
+
+do_test 5.2 {
+  set tblroot [db one { SELECT rootpage FROM sqlite_master WHERE name='t5' }]
+  sqlite3_imposter db main $tblroot \
+      {CREATE TABLE xt5(a INTEGER PRIMARY KEY, c1 TEXT);}
+  db eval {
+    UPDATE xt5 SET c1='{"x":22, "y":11}' WHERE rowid=1;
+    DELETE FROM xt5 WHERE rowid = 4;
+  }
+  sqlite3_imposter db main
+} {}
+
+do_index_check_test 5.3.1 t5x {
+  {row missing} NULL,4 
+  {row data mismatch} 1,1 
+  {} 2,2 
+  {} 3,3 
+  {} 5,5
+}
+
+do_index_check_test 5.3.2 sqlite_autoindex_t5_1 {
+  {row missing} {'{"w":4, "z":4}',4} 
+  {row data mismatch} {'{"x":1, "y":1}',1} 
+  {} {'{"x":2, "y":2}',2} 
+  {} {'{"x":3, "y":3}',3} 
+  {} {'{"x":5, "y":5}',5}
+}
+
+#-------------------------------------------------------------------------
+#
+do_execsql_test 6.0 {
+  CREATE TABLE t6(x INTEGER PRIMARY KEY, y, z);
+  CREATE INDEX t6x1 ON t6(y, /* one,two,three */ z);
+  CREATE INDEX t6x2 ON t6(z, -- hello,world,
+  y);
+
+  CREATE INDEX t6x3 ON t6(z -- hello,world
+  , y);
+
+  INSERT INTO t6 VALUES(1, 2, 3);
+  INSERT INTO t6 VALUES(4, 5, 6);
+}
+
+do_index_check_test 6.1 t6x1 {
+  {} 2,3,1 
+  {} 5,6,4
+}
+do_index_check_test 6.2 t6x2 {
+  {} 3,2,1 
+  {} 6,5,4
+}
+do_index_check_test 6.2 t6x3 {
+  {} 3,2,1 
+  {} 6,5,4
+}
diff --git a/ext/repair/test/test.tcl b/ext/repair/test/test.tcl
new file mode 100644
index 0000000000..c073bb73c5
--- /dev/null
+++ b/ext/repair/test/test.tcl
@@ -0,0 +1,67 @@
+# Run this script using
+#
+#       sqlite3_checker --test $thisscript $testscripts
+#
+# The $testscripts argument is optional.  If omitted, all *.test files
+# in the same directory as $thisscript are run.
+#
+set NTEST 0
+set NERR  0
+
+
+# Invoke the do_test procedure to run a single test
+#
+# The $expected parameter is the expected result.  The result is the return
+# value from the last TCL command in $cmd.
+#
+# Normally, $expected must match exactly.  But if $expected is of the form
+# "/regexp/" then regular expression matching is used.  If $expected is
+# "~/regexp/" then the regular expression must NOT match.  If $expected is
+# of the form "#/value-list/" then each term in value-list must be numeric
+# and must approximately match the corresponding numeric term in $result.
+# Values must match within 10%.  Or if the $expected term is A..B then the
+# $result term must be in between A and B.
+#
+proc do_test {name cmd expected} {
+  if {[info exists ::testprefix]} {
+    set name "$::testprefix$name"
+  }
+
+  incr ::NTEST
+  puts -nonewline $name...
+  flush stdout
+
+  if {[catch {uplevel #0 "$cmd;\n"} result]} {
+    puts -nonewline $name...
+    puts "\nError: $result"
+    incr ::NERR
+  } else {
+    set ok [expr {[string compare $result $expected]==0}]
+    if {!$ok} {
+      puts "\n!  $name expected: \[$expected\]\n! $name got:      \[$result\]"
+      incr ::NERR
+    } else {
+      puts " Ok"
+    }
+  }
+  flush stdout
+}
+
+#
+#   do_execsql_test TESTNAME SQL RES
+#
+proc do_execsql_test {testname sql {result {}}} {
+  uplevel [list do_test $testname [list db eval $sql] [list {*}$result]]
+}
+
+if {[llength $argv]==0} {
+  set dir [file dirname $argv0]
+  set argv [glob -nocomplain $dir/*.test]
+}
+foreach testfile $argv {
+  file delete -force test.db
+  sqlite3 db test.db
+  source $testfile
+  catch {db close}
+}
+puts "$NERR errors out of $NTEST tests"
diff --git a/main.mk b/main.mk
index c74759b9cc..d8660fc17b 100644
--- a/main.mk
+++ b/main.mk
@@ -464,6 +464,7 @@ TESTPROGS = \
   testfixture$(EXE) \
   sqlite3$(EXE) \
   sqlite3_analyzer$(EXE) \
+  sqlite3_checker$(EXE) \
   sqldiff$(EXE) \
   dbhash$(EXE)
 
@@ -786,6 +787,22 @@ sqlite3_analyzer.c: sqlite3.c $(TOP)/src/tclsqlite.c $(TOP)/tool/spaceanal.tcl $
 sqlite3_analyzer$(EXE): sqlite3_analyzer.c
 	$(TCCX) $(TCL_FLAGS) sqlite3_analyzer.c -o $@ $(LIBTCL) $(THREADLIB) 
 
+CHECKER_DEPS =\
+  $(TOP)/tool/mkccode.tcl \
+  sqlite3.c \
+  $(TOP)/src/tclsqlite.c \
+  $(TOP)/ext/repair/sqlite3_checker.tcl \
+  $(TOP)/ext/repair/checkindex.c \
+  $(TOP)/ext/repair/checkfreelist.c \
+  $(TOP)/ext/misc/btreeinfo.c \
+  $(TOP)/ext/repair/sqlite3_checker.c.in
+
+sqlite3_checker.c:	$(CHECKER_DEPS)
+	tclsh $(TOP)/tool/mkccode.tcl $(TOP)/ext/repair/sqlite3_checker.c.in >$@
+
+sqlite3_checker$(TEXE):	sqlite3_checker.c
+	$(TCCX) $(TCL_FLAGS) sqlite3_checker.c -o $@ $(LIBTCL) $(THREADLIB)
+
 dbdump$(EXE):	$(TOP)/ext/misc/dbdump.c sqlite3.o
 	$(TCCX) -DDBDUMP_STANDALONE -o dbdump$(EXE) \
             $(TOP)/ext/misc/dbdump.c sqlite3.o $(THREADLIB)
diff --git a/manifest b/manifest
index aaea49591f..ef298569fa 100644
--- a/manifest
+++ b/manifest
@@ -1,8 +1,8 @@
-C Allow\sreadonly_shm\sconnections\sto\saccess\sthe\s*-shm\sfile\susing\sread()\seven\sif\nit\sis\sunable\sto\stake\sa\sDMS\slock.
-D 2017-11-03T17:17:44.636
-F Makefile.in 5bae3f2f3d42f2ad52b141562d74872c97ac0fca6c54953c91bb150a0e6427a8
+C Merge\slatest\strunk\schanges\swith\sthis\sbranch.
+D 2017-11-03T17:51:37.040
+F Makefile.in b142eb20482922153ebc77b261cdfd0a560ed05a81e9f6d9a2b0e8192922a1d2
 F Makefile.linux-gcc 7bc79876b875010e8c8f9502eb935ca92aa3c434
-F Makefile.msc 3a5cb477ec3ce5274663b693164e349db63348667cd45bad78cc13d580b691e2
+F Makefile.msc a55372a22454e742ba7c8f6edf05b83213ec01125166ad7dcee0567e2f7fc81b
 F README.md f5c87359573c4d255425e588a56554b50fdcc2afba4e017a2e02a43701456afd
 F VERSION 0c10cdfed866fdd2d80434f64f042c3330f1daaed12e54287beb104f04b3faaf
 F aclocal.m4 a5c22d164aff7ed549d53a90fa56d56955281f50
@@ -258,7 +258,7 @@ F ext/lsm1/test/lsm1_simple.test ca949efefa102f4644231dcd9291d8cda7699a4ce1006b2
 F ext/misc/README.md 8e008c8d2b02e09096b31dfba033253ac27c6c06a18aa5826e299fa7601d90b2
 F ext/misc/amatch.c 6db4607cb17c54b853a2d7c7c36046d004853f65b9b733e6f019d543d5dfae87
 F ext/misc/anycollseq.c 5ffdfde9829eeac52219136ad6aa7cd9a4edb3b15f4f2532de52f4a22525eddb
-F ext/misc/btreeinfo.c 89488a065f5fc3c54f81c589460d69d83cd2f337ae59ed1cf813b8572b258516
+F ext/misc/btreeinfo.c d7fd9a2fe2fa33ba28488e2fce703ebecc759219ea9e0bb3b254784866c0a676
 F ext/misc/carray.c ed96c218ea940b85c9a274c4d9c59fe9491c299147a38a8bba537687bd6c6005
 F ext/misc/closure.c 0d2a038df8fbae7f19de42e7c7d71f2e4dc88704
 F ext/misc/completion.c 52c3f01523e3e387eb321b4739a89d1fe47cbe6025aa1f2d8d3685e9e365df0f
@@ -282,7 +282,7 @@ F ext/misc/series.c f3c0dba5c5c749ce1782b53076108f87cf0b71041eb6023f727a9c50681d
 F ext/misc/sha1.c 0b9e9b855354910d3ca467bf39099d570e73db56
 F ext/misc/shathree.c fa185d7aee0ad0aca5e091b4a2db7baff11796170e5793b5de99e511a13af448
 F ext/misc/showauth.c 732578f0fe4ce42d577e1c86dc89dd14a006ab52
-F ext/misc/spellfix.c a4723b6aff748a417b5091b68a46443265c40f0d
+F ext/misc/spellfix.c 41cf26c6b89fcaa8798ae10ae64d39c1f1d9d6995152e545bd491c13058b8fac
 F ext/misc/stmt.c 6f16443abb3551e3f5813bb13ba19a30e7032830015b0f92fe0c0453045c0a11
 F ext/misc/totype.c 4a167594e791abeed95e0a8db028822b5e8fe512
 F ext/misc/unionvtab.c 1e0ebc5078e1a916db191bcd88f87e94ea7ba4aa563ee30ff706261cb4b39461
@@ -327,7 +327,14 @@ F ext/rbu/sqlite3rbu.c 64bd08c1011456f90564ed167abce3a9c2af421a924b21eb57231e078
 F ext/rbu/sqlite3rbu.h b42bcd4d8357268c6c39ab2a60b29c091e89328fa8cc49c8fac5ab8d007e79b2
 F ext/rbu/test_rbu.c 7073979b9cc80912bb03599ac8d85ab5d3bf03cfacd3463f2dcdd7822997533a
 F ext/repair/README.md 92f5e8aae749a4dae14f02eea8e1bb42d4db2b6ce5e83dbcdd6b1446997e0c15
-F ext/repair/checkfreelist.c 0abb84b4545016d57ba1a2aa8884c72c73ed838968909858c03bc1f38fb6b054
+F ext/repair/checkfreelist.c 0dbae18c1b552f58d64f8969e4fb1e7f11930c60a8c2a9a8d50b7f15bdfd54bd
+F ext/repair/checkindex.c 73f26fc1e2e17d68ede5db5b0aaf4869f2d6182f45f3d3624befc503c0f04a70
+F ext/repair/sqlite3_checker.c.in 4a5a3af3f450fe503e5a2985e98516dc2a6b9ad247449e284c1cf140fc91720f
+F ext/repair/sqlite3_checker.tcl 4820d7f58428d47336874b5a148a95b4dad38fe5da72286c01a861590b8f8337
+F ext/repair/test/README.md 34b2f542cf5be7bffe479242b33ee3492cea30711e447cc4a1a86cb5915f419e
+F ext/repair/test/checkfreelist01.test 3e8aa6aeb4007680c94a8d07b41c339aa635cc78249442da72ff3f8297398a69
+F ext/repair/test/checkindex01.test 98bfac50822da9681d75570087aac92a905290ffdaddf95ab6f69212fb4c7b14
+F ext/repair/test/test.tcl 686d76d888dffd021f64260abf29a55c57b2cedfa7fc69150b42b1d6119aac3c
 F ext/rtree/README 6315c0d73ebf0ec40dedb5aa0e942bc8b54e3761
 F ext/rtree/rtree.c cc91b6905bf55512c6ebc7dfdd37ac81c86f1753db8cfa6d62f0ee864464044f
 F ext/rtree/rtree.h 834dbcb82dc85b2481cde6a07cdadfddc99e9b9e
@@ -386,7 +393,7 @@ F ext/userauth/userauth.c 3410be31283abba70255d71fd24734e017a4497f
 F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895 x
 F ltmain.sh 3ff0879076df340d2e23ae905484d8c15d5fdea8
 F magic.txt 8273bf49ba3b0c8559cb2774495390c31fd61c60
-F main.mk 4fafbf2c23268ad5c497bd7c9da99dd3a53b1ffa2c150b6eb975397d4bb3f12f
+F main.mk fbe15be384ec172be0cc30efc91cda61ca16bd5d833e8b812cf653ccb0c74977
 F mkso.sh fd21c06b063bb16a5d25deea1752c2da6ac3ed83
 F mptest/config01.test 3c6adcbc50b991866855f1977ff172eb6d901271
 F mptest/config02.test 4415dfe36c48785f751e16e32c20b077c28ae504
@@ -413,7 +420,7 @@ F src/callback.c 28a8ede982fde4129b828350f78f2c01fe7d12c74d1a0a05d7108ab36f30868
 F src/complete.c a3634ab1e687055cd002e11b8f43eb75c17da23e
 F src/ctime.c ff1be3eed7bdd75aaca61ca8dc848f7c9f850ef2fb9cb56f2734e922a098f9c0
 F src/date.c 48f743d88bbe88f848532d333cca84f26e52a4f217e86f86be7fc1b919c33d74
-F src/dbpage.c 003755140e21b917c0a39e70907c1e4612b25d1e24b9a3c64b0d638c8ecb5dc2
+F src/dbpage.c 432f46fb47c99ae1f0e2863fe595038a6f9d3b59f4a3dabe5f86ec2a88758fde
 F src/dbstat.c 7a4ba8518b6369ef3600c49cf9c918ad979acba610b2aebef1b656d649b96720
 F src/delete.c 21a5f1812fdb599e9f7afb9f650bdabab60a3afd51d7e94e539c982f647b0023
 F src/expr.c 0016b95aed1df47ebc0eb7415bd621841d72dbffd3bfb62210e50e71d83b4691
@@ -549,7 +556,7 @@ F src/walker.c d591e8a9ccf60abb010966b354fcea4aa08eba4d83675c2b281a8764c76cc22f
 F src/where.c b7a075f5fb3d912a891dcc3257f538372bb4a1622dd8ca7d752ad95ce8949ba4
 F src/whereInt.h 82c04c5075308abbac59180c8bad5ecb45b07453981f60a53f3c7dee21e1e971
 F src/wherecode.c 4a117dd5886616d074f7b6589c23bf742f5a9858d6ffdaf8b9d1f76ab06245d2
-F src/whereexpr.c afcac9cccfc0fdaccbdda94034a398947b6dc47dbf821c1b496261722832a6a4
+F src/whereexpr.c 427ea8e96ec24f2a7814c67b8024ad664a9c7656264c4566c34743cb23186e46
 F test/8_3_names.test ebbb5cd36741350040fd28b432ceadf495be25b2
 F test/affinity2.test a6d901b436328bd67a79b41bb0ac2663918fe3bd
 F test/affinity3.test 6a101af2fc945ce2912f6fe54dd646018551710d
@@ -652,7 +659,6 @@ F test/capi3e.test 3d49c01ef2a1a55f41d73cba2b23b5059ec460fe
 F test/cast.test 4c275cbdc8202d6f9c54a3596701719868ac7dc3
 F test/cffault.test 9d6b20606afe712374952eec4f8fd74b1a8097ef
 F test/check.test 33a698e8c63613449d85d624a38ef669bf20331daabebe3891c9405dd6df463a
-F test/checkfreelist.test 100283a3e6b8a3018c7fab7cfdaf03d1d6540fc66453114e248cf82b25784d3b
 F test/close.test 799ea4599d2f5704b0a30f477d17c2c760d8523fa5d0c8be4a7df2a8cad787d8
 F test/closure01.test b1703ba40639cfc9b295cf478d70739415eec6a4
 F test/coalesce.test cee0dccb9fbd2d494b77234bccf9dc6c6786eb91
@@ -1668,7 +1674,7 @@ F vsixtest/vsixtest.tcl 6a9a6ab600c25a91a7acc6293828957a386a8a93
 F vsixtest/vsixtest.vcxproj.data 2ed517e100c66dc455b492e1a33350c1b20fbcdc
 F vsixtest/vsixtest.vcxproj.filters 37e51ffedcdb064aad6ff33b6148725226cd608e
 F vsixtest/vsixtest_TemporaryKey.pfx e5b1b036facdb453873e7084e1cae9102ccc67a0
-P f569c3517234881f9425075aab65a32ffd0deb8e793f421a241d8cca881da33f
-R 20903fe541f5da42c2200a9eba3c1e5d
+P 9b0d5c4ff707f58b07ae28cfe0a7de62fbd22fa20678e446350d1472391bc0b9 29ec855e13e0dcd675dcf12948b42f9e669d0a31c5d9efb95857888aba0beeee
+R 04d6fa7835319401e085a65123a1b583
 U dan
-Z 111bc60b3d02df6a9da28fff434dc070
+Z 9bd997c1b71c6c7594ae27b51b9c96d2
diff --git a/manifest.uuid b/manifest.uuid
index 910f081e0e..8e06905bef 100644
--- a/manifest.uuid
+++ b/manifest.uuid
@@ -1 +1 @@
-9b0d5c4ff707f58b07ae28cfe0a7de62fbd22fa20678e446350d1472391bc0b9
\ No newline at end of file
+585e0a09c5e1cd3d32e7b3fe228bd3eb674631f4074f517aad4c2600818a337a
\ No newline at end of file
diff --git a/src/dbpage.c b/src/dbpage.c
index f287e72229..75e4c42e67 100644
--- a/src/dbpage.c
+++ b/src/dbpage.c
@@ -329,7 +329,7 @@ static int dbpageUpdate(
     goto update_fail;
   }
   pBt = pTab->db->aDb[iDb].pBt;
-  if( pgno<1 || pBt==0 || pgno>sqlite3BtreeLastPage(pBt) ){
+  if( pgno<1 || pBt==0 || pgno>(int)sqlite3BtreeLastPage(pBt) ){
     zErr = "bad page number";
     goto update_fail;
   }
diff --git a/src/whereexpr.c b/src/whereexpr.c
index 9f83a84534..58f1908cf8 100644
--- a/src/whereexpr.c
+++ b/src/whereexpr.c
@@ -983,7 +983,7 @@ static void exprAnalyze(
   int op;                          /* Top-level operator.  pExpr->op */
   Parse *pParse = pWInfo->pParse;  /* Parsing context */
   sqlite3 *db = pParse->db;        /* Database connection */
-  unsigned char eOp2;              /* op2 value for LIKE/REGEXP/GLOB */
+  unsigned char eOp2 = 0;          /* op2 value for LIKE/REGEXP/GLOB */
   int nLeft;                       /* Number of elements on left side vector */
 
   if( db->mallocFailed ){
@@ -1227,7 +1227,7 @@ static void exprAnalyze(
   ** to do anything with MATCH functions.
   */
   if( pWC->op==TK_AND ){
-    Expr *pRight, *pLeft;
+    Expr *pRight = 0, *pLeft = 0;
     int res = isAuxiliaryVtabOperator(pExpr, &eOp2, &pLeft, &pRight);
     while( res-- > 0 ){
       int idxNew;