Restoring authorship annotation for <snermolaev@yandex-team.ru>. Commit 1 of 2.

1 files changed, 1295 insertions, 1295 deletions

diff --git a/contrib/libs/sqlite3/test_multiplex.c b/contrib/libs/sqlite3/test_multiplex.c
index 1e185a95a2..1c88c59543 100644
--- a/contrib/libs/sqlite3/test_multiplex.c
+++ b/contrib/libs/sqlite3/test_multiplex.c
@@ -1,967 +1,967 @@
-/*
-** 2010 October 28
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-*************************************************************************
-**
-** This file contains a VFS "shim" - a layer that sits in between the
-** pager and the real VFS - that breaks up a very large database file
-** into two or more smaller files on disk.  This is useful, for example,
-** in order to support large, multi-gigabyte databases on older filesystems
-** that limit the maximum file size to 2 GiB.
-**
-** USAGE:
-**
-** Compile this source file and link it with your application.  Then
-** at start-time, invoke the following procedure:
-**
-**   int sqlite3_multiplex_initialize(
-**      const char *zOrigVfsName,    // The underlying real VFS
-**      int makeDefault              // True to make multiplex the default VFS
-**   );
-**
-** The procedure call above will create and register a new VFS shim named
-** "multiplex".  The multiplex VFS will use the VFS named by zOrigVfsName to
-** do the actual disk I/O.  (The zOrigVfsName parameter may be NULL, in 
-** which case the default VFS at the moment sqlite3_multiplex_initialize()
-** is called will be used as the underlying real VFS.)  
-**
-** If the makeDefault parameter is TRUE then multiplex becomes the new
-** default VFS.  Otherwise, you can use the multiplex VFS by specifying
-** "multiplex" as the 4th parameter to sqlite3_open_v2() or by employing
-** URI filenames and adding "vfs=multiplex" as a parameter to the filename
-** URI.
-**
-** The multiplex VFS allows databases up to 32 GiB in size.  But it splits
-** the files up into smaller pieces, so that they will work even on 
-** filesystems that do not support large files.  The default chunk size
-** is 2147418112 bytes (which is 64KiB less than 2GiB) but this can be
-** changed at compile-time by defining the SQLITE_MULTIPLEX_CHUNK_SIZE
-** macro.  Use the "chunksize=NNNN" query parameter with a URI filename
-** in order to select an alternative chunk size for individual connections
-** at run-time.
-*/
-#include "sqlite3.h"
-#include <string.h>
-#include <assert.h>
-#include <stdlib.h>
-#include "test_multiplex.h"
-
-#ifndef SQLITE_CORE
-  #define SQLITE_CORE 1  /* Disable the API redefinition in sqlite3ext.h */
-#endif
-#include "sqlite3ext.h"
-
 /* 
-** These should be defined to be the same as the values in 
-** sqliteInt.h.  They are defined separately here so that
-** the multiplex VFS shim can be built as a loadable 
-** module.
-*/
-#define UNUSED_PARAMETER(x) (void)(x)
-#define MAX_PAGE_SIZE       0x10000
-#define DEFAULT_SECTOR_SIZE 0x1000
-
-/* Maximum chunk number */
-#define MX_CHUNK_NUMBER 299
-
-/* First chunk for rollback journal files */
-#define SQLITE_MULTIPLEX_JOURNAL_8_3_OFFSET 400
-#define SQLITE_MULTIPLEX_WAL_8_3_OFFSET 700
-
-
-/************************ Shim Definitions ******************************/
-
-#ifndef SQLITE_MULTIPLEX_VFS_NAME
-# define SQLITE_MULTIPLEX_VFS_NAME "multiplex"
-#endif
-
-/* This is the limit on the chunk size.  It may be changed by calling
-** the xFileControl() interface.  It will be rounded up to a 
-** multiple of MAX_PAGE_SIZE.  We default it here to 2GiB less 64KiB.
-*/
-#ifndef SQLITE_MULTIPLEX_CHUNK_SIZE
-# define SQLITE_MULTIPLEX_CHUNK_SIZE 2147418112
-#endif
-
-/* This used to be the default limit on number of chunks, but
-** it is no longer enforced. There is currently no limit to the
-** number of chunks.
-**
-** May be changed by calling the xFileControl() interface.
-*/
-#ifndef SQLITE_MULTIPLEX_MAX_CHUNKS
-# define SQLITE_MULTIPLEX_MAX_CHUNKS 12
-#endif
-
-/************************ Object Definitions ******************************/
-
-/* Forward declaration of all object types */
-typedef struct multiplexGroup multiplexGroup;
-typedef struct multiplexConn multiplexConn;
-
-/*
-** A "multiplex group" is a collection of files that collectively
-** makeup a single SQLite DB file.  This allows the size of the DB
-** to exceed the limits imposed by the file system.
-**
-** There is an instance of the following object for each defined multiplex
-** group.
-*/
-struct multiplexGroup {
-  struct multiplexReal {           /* For each chunk */
-    sqlite3_file *p;                  /* Handle for the chunk */
-    char *z;                          /* Name of this chunk */
-  } *aReal;                        /* list of all chunks */
-  int nReal;                       /* Number of chunks */
-  char *zName;                     /* Base filename of this group */
-  int nName;                       /* Length of base filename */
-  int flags;                       /* Flags used for original opening */
-  unsigned int szChunk;            /* Chunk size used for this group */
-  unsigned char bEnabled;          /* TRUE to use Multiplex VFS for this file */
-  unsigned char bTruncate;         /* TRUE to enable truncation of databases */
-};
-
-/*
-** An instance of the following object represents each open connection
-** to a file that is multiplex'ed.  This object is a 
-** subclass of sqlite3_file.  The sqlite3_file object for the underlying
-** VFS is appended to this structure.
-*/
-struct multiplexConn {
-  sqlite3_file base;              /* Base class - must be first */
-  multiplexGroup *pGroup;         /* The underlying group of files */
-};
-
-/************************* Global Variables **********************************/
-/*
-** All global variables used by this file are containing within the following
-** gMultiplex structure.
-*/
-static struct {
-  /* The pOrigVfs is the real, original underlying VFS implementation.
-  ** Most operations pass-through to the real VFS.  This value is read-only
-  ** during operation.  It is only modified at start-time and thus does not
-  ** require a mutex.
-  */
-  sqlite3_vfs *pOrigVfs;
-
-  /* The sThisVfs is the VFS structure used by this shim.  It is initialized
-  ** at start-time and thus does not require a mutex
-  */
-  sqlite3_vfs sThisVfs;
-
-  /* The sIoMethods defines the methods used by sqlite3_file objects 
-  ** associated with this shim.  It is initialized at start-time and does
-  ** not require a mutex.
-  **
-  ** When the underlying VFS is called to open a file, it might return 
-  ** either a version 1 or a version 2 sqlite3_file object.  This shim
-  ** has to create a wrapper sqlite3_file of the same version.  Hence
-  ** there are two I/O method structures, one for version 1 and the other
-  ** for version 2.
-  */
-  sqlite3_io_methods sIoMethodsV1;
-  sqlite3_io_methods sIoMethodsV2;
-
-  /* True when this shim has been initialized.
-  */
-  int isInitialized;
-} gMultiplex;
-
-/************************* Utility Routines *********************************/
-/*
-** Compute a string length that is limited to what can be stored in
-** lower 30 bits of a 32-bit signed integer.
-**
-** The value returned will never be negative.  Nor will it ever be greater
-** than the actual length of the string.  For very long strings (greater
-** than 1GiB) the value returned might be less than the true string length.
-*/
-static int multiplexStrlen30(const char *z){
-  const char *z2 = z;
-  if( z==0 ) return 0;
-  while( *z2 ){ z2++; }
-  return 0x3fffffff & (int)(z2 - z);
-}
-
-/*
-** Generate the file-name for chunk iChunk of the group with base name
-** zBase. The file-name is written to buffer zOut before returning. Buffer
-** zOut must be allocated by the caller so that it is at least (nBase+5)
-** bytes in size, where nBase is the length of zBase, not including the
-** nul-terminator.
-**
-** If iChunk is 0 (or 400 - the number for the first journal file chunk),
-** the output is a copy of the input string. Otherwise, if 
-** SQLITE_ENABLE_8_3_NAMES is not defined or the input buffer does not contain
-** a "." character, then the output is a copy of the input string with the 
-** three-digit zero-padded decimal representation if iChunk appended to it. 
-** For example:
-**
-**   zBase="test.db", iChunk=4  ->  zOut="test.db004"
-**
-** Or, if SQLITE_ENABLE_8_3_NAMES is defined and the input buffer contains
-** a "." character, then everything after the "." is replaced by the 
-** three-digit representation of iChunk.
-**
-**   zBase="test.db", iChunk=4  ->  zOut="test.004"
-**
-** The output buffer string is terminated by 2 0x00 bytes. This makes it safe
-** to pass to sqlite3_uri_parameter() and similar.
-*/
-static void multiplexFilename(
-  const char *zBase,              /* Filename for chunk 0 */
-  int nBase,                      /* Size of zBase in bytes (without \0) */
-  int flags,                      /* Flags used to open file */
-  int iChunk,                     /* Chunk to generate filename for */
-  char *zOut                      /* Buffer to write generated name to */
-){
-  int n = nBase;
-  memcpy(zOut, zBase, n+1);
-  if( iChunk!=0 && iChunk<=MX_CHUNK_NUMBER ){
-#ifdef SQLITE_ENABLE_8_3_NAMES
-    int i;
-    for(i=n-1; i>0 && i>=n-4 && zOut[i]!='.'; i--){}
-    if( i>=n-4 ) n = i+1;
-    if( flags & SQLITE_OPEN_MAIN_JOURNAL ){
-      /* The extensions on overflow files for main databases are 001, 002,
-      ** 003 and so forth.  To avoid name collisions, add 400 to the 
-      ** extensions of journal files so that they are 401, 402, 403, ....
-      */
-      iChunk += SQLITE_MULTIPLEX_JOURNAL_8_3_OFFSET;
-    }else if( flags & SQLITE_OPEN_WAL ){
-      /* To avoid name collisions, add 700 to the 
-      ** extensions of WAL files so that they are 701, 702, 703, ....
-      */
-      iChunk += SQLITE_MULTIPLEX_WAL_8_3_OFFSET;
-    }
-#endif
-    sqlite3_snprintf(4,&zOut[n],"%03d",iChunk);
-    n += 3;
-  }
-
-  assert( zOut[n]=='\0' );
-  zOut[n+1] = '\0';
-}
-
-/* Compute the filename for the iChunk-th chunk
-*/
-static int multiplexSubFilename(multiplexGroup *pGroup, int iChunk){
-  if( iChunk>=pGroup->nReal ){
-    struct multiplexReal *p;
-    p = sqlite3_realloc64(pGroup->aReal, (iChunk+1)*sizeof(*p));
-    if( p==0 ){
-      return SQLITE_NOMEM;
-    }
-    memset(&p[pGroup->nReal], 0, sizeof(p[0])*(iChunk+1-pGroup->nReal));
-    pGroup->aReal = p;
-    pGroup->nReal = iChunk+1;
-  }
-  if( pGroup->zName && pGroup->aReal[iChunk].z==0 ){
-    char *z;
-    int n = pGroup->nName;
+** 2010 October 28 
+** 
+** The author disclaims copyright to this source code.  In place of 
+** a legal notice, here is a blessing: 
+** 
+**    May you do good and not evil. 
+**    May you find forgiveness for yourself and forgive others. 
+**    May you share freely, never taking more than you give. 
+** 
+************************************************************************* 
+** 
+** This file contains a VFS "shim" - a layer that sits in between the 
+** pager and the real VFS - that breaks up a very large database file 
+** into two or more smaller files on disk.  This is useful, for example, 
+** in order to support large, multi-gigabyte databases on older filesystems 
+** that limit the maximum file size to 2 GiB. 
+** 
+** USAGE: 
+** 
+** Compile this source file and link it with your application.  Then 
+** at start-time, invoke the following procedure: 
+** 
+**   int sqlite3_multiplex_initialize( 
+**      const char *zOrigVfsName,    // The underlying real VFS 
+**      int makeDefault              // True to make multiplex the default VFS 
+**   ); 
+** 
+** The procedure call above will create and register a new VFS shim named 
+** "multiplex".  The multiplex VFS will use the VFS named by zOrigVfsName to 
+** do the actual disk I/O.  (The zOrigVfsName parameter may be NULL, in  
+** which case the default VFS at the moment sqlite3_multiplex_initialize() 
+** is called will be used as the underlying real VFS.)   
+** 
+** If the makeDefault parameter is TRUE then multiplex becomes the new 
+** default VFS.  Otherwise, you can use the multiplex VFS by specifying 
+** "multiplex" as the 4th parameter to sqlite3_open_v2() or by employing 
+** URI filenames and adding "vfs=multiplex" as a parameter to the filename 
+** URI. 
+** 
+** The multiplex VFS allows databases up to 32 GiB in size.  But it splits 
+** the files up into smaller pieces, so that they will work even on  
+** filesystems that do not support large files.  The default chunk size 
+** is 2147418112 bytes (which is 64KiB less than 2GiB) but this can be 
+** changed at compile-time by defining the SQLITE_MULTIPLEX_CHUNK_SIZE 
+** macro.  Use the "chunksize=NNNN" query parameter with a URI filename 
+** in order to select an alternative chunk size for individual connections 
+** at run-time. 
+*/ 
+#include "sqlite3.h" 
+#include <string.h> 
+#include <assert.h> 
+#include <stdlib.h> 
+#include "test_multiplex.h" 
+ 
+#ifndef SQLITE_CORE 
+  #define SQLITE_CORE 1  /* Disable the API redefinition in sqlite3ext.h */ 
+#endif 
+#include "sqlite3ext.h" 
+ 
+/*  
+** These should be defined to be the same as the values in  
+** sqliteInt.h.  They are defined separately here so that 
+** the multiplex VFS shim can be built as a loadable  
+** module. 
+*/ 
+#define UNUSED_PARAMETER(x) (void)(x) 
+#define MAX_PAGE_SIZE       0x10000 
+#define DEFAULT_SECTOR_SIZE 0x1000 
+ 
+/* Maximum chunk number */ 
+#define MX_CHUNK_NUMBER 299 
+ 
+/* First chunk for rollback journal files */ 
+#define SQLITE_MULTIPLEX_JOURNAL_8_3_OFFSET 400 
+#define SQLITE_MULTIPLEX_WAL_8_3_OFFSET 700 
+ 
+ 
+/************************ Shim Definitions ******************************/ 
+ 
+#ifndef SQLITE_MULTIPLEX_VFS_NAME 
+# define SQLITE_MULTIPLEX_VFS_NAME "multiplex" 
+#endif 
+ 
+/* This is the limit on the chunk size.  It may be changed by calling 
+** the xFileControl() interface.  It will be rounded up to a  
+** multiple of MAX_PAGE_SIZE.  We default it here to 2GiB less 64KiB. 
+*/ 
+#ifndef SQLITE_MULTIPLEX_CHUNK_SIZE 
+# define SQLITE_MULTIPLEX_CHUNK_SIZE 2147418112 
+#endif 
+ 
+/* This used to be the default limit on number of chunks, but 
+** it is no longer enforced. There is currently no limit to the 
+** number of chunks. 
+** 
+** May be changed by calling the xFileControl() interface. 
+*/ 
+#ifndef SQLITE_MULTIPLEX_MAX_CHUNKS 
+# define SQLITE_MULTIPLEX_MAX_CHUNKS 12 
+#endif 
+ 
+/************************ Object Definitions ******************************/ 
+ 
+/* Forward declaration of all object types */ 
+typedef struct multiplexGroup multiplexGroup; 
+typedef struct multiplexConn multiplexConn; 
+ 
+/* 
+** A "multiplex group" is a collection of files that collectively 
+** makeup a single SQLite DB file.  This allows the size of the DB 
+** to exceed the limits imposed by the file system. 
+** 
+** There is an instance of the following object for each defined multiplex 
+** group. 
+*/ 
+struct multiplexGroup { 
+  struct multiplexReal {           /* For each chunk */ 
+    sqlite3_file *p;                  /* Handle for the chunk */ 
+    char *z;                          /* Name of this chunk */ 
+  } *aReal;                        /* list of all chunks */ 
+  int nReal;                       /* Number of chunks */ 
+  char *zName;                     /* Base filename of this group */ 
+  int nName;                       /* Length of base filename */ 
+  int flags;                       /* Flags used for original opening */ 
+  unsigned int szChunk;            /* Chunk size used for this group */ 
+  unsigned char bEnabled;          /* TRUE to use Multiplex VFS for this file */ 
+  unsigned char bTruncate;         /* TRUE to enable truncation of databases */ 
+}; 
+ 
+/* 
+** An instance of the following object represents each open connection 
+** to a file that is multiplex'ed.  This object is a  
+** subclass of sqlite3_file.  The sqlite3_file object for the underlying 
+** VFS is appended to this structure. 
+*/ 
+struct multiplexConn { 
+  sqlite3_file base;              /* Base class - must be first */ 
+  multiplexGroup *pGroup;         /* The underlying group of files */ 
+}; 
+ 
+/************************* Global Variables **********************************/ 
+/* 
+** All global variables used by this file are containing within the following 
+** gMultiplex structure. 
+*/ 
+static struct { 
+  /* The pOrigVfs is the real, original underlying VFS implementation. 
+  ** Most operations pass-through to the real VFS.  This value is read-only 
+  ** during operation.  It is only modified at start-time and thus does not 
+  ** require a mutex. 
+  */ 
+  sqlite3_vfs *pOrigVfs; 
+ 
+  /* The sThisVfs is the VFS structure used by this shim.  It is initialized 
+  ** at start-time and thus does not require a mutex 
+  */ 
+  sqlite3_vfs sThisVfs; 
+ 
+  /* The sIoMethods defines the methods used by sqlite3_file objects  
+  ** associated with this shim.  It is initialized at start-time and does 
+  ** not require a mutex. 
+  ** 
+  ** When the underlying VFS is called to open a file, it might return  
+  ** either a version 1 or a version 2 sqlite3_file object.  This shim 
+  ** has to create a wrapper sqlite3_file of the same version.  Hence 
+  ** there are two I/O method structures, one for version 1 and the other 
+  ** for version 2. 
+  */ 
+  sqlite3_io_methods sIoMethodsV1; 
+  sqlite3_io_methods sIoMethodsV2; 
+ 
+  /* True when this shim has been initialized. 
+  */ 
+  int isInitialized; 
+} gMultiplex; 
+ 
+/************************* Utility Routines *********************************/ 
+/* 
+** Compute a string length that is limited to what can be stored in 
+** lower 30 bits of a 32-bit signed integer. 
+** 
+** The value returned will never be negative.  Nor will it ever be greater 
+** than the actual length of the string.  For very long strings (greater 
+** than 1GiB) the value returned might be less than the true string length. 
+*/ 
+static int multiplexStrlen30(const char *z){ 
+  const char *z2 = z; 
+  if( z==0 ) return 0; 
+  while( *z2 ){ z2++; } 
+  return 0x3fffffff & (int)(z2 - z); 
+} 
+ 
+/* 
+** Generate the file-name for chunk iChunk of the group with base name 
+** zBase. The file-name is written to buffer zOut before returning. Buffer 
+** zOut must be allocated by the caller so that it is at least (nBase+5) 
+** bytes in size, where nBase is the length of zBase, not including the 
+** nul-terminator. 
+** 
+** If iChunk is 0 (or 400 - the number for the first journal file chunk), 
+** the output is a copy of the input string. Otherwise, if  
+** SQLITE_ENABLE_8_3_NAMES is not defined or the input buffer does not contain 
+** a "." character, then the output is a copy of the input string with the  
+** three-digit zero-padded decimal representation if iChunk appended to it.  
+** For example: 
+** 
+**   zBase="test.db", iChunk=4  ->  zOut="test.db004" 
+** 
+** Or, if SQLITE_ENABLE_8_3_NAMES is defined and the input buffer contains 
+** a "." character, then everything after the "." is replaced by the  
+** three-digit representation of iChunk. 
+** 
+**   zBase="test.db", iChunk=4  ->  zOut="test.004" 
+** 
+** The output buffer string is terminated by 2 0x00 bytes. This makes it safe 
+** to pass to sqlite3_uri_parameter() and similar. 
+*/ 
+static void multiplexFilename( 
+  const char *zBase,              /* Filename for chunk 0 */ 
+  int nBase,                      /* Size of zBase in bytes (without \0) */ 
+  int flags,                      /* Flags used to open file */ 
+  int iChunk,                     /* Chunk to generate filename for */ 
+  char *zOut                      /* Buffer to write generated name to */ 
+){ 
+  int n = nBase; 
+  memcpy(zOut, zBase, n+1); 
+  if( iChunk!=0 && iChunk<=MX_CHUNK_NUMBER ){ 
+#ifdef SQLITE_ENABLE_8_3_NAMES 
+    int i; 
+    for(i=n-1; i>0 && i>=n-4 && zOut[i]!='.'; i--){} 
+    if( i>=n-4 ) n = i+1; 
+    if( flags & SQLITE_OPEN_MAIN_JOURNAL ){ 
+      /* The extensions on overflow files for main databases are 001, 002, 
+      ** 003 and so forth.  To avoid name collisions, add 400 to the  
+      ** extensions of journal files so that they are 401, 402, 403, .... 
+      */ 
+      iChunk += SQLITE_MULTIPLEX_JOURNAL_8_3_OFFSET; 
+    }else if( flags & SQLITE_OPEN_WAL ){ 
+      /* To avoid name collisions, add 700 to the  
+      ** extensions of WAL files so that they are 701, 702, 703, .... 
+      */ 
+      iChunk += SQLITE_MULTIPLEX_WAL_8_3_OFFSET; 
+    } 
+#endif 
+    sqlite3_snprintf(4,&zOut[n],"%03d",iChunk); 
+    n += 3; 
+  } 
+ 
+  assert( zOut[n]=='\0' ); 
+  zOut[n+1] = '\0'; 
+} 
+ 
+/* Compute the filename for the iChunk-th chunk 
+*/ 
+static int multiplexSubFilename(multiplexGroup *pGroup, int iChunk){ 
+  if( iChunk>=pGroup->nReal ){ 
+    struct multiplexReal *p; 
+    p = sqlite3_realloc64(pGroup->aReal, (iChunk+1)*sizeof(*p)); 
+    if( p==0 ){ 
+      return SQLITE_NOMEM; 
+    } 
+    memset(&p[pGroup->nReal], 0, sizeof(p[0])*(iChunk+1-pGroup->nReal)); 
+    pGroup->aReal = p; 
+    pGroup->nReal = iChunk+1; 
+  } 
+  if( pGroup->zName && pGroup->aReal[iChunk].z==0 ){ 
+    char *z; 
+    int n = pGroup->nName; 
     z = sqlite3_malloc64( n+5 );
-    if( z==0 ){
-      return SQLITE_NOMEM;
-    }
-    multiplexFilename(pGroup->zName, pGroup->nName, pGroup->flags, iChunk, z);
+    if( z==0 ){ 
+      return SQLITE_NOMEM; 
+    } 
+    multiplexFilename(pGroup->zName, pGroup->nName, pGroup->flags, iChunk, z); 
     pGroup->aReal[iChunk].z = sqlite3_create_filename(z,"","",0,0);
     sqlite3_free(z);
     if( pGroup->aReal[iChunk].z==0 ) return SQLITE_NOMEM;
-  }
-  return SQLITE_OK;
-}
-
-/* Translate an sqlite3_file* that is really a multiplexGroup* into
-** the sqlite3_file* for the underlying original VFS.
-**
-** For chunk 0, the pGroup->flags determines whether or not a new file
-** is created if it does not already exist.  For chunks 1 and higher, the
-** file is created only if createFlag is 1.
-*/
-static sqlite3_file *multiplexSubOpen(
-  multiplexGroup *pGroup,    /* The multiplexor group */
-  int iChunk,                /* Which chunk to open.  0==original file */
-  int *rc,                   /* Result code in and out */
-  int *pOutFlags,            /* Output flags */
-  int createFlag             /* True to create if iChunk>0 */
-){
-  sqlite3_file *pSubOpen = 0;
-  sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs;        /* Real VFS */
-
-#ifdef SQLITE_ENABLE_8_3_NAMES
-  /* If JOURNAL_8_3_OFFSET is set to (say) 400, then any overflow files are 
-  ** part of a database journal are named db.401, db.402, and so on. A 
-  ** database may therefore not grow to larger than 400 chunks. Attempting
-  ** to open chunk 401 indicates the database is full. */
-  if( iChunk>=SQLITE_MULTIPLEX_JOURNAL_8_3_OFFSET ){
-    sqlite3_log(SQLITE_FULL, "multiplexed chunk overflow: %s", pGroup->zName);
-    *rc = SQLITE_FULL;
-    return 0;
-  }
-#endif
-
-  *rc = multiplexSubFilename(pGroup, iChunk);
-  if( (*rc)==SQLITE_OK && (pSubOpen = pGroup->aReal[iChunk].p)==0 ){
-    int flags, bExists;
-    flags = pGroup->flags;
-    if( createFlag ){
-      flags |= SQLITE_OPEN_CREATE;
-    }else if( iChunk==0 ){
-      /* Fall through */
-    }else if( pGroup->aReal[iChunk].z==0 ){
-      return 0;
-    }else{
-      *rc = pOrigVfs->xAccess(pOrigVfs, pGroup->aReal[iChunk].z,
-                              SQLITE_ACCESS_EXISTS, &bExists);
-     if( *rc || !bExists ){
-        if( *rc ){
-          sqlite3_log(*rc, "multiplexor.xAccess failure on %s",
-                      pGroup->aReal[iChunk].z);
-        }
-        return 0;
-      }
-      flags &= ~SQLITE_OPEN_CREATE;
-    }
-    pSubOpen = sqlite3_malloc64( pOrigVfs->szOsFile );
-    if( pSubOpen==0 ){
-      *rc = SQLITE_IOERR_NOMEM;
-      return 0;
-    }
-    pGroup->aReal[iChunk].p = pSubOpen;
-    *rc = pOrigVfs->xOpen(pOrigVfs, pGroup->aReal[iChunk].z, pSubOpen,
-                          flags, pOutFlags);
-    if( (*rc)!=SQLITE_OK ){
-      sqlite3_log(*rc, "multiplexor.xOpen failure on %s",
-                  pGroup->aReal[iChunk].z);
-      sqlite3_free(pSubOpen);
-      pGroup->aReal[iChunk].p = 0;
-      return 0;
-    }
-  }
-  return pSubOpen;
-}
-
-/*
-** Return the size, in bytes, of chunk number iChunk.  If that chunk
-** does not exist, then return 0.  This function does not distingish between
-** non-existant files and zero-length files.
-*/
-static sqlite3_int64 multiplexSubSize(
-  multiplexGroup *pGroup,    /* The multiplexor group */
-  int iChunk,                /* Which chunk to open.  0==original file */
-  int *rc                    /* Result code in and out */
-){
-  sqlite3_file *pSub;
-  sqlite3_int64 sz = 0;
-
-  if( *rc ) return 0;
-  pSub = multiplexSubOpen(pGroup, iChunk, rc, NULL, 0);
-  if( pSub==0 ) return 0;
-  *rc = pSub->pMethods->xFileSize(pSub, &sz);
-  return sz;
-}    
-
-/*
-** This is the implementation of the multiplex_control() SQL function.
-*/
-static void multiplexControlFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  int rc = SQLITE_OK;
-  sqlite3 *db = sqlite3_context_db_handle(context);
-  int op = 0;
-  int iVal;
-
-  if( !db || argc!=2 ){ 
-    rc = SQLITE_ERROR; 
-  }else{
-    /* extract params */
-    op = sqlite3_value_int(argv[0]);
-    iVal = sqlite3_value_int(argv[1]);
-    /* map function op to file_control op */
-    switch( op ){
-      case 1: 
-        op = MULTIPLEX_CTRL_ENABLE; 
-        break;
-      case 2: 
-        op = MULTIPLEX_CTRL_SET_CHUNK_SIZE; 
-        break;
-      case 3: 
-        op = MULTIPLEX_CTRL_SET_MAX_CHUNKS; 
-        break;
-      default:
-        rc = SQLITE_NOTFOUND;
-        break;
-    }
-  }
-  if( rc==SQLITE_OK ){
-    rc = sqlite3_file_control(db, 0, op, &iVal);
-  }
-  sqlite3_result_error_code(context, rc);
-}
-
-/*
-** This is the entry point to register the auto-extension for the 
-** multiplex_control() function.
-*/
-static int multiplexFuncInit(
-  sqlite3 *db, 
-  char **pzErrMsg, 
-  const sqlite3_api_routines *pApi
-){
-  int rc;
-  rc = sqlite3_create_function(db, "multiplex_control", 2, SQLITE_ANY, 
-      0, multiplexControlFunc, 0, 0);
-  return rc;
-}
-
-/*
-** Close a single sub-file in the connection group.
-*/
-static void multiplexSubClose(
-  multiplexGroup *pGroup,
-  int iChunk,
-  sqlite3_vfs *pOrigVfs
-){
-  sqlite3_file *pSubOpen = pGroup->aReal[iChunk].p;
-  if( pSubOpen ){
-    pSubOpen->pMethods->xClose(pSubOpen);
-    if( pOrigVfs && pGroup->aReal[iChunk].z ){
-      pOrigVfs->xDelete(pOrigVfs, pGroup->aReal[iChunk].z, 0);
-    }
-    sqlite3_free(pGroup->aReal[iChunk].p);
-  }
+  } 
+  return SQLITE_OK; 
+} 
+ 
+/* Translate an sqlite3_file* that is really a multiplexGroup* into 
+** the sqlite3_file* for the underlying original VFS. 
+** 
+** For chunk 0, the pGroup->flags determines whether or not a new file 
+** is created if it does not already exist.  For chunks 1 and higher, the 
+** file is created only if createFlag is 1. 
+*/ 
+static sqlite3_file *multiplexSubOpen( 
+  multiplexGroup *pGroup,    /* The multiplexor group */ 
+  int iChunk,                /* Which chunk to open.  0==original file */ 
+  int *rc,                   /* Result code in and out */ 
+  int *pOutFlags,            /* Output flags */ 
+  int createFlag             /* True to create if iChunk>0 */ 
+){ 
+  sqlite3_file *pSubOpen = 0; 
+  sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs;        /* Real VFS */ 
+ 
+#ifdef SQLITE_ENABLE_8_3_NAMES 
+  /* If JOURNAL_8_3_OFFSET is set to (say) 400, then any overflow files are  
+  ** part of a database journal are named db.401, db.402, and so on. A  
+  ** database may therefore not grow to larger than 400 chunks. Attempting 
+  ** to open chunk 401 indicates the database is full. */ 
+  if( iChunk>=SQLITE_MULTIPLEX_JOURNAL_8_3_OFFSET ){ 
+    sqlite3_log(SQLITE_FULL, "multiplexed chunk overflow: %s", pGroup->zName); 
+    *rc = SQLITE_FULL; 
+    return 0; 
+  } 
+#endif 
+ 
+  *rc = multiplexSubFilename(pGroup, iChunk); 
+  if( (*rc)==SQLITE_OK && (pSubOpen = pGroup->aReal[iChunk].p)==0 ){ 
+    int flags, bExists; 
+    flags = pGroup->flags; 
+    if( createFlag ){ 
+      flags |= SQLITE_OPEN_CREATE; 
+    }else if( iChunk==0 ){ 
+      /* Fall through */ 
+    }else if( pGroup->aReal[iChunk].z==0 ){ 
+      return 0; 
+    }else{ 
+      *rc = pOrigVfs->xAccess(pOrigVfs, pGroup->aReal[iChunk].z, 
+                              SQLITE_ACCESS_EXISTS, &bExists); 
+     if( *rc || !bExists ){ 
+        if( *rc ){ 
+          sqlite3_log(*rc, "multiplexor.xAccess failure on %s", 
+                      pGroup->aReal[iChunk].z); 
+        } 
+        return 0; 
+      } 
+      flags &= ~SQLITE_OPEN_CREATE; 
+    } 
+    pSubOpen = sqlite3_malloc64( pOrigVfs->szOsFile ); 
+    if( pSubOpen==0 ){ 
+      *rc = SQLITE_IOERR_NOMEM; 
+      return 0; 
+    } 
+    pGroup->aReal[iChunk].p = pSubOpen; 
+    *rc = pOrigVfs->xOpen(pOrigVfs, pGroup->aReal[iChunk].z, pSubOpen, 
+                          flags, pOutFlags); 
+    if( (*rc)!=SQLITE_OK ){ 
+      sqlite3_log(*rc, "multiplexor.xOpen failure on %s", 
+                  pGroup->aReal[iChunk].z); 
+      sqlite3_free(pSubOpen); 
+      pGroup->aReal[iChunk].p = 0; 
+      return 0; 
+    } 
+  } 
+  return pSubOpen; 
+} 
+ 
+/* 
+** Return the size, in bytes, of chunk number iChunk.  If that chunk 
+** does not exist, then return 0.  This function does not distingish between 
+** non-existant files and zero-length files. 
+*/ 
+static sqlite3_int64 multiplexSubSize( 
+  multiplexGroup *pGroup,    /* The multiplexor group */ 
+  int iChunk,                /* Which chunk to open.  0==original file */ 
+  int *rc                    /* Result code in and out */ 
+){ 
+  sqlite3_file *pSub; 
+  sqlite3_int64 sz = 0; 
+ 
+  if( *rc ) return 0; 
+  pSub = multiplexSubOpen(pGroup, iChunk, rc, NULL, 0); 
+  if( pSub==0 ) return 0; 
+  *rc = pSub->pMethods->xFileSize(pSub, &sz); 
+  return sz; 
+}     
+ 
+/* 
+** This is the implementation of the multiplex_control() SQL function. 
+*/ 
+static void multiplexControlFunc( 
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  int rc = SQLITE_OK; 
+  sqlite3 *db = sqlite3_context_db_handle(context); 
+  int op = 0; 
+  int iVal; 
+ 
+  if( !db || argc!=2 ){  
+    rc = SQLITE_ERROR;  
+  }else{ 
+    /* extract params */ 
+    op = sqlite3_value_int(argv[0]); 
+    iVal = sqlite3_value_int(argv[1]); 
+    /* map function op to file_control op */ 
+    switch( op ){ 
+      case 1:  
+        op = MULTIPLEX_CTRL_ENABLE;  
+        break; 
+      case 2:  
+        op = MULTIPLEX_CTRL_SET_CHUNK_SIZE;  
+        break; 
+      case 3:  
+        op = MULTIPLEX_CTRL_SET_MAX_CHUNKS;  
+        break; 
+      default: 
+        rc = SQLITE_NOTFOUND; 
+        break; 
+    } 
+  } 
+  if( rc==SQLITE_OK ){ 
+    rc = sqlite3_file_control(db, 0, op, &iVal); 
+  } 
+  sqlite3_result_error_code(context, rc); 
+} 
+ 
+/* 
+** This is the entry point to register the auto-extension for the  
+** multiplex_control() function. 
+*/ 
+static int multiplexFuncInit( 
+  sqlite3 *db,  
+  char **pzErrMsg,  
+  const sqlite3_api_routines *pApi 
+){ 
+  int rc; 
+  rc = sqlite3_create_function(db, "multiplex_control", 2, SQLITE_ANY,  
+      0, multiplexControlFunc, 0, 0); 
+  return rc; 
+} 
+ 
+/* 
+** Close a single sub-file in the connection group. 
+*/ 
+static void multiplexSubClose( 
+  multiplexGroup *pGroup, 
+  int iChunk, 
+  sqlite3_vfs *pOrigVfs 
+){ 
+  sqlite3_file *pSubOpen = pGroup->aReal[iChunk].p; 
+  if( pSubOpen ){ 
+    pSubOpen->pMethods->xClose(pSubOpen); 
+    if( pOrigVfs && pGroup->aReal[iChunk].z ){ 
+      pOrigVfs->xDelete(pOrigVfs, pGroup->aReal[iChunk].z, 0); 
+    } 
+    sqlite3_free(pGroup->aReal[iChunk].p); 
+  } 
   sqlite3_free_filename(pGroup->aReal[iChunk].z);
-  memset(&pGroup->aReal[iChunk], 0, sizeof(pGroup->aReal[iChunk]));
-}
-
-/*
-** Deallocate memory held by a multiplexGroup
-*/
-static void multiplexFreeComponents(multiplexGroup *pGroup){
-  int i;
-  for(i=0; i<pGroup->nReal; i++){ multiplexSubClose(pGroup, i, 0); }
-  sqlite3_free(pGroup->aReal);
-  pGroup->aReal = 0;
-  pGroup->nReal = 0;
-}
-
-
-/************************* VFS Method Wrappers *****************************/
-
-/*
-** This is the xOpen method used for the "multiplex" VFS.
-**
-** Most of the work is done by the underlying original VFS.  This method
-** simply links the new file into the appropriate multiplex group if it is a
-** file that needs to be tracked.
-*/
-static int multiplexOpen(
-  sqlite3_vfs *pVfs,         /* The multiplex VFS */
-  const char *zName,         /* Name of file to be opened */
-  sqlite3_file *pConn,       /* Fill in this file descriptor */
-  int flags,                 /* Flags to control the opening */
-  int *pOutFlags             /* Flags showing results of opening */
-){
-  int rc = SQLITE_OK;                  /* Result code */
-  multiplexConn *pMultiplexOpen;       /* The new multiplex file descriptor */
-  multiplexGroup *pGroup = 0;          /* Corresponding multiplexGroup object */
-  sqlite3_file *pSubOpen = 0;                    /* Real file descriptor */
-  sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs;   /* Real VFS */
-  int nName = 0;
-  int sz = 0;
-  char *zToFree = 0;
-
-  UNUSED_PARAMETER(pVfs);
-  memset(pConn, 0, pVfs->szOsFile);
-  assert( zName || (flags & SQLITE_OPEN_DELETEONCLOSE) );
-
-  /* We need to create a group structure and manage
-  ** access to this group of files.
-  */
-  pMultiplexOpen = (multiplexConn*)pConn;
-
-  if( rc==SQLITE_OK ){
-    /* allocate space for group */
-    nName = zName ? multiplexStrlen30(zName) : 0;
-    sz = sizeof(multiplexGroup)                             /* multiplexGroup */
-       + nName + 1;                                         /* zName */
-    pGroup = sqlite3_malloc64( sz );
-    if( pGroup==0 ){
-      rc = SQLITE_NOMEM;
-    }
-  }
-
-  if( rc==SQLITE_OK ){
-    const char *zUri = (flags & SQLITE_OPEN_URI) ? zName : 0;
-    /* assign pointers to extra space allocated */
-    memset(pGroup, 0, sz);
-    pMultiplexOpen->pGroup = pGroup;
-    pGroup->bEnabled = (unsigned char)-1;
-    pGroup->bTruncate = (unsigned char)sqlite3_uri_boolean(zUri, "truncate", 
-                                   (flags & SQLITE_OPEN_MAIN_DB)==0);
-    pGroup->szChunk = (int)sqlite3_uri_int64(zUri, "chunksize",
-                                        SQLITE_MULTIPLEX_CHUNK_SIZE);
-    pGroup->szChunk = (pGroup->szChunk+0xffff)&~0xffff;
-    if( zName ){
-      char *p = (char *)&pGroup[1];
-      pGroup->zName = p;
-      memcpy(pGroup->zName, zName, nName+1);
-      pGroup->nName = nName;
-    }
-    if( pGroup->bEnabled ){
-      /* Make sure that the chunksize is such that the pending byte does not
-      ** falls at the end of a chunk.  A region of up to 64K following
-      ** the pending byte is never written, so if the pending byte occurs
-      ** near the end of a chunk, that chunk will be too small. */
-#ifndef SQLITE_OMIT_WSD
-      extern int sqlite3PendingByte;
-#else
-      int sqlite3PendingByte = 0x40000000;
-#endif
-      while( (sqlite3PendingByte % pGroup->szChunk)>=(pGroup->szChunk-65536) ){
-        pGroup->szChunk += 65536;
-      }
-    }
+  memset(&pGroup->aReal[iChunk], 0, sizeof(pGroup->aReal[iChunk])); 
+} 
+ 
+/* 
+** Deallocate memory held by a multiplexGroup 
+*/ 
+static void multiplexFreeComponents(multiplexGroup *pGroup){ 
+  int i; 
+  for(i=0; i<pGroup->nReal; i++){ multiplexSubClose(pGroup, i, 0); } 
+  sqlite3_free(pGroup->aReal); 
+  pGroup->aReal = 0; 
+  pGroup->nReal = 0; 
+} 
+ 
+ 
+/************************* VFS Method Wrappers *****************************/ 
+ 
+/* 
+** This is the xOpen method used for the "multiplex" VFS. 
+** 
+** Most of the work is done by the underlying original VFS.  This method 
+** simply links the new file into the appropriate multiplex group if it is a 
+** file that needs to be tracked. 
+*/ 
+static int multiplexOpen( 
+  sqlite3_vfs *pVfs,         /* The multiplex VFS */ 
+  const char *zName,         /* Name of file to be opened */ 
+  sqlite3_file *pConn,       /* Fill in this file descriptor */ 
+  int flags,                 /* Flags to control the opening */ 
+  int *pOutFlags             /* Flags showing results of opening */ 
+){ 
+  int rc = SQLITE_OK;                  /* Result code */ 
+  multiplexConn *pMultiplexOpen;       /* The new multiplex file descriptor */ 
+  multiplexGroup *pGroup = 0;          /* Corresponding multiplexGroup object */ 
+  sqlite3_file *pSubOpen = 0;                    /* Real file descriptor */ 
+  sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs;   /* Real VFS */ 
+  int nName = 0; 
+  int sz = 0; 
+  char *zToFree = 0; 
+ 
+  UNUSED_PARAMETER(pVfs); 
+  memset(pConn, 0, pVfs->szOsFile); 
+  assert( zName || (flags & SQLITE_OPEN_DELETEONCLOSE) ); 
+ 
+  /* We need to create a group structure and manage 
+  ** access to this group of files. 
+  */ 
+  pMultiplexOpen = (multiplexConn*)pConn; 
+ 
+  if( rc==SQLITE_OK ){ 
+    /* allocate space for group */ 
+    nName = zName ? multiplexStrlen30(zName) : 0; 
+    sz = sizeof(multiplexGroup)                             /* multiplexGroup */ 
+       + nName + 1;                                         /* zName */ 
+    pGroup = sqlite3_malloc64( sz ); 
+    if( pGroup==0 ){ 
+      rc = SQLITE_NOMEM; 
+    } 
+  } 
+ 
+  if( rc==SQLITE_OK ){ 
+    const char *zUri = (flags & SQLITE_OPEN_URI) ? zName : 0; 
+    /* assign pointers to extra space allocated */ 
+    memset(pGroup, 0, sz); 
+    pMultiplexOpen->pGroup = pGroup; 
+    pGroup->bEnabled = (unsigned char)-1; 
+    pGroup->bTruncate = (unsigned char)sqlite3_uri_boolean(zUri, "truncate",  
+                                   (flags & SQLITE_OPEN_MAIN_DB)==0); 
+    pGroup->szChunk = (int)sqlite3_uri_int64(zUri, "chunksize", 
+                                        SQLITE_MULTIPLEX_CHUNK_SIZE); 
+    pGroup->szChunk = (pGroup->szChunk+0xffff)&~0xffff; 
+    if( zName ){ 
+      char *p = (char *)&pGroup[1]; 
+      pGroup->zName = p; 
+      memcpy(pGroup->zName, zName, nName+1); 
+      pGroup->nName = nName; 
+    } 
+    if( pGroup->bEnabled ){ 
+      /* Make sure that the chunksize is such that the pending byte does not 
+      ** falls at the end of a chunk.  A region of up to 64K following 
+      ** the pending byte is never written, so if the pending byte occurs 
+      ** near the end of a chunk, that chunk will be too small. */ 
+#ifndef SQLITE_OMIT_WSD 
+      extern int sqlite3PendingByte; 
+#else 
+      int sqlite3PendingByte = 0x40000000; 
+#endif 
+      while( (sqlite3PendingByte % pGroup->szChunk)>=(pGroup->szChunk-65536) ){ 
+        pGroup->szChunk += 65536; 
+      } 
+    } 
     pGroup->flags = (flags & ~SQLITE_OPEN_URI);
-    rc = multiplexSubFilename(pGroup, 1);
-    if( rc==SQLITE_OK ){
-      pSubOpen = multiplexSubOpen(pGroup, 0, &rc, pOutFlags, 0);
-      if( pSubOpen==0 && rc==SQLITE_OK ) rc = SQLITE_CANTOPEN;
-    }
-    if( rc==SQLITE_OK ){
-      sqlite3_int64 sz64;
-
-      rc = pSubOpen->pMethods->xFileSize(pSubOpen, &sz64);
-      if( rc==SQLITE_OK && zName ){
-        int bExists;
+    rc = multiplexSubFilename(pGroup, 1); 
+    if( rc==SQLITE_OK ){ 
+      pSubOpen = multiplexSubOpen(pGroup, 0, &rc, pOutFlags, 0); 
+      if( pSubOpen==0 && rc==SQLITE_OK ) rc = SQLITE_CANTOPEN; 
+    } 
+    if( rc==SQLITE_OK ){ 
+      sqlite3_int64 sz64; 
+ 
+      rc = pSubOpen->pMethods->xFileSize(pSubOpen, &sz64); 
+      if( rc==SQLITE_OK && zName ){ 
+        int bExists; 
         if( flags & SQLITE_OPEN_SUPER_JOURNAL ){
-          pGroup->bEnabled = 0;
-        }else
-        if( sz64==0 ){
-          if( flags & SQLITE_OPEN_MAIN_JOURNAL ){
-            /* If opening a main journal file and the first chunk is zero
-            ** bytes in size, delete any subsequent chunks from the 
-            ** file-system. */
-            int iChunk = 1;
-            do {
-              rc = pOrigVfs->xAccess(pOrigVfs, 
-                  pGroup->aReal[iChunk].z, SQLITE_ACCESS_EXISTS, &bExists
-              );
-              if( rc==SQLITE_OK && bExists ){
-                rc = pOrigVfs->xDelete(pOrigVfs, pGroup->aReal[iChunk].z, 0);
-                if( rc==SQLITE_OK ){
-                  rc = multiplexSubFilename(pGroup, ++iChunk);
-                }
-              }
-            }while( rc==SQLITE_OK && bExists );
-          }
-        }else{
-          /* If the first overflow file exists and if the size of the main file
-          ** is different from the chunk size, that means the chunk size is set
-          ** set incorrectly.  So fix it.
-          **
-          ** Or, if the first overflow file does not exist and the main file is
-          ** larger than the chunk size, that means the chunk size is too small.
-          ** But we have no way of determining the intended chunk size, so 
-          ** just disable the multiplexor all togethre.
-          */
-          rc = pOrigVfs->xAccess(pOrigVfs, pGroup->aReal[1].z,
-              SQLITE_ACCESS_EXISTS, &bExists);
-          bExists = multiplexSubSize(pGroup, 1, &rc)>0;
-          if( rc==SQLITE_OK && bExists && sz64==(sz64&0xffff0000) && sz64>0
-              && sz64!=pGroup->szChunk ){
-            pGroup->szChunk = (int)sz64;
-          }else if( rc==SQLITE_OK && !bExists && sz64>pGroup->szChunk ){
-            pGroup->bEnabled = 0;
-          }
-        }
-      }
-    }
-
-    if( rc==SQLITE_OK ){
-      if( pSubOpen->pMethods->iVersion==1 ){
+          pGroup->bEnabled = 0; 
+        }else 
+        if( sz64==0 ){ 
+          if( flags & SQLITE_OPEN_MAIN_JOURNAL ){ 
+            /* If opening a main journal file and the first chunk is zero 
+            ** bytes in size, delete any subsequent chunks from the  
+            ** file-system. */ 
+            int iChunk = 1; 
+            do { 
+              rc = pOrigVfs->xAccess(pOrigVfs,  
+                  pGroup->aReal[iChunk].z, SQLITE_ACCESS_EXISTS, &bExists 
+              ); 
+              if( rc==SQLITE_OK && bExists ){ 
+                rc = pOrigVfs->xDelete(pOrigVfs, pGroup->aReal[iChunk].z, 0); 
+                if( rc==SQLITE_OK ){ 
+                  rc = multiplexSubFilename(pGroup, ++iChunk); 
+                } 
+              } 
+            }while( rc==SQLITE_OK && bExists ); 
+          } 
+        }else{ 
+          /* If the first overflow file exists and if the size of the main file 
+          ** is different from the chunk size, that means the chunk size is set 
+          ** set incorrectly.  So fix it. 
+          ** 
+          ** Or, if the first overflow file does not exist and the main file is 
+          ** larger than the chunk size, that means the chunk size is too small. 
+          ** But we have no way of determining the intended chunk size, so  
+          ** just disable the multiplexor all togethre. 
+          */ 
+          rc = pOrigVfs->xAccess(pOrigVfs, pGroup->aReal[1].z, 
+              SQLITE_ACCESS_EXISTS, &bExists); 
+          bExists = multiplexSubSize(pGroup, 1, &rc)>0; 
+          if( rc==SQLITE_OK && bExists && sz64==(sz64&0xffff0000) && sz64>0 
+              && sz64!=pGroup->szChunk ){ 
+            pGroup->szChunk = (int)sz64; 
+          }else if( rc==SQLITE_OK && !bExists && sz64>pGroup->szChunk ){ 
+            pGroup->bEnabled = 0; 
+          } 
+        } 
+      } 
+    } 
+ 
+    if( rc==SQLITE_OK ){ 
+      if( pSubOpen->pMethods->iVersion==1 ){ 
         pConn->pMethods = &gMultiplex.sIoMethodsV1;
-      }else{
+      }else{ 
         pConn->pMethods = &gMultiplex.sIoMethodsV2;
-      }
-    }else{
-      multiplexFreeComponents(pGroup);
-      sqlite3_free(pGroup);
-    }
-  }
-  sqlite3_free(zToFree);
-  return rc;
-}
-
-/*
-** This is the xDelete method used for the "multiplex" VFS.
-** It attempts to delete the filename specified.
-*/
-static int multiplexDelete(
-  sqlite3_vfs *pVfs,         /* The multiplex VFS */
-  const char *zName,         /* Name of file to delete */
-  int syncDir
-){
-  int rc;
-  sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs;   /* Real VFS */
-  rc = pOrigVfs->xDelete(pOrigVfs, zName, syncDir);
-  if( rc==SQLITE_OK ){
-    /* If the main chunk was deleted successfully, also delete any subsequent
-    ** chunks - starting with the last (highest numbered). 
-    */
-    int nName = (int)strlen(zName);
-    char *z;
-    z = sqlite3_malloc64(nName + 5);
-    if( z==0 ){
-      rc = SQLITE_IOERR_NOMEM;
-    }else{
-      int iChunk = 0;
-      int bExists;
-      do{
-        multiplexFilename(zName, nName, SQLITE_OPEN_MAIN_JOURNAL, ++iChunk, z);
-        rc = pOrigVfs->xAccess(pOrigVfs, z, SQLITE_ACCESS_EXISTS, &bExists);
-      }while( rc==SQLITE_OK && bExists );
-      while( rc==SQLITE_OK && iChunk>1 ){
-        multiplexFilename(zName, nName, SQLITE_OPEN_MAIN_JOURNAL, --iChunk, z);
-        rc = pOrigVfs->xDelete(pOrigVfs, z, syncDir);
-      }
-      if( rc==SQLITE_OK ){
-        iChunk = 0;
-        do{
-          multiplexFilename(zName, nName, SQLITE_OPEN_WAL, ++iChunk, z);
-          rc = pOrigVfs->xAccess(pOrigVfs, z, SQLITE_ACCESS_EXISTS, &bExists);
-        }while( rc==SQLITE_OK && bExists );
-        while( rc==SQLITE_OK && iChunk>1 ){
-          multiplexFilename(zName, nName, SQLITE_OPEN_WAL, --iChunk, z);
-          rc = pOrigVfs->xDelete(pOrigVfs, z, syncDir);
-        }
-      }
-    }
-    sqlite3_free(z);
-  }
-  return rc;
-}
-
-static int multiplexAccess(sqlite3_vfs *a, const char *b, int c, int *d){
-  return gMultiplex.pOrigVfs->xAccess(gMultiplex.pOrigVfs, b, c, d);
-}
-static int multiplexFullPathname(sqlite3_vfs *a, const char *b, int c, char *d){
-  return gMultiplex.pOrigVfs->xFullPathname(gMultiplex.pOrigVfs, b, c, d);
-}
-static void *multiplexDlOpen(sqlite3_vfs *a, const char *b){
-  return gMultiplex.pOrigVfs->xDlOpen(gMultiplex.pOrigVfs, b);
-}
-static void multiplexDlError(sqlite3_vfs *a, int b, char *c){
-  gMultiplex.pOrigVfs->xDlError(gMultiplex.pOrigVfs, b, c);
-}
-static void (*multiplexDlSym(sqlite3_vfs *a, void *b, const char *c))(void){
-  return gMultiplex.pOrigVfs->xDlSym(gMultiplex.pOrigVfs, b, c);
-}
-static void multiplexDlClose(sqlite3_vfs *a, void *b){
-  gMultiplex.pOrigVfs->xDlClose(gMultiplex.pOrigVfs, b);
-}
-static int multiplexRandomness(sqlite3_vfs *a, int b, char *c){
-  return gMultiplex.pOrigVfs->xRandomness(gMultiplex.pOrigVfs, b, c);
-}
-static int multiplexSleep(sqlite3_vfs *a, int b){
-  return gMultiplex.pOrigVfs->xSleep(gMultiplex.pOrigVfs, b);
-}
-static int multiplexCurrentTime(sqlite3_vfs *a, double *b){
-  return gMultiplex.pOrigVfs->xCurrentTime(gMultiplex.pOrigVfs, b);
-}
-static int multiplexGetLastError(sqlite3_vfs *a, int b, char *c){
-  if( gMultiplex.pOrigVfs->xGetLastError ){
-    return gMultiplex.pOrigVfs->xGetLastError(gMultiplex.pOrigVfs, b, c);
-  }else{
-    return 0;
-  }
-}
-static int multiplexCurrentTimeInt64(sqlite3_vfs *a, sqlite3_int64 *b){
-  return gMultiplex.pOrigVfs->xCurrentTimeInt64(gMultiplex.pOrigVfs, b);
-}
-
-/************************ I/O Method Wrappers *******************************/
-
-/* xClose requests get passed through to the original VFS.
-** We loop over all open chunk handles and close them.
-** The group structure for this file is unlinked from 
-** our list of groups and freed.
-*/
-static int multiplexClose(sqlite3_file *pConn){
-  multiplexConn *p = (multiplexConn*)pConn;
-  multiplexGroup *pGroup = p->pGroup;
-  int rc = SQLITE_OK;
-  multiplexFreeComponents(pGroup);
-  sqlite3_free(pGroup);
-  return rc;
-}
-
-/* Pass xRead requests thru to the original VFS after
-** determining the correct chunk to operate on.
-** Break up reads across chunk boundaries.
-*/
-static int multiplexRead(
-  sqlite3_file *pConn,
-  void *pBuf,
-  int iAmt,
-  sqlite3_int64 iOfst
-){
-  multiplexConn *p = (multiplexConn*)pConn;
-  multiplexGroup *pGroup = p->pGroup;
-  int rc = SQLITE_OK;
-  if( !pGroup->bEnabled ){
-    sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0);
-    if( pSubOpen==0 ){
-      rc = SQLITE_IOERR_READ;
-    }else{
-      rc = pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt, iOfst);
-    }
-  }else{
-    while( iAmt > 0 ){
-      int i = (int)(iOfst / pGroup->szChunk);
-      sqlite3_file *pSubOpen;
-      pSubOpen = multiplexSubOpen(pGroup, i, &rc, NULL, 1);
-      if( pSubOpen ){
-        int extra = ((int)(iOfst % pGroup->szChunk) + iAmt) - pGroup->szChunk;
-        if( extra<0 ) extra = 0;
-        iAmt -= extra;
-        rc = pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt,
-                                       iOfst % pGroup->szChunk);
-        if( rc!=SQLITE_OK ) break;
-        pBuf = (char *)pBuf + iAmt;
-        iOfst += iAmt;
-        iAmt = extra;
-      }else{
-        rc = SQLITE_IOERR_READ;
-        break;
-      }
-    }
-  }
-
-  return rc;
-}
-
-/* Pass xWrite requests thru to the original VFS after
-** determining the correct chunk to operate on.
-** Break up writes across chunk boundaries.
-*/
-static int multiplexWrite(
-  sqlite3_file *pConn,
-  const void *pBuf,
-  int iAmt,
-  sqlite3_int64 iOfst
-){
-  multiplexConn *p = (multiplexConn*)pConn;
-  multiplexGroup *pGroup = p->pGroup;
-  int rc = SQLITE_OK;
-  if( !pGroup->bEnabled ){
-    sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0);
-    if( pSubOpen==0 ){
-      rc = SQLITE_IOERR_WRITE;
-    }else{
-      rc = pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt, iOfst);
-    }
-  }else{
-    while( rc==SQLITE_OK && iAmt>0 ){
-      int i = (int)(iOfst / pGroup->szChunk);
-      sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, i, &rc, NULL, 1);
-      if( pSubOpen ){
-        int extra = ((int)(iOfst % pGroup->szChunk) + iAmt) -
-                    pGroup->szChunk;
-        if( extra<0 ) extra = 0;
-        iAmt -= extra;
-        rc = pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt,
-                                        iOfst % pGroup->szChunk);
-        pBuf = (char *)pBuf + iAmt;
-        iOfst += iAmt;
-        iAmt = extra;
-      }
-    }
-  }
-  return rc;
-}
-
-/* Pass xTruncate requests thru to the original VFS after
-** determining the correct chunk to operate on.  Delete any
-** chunks above the truncate mark.
-*/
-static int multiplexTruncate(sqlite3_file *pConn, sqlite3_int64 size){
-  multiplexConn *p = (multiplexConn*)pConn;
-  multiplexGroup *pGroup = p->pGroup;
-  int rc = SQLITE_OK;
-  if( !pGroup->bEnabled ){
-    sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0);
-    if( pSubOpen==0 ){
-      rc = SQLITE_IOERR_TRUNCATE;
-    }else{
-      rc = pSubOpen->pMethods->xTruncate(pSubOpen, size);
-    }
-  }else{
-    int i;
-    int iBaseGroup = (int)(size / pGroup->szChunk);
-    sqlite3_file *pSubOpen;
-    sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs;   /* Real VFS */
-    /* delete the chunks above the truncate limit */
-    for(i = pGroup->nReal-1; i>iBaseGroup && rc==SQLITE_OK; i--){
-      if( pGroup->bTruncate ){
-        multiplexSubClose(pGroup, i, pOrigVfs);
-      }else{
-        pSubOpen = multiplexSubOpen(pGroup, i, &rc, 0, 0);
-        if( pSubOpen ){
-          rc = pSubOpen->pMethods->xTruncate(pSubOpen, 0);
-        }
-      }
-    }
-    if( rc==SQLITE_OK ){
-      pSubOpen = multiplexSubOpen(pGroup, iBaseGroup, &rc, 0, 0);
-      if( pSubOpen ){
-        rc = pSubOpen->pMethods->xTruncate(pSubOpen, size % pGroup->szChunk);
-      }
-    }
-    if( rc ) rc = SQLITE_IOERR_TRUNCATE;
-  }
-  return rc;
-}
-
-/* Pass xSync requests through to the original VFS without change
-*/
-static int multiplexSync(sqlite3_file *pConn, int flags){
-  multiplexConn *p = (multiplexConn*)pConn;
-  multiplexGroup *pGroup = p->pGroup;
-  int rc = SQLITE_OK;
-  int i;
-  for(i=0; i<pGroup->nReal; i++){
-    sqlite3_file *pSubOpen = pGroup->aReal[i].p;
-    if( pSubOpen ){
-      int rc2 = pSubOpen->pMethods->xSync(pSubOpen, flags);
-      if( rc2!=SQLITE_OK ) rc = rc2;
-    }
-  }
-  return rc;
-}
-
-/* Pass xFileSize requests through to the original VFS.
-** Aggregate the size of all the chunks before returning.
-*/
-static int multiplexFileSize(sqlite3_file *pConn, sqlite3_int64 *pSize){
-  multiplexConn *p = (multiplexConn*)pConn;
-  multiplexGroup *pGroup = p->pGroup;
-  int rc = SQLITE_OK;
-  int i;
-  if( !pGroup->bEnabled ){
-    sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0);
-    if( pSubOpen==0 ){
-      rc = SQLITE_IOERR_FSTAT;
-    }else{
-      rc = pSubOpen->pMethods->xFileSize(pSubOpen, pSize);
-    }
-  }else{
-    *pSize = 0;
-    for(i=0; rc==SQLITE_OK; i++){
-      sqlite3_int64 sz = multiplexSubSize(pGroup, i, &rc);
-      if( sz==0 ) break;
-      *pSize = i*(sqlite3_int64)pGroup->szChunk + sz;
-    }
-  }
-  return rc;
-}
-
-/* Pass xLock requests through to the original VFS unchanged.
-*/
-static int multiplexLock(sqlite3_file *pConn, int lock){
-  multiplexConn *p = (multiplexConn*)pConn;
-  int rc;
-  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
-  if( pSubOpen ){
-    return pSubOpen->pMethods->xLock(pSubOpen, lock);
-  }
-  return SQLITE_BUSY;
-}
-
-/* Pass xUnlock requests through to the original VFS unchanged.
-*/
-static int multiplexUnlock(sqlite3_file *pConn, int lock){
-  multiplexConn *p = (multiplexConn*)pConn;
-  int rc;
-  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
-  if( pSubOpen ){
-    return pSubOpen->pMethods->xUnlock(pSubOpen, lock);
-  }
-  return SQLITE_IOERR_UNLOCK;
-}
-
-/* Pass xCheckReservedLock requests through to the original VFS unchanged.
-*/
-static int multiplexCheckReservedLock(sqlite3_file *pConn, int *pResOut){
-  multiplexConn *p = (multiplexConn*)pConn;
-  int rc;
-  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
-  if( pSubOpen ){
-    return pSubOpen->pMethods->xCheckReservedLock(pSubOpen, pResOut);
-  }
-  return SQLITE_IOERR_CHECKRESERVEDLOCK;
-}
-
-/* Pass xFileControl requests through to the original VFS unchanged,
-** except for any MULTIPLEX_CTRL_* requests here.
-*/
-static int multiplexFileControl(sqlite3_file *pConn, int op, void *pArg){
-  multiplexConn *p = (multiplexConn*)pConn;
-  multiplexGroup *pGroup = p->pGroup;
-  int rc = SQLITE_ERROR;
-  sqlite3_file *pSubOpen;
-
-  if( !gMultiplex.isInitialized ) return SQLITE_MISUSE;
-  switch( op ){
-    case MULTIPLEX_CTRL_ENABLE:
-      if( pArg ) {
-        int bEnabled = *(int *)pArg;
-        pGroup->bEnabled = (unsigned char)bEnabled;
-        rc = SQLITE_OK;
-      }
-      break;
-    case MULTIPLEX_CTRL_SET_CHUNK_SIZE:
-      if( pArg ) {
-        unsigned int szChunk = *(unsigned*)pArg;
-        if( szChunk<1 ){
-          rc = SQLITE_MISUSE;
-        }else{
-          /* Round up to nearest multiple of MAX_PAGE_SIZE. */
-          szChunk = (szChunk + (MAX_PAGE_SIZE-1));
-          szChunk &= ~(MAX_PAGE_SIZE-1);
-          pGroup->szChunk = szChunk;
-          rc = SQLITE_OK;
-        }
-      }
-      break;
-    case MULTIPLEX_CTRL_SET_MAX_CHUNKS:
-      rc = SQLITE_OK;
-      break;
-    case SQLITE_FCNTL_SIZE_HINT:
-    case SQLITE_FCNTL_CHUNK_SIZE:
-      /* no-op these */
-      rc = SQLITE_OK;
-      break;
-    case SQLITE_FCNTL_PRAGMA: {
-      char **aFcntl = (char**)pArg;
-      /*
-      ** EVIDENCE-OF: R-29875-31678 The argument to the SQLITE_FCNTL_PRAGMA
-      ** file control is an array of pointers to strings (char**) in which the
-      ** second element of the array is the name of the pragma and the third
-      ** element is the argument to the pragma or NULL if the pragma has no
-      ** argument.
-      */
+      } 
+    }else{ 
+      multiplexFreeComponents(pGroup); 
+      sqlite3_free(pGroup); 
+    } 
+  } 
+  sqlite3_free(zToFree); 
+  return rc; 
+} 
+ 
+/* 
+** This is the xDelete method used for the "multiplex" VFS. 
+** It attempts to delete the filename specified. 
+*/ 
+static int multiplexDelete( 
+  sqlite3_vfs *pVfs,         /* The multiplex VFS */ 
+  const char *zName,         /* Name of file to delete */ 
+  int syncDir 
+){ 
+  int rc; 
+  sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs;   /* Real VFS */ 
+  rc = pOrigVfs->xDelete(pOrigVfs, zName, syncDir); 
+  if( rc==SQLITE_OK ){ 
+    /* If the main chunk was deleted successfully, also delete any subsequent 
+    ** chunks - starting with the last (highest numbered).  
+    */ 
+    int nName = (int)strlen(zName); 
+    char *z; 
+    z = sqlite3_malloc64(nName + 5); 
+    if( z==0 ){ 
+      rc = SQLITE_IOERR_NOMEM; 
+    }else{ 
+      int iChunk = 0; 
+      int bExists; 
+      do{ 
+        multiplexFilename(zName, nName, SQLITE_OPEN_MAIN_JOURNAL, ++iChunk, z); 
+        rc = pOrigVfs->xAccess(pOrigVfs, z, SQLITE_ACCESS_EXISTS, &bExists); 
+      }while( rc==SQLITE_OK && bExists ); 
+      while( rc==SQLITE_OK && iChunk>1 ){ 
+        multiplexFilename(zName, nName, SQLITE_OPEN_MAIN_JOURNAL, --iChunk, z); 
+        rc = pOrigVfs->xDelete(pOrigVfs, z, syncDir); 
+      } 
+      if( rc==SQLITE_OK ){ 
+        iChunk = 0; 
+        do{ 
+          multiplexFilename(zName, nName, SQLITE_OPEN_WAL, ++iChunk, z); 
+          rc = pOrigVfs->xAccess(pOrigVfs, z, SQLITE_ACCESS_EXISTS, &bExists); 
+        }while( rc==SQLITE_OK && bExists ); 
+        while( rc==SQLITE_OK && iChunk>1 ){ 
+          multiplexFilename(zName, nName, SQLITE_OPEN_WAL, --iChunk, z); 
+          rc = pOrigVfs->xDelete(pOrigVfs, z, syncDir); 
+        } 
+      } 
+    } 
+    sqlite3_free(z); 
+  } 
+  return rc; 
+} 
+ 
+static int multiplexAccess(sqlite3_vfs *a, const char *b, int c, int *d){ 
+  return gMultiplex.pOrigVfs->xAccess(gMultiplex.pOrigVfs, b, c, d); 
+} 
+static int multiplexFullPathname(sqlite3_vfs *a, const char *b, int c, char *d){ 
+  return gMultiplex.pOrigVfs->xFullPathname(gMultiplex.pOrigVfs, b, c, d); 
+} 
+static void *multiplexDlOpen(sqlite3_vfs *a, const char *b){ 
+  return gMultiplex.pOrigVfs->xDlOpen(gMultiplex.pOrigVfs, b); 
+} 
+static void multiplexDlError(sqlite3_vfs *a, int b, char *c){ 
+  gMultiplex.pOrigVfs->xDlError(gMultiplex.pOrigVfs, b, c); 
+} 
+static void (*multiplexDlSym(sqlite3_vfs *a, void *b, const char *c))(void){ 
+  return gMultiplex.pOrigVfs->xDlSym(gMultiplex.pOrigVfs, b, c); 
+} 
+static void multiplexDlClose(sqlite3_vfs *a, void *b){ 
+  gMultiplex.pOrigVfs->xDlClose(gMultiplex.pOrigVfs, b); 
+} 
+static int multiplexRandomness(sqlite3_vfs *a, int b, char *c){ 
+  return gMultiplex.pOrigVfs->xRandomness(gMultiplex.pOrigVfs, b, c); 
+} 
+static int multiplexSleep(sqlite3_vfs *a, int b){ 
+  return gMultiplex.pOrigVfs->xSleep(gMultiplex.pOrigVfs, b); 
+} 
+static int multiplexCurrentTime(sqlite3_vfs *a, double *b){ 
+  return gMultiplex.pOrigVfs->xCurrentTime(gMultiplex.pOrigVfs, b); 
+} 
+static int multiplexGetLastError(sqlite3_vfs *a, int b, char *c){ 
+  if( gMultiplex.pOrigVfs->xGetLastError ){ 
+    return gMultiplex.pOrigVfs->xGetLastError(gMultiplex.pOrigVfs, b, c); 
+  }else{ 
+    return 0; 
+  } 
+} 
+static int multiplexCurrentTimeInt64(sqlite3_vfs *a, sqlite3_int64 *b){ 
+  return gMultiplex.pOrigVfs->xCurrentTimeInt64(gMultiplex.pOrigVfs, b); 
+} 
+ 
+/************************ I/O Method Wrappers *******************************/ 
+ 
+/* xClose requests get passed through to the original VFS. 
+** We loop over all open chunk handles and close them. 
+** The group structure for this file is unlinked from  
+** our list of groups and freed. 
+*/ 
+static int multiplexClose(sqlite3_file *pConn){ 
+  multiplexConn *p = (multiplexConn*)pConn; 
+  multiplexGroup *pGroup = p->pGroup; 
+  int rc = SQLITE_OK; 
+  multiplexFreeComponents(pGroup); 
+  sqlite3_free(pGroup); 
+  return rc; 
+} 
+ 
+/* Pass xRead requests thru to the original VFS after 
+** determining the correct chunk to operate on. 
+** Break up reads across chunk boundaries. 
+*/ 
+static int multiplexRead( 
+  sqlite3_file *pConn, 
+  void *pBuf, 
+  int iAmt, 
+  sqlite3_int64 iOfst 
+){ 
+  multiplexConn *p = (multiplexConn*)pConn; 
+  multiplexGroup *pGroup = p->pGroup; 
+  int rc = SQLITE_OK; 
+  if( !pGroup->bEnabled ){ 
+    sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0); 
+    if( pSubOpen==0 ){ 
+      rc = SQLITE_IOERR_READ; 
+    }else{ 
+      rc = pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt, iOfst); 
+    } 
+  }else{ 
+    while( iAmt > 0 ){ 
+      int i = (int)(iOfst / pGroup->szChunk); 
+      sqlite3_file *pSubOpen; 
+      pSubOpen = multiplexSubOpen(pGroup, i, &rc, NULL, 1); 
+      if( pSubOpen ){ 
+        int extra = ((int)(iOfst % pGroup->szChunk) + iAmt) - pGroup->szChunk; 
+        if( extra<0 ) extra = 0; 
+        iAmt -= extra; 
+        rc = pSubOpen->pMethods->xRead(pSubOpen, pBuf, iAmt, 
+                                       iOfst % pGroup->szChunk); 
+        if( rc!=SQLITE_OK ) break; 
+        pBuf = (char *)pBuf + iAmt; 
+        iOfst += iAmt; 
+        iAmt = extra; 
+      }else{ 
+        rc = SQLITE_IOERR_READ; 
+        break; 
+      } 
+    } 
+  } 
+ 
+  return rc; 
+} 
+ 
+/* Pass xWrite requests thru to the original VFS after 
+** determining the correct chunk to operate on. 
+** Break up writes across chunk boundaries. 
+*/ 
+static int multiplexWrite( 
+  sqlite3_file *pConn, 
+  const void *pBuf, 
+  int iAmt, 
+  sqlite3_int64 iOfst 
+){ 
+  multiplexConn *p = (multiplexConn*)pConn; 
+  multiplexGroup *pGroup = p->pGroup; 
+  int rc = SQLITE_OK; 
+  if( !pGroup->bEnabled ){ 
+    sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0); 
+    if( pSubOpen==0 ){ 
+      rc = SQLITE_IOERR_WRITE; 
+    }else{ 
+      rc = pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt, iOfst); 
+    } 
+  }else{ 
+    while( rc==SQLITE_OK && iAmt>0 ){ 
+      int i = (int)(iOfst / pGroup->szChunk); 
+      sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, i, &rc, NULL, 1); 
+      if( pSubOpen ){ 
+        int extra = ((int)(iOfst % pGroup->szChunk) + iAmt) - 
+                    pGroup->szChunk; 
+        if( extra<0 ) extra = 0; 
+        iAmt -= extra; 
+        rc = pSubOpen->pMethods->xWrite(pSubOpen, pBuf, iAmt, 
+                                        iOfst % pGroup->szChunk); 
+        pBuf = (char *)pBuf + iAmt; 
+        iOfst += iAmt; 
+        iAmt = extra; 
+      } 
+    } 
+  } 
+  return rc; 
+} 
+ 
+/* Pass xTruncate requests thru to the original VFS after 
+** determining the correct chunk to operate on.  Delete any 
+** chunks above the truncate mark. 
+*/ 
+static int multiplexTruncate(sqlite3_file *pConn, sqlite3_int64 size){ 
+  multiplexConn *p = (multiplexConn*)pConn; 
+  multiplexGroup *pGroup = p->pGroup; 
+  int rc = SQLITE_OK; 
+  if( !pGroup->bEnabled ){ 
+    sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0); 
+    if( pSubOpen==0 ){ 
+      rc = SQLITE_IOERR_TRUNCATE; 
+    }else{ 
+      rc = pSubOpen->pMethods->xTruncate(pSubOpen, size); 
+    } 
+  }else{ 
+    int i; 
+    int iBaseGroup = (int)(size / pGroup->szChunk); 
+    sqlite3_file *pSubOpen; 
+    sqlite3_vfs *pOrigVfs = gMultiplex.pOrigVfs;   /* Real VFS */ 
+    /* delete the chunks above the truncate limit */ 
+    for(i = pGroup->nReal-1; i>iBaseGroup && rc==SQLITE_OK; i--){ 
+      if( pGroup->bTruncate ){ 
+        multiplexSubClose(pGroup, i, pOrigVfs); 
+      }else{ 
+        pSubOpen = multiplexSubOpen(pGroup, i, &rc, 0, 0); 
+        if( pSubOpen ){ 
+          rc = pSubOpen->pMethods->xTruncate(pSubOpen, 0); 
+        } 
+      } 
+    } 
+    if( rc==SQLITE_OK ){ 
+      pSubOpen = multiplexSubOpen(pGroup, iBaseGroup, &rc, 0, 0); 
+      if( pSubOpen ){ 
+        rc = pSubOpen->pMethods->xTruncate(pSubOpen, size % pGroup->szChunk); 
+      } 
+    } 
+    if( rc ) rc = SQLITE_IOERR_TRUNCATE; 
+  } 
+  return rc; 
+} 
+ 
+/* Pass xSync requests through to the original VFS without change 
+*/ 
+static int multiplexSync(sqlite3_file *pConn, int flags){ 
+  multiplexConn *p = (multiplexConn*)pConn; 
+  multiplexGroup *pGroup = p->pGroup; 
+  int rc = SQLITE_OK; 
+  int i; 
+  for(i=0; i<pGroup->nReal; i++){ 
+    sqlite3_file *pSubOpen = pGroup->aReal[i].p; 
+    if( pSubOpen ){ 
+      int rc2 = pSubOpen->pMethods->xSync(pSubOpen, flags); 
+      if( rc2!=SQLITE_OK ) rc = rc2; 
+    } 
+  } 
+  return rc; 
+} 
+ 
+/* Pass xFileSize requests through to the original VFS. 
+** Aggregate the size of all the chunks before returning. 
+*/ 
+static int multiplexFileSize(sqlite3_file *pConn, sqlite3_int64 *pSize){ 
+  multiplexConn *p = (multiplexConn*)pConn; 
+  multiplexGroup *pGroup = p->pGroup; 
+  int rc = SQLITE_OK; 
+  int i; 
+  if( !pGroup->bEnabled ){ 
+    sqlite3_file *pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0); 
+    if( pSubOpen==0 ){ 
+      rc = SQLITE_IOERR_FSTAT; 
+    }else{ 
+      rc = pSubOpen->pMethods->xFileSize(pSubOpen, pSize); 
+    } 
+  }else{ 
+    *pSize = 0; 
+    for(i=0; rc==SQLITE_OK; i++){ 
+      sqlite3_int64 sz = multiplexSubSize(pGroup, i, &rc); 
+      if( sz==0 ) break; 
+      *pSize = i*(sqlite3_int64)pGroup->szChunk + sz; 
+    } 
+  } 
+  return rc; 
+} 
+ 
+/* Pass xLock requests through to the original VFS unchanged. 
+*/ 
+static int multiplexLock(sqlite3_file *pConn, int lock){ 
+  multiplexConn *p = (multiplexConn*)pConn; 
+  int rc; 
+  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); 
+  if( pSubOpen ){ 
+    return pSubOpen->pMethods->xLock(pSubOpen, lock); 
+  } 
+  return SQLITE_BUSY; 
+} 
+ 
+/* Pass xUnlock requests through to the original VFS unchanged. 
+*/ 
+static int multiplexUnlock(sqlite3_file *pConn, int lock){ 
+  multiplexConn *p = (multiplexConn*)pConn; 
+  int rc; 
+  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); 
+  if( pSubOpen ){ 
+    return pSubOpen->pMethods->xUnlock(pSubOpen, lock); 
+  } 
+  return SQLITE_IOERR_UNLOCK; 
+} 
+ 
+/* Pass xCheckReservedLock requests through to the original VFS unchanged. 
+*/ 
+static int multiplexCheckReservedLock(sqlite3_file *pConn, int *pResOut){ 
+  multiplexConn *p = (multiplexConn*)pConn; 
+  int rc; 
+  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); 
+  if( pSubOpen ){ 
+    return pSubOpen->pMethods->xCheckReservedLock(pSubOpen, pResOut); 
+  } 
+  return SQLITE_IOERR_CHECKRESERVEDLOCK; 
+} 
+ 
+/* Pass xFileControl requests through to the original VFS unchanged, 
+** except for any MULTIPLEX_CTRL_* requests here. 
+*/ 
+static int multiplexFileControl(sqlite3_file *pConn, int op, void *pArg){ 
+  multiplexConn *p = (multiplexConn*)pConn; 
+  multiplexGroup *pGroup = p->pGroup; 
+  int rc = SQLITE_ERROR; 
+  sqlite3_file *pSubOpen; 
+ 
+  if( !gMultiplex.isInitialized ) return SQLITE_MISUSE; 
+  switch( op ){ 
+    case MULTIPLEX_CTRL_ENABLE: 
+      if( pArg ) { 
+        int bEnabled = *(int *)pArg; 
+        pGroup->bEnabled = (unsigned char)bEnabled; 
+        rc = SQLITE_OK; 
+      } 
+      break; 
+    case MULTIPLEX_CTRL_SET_CHUNK_SIZE: 
+      if( pArg ) { 
+        unsigned int szChunk = *(unsigned*)pArg; 
+        if( szChunk<1 ){ 
+          rc = SQLITE_MISUSE; 
+        }else{ 
+          /* Round up to nearest multiple of MAX_PAGE_SIZE. */ 
+          szChunk = (szChunk + (MAX_PAGE_SIZE-1)); 
+          szChunk &= ~(MAX_PAGE_SIZE-1); 
+          pGroup->szChunk = szChunk; 
+          rc = SQLITE_OK; 
+        } 
+      } 
+      break; 
+    case MULTIPLEX_CTRL_SET_MAX_CHUNKS: 
+      rc = SQLITE_OK; 
+      break; 
+    case SQLITE_FCNTL_SIZE_HINT: 
+    case SQLITE_FCNTL_CHUNK_SIZE: 
+      /* no-op these */ 
+      rc = SQLITE_OK; 
+      break; 
+    case SQLITE_FCNTL_PRAGMA: { 
+      char **aFcntl = (char**)pArg; 
+      /* 
+      ** EVIDENCE-OF: R-29875-31678 The argument to the SQLITE_FCNTL_PRAGMA 
+      ** file control is an array of pointers to strings (char**) in which the 
+      ** second element of the array is the name of the pragma and the third 
+      ** element is the argument to the pragma or NULL if the pragma has no 
+      ** argument. 
+      */ 
       if( aFcntl[1] && sqlite3_strnicmp(aFcntl[1],"multiplex_",10)==0 ){
         sqlite3_int64 sz = 0;
         (void)multiplexFileSize(pConn, &sz);
@@ -983,7 +983,7 @@ static int multiplexFileControl(sqlite3_file *pConn, int op, void *pArg){
              || sqlite3_stricmp(aFcntl[2], "0")==0 ){
               pGroup->bTruncate = 0;
             }
-          }
+          } 
           /* EVIDENCE-OF: R-27806-26076 The handler for an SQLITE_FCNTL_PRAGMA
           ** file control can optionally make the first element of the char**
           ** argument point to a string obtained from sqlite3_mprintf() or the
@@ -993,13 +993,13 @@ static int multiplexFileControl(sqlite3_file *pConn, int op, void *pArg){
           aFcntl[0] = sqlite3_mprintf(pGroup->bTruncate ? "on" : "off");
           rc = SQLITE_OK;
           break;
-        }
+        } 
         /*
         ** PRAGMA multiplex_enabled;
         **
         ** Return 0 or 1 depending on whether the multiplexor is enabled or
         ** disabled, respectively.
-        */
+        */ 
         if( sqlite3_stricmp(aFcntl[1],"multiplex_enabled")==0 ){
           aFcntl[0] = sqlite3_mprintf("%d", pGroup->bEnabled!=0);
           rc = SQLITE_OK;
@@ -1035,342 +1035,342 @@ static int multiplexFileControl(sqlite3_file *pConn, int op, void *pArg){
           rc = SQLITE_OK;
           break;
         }
-      }
-      /* If the multiplexor does not handle the pragma, pass it through
-      ** into the default case. */
-    }
-    default:
-      pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0);
-      if( pSubOpen ){
-        rc = pSubOpen->pMethods->xFileControl(pSubOpen, op, pArg);
-        if( op==SQLITE_FCNTL_VFSNAME && rc==SQLITE_OK ){
-         *(char**)pArg = sqlite3_mprintf("multiplex/%z", *(char**)pArg);
-        }
-      }
-      break;
-  }
-  return rc;
-}
-
-/* Pass xSectorSize requests through to the original VFS unchanged.
-*/
-static int multiplexSectorSize(sqlite3_file *pConn){
-  multiplexConn *p = (multiplexConn*)pConn;
-  int rc;
-  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
-  if( pSubOpen && pSubOpen->pMethods->xSectorSize ){
-    return pSubOpen->pMethods->xSectorSize(pSubOpen);
-  }
-  return DEFAULT_SECTOR_SIZE;
-}
-
-/* Pass xDeviceCharacteristics requests through to the original VFS unchanged.
-*/
-static int multiplexDeviceCharacteristics(sqlite3_file *pConn){
-  multiplexConn *p = (multiplexConn*)pConn;
-  int rc;
-  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
-  if( pSubOpen ){
-    return pSubOpen->pMethods->xDeviceCharacteristics(pSubOpen);
-  }
-  return 0;
-}
-
-/* Pass xShmMap requests through to the original VFS unchanged.
-*/
-static int multiplexShmMap(
-  sqlite3_file *pConn,            /* Handle open on database file */
-  int iRegion,                    /* Region to retrieve */
-  int szRegion,                   /* Size of regions */
-  int bExtend,                    /* True to extend file if necessary */
-  void volatile **pp              /* OUT: Mapped memory */
-){
-  multiplexConn *p = (multiplexConn*)pConn;
-  int rc;
-  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
-  if( pSubOpen ){
-    return pSubOpen->pMethods->xShmMap(pSubOpen, iRegion, szRegion, bExtend,pp);
-  }
-  return SQLITE_IOERR;
-}
-
-/* Pass xShmLock requests through to the original VFS unchanged.
-*/
-static int multiplexShmLock(
-  sqlite3_file *pConn,       /* Database file holding the shared memory */
-  int ofst,                  /* First lock to acquire or release */
-  int n,                     /* Number of locks to acquire or release */
-  int flags                  /* What to do with the lock */
-){
-  multiplexConn *p = (multiplexConn*)pConn;
-  int rc;
-  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
-  if( pSubOpen ){
-    return pSubOpen->pMethods->xShmLock(pSubOpen, ofst, n, flags);
-  }
-  return SQLITE_BUSY;
-}
-
-/* Pass xShmBarrier requests through to the original VFS unchanged.
-*/
-static void multiplexShmBarrier(sqlite3_file *pConn){
-  multiplexConn *p = (multiplexConn*)pConn;
-  int rc;
-  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
-  if( pSubOpen ){
-    pSubOpen->pMethods->xShmBarrier(pSubOpen);
-  }
-}
-
-/* Pass xShmUnmap requests through to the original VFS unchanged.
-*/
-static int multiplexShmUnmap(sqlite3_file *pConn, int deleteFlag){
-  multiplexConn *p = (multiplexConn*)pConn;
-  int rc;
-  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0);
-  if( pSubOpen ){
-    return pSubOpen->pMethods->xShmUnmap(pSubOpen, deleteFlag);
-  }
-  return SQLITE_OK;
-}
-
-/************************** Public Interfaces *****************************/
-/*
-** CAPI: Initialize the multiplex VFS shim - sqlite3_multiplex_initialize()
-**
-** Use the VFS named zOrigVfsName as the VFS that does the actual work.  
-** Use the default if zOrigVfsName==NULL.  
-**
-** The multiplex VFS shim is named "multiplex".  It will become the default
-** VFS if makeDefault is non-zero.
-**
-** THIS ROUTINE IS NOT THREADSAFE.  Call this routine exactly once
-** during start-up.
-*/
-int sqlite3_multiplex_initialize(const char *zOrigVfsName, int makeDefault){
-  sqlite3_vfs *pOrigVfs;
-  if( gMultiplex.isInitialized ) return SQLITE_MISUSE;
-  pOrigVfs = sqlite3_vfs_find(zOrigVfsName);
-  if( pOrigVfs==0 ) return SQLITE_ERROR;
-  assert( pOrigVfs!=&gMultiplex.sThisVfs );
-  gMultiplex.isInitialized = 1;
-  gMultiplex.pOrigVfs = pOrigVfs;
-  gMultiplex.sThisVfs = *pOrigVfs;
-  gMultiplex.sThisVfs.szOsFile += sizeof(multiplexConn);
-  gMultiplex.sThisVfs.zName = SQLITE_MULTIPLEX_VFS_NAME;
-  gMultiplex.sThisVfs.xOpen = multiplexOpen;
-  gMultiplex.sThisVfs.xDelete = multiplexDelete;
-  gMultiplex.sThisVfs.xAccess = multiplexAccess;
-  gMultiplex.sThisVfs.xFullPathname = multiplexFullPathname;
-  gMultiplex.sThisVfs.xDlOpen = multiplexDlOpen;
-  gMultiplex.sThisVfs.xDlError = multiplexDlError;
-  gMultiplex.sThisVfs.xDlSym = multiplexDlSym;
-  gMultiplex.sThisVfs.xDlClose = multiplexDlClose;
-  gMultiplex.sThisVfs.xRandomness = multiplexRandomness;
-  gMultiplex.sThisVfs.xSleep = multiplexSleep;
-  gMultiplex.sThisVfs.xCurrentTime = multiplexCurrentTime;
-  gMultiplex.sThisVfs.xGetLastError = multiplexGetLastError;
-  gMultiplex.sThisVfs.xCurrentTimeInt64 = multiplexCurrentTimeInt64;
-
-  gMultiplex.sIoMethodsV1.iVersion = 1;
-  gMultiplex.sIoMethodsV1.xClose = multiplexClose;
-  gMultiplex.sIoMethodsV1.xRead = multiplexRead;
-  gMultiplex.sIoMethodsV1.xWrite = multiplexWrite;
-  gMultiplex.sIoMethodsV1.xTruncate = multiplexTruncate;
-  gMultiplex.sIoMethodsV1.xSync = multiplexSync;
-  gMultiplex.sIoMethodsV1.xFileSize = multiplexFileSize;
-  gMultiplex.sIoMethodsV1.xLock = multiplexLock;
-  gMultiplex.sIoMethodsV1.xUnlock = multiplexUnlock;
-  gMultiplex.sIoMethodsV1.xCheckReservedLock = multiplexCheckReservedLock;
-  gMultiplex.sIoMethodsV1.xFileControl = multiplexFileControl;
-  gMultiplex.sIoMethodsV1.xSectorSize = multiplexSectorSize;
-  gMultiplex.sIoMethodsV1.xDeviceCharacteristics =
-                                            multiplexDeviceCharacteristics;
-  gMultiplex.sIoMethodsV2 = gMultiplex.sIoMethodsV1;
-  gMultiplex.sIoMethodsV2.iVersion = 2;
-  gMultiplex.sIoMethodsV2.xShmMap = multiplexShmMap;
-  gMultiplex.sIoMethodsV2.xShmLock = multiplexShmLock;
-  gMultiplex.sIoMethodsV2.xShmBarrier = multiplexShmBarrier;
-  gMultiplex.sIoMethodsV2.xShmUnmap = multiplexShmUnmap;
-  sqlite3_vfs_register(&gMultiplex.sThisVfs, makeDefault);
-
-  sqlite3_auto_extension((void(*)(void))multiplexFuncInit);
-
-  return SQLITE_OK;
-}
-
-/*
-** CAPI: Shutdown the multiplex system - sqlite3_multiplex_shutdown()
-**
-** All SQLite database connections must be closed before calling this
-** routine.
-**
-** THIS ROUTINE IS NOT THREADSAFE.  Call this routine exactly once while
-** shutting down in order to free all remaining multiplex groups.
-*/
-int sqlite3_multiplex_shutdown(int eForce){
-  int rc = SQLITE_OK;
-  if( gMultiplex.isInitialized==0 ) return SQLITE_MISUSE;
-  gMultiplex.isInitialized = 0;
-  sqlite3_vfs_unregister(&gMultiplex.sThisVfs);
-  memset(&gMultiplex, 0, sizeof(gMultiplex));
-  return rc;
-}
-
-/***************************** Test Code ***********************************/
-#ifdef SQLITE_TEST
-#if defined(INCLUDE_SQLITE_TCL_H)
+      } 
+      /* If the multiplexor does not handle the pragma, pass it through 
+      ** into the default case. */ 
+    } 
+    default: 
+      pSubOpen = multiplexSubOpen(pGroup, 0, &rc, NULL, 0); 
+      if( pSubOpen ){ 
+        rc = pSubOpen->pMethods->xFileControl(pSubOpen, op, pArg); 
+        if( op==SQLITE_FCNTL_VFSNAME && rc==SQLITE_OK ){ 
+         *(char**)pArg = sqlite3_mprintf("multiplex/%z", *(char**)pArg); 
+        } 
+      } 
+      break; 
+  } 
+  return rc; 
+} 
+ 
+/* Pass xSectorSize requests through to the original VFS unchanged. 
+*/ 
+static int multiplexSectorSize(sqlite3_file *pConn){ 
+  multiplexConn *p = (multiplexConn*)pConn; 
+  int rc; 
+  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); 
+  if( pSubOpen && pSubOpen->pMethods->xSectorSize ){ 
+    return pSubOpen->pMethods->xSectorSize(pSubOpen); 
+  } 
+  return DEFAULT_SECTOR_SIZE; 
+} 
+ 
+/* Pass xDeviceCharacteristics requests through to the original VFS unchanged. 
+*/ 
+static int multiplexDeviceCharacteristics(sqlite3_file *pConn){ 
+  multiplexConn *p = (multiplexConn*)pConn; 
+  int rc; 
+  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); 
+  if( pSubOpen ){ 
+    return pSubOpen->pMethods->xDeviceCharacteristics(pSubOpen); 
+  } 
+  return 0; 
+} 
+ 
+/* Pass xShmMap requests through to the original VFS unchanged. 
+*/ 
+static int multiplexShmMap( 
+  sqlite3_file *pConn,            /* Handle open on database file */ 
+  int iRegion,                    /* Region to retrieve */ 
+  int szRegion,                   /* Size of regions */ 
+  int bExtend,                    /* True to extend file if necessary */ 
+  void volatile **pp              /* OUT: Mapped memory */ 
+){ 
+  multiplexConn *p = (multiplexConn*)pConn; 
+  int rc; 
+  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); 
+  if( pSubOpen ){ 
+    return pSubOpen->pMethods->xShmMap(pSubOpen, iRegion, szRegion, bExtend,pp); 
+  } 
+  return SQLITE_IOERR; 
+} 
+ 
+/* Pass xShmLock requests through to the original VFS unchanged. 
+*/ 
+static int multiplexShmLock( 
+  sqlite3_file *pConn,       /* Database file holding the shared memory */ 
+  int ofst,                  /* First lock to acquire or release */ 
+  int n,                     /* Number of locks to acquire or release */ 
+  int flags                  /* What to do with the lock */ 
+){ 
+  multiplexConn *p = (multiplexConn*)pConn; 
+  int rc; 
+  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); 
+  if( pSubOpen ){ 
+    return pSubOpen->pMethods->xShmLock(pSubOpen, ofst, n, flags); 
+  } 
+  return SQLITE_BUSY; 
+} 
+ 
+/* Pass xShmBarrier requests through to the original VFS unchanged. 
+*/ 
+static void multiplexShmBarrier(sqlite3_file *pConn){ 
+  multiplexConn *p = (multiplexConn*)pConn; 
+  int rc; 
+  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); 
+  if( pSubOpen ){ 
+    pSubOpen->pMethods->xShmBarrier(pSubOpen); 
+  } 
+} 
+ 
+/* Pass xShmUnmap requests through to the original VFS unchanged. 
+*/ 
+static int multiplexShmUnmap(sqlite3_file *pConn, int deleteFlag){ 
+  multiplexConn *p = (multiplexConn*)pConn; 
+  int rc; 
+  sqlite3_file *pSubOpen = multiplexSubOpen(p->pGroup, 0, &rc, NULL, 0); 
+  if( pSubOpen ){ 
+    return pSubOpen->pMethods->xShmUnmap(pSubOpen, deleteFlag); 
+  } 
+  return SQLITE_OK; 
+} 
+ 
+/************************** Public Interfaces *****************************/ 
+/* 
+** CAPI: Initialize the multiplex VFS shim - sqlite3_multiplex_initialize() 
+** 
+** Use the VFS named zOrigVfsName as the VFS that does the actual work.   
+** Use the default if zOrigVfsName==NULL.   
+** 
+** The multiplex VFS shim is named "multiplex".  It will become the default 
+** VFS if makeDefault is non-zero. 
+** 
+** THIS ROUTINE IS NOT THREADSAFE.  Call this routine exactly once 
+** during start-up. 
+*/ 
+int sqlite3_multiplex_initialize(const char *zOrigVfsName, int makeDefault){ 
+  sqlite3_vfs *pOrigVfs; 
+  if( gMultiplex.isInitialized ) return SQLITE_MISUSE; 
+  pOrigVfs = sqlite3_vfs_find(zOrigVfsName); 
+  if( pOrigVfs==0 ) return SQLITE_ERROR; 
+  assert( pOrigVfs!=&gMultiplex.sThisVfs ); 
+  gMultiplex.isInitialized = 1; 
+  gMultiplex.pOrigVfs = pOrigVfs; 
+  gMultiplex.sThisVfs = *pOrigVfs; 
+  gMultiplex.sThisVfs.szOsFile += sizeof(multiplexConn); 
+  gMultiplex.sThisVfs.zName = SQLITE_MULTIPLEX_VFS_NAME; 
+  gMultiplex.sThisVfs.xOpen = multiplexOpen; 
+  gMultiplex.sThisVfs.xDelete = multiplexDelete; 
+  gMultiplex.sThisVfs.xAccess = multiplexAccess; 
+  gMultiplex.sThisVfs.xFullPathname = multiplexFullPathname; 
+  gMultiplex.sThisVfs.xDlOpen = multiplexDlOpen; 
+  gMultiplex.sThisVfs.xDlError = multiplexDlError; 
+  gMultiplex.sThisVfs.xDlSym = multiplexDlSym; 
+  gMultiplex.sThisVfs.xDlClose = multiplexDlClose; 
+  gMultiplex.sThisVfs.xRandomness = multiplexRandomness; 
+  gMultiplex.sThisVfs.xSleep = multiplexSleep; 
+  gMultiplex.sThisVfs.xCurrentTime = multiplexCurrentTime; 
+  gMultiplex.sThisVfs.xGetLastError = multiplexGetLastError; 
+  gMultiplex.sThisVfs.xCurrentTimeInt64 = multiplexCurrentTimeInt64; 
+ 
+  gMultiplex.sIoMethodsV1.iVersion = 1; 
+  gMultiplex.sIoMethodsV1.xClose = multiplexClose; 
+  gMultiplex.sIoMethodsV1.xRead = multiplexRead; 
+  gMultiplex.sIoMethodsV1.xWrite = multiplexWrite; 
+  gMultiplex.sIoMethodsV1.xTruncate = multiplexTruncate; 
+  gMultiplex.sIoMethodsV1.xSync = multiplexSync; 
+  gMultiplex.sIoMethodsV1.xFileSize = multiplexFileSize; 
+  gMultiplex.sIoMethodsV1.xLock = multiplexLock; 
+  gMultiplex.sIoMethodsV1.xUnlock = multiplexUnlock; 
+  gMultiplex.sIoMethodsV1.xCheckReservedLock = multiplexCheckReservedLock; 
+  gMultiplex.sIoMethodsV1.xFileControl = multiplexFileControl; 
+  gMultiplex.sIoMethodsV1.xSectorSize = multiplexSectorSize; 
+  gMultiplex.sIoMethodsV1.xDeviceCharacteristics = 
+                                            multiplexDeviceCharacteristics; 
+  gMultiplex.sIoMethodsV2 = gMultiplex.sIoMethodsV1; 
+  gMultiplex.sIoMethodsV2.iVersion = 2; 
+  gMultiplex.sIoMethodsV2.xShmMap = multiplexShmMap; 
+  gMultiplex.sIoMethodsV2.xShmLock = multiplexShmLock; 
+  gMultiplex.sIoMethodsV2.xShmBarrier = multiplexShmBarrier; 
+  gMultiplex.sIoMethodsV2.xShmUnmap = multiplexShmUnmap; 
+  sqlite3_vfs_register(&gMultiplex.sThisVfs, makeDefault); 
+ 
+  sqlite3_auto_extension((void(*)(void))multiplexFuncInit); 
+ 
+  return SQLITE_OK; 
+} 
+ 
+/* 
+** CAPI: Shutdown the multiplex system - sqlite3_multiplex_shutdown() 
+** 
+** All SQLite database connections must be closed before calling this 
+** routine. 
+** 
+** THIS ROUTINE IS NOT THREADSAFE.  Call this routine exactly once while 
+** shutting down in order to free all remaining multiplex groups. 
+*/ 
+int sqlite3_multiplex_shutdown(int eForce){ 
+  int rc = SQLITE_OK; 
+  if( gMultiplex.isInitialized==0 ) return SQLITE_MISUSE; 
+  gMultiplex.isInitialized = 0; 
+  sqlite3_vfs_unregister(&gMultiplex.sThisVfs); 
+  memset(&gMultiplex, 0, sizeof(gMultiplex)); 
+  return rc; 
+} 
+ 
+/***************************** Test Code ***********************************/ 
+#ifdef SQLITE_TEST 
+#if defined(INCLUDE_SQLITE_TCL_H) 
 #  error #include "sqlite_tcl.h"
-#else
-#  include "tcl.h"
-#  ifndef SQLITE_TCLAPI
-#    define SQLITE_TCLAPI
-#  endif
-#endif
-extern const char *sqlite3ErrName(int);
-
-
-/*
-** tclcmd: sqlite3_multiplex_initialize NAME MAKEDEFAULT
-*/
-static int SQLITE_TCLAPI test_multiplex_initialize(
-  void * clientData,
-  Tcl_Interp *interp,
-  int objc,
-  Tcl_Obj *CONST objv[]
-){
-  const char *zName;              /* Name of new multiplex VFS */
-  int makeDefault;                /* True to make the new VFS the default */
-  int rc;                         /* Value returned by multiplex_initialize() */
-
-  UNUSED_PARAMETER(clientData);
-
-  /* Process arguments */
-  if( objc!=3 ){
-    Tcl_WrongNumArgs(interp, 1, objv, "NAME MAKEDEFAULT");
-    return TCL_ERROR;
-  }
-  zName = Tcl_GetString(objv[1]);
-  if( Tcl_GetBooleanFromObj(interp, objv[2], &makeDefault) ) return TCL_ERROR;
-  if( zName[0]=='\0' ) zName = 0;
-
-  /* Call sqlite3_multiplex_initialize() */
-  rc = sqlite3_multiplex_initialize(zName, makeDefault);
-  Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);
-
-  return TCL_OK;
-}
-
-/*
-** tclcmd: sqlite3_multiplex_shutdown
-*/
-static int SQLITE_TCLAPI test_multiplex_shutdown(
-  void * clientData,
-  Tcl_Interp *interp,
-  int objc,
-  Tcl_Obj *CONST objv[]
-){
-  int rc;                         /* Value returned by multiplex_shutdown() */
-
-  UNUSED_PARAMETER(clientData);
-
-  if( objc==2 && strcmp(Tcl_GetString(objv[1]),"-force")!=0 ){
-    objc = 3;
-  }
-  if( (objc!=1 && objc!=2) ){
-    Tcl_WrongNumArgs(interp, 1, objv, "?-force?");
-    return TCL_ERROR;
-  }
-
-  /* Call sqlite3_multiplex_shutdown() */
-  rc = sqlite3_multiplex_shutdown(objc==2);
-  Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);
-
-  return TCL_OK;
-}
-
-/*
-** Tclcmd: test_multiplex_control HANDLE DBNAME SUB-COMMAND ?INT-VALUE?
-*/
-static int SQLITE_TCLAPI test_multiplex_control(
-  ClientData cd,
-  Tcl_Interp *interp,
-  int objc,
-  Tcl_Obj *CONST objv[]
-){
-  int rc;                         /* Return code from file_control() */
-  int idx;                        /* Index in aSub[] */
-  Tcl_CmdInfo cmdInfo;            /* Command info structure for HANDLE */
-  sqlite3 *db;                    /* Underlying db handle for HANDLE */
-  int iValue = 0;
-  void *pArg = 0;
-
-  struct SubCommand {
-    const char *zName;
-    int op;
-    int argtype;
-  } aSub[] = {
-    { "enable",       MULTIPLEX_CTRL_ENABLE,           1 },
-    { "chunk_size",   MULTIPLEX_CTRL_SET_CHUNK_SIZE,   1 },
-    { "max_chunks",   MULTIPLEX_CTRL_SET_MAX_CHUNKS,   1 },
-    { 0, 0, 0 }
-  };
-
-  if( objc!=5 ){
-    Tcl_WrongNumArgs(interp, 1, objv, "HANDLE DBNAME SUB-COMMAND INT-VALUE");
-    return TCL_ERROR;
-  }
-
-  if( 0==Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){
-    Tcl_AppendResult(interp, "expected database handle, got \"", 0);
-    Tcl_AppendResult(interp, Tcl_GetString(objv[1]), "\"", 0);
-    return TCL_ERROR;
-  }else{
-    db = *(sqlite3 **)cmdInfo.objClientData;
-  }
-
-  rc = Tcl_GetIndexFromObjStruct(
-      interp, objv[3], aSub, sizeof(aSub[0]), "sub-command", 0, &idx
-  );
-  if( rc!=TCL_OK ) return rc;
-
-  switch( aSub[idx].argtype ){
-    case 1:
-      if( Tcl_GetIntFromObj(interp, objv[4], &iValue) ){
-        return TCL_ERROR;
-      }
-      pArg = (void *)&iValue;
-      break;
-    default:
-      Tcl_WrongNumArgs(interp, 4, objv, "SUB-COMMAND");
-      return TCL_ERROR;
-  }
-
-  rc = sqlite3_file_control(db, Tcl_GetString(objv[2]), aSub[idx].op, pArg);
-  Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC);
-  return (rc==SQLITE_OK) ? TCL_OK : TCL_ERROR;
-}
-
-/*
-** This routine registers the custom TCL commands defined in this
-** module.  This should be the only procedure visible from outside
-** of this module.
-*/
-int Sqlitemultiplex_Init(Tcl_Interp *interp){
-  static struct {
-     char *zName;
-     Tcl_ObjCmdProc *xProc;
-  } aCmd[] = {
-    { "sqlite3_multiplex_initialize", test_multiplex_initialize },
-    { "sqlite3_multiplex_shutdown", test_multiplex_shutdown },
-    { "sqlite3_multiplex_control", test_multiplex_control },
-  };
-  int i;
-
-  for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
-    Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
-  }
-
-  return TCL_OK;
-}
-#endif
+#else 
+#  include "tcl.h" 
+#  ifndef SQLITE_TCLAPI 
+#    define SQLITE_TCLAPI 
+#  endif 
+#endif 
+extern const char *sqlite3ErrName(int); 
+ 
+ 
+/* 
+** tclcmd: sqlite3_multiplex_initialize NAME MAKEDEFAULT 
+*/ 
+static int SQLITE_TCLAPI test_multiplex_initialize( 
+  void * clientData, 
+  Tcl_Interp *interp, 
+  int objc, 
+  Tcl_Obj *CONST objv[] 
+){ 
+  const char *zName;              /* Name of new multiplex VFS */ 
+  int makeDefault;                /* True to make the new VFS the default */ 
+  int rc;                         /* Value returned by multiplex_initialize() */ 
+ 
+  UNUSED_PARAMETER(clientData); 
+ 
+  /* Process arguments */ 
+  if( objc!=3 ){ 
+    Tcl_WrongNumArgs(interp, 1, objv, "NAME MAKEDEFAULT"); 
+    return TCL_ERROR; 
+  } 
+  zName = Tcl_GetString(objv[1]); 
+  if( Tcl_GetBooleanFromObj(interp, objv[2], &makeDefault) ) return TCL_ERROR; 
+  if( zName[0]=='\0' ) zName = 0; 
+ 
+  /* Call sqlite3_multiplex_initialize() */ 
+  rc = sqlite3_multiplex_initialize(zName, makeDefault); 
+  Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC); 
+ 
+  return TCL_OK; 
+} 
+ 
+/* 
+** tclcmd: sqlite3_multiplex_shutdown 
+*/ 
+static int SQLITE_TCLAPI test_multiplex_shutdown( 
+  void * clientData, 
+  Tcl_Interp *interp, 
+  int objc, 
+  Tcl_Obj *CONST objv[] 
+){ 
+  int rc;                         /* Value returned by multiplex_shutdown() */ 
+ 
+  UNUSED_PARAMETER(clientData); 
+ 
+  if( objc==2 && strcmp(Tcl_GetString(objv[1]),"-force")!=0 ){ 
+    objc = 3; 
+  } 
+  if( (objc!=1 && objc!=2) ){ 
+    Tcl_WrongNumArgs(interp, 1, objv, "?-force?"); 
+    return TCL_ERROR; 
+  } 
+ 
+  /* Call sqlite3_multiplex_shutdown() */ 
+  rc = sqlite3_multiplex_shutdown(objc==2); 
+  Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC); 
+ 
+  return TCL_OK; 
+} 
+ 
+/* 
+** Tclcmd: test_multiplex_control HANDLE DBNAME SUB-COMMAND ?INT-VALUE? 
+*/ 
+static int SQLITE_TCLAPI test_multiplex_control( 
+  ClientData cd, 
+  Tcl_Interp *interp, 
+  int objc, 
+  Tcl_Obj *CONST objv[] 
+){ 
+  int rc;                         /* Return code from file_control() */ 
+  int idx;                        /* Index in aSub[] */ 
+  Tcl_CmdInfo cmdInfo;            /* Command info structure for HANDLE */ 
+  sqlite3 *db;                    /* Underlying db handle for HANDLE */ 
+  int iValue = 0; 
+  void *pArg = 0; 
+ 
+  struct SubCommand { 
+    const char *zName; 
+    int op; 
+    int argtype; 
+  } aSub[] = { 
+    { "enable",       MULTIPLEX_CTRL_ENABLE,           1 }, 
+    { "chunk_size",   MULTIPLEX_CTRL_SET_CHUNK_SIZE,   1 }, 
+    { "max_chunks",   MULTIPLEX_CTRL_SET_MAX_CHUNKS,   1 }, 
+    { 0, 0, 0 } 
+  }; 
+ 
+  if( objc!=5 ){ 
+    Tcl_WrongNumArgs(interp, 1, objv, "HANDLE DBNAME SUB-COMMAND INT-VALUE"); 
+    return TCL_ERROR; 
+  } 
+ 
+  if( 0==Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){ 
+    Tcl_AppendResult(interp, "expected database handle, got \"", 0); 
+    Tcl_AppendResult(interp, Tcl_GetString(objv[1]), "\"", 0); 
+    return TCL_ERROR; 
+  }else{ 
+    db = *(sqlite3 **)cmdInfo.objClientData; 
+  } 
+ 
+  rc = Tcl_GetIndexFromObjStruct( 
+      interp, objv[3], aSub, sizeof(aSub[0]), "sub-command", 0, &idx 
+  ); 
+  if( rc!=TCL_OK ) return rc; 
+ 
+  switch( aSub[idx].argtype ){ 
+    case 1: 
+      if( Tcl_GetIntFromObj(interp, objv[4], &iValue) ){ 
+        return TCL_ERROR; 
+      } 
+      pArg = (void *)&iValue; 
+      break; 
+    default: 
+      Tcl_WrongNumArgs(interp, 4, objv, "SUB-COMMAND"); 
+      return TCL_ERROR; 
+  } 
+ 
+  rc = sqlite3_file_control(db, Tcl_GetString(objv[2]), aSub[idx].op, pArg); 
+  Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_STATIC); 
+  return (rc==SQLITE_OK) ? TCL_OK : TCL_ERROR; 
+} 
+ 
+/* 
+** This routine registers the custom TCL commands defined in this 
+** module.  This should be the only procedure visible from outside 
+** of this module. 
+*/ 
+int Sqlitemultiplex_Init(Tcl_Interp *interp){ 
+  static struct { 
+     char *zName; 
+     Tcl_ObjCmdProc *xProc; 
+  } aCmd[] = { 
+    { "sqlite3_multiplex_initialize", test_multiplex_initialize }, 
+    { "sqlite3_multiplex_shutdown", test_multiplex_shutdown }, 
+    { "sqlite3_multiplex_control", test_multiplex_control }, 
+  }; 
+  int i; 
+ 
+  for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){ 
+    Tcl_CreateObjCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0); 
+  } 
+ 
+  return TCL_OK; 
+} 
+#endif