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

8 files changed, 23560 insertions, 23560 deletions

diff --git a/contrib/libs/sqlite3/LICENSE.md b/contrib/libs/sqlite3/LICENSE.md
index f68a6c175f..ffe0385a07 100644
--- a/contrib/libs/sqlite3/LICENSE.md
+++ b/contrib/libs/sqlite3/LICENSE.md
@@ -1,6 +1,6 @@
-The author disclaims copyright to this source code.  In place of
-a legal notice, here is a blessing:
-
-  *   May you do good and not evil.
-  *   May you find forgiveness for yourself and forgive others.
-  *   May you share freely, never taking more than you give.
+The 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. 
diff --git a/contrib/libs/sqlite3/README.md b/contrib/libs/sqlite3/README.md
index b79fc67f15..70d734297e 100644
--- a/contrib/libs/sqlite3/README.md
+++ b/contrib/libs/sqlite3/README.md
@@ -1,327 +1,327 @@
-<h1 align="center">SQLite Source Repository</h1>
-
-This repository contains the complete source code for the 
-[SQLite database engine](https://sqlite.org/).  Some test scripts 
-are also included.  However, many other test scripts
-and most of the documentation are managed separately.
-
-## Version Control
-
-SQLite sources are managed using the
-[Fossil](https://www.fossil-scm.org/), a distributed version control system
-that was specifically designed and written to support SQLite development.
-The [Fossil repository](https://sqlite.org/src/timeline) contains the urtext.
-
-If you are reading this on GitHub or some other Git repository or service,
-then you are looking at a mirror.  The names of check-ins and
-other artifacts in a Git mirror are different from the official
-names for those objects.  The offical names for check-ins are
-found in a footer on the check-in comment for authorized mirrors.
-The official check-in name can also be seen in the `manifest.uuid` file
-in the root of the tree.  Always use the official name, not  the
-Git-name, when communicating about an SQLite check-in.
-
-If you pulled your SQLite source code from a secondary source and want to
-verify its integrity, there are hints on how to do that in the
-[Verifying Code Authenticity](#vauth) section below.
-
-## Obtaining The Code
-
-If you do not want to use Fossil, you can download tarballs or ZIP
-archives or [SQLite archives](https://sqlite.org/cli.html#sqlar) as follows:
-
-  *  Lastest trunk check-in as
-     [Tarball](https://www.sqlite.org/src/tarball/sqlite.tar.gz),
-     [ZIP-archive](https://www.sqlite.org/src/zip/sqlite.zip), or
-     [SQLite-archive](https://www.sqlite.org/src/sqlar/sqlite.sqlar).
-
-  *  Latest release as
-     [Tarball](https://www.sqlite.org/src/tarball/sqlite.tar.gz?r=release),
-     [ZIP-archive](https://www.sqlite.org/src/zip/sqlite.zip?r=release), or
-     [SQLite-archive](https://www.sqlite.org/src/sqlar/sqlite.sqlar?r=release).
-
-  *  For other check-ins, substitute an appropriate branch name or
-     tag or hash prefix in place of "release" in the URLs of the previous
-     bullet.  Or browse the [timeline](https://www.sqlite.org/src/timeline)
-     to locate the check-in desired, click on its information page link,
-     then click on the "Tarball" or "ZIP Archive" links on the information
-     page.
-
-If you do want to use Fossil to check out the source tree, 
-first install Fossil version 2.0 or later.
-(Source tarballs and precompiled binaries available
-[here](https://www.fossil-scm.org/fossil/uv/download.html).  Fossil is
-a stand-alone program.  To install, simply download or build the single 
-executable file and put that file someplace on your $PATH.)
-Then run commands like this:
-
+<h1 align="center">SQLite Source Repository</h1> 
+ 
+This repository contains the complete source code for the  
+[SQLite database engine](https://sqlite.org/).  Some test scripts  
+are also included.  However, many other test scripts 
+and most of the documentation are managed separately. 
+ 
+## Version Control 
+ 
+SQLite sources are managed using the 
+[Fossil](https://www.fossil-scm.org/), a distributed version control system 
+that was specifically designed and written to support SQLite development. 
+The [Fossil repository](https://sqlite.org/src/timeline) contains the urtext. 
+ 
+If you are reading this on GitHub or some other Git repository or service, 
+then you are looking at a mirror.  The names of check-ins and 
+other artifacts in a Git mirror are different from the official 
+names for those objects.  The offical names for check-ins are 
+found in a footer on the check-in comment for authorized mirrors. 
+The official check-in name can also be seen in the `manifest.uuid` file 
+in the root of the tree.  Always use the official name, not  the 
+Git-name, when communicating about an SQLite check-in. 
+ 
+If you pulled your SQLite source code from a secondary source and want to 
+verify its integrity, there are hints on how to do that in the 
+[Verifying Code Authenticity](#vauth) section below. 
+ 
+## Obtaining The Code 
+ 
+If you do not want to use Fossil, you can download tarballs or ZIP 
+archives or [SQLite archives](https://sqlite.org/cli.html#sqlar) as follows: 
+ 
+  *  Lastest trunk check-in as 
+     [Tarball](https://www.sqlite.org/src/tarball/sqlite.tar.gz), 
+     [ZIP-archive](https://www.sqlite.org/src/zip/sqlite.zip), or 
+     [SQLite-archive](https://www.sqlite.org/src/sqlar/sqlite.sqlar). 
+ 
+  *  Latest release as 
+     [Tarball](https://www.sqlite.org/src/tarball/sqlite.tar.gz?r=release), 
+     [ZIP-archive](https://www.sqlite.org/src/zip/sqlite.zip?r=release), or 
+     [SQLite-archive](https://www.sqlite.org/src/sqlar/sqlite.sqlar?r=release). 
+ 
+  *  For other check-ins, substitute an appropriate branch name or 
+     tag or hash prefix in place of "release" in the URLs of the previous 
+     bullet.  Or browse the [timeline](https://www.sqlite.org/src/timeline) 
+     to locate the check-in desired, click on its information page link, 
+     then click on the "Tarball" or "ZIP Archive" links on the information 
+     page. 
+ 
+If you do want to use Fossil to check out the source tree,  
+first install Fossil version 2.0 or later. 
+(Source tarballs and precompiled binaries available 
+[here](https://www.fossil-scm.org/fossil/uv/download.html).  Fossil is 
+a stand-alone program.  To install, simply download or build the single  
+executable file and put that file someplace on your $PATH.) 
+Then run commands like this: 
+ 
         mkdir -p ~/sqlite ~/Fossils
-        cd ~/sqlite
+        cd ~/sqlite 
         fossil clone https://www.sqlite.org/src ~/Fossils/sqlite.fossil
         fossil open ~/Fossils/sqlite.fossil
 
-After setting up a repository using the steps above, you can always
-update to the lastest version using:
-
-        fossil update trunk   ;# latest trunk check-in
-        fossil update release ;# latest official release
-
-Or type "fossil ui" to get a web-based user interface.
-
+After setting up a repository using the steps above, you can always 
+update to the lastest version using: 
+ 
+        fossil update trunk   ;# latest trunk check-in 
+        fossil update release ;# latest official release 
+ 
+Or type "fossil ui" to get a web-based user interface. 
+ 
 ## Compiling for Unix-like systems
-
-First create a directory in which to place
-the build products.  It is recommended, but not required, that the
-build directory be separate from the source directory.  Cd into the
-build directory and then from the build directory run the configure
-script found at the root of the source tree.  Then run "make".
-
-For example:
-
-        tar xzf sqlite.tar.gz    ;#  Unpack the source tree into "sqlite"
-        mkdir bld                ;#  Build will occur in a sibling directory
-        cd bld                   ;#  Change to the build directory
-        ../sqlite/configure      ;#  Run the configure script
-        make                     ;#  Run the makefile.
-        make sqlite3.c           ;#  Build the "amalgamation" source file
-        make test                ;#  Run some tests (requires Tcl)
-
-See the makefile for additional targets.
-
-The configure script uses autoconf 2.61 and libtool.  If the configure
-script does not work out for you, there is a generic makefile named
-"Makefile.linux-gcc" in the top directory of the source tree that you
-can copy and edit to suit your needs.  Comments on the generic makefile
-show what changes are needed.
-
+ 
+First create a directory in which to place 
+the build products.  It is recommended, but not required, that the 
+build directory be separate from the source directory.  Cd into the 
+build directory and then from the build directory run the configure 
+script found at the root of the source tree.  Then run "make". 
+ 
+For example: 
+ 
+        tar xzf sqlite.tar.gz    ;#  Unpack the source tree into "sqlite" 
+        mkdir bld                ;#  Build will occur in a sibling directory 
+        cd bld                   ;#  Change to the build directory 
+        ../sqlite/configure      ;#  Run the configure script 
+        make                     ;#  Run the makefile. 
+        make sqlite3.c           ;#  Build the "amalgamation" source file 
+        make test                ;#  Run some tests (requires Tcl) 
+ 
+See the makefile for additional targets. 
+ 
+The configure script uses autoconf 2.61 and libtool.  If the configure 
+script does not work out for you, there is a generic makefile named 
+"Makefile.linux-gcc" in the top directory of the source tree that you 
+can copy and edit to suit your needs.  Comments on the generic makefile 
+show what changes are needed. 
+ 
 ## Using MSVC for Windows systems
-
-On Windows, all applicable build products can be compiled with MSVC.
-First open the command prompt window associated with the desired compiler
-version (e.g. "Developer Command Prompt for VS2013").  Next, use NMAKE
-with the provided "Makefile.msc" to build one of the supported targets.
-
+ 
+On Windows, all applicable build products can be compiled with MSVC. 
+First open the command prompt window associated with the desired compiler 
+version (e.g. "Developer Command Prompt for VS2013").  Next, use NMAKE 
+with the provided "Makefile.msc" to build one of the supported targets. 
+ 
 For example, from the parent directory of the source subtree named "sqlite":
-
-        mkdir bld
-        cd bld
+ 
+        mkdir bld 
+        cd bld 
         nmake /f ..\sqlite\Makefile.msc TOP=..\sqlite
         nmake /f ..\sqlite\Makefile.msc sqlite3.c TOP=..\sqlite
         nmake /f ..\sqlite\Makefile.msc sqlite3.dll TOP=..\sqlite
         nmake /f ..\sqlite\Makefile.msc sqlite3.exe TOP=..\sqlite
         nmake /f ..\sqlite\Makefile.msc test TOP=..\sqlite
-
-There are several build options that can be set via the NMAKE command
-line.  For example, to build for WinRT, simply add "FOR_WINRT=1" argument
-to the "sqlite3.dll" command line above.  When debugging into the SQLite
-code, adding the "DEBUG=1" argument to one of the above command lines is
-recommended.
-
-SQLite does not require [Tcl](http://www.tcl.tk/) to run, but a Tcl installation
-is required by the makefiles (including those for MSVC).  SQLite contains
-a lot of generated code and Tcl is used to do much of that code generation.
-
-## Source Code Tour
-
-Most of the core source files are in the **src/** subdirectory.  The
-**src/** folder also contains files used to build the "testfixture" test
-harness. The names of the source files used by "testfixture" all begin
-with "test".
-The **src/** also contains the "shell.c" file
-which is the main program for the "sqlite3.exe"
-[command-line shell](https://sqlite.org/cli.html) and
-the "tclsqlite.c" file which implements the
-[Tcl bindings](https://sqlite.org/tclsqlite.html) for SQLite.
-(Historical note:  SQLite began as a Tcl
-extension and only later escaped to the wild as an independent library.)
-
-Test scripts and programs are found in the **test/** subdirectory.
-Addtional test code is found in other source repositories.
-See [How SQLite Is Tested](http://www.sqlite.org/testing.html) for
-additional information.
-
-The **ext/** subdirectory contains code for extensions.  The
-Full-text search engine is in **ext/fts3**.  The R-Tree engine is in
-**ext/rtree**.  The **ext/misc** subdirectory contains a number of
-smaller, single-file extensions, such as a REGEXP operator.
-
-The **tool/** subdirectory contains various scripts and programs used
-for building generated source code files or for testing or for generating
-accessory programs such as "sqlite3_analyzer(.exe)".
-
-### Generated Source Code Files
-
-Several of the C-language source files used by SQLite are generated from
-other sources rather than being typed in manually by a programmer.  This
-section will summarize those automatically-generated files.  To create all
-of the automatically-generated files, simply run "make target&#95;source".
-The "target&#95;source" make target will create a subdirectory "tsrc/" and
-fill it with all the source files needed to build SQLite, both
-manually-edited files and automatically-generated files.
-
-The SQLite interface is defined by the **sqlite3.h** header file, which is
-generated from src/sqlite.h.in, ./manifest.uuid, and ./VERSION.  The
-[Tcl script](http://www.tcl.tk) at tool/mksqlite3h.tcl does the conversion.
-The manifest.uuid file contains the SHA3 hash of the particular check-in
-and is used to generate the SQLITE\_SOURCE\_ID macro.  The VERSION file
-contains the current SQLite version number.  The sqlite3.h header is really
-just a copy of src/sqlite.h.in with the source-id and version number inserted
-at just the right spots. Note that comment text in the sqlite3.h file is
-used to generate much of the SQLite API documentation.  The Tcl scripts
-used to generate that documentation are in a separate source repository.
-
-The SQL language parser is **parse.c** which is generate from a grammar in
-the src/parse.y file.  The conversion of "parse.y" into "parse.c" is done
-by the [lemon](./doc/lemon.html) LALR(1) parser generator.  The source code
-for lemon is at tool/lemon.c.  Lemon uses the tool/lempar.c file as a
-template for generating its parser.
-Lemon also generates the **parse.h** header file, at the same time it
-generates parse.c.
-
-The **opcodes.h** header file contains macros that define the numbers
-corresponding to opcodes in the "VDBE" virtual machine.  The opcodes.h
-file is generated by the scanning the src/vdbe.c source file.  The
-Tcl script at ./mkopcodeh.tcl does this scan and generates opcodes.h.
-A second Tcl script, ./mkopcodec.tcl, then scans opcodes.h to generate
-the **opcodes.c** source file, which contains a reverse mapping from
-opcode-number to opcode-name that is used for EXPLAIN output.
-
-The **keywordhash.h** header file contains the definition of a hash table
-that maps SQL language keywords (ex: "CREATE", "SELECT", "INDEX", etc.) into
-the numeric codes used by the parse.c parser.  The keywordhash.h file is
-generated by a C-language program at tool mkkeywordhash.c.
-
-The **pragma.h** header file contains various definitions used to parse
-and implement the PRAGMA statements.  The header is generated by a
-script **tool/mkpragmatab.tcl**. If you want to add a new PRAGMA, edit
-the **tool/mkpragmatab.tcl** file to insert the information needed by the
-parser for your new PRAGMA, then run the script to regenerate the
-**pragma.h** header file.
-
-### The Amalgamation
-
-All of the individual C source code and header files (both manually-edited
-and automatically-generated) can be combined into a single big source file
-**sqlite3.c** called "the amalgamation".  The amalgamation is the recommended
-way of using SQLite in a larger application.  Combining all individual
-source code files into a single big source code file allows the C compiler
-to perform more cross-procedure analysis and generate better code.  SQLite
-runs about 5% faster when compiled from the amalgamation versus when compiled
-from individual source files.
-
-The amalgamation is generated from the tool/mksqlite3c.tcl Tcl script.
-First, all of the individual source files must be gathered into the tsrc/
-subdirectory (using the equivalent of "make target_source") then the
-tool/mksqlite3c.tcl script is run to copy them all together in just the
-right order while resolving internal "#include" references.
-
-The amalgamation source file is more than 200K lines long.  Some symbolic
-debuggers (most notably MSVC) are unable to deal with files longer than 64K
-lines.  To work around this, a separate Tcl script, tool/split-sqlite3c.tcl,
-can be run on the amalgamation to break it up into a single small C file
-called **sqlite3-all.c** that does #include on about seven other files
-named **sqlite3-1.c**, **sqlite3-2.c**, ..., **sqlite3-7.c**.  In this way,
-all of the source code is contained within a single translation unit so
-that the compiler can do extra cross-procedure optimization, but no
-individual source file exceeds 32K lines in length.
-
-## How It All Fits Together
-
-SQLite is modular in design.
-See the [architectural description](http://www.sqlite.org/arch.html)
-for details. Other documents that are useful in
-(helping to understand how SQLite works include the
-[file format](http://www.sqlite.org/fileformat2.html) description,
-the [virtual machine](http://www.sqlite.org/opcode.html) that runs
-prepared statements, the description of
-[how transactions work](http://www.sqlite.org/atomiccommit.html), and
-the [overview of the query planner](http://www.sqlite.org/optoverview.html).
-
-Years of effort have gone into optimizating SQLite, both
-for small size and high performance.  And optimizations tend to result in
-complex code.  So there is a lot of complexity in the current SQLite
-implementation.  It will not be the easiest library in the world to hack.
-
-Key files:
-
-  *  **sqlite.h.in** - This file defines the public interface to the SQLite
-     library.  Readers will need to be familiar with this interface before
-     trying to understand how the library works internally.
-
-  *  **sqliteInt.h** - this header file defines many of the data objects
-     used internally by SQLite.  In addition to "sqliteInt.h", some
-     subsystems have their own header files.
-
-  *  **parse.y** - This file describes the LALR(1) grammar that SQLite uses
-     to parse SQL statements, and the actions that are taken at each step
-     in the parsing process.
-
-  *  **vdbe.c** - This file implements the virtual machine that runs
-     prepared statements.  There are various helper files whose names
-     begin with "vdbe".  The VDBE has access to the vdbeInt.h header file
-     which defines internal data objects.  The rest of SQLite interacts
-     with the VDBE through an interface defined by vdbe.h.
-
-  *  **where.c** - This file (together with its helper files named
-     by "where*.c") analyzes the WHERE clause and generates
-     virtual machine code to run queries efficiently.  This file is
-     sometimes called the "query optimizer".  It has its own private
-     header file, whereInt.h, that defines data objects used internally.
-
-  *  **btree.c** - This file contains the implementation of the B-Tree
-     storage engine used by SQLite.  The interface to the rest of the system
-     is defined by "btree.h".  The "btreeInt.h" header defines objects
-     used internally by btree.c and not published to the rest of the system.
-
-  *  **pager.c** - This file contains the "pager" implementation, the
-     module that implements transactions.  The "pager.h" header file
-     defines the interface between pager.c and the rest of the system.
-
-  *  **os_unix.c** and **os_win.c** - These two files implement the interface
-     between SQLite and the underlying operating system using the run-time
-     pluggable VFS interface.
-
-  *  **shell.c.in** - This file is not part of the core SQLite library.  This
-     is the file that, when linked against sqlite3.a, generates the
-     "sqlite3.exe" command-line shell.  The "shell.c.in" file is transformed
-     into "shell.c" as part of the build process.
-
-  *  **tclsqlite.c** - This file implements the Tcl bindings for SQLite.  It
-     is not part of the core SQLite library.  But as most of the tests in this
-     repository are written in Tcl, the Tcl language bindings are important.
-
-  *  **test*.c** - Files in the src/ folder that begin with "test" go into
-     building the "testfixture.exe" program.  The testfixture.exe program is
-     an enhanced Tcl shell.  The testfixture.exe program runs scripts in the
-     test/ folder to validate the core SQLite code.  The testfixture program
-     (and some other test programs too) is build and run when you type
-     "make test".
-
-  *  **ext/misc/json1.c** - This file implements the various JSON functions
-     that are build into SQLite.
-
-There are many other source files.  Each has a succinct header comment that
-describes its purpose and role within the larger system.
-
-<a name="vauth"></a>
-## Verifying Code Authenticity
-
-The `manifest` file at the root directory of the source tree
-contains either a SHA3-256 hash (for newer files) or a SHA1 hash (for 
-older files) for every source file in the repository.
-The SHA3-256 hash of the `manifest`
-file itself is the official name of the version of the source tree that you
-have. The `manifest.uuid` file should contain the SHA3-256 hash of the
-`manifest` file. If all of the above hash comparisons are correct, then
-you can be confident that your source tree is authentic and unadulterated.
-
-The format of the `manifest` file should be mostly self-explanatory, but
-if you want details, they are available
-[here](https://fossil-scm.org/fossil/doc/trunk/www/fileformat.wiki#manifest).
-
-## Contacts
-
-The main SQLite website is [http://www.sqlite.org/](http://www.sqlite.org/)
-with geographically distributed backups at
-[http://www2.sqlite.org/](http://www2.sqlite.org) and
-[http://www3.sqlite.org/](http://www3.sqlite.org).
+ 
+There are several build options that can be set via the NMAKE command 
+line.  For example, to build for WinRT, simply add "FOR_WINRT=1" argument 
+to the "sqlite3.dll" command line above.  When debugging into the SQLite 
+code, adding the "DEBUG=1" argument to one of the above command lines is 
+recommended. 
+ 
+SQLite does not require [Tcl](http://www.tcl.tk/) to run, but a Tcl installation 
+is required by the makefiles (including those for MSVC).  SQLite contains 
+a lot of generated code and Tcl is used to do much of that code generation. 
+ 
+## Source Code Tour 
+ 
+Most of the core source files are in the **src/** subdirectory.  The 
+**src/** folder also contains files used to build the "testfixture" test 
+harness. The names of the source files used by "testfixture" all begin 
+with "test". 
+The **src/** also contains the "shell.c" file 
+which is the main program for the "sqlite3.exe" 
+[command-line shell](https://sqlite.org/cli.html) and 
+the "tclsqlite.c" file which implements the 
+[Tcl bindings](https://sqlite.org/tclsqlite.html) for SQLite. 
+(Historical note:  SQLite began as a Tcl 
+extension and only later escaped to the wild as an independent library.) 
+ 
+Test scripts and programs are found in the **test/** subdirectory. 
+Addtional test code is found in other source repositories. 
+See [How SQLite Is Tested](http://www.sqlite.org/testing.html) for 
+additional information. 
+ 
+The **ext/** subdirectory contains code for extensions.  The 
+Full-text search engine is in **ext/fts3**.  The R-Tree engine is in 
+**ext/rtree**.  The **ext/misc** subdirectory contains a number of 
+smaller, single-file extensions, such as a REGEXP operator. 
+ 
+The **tool/** subdirectory contains various scripts and programs used 
+for building generated source code files or for testing or for generating 
+accessory programs such as "sqlite3_analyzer(.exe)". 
+ 
+### Generated Source Code Files 
+ 
+Several of the C-language source files used by SQLite are generated from 
+other sources rather than being typed in manually by a programmer.  This 
+section will summarize those automatically-generated files.  To create all 
+of the automatically-generated files, simply run "make target&#95;source". 
+The "target&#95;source" make target will create a subdirectory "tsrc/" and 
+fill it with all the source files needed to build SQLite, both 
+manually-edited files and automatically-generated files. 
+ 
+The SQLite interface is defined by the **sqlite3.h** header file, which is 
+generated from src/sqlite.h.in, ./manifest.uuid, and ./VERSION.  The 
+[Tcl script](http://www.tcl.tk) at tool/mksqlite3h.tcl does the conversion. 
+The manifest.uuid file contains the SHA3 hash of the particular check-in 
+and is used to generate the SQLITE\_SOURCE\_ID macro.  The VERSION file 
+contains the current SQLite version number.  The sqlite3.h header is really 
+just a copy of src/sqlite.h.in with the source-id and version number inserted 
+at just the right spots. Note that comment text in the sqlite3.h file is 
+used to generate much of the SQLite API documentation.  The Tcl scripts 
+used to generate that documentation are in a separate source repository. 
+ 
+The SQL language parser is **parse.c** which is generate from a grammar in 
+the src/parse.y file.  The conversion of "parse.y" into "parse.c" is done 
+by the [lemon](./doc/lemon.html) LALR(1) parser generator.  The source code 
+for lemon is at tool/lemon.c.  Lemon uses the tool/lempar.c file as a 
+template for generating its parser. 
+Lemon also generates the **parse.h** header file, at the same time it 
+generates parse.c. 
+ 
+The **opcodes.h** header file contains macros that define the numbers 
+corresponding to opcodes in the "VDBE" virtual machine.  The opcodes.h 
+file is generated by the scanning the src/vdbe.c source file.  The 
+Tcl script at ./mkopcodeh.tcl does this scan and generates opcodes.h. 
+A second Tcl script, ./mkopcodec.tcl, then scans opcodes.h to generate 
+the **opcodes.c** source file, which contains a reverse mapping from 
+opcode-number to opcode-name that is used for EXPLAIN output. 
+ 
+The **keywordhash.h** header file contains the definition of a hash table 
+that maps SQL language keywords (ex: "CREATE", "SELECT", "INDEX", etc.) into 
+the numeric codes used by the parse.c parser.  The keywordhash.h file is 
+generated by a C-language program at tool mkkeywordhash.c. 
+ 
+The **pragma.h** header file contains various definitions used to parse 
+and implement the PRAGMA statements.  The header is generated by a 
+script **tool/mkpragmatab.tcl**. If you want to add a new PRAGMA, edit 
+the **tool/mkpragmatab.tcl** file to insert the information needed by the 
+parser for your new PRAGMA, then run the script to regenerate the 
+**pragma.h** header file. 
+ 
+### The Amalgamation 
+ 
+All of the individual C source code and header files (both manually-edited 
+and automatically-generated) can be combined into a single big source file 
+**sqlite3.c** called "the amalgamation".  The amalgamation is the recommended 
+way of using SQLite in a larger application.  Combining all individual 
+source code files into a single big source code file allows the C compiler 
+to perform more cross-procedure analysis and generate better code.  SQLite 
+runs about 5% faster when compiled from the amalgamation versus when compiled 
+from individual source files. 
+ 
+The amalgamation is generated from the tool/mksqlite3c.tcl Tcl script. 
+First, all of the individual source files must be gathered into the tsrc/ 
+subdirectory (using the equivalent of "make target_source") then the 
+tool/mksqlite3c.tcl script is run to copy them all together in just the 
+right order while resolving internal "#include" references. 
+ 
+The amalgamation source file is more than 200K lines long.  Some symbolic 
+debuggers (most notably MSVC) are unable to deal with files longer than 64K 
+lines.  To work around this, a separate Tcl script, tool/split-sqlite3c.tcl, 
+can be run on the amalgamation to break it up into a single small C file 
+called **sqlite3-all.c** that does #include on about seven other files 
+named **sqlite3-1.c**, **sqlite3-2.c**, ..., **sqlite3-7.c**.  In this way, 
+all of the source code is contained within a single translation unit so 
+that the compiler can do extra cross-procedure optimization, but no 
+individual source file exceeds 32K lines in length. 
+ 
+## How It All Fits Together 
+ 
+SQLite is modular in design. 
+See the [architectural description](http://www.sqlite.org/arch.html) 
+for details. Other documents that are useful in 
+(helping to understand how SQLite works include the 
+[file format](http://www.sqlite.org/fileformat2.html) description, 
+the [virtual machine](http://www.sqlite.org/opcode.html) that runs 
+prepared statements, the description of 
+[how transactions work](http://www.sqlite.org/atomiccommit.html), and 
+the [overview of the query planner](http://www.sqlite.org/optoverview.html). 
+ 
+Years of effort have gone into optimizating SQLite, both 
+for small size and high performance.  And optimizations tend to result in 
+complex code.  So there is a lot of complexity in the current SQLite 
+implementation.  It will not be the easiest library in the world to hack. 
+ 
+Key files: 
+ 
+  *  **sqlite.h.in** - This file defines the public interface to the SQLite 
+     library.  Readers will need to be familiar with this interface before 
+     trying to understand how the library works internally. 
+ 
+  *  **sqliteInt.h** - this header file defines many of the data objects 
+     used internally by SQLite.  In addition to "sqliteInt.h", some 
+     subsystems have their own header files. 
+ 
+  *  **parse.y** - This file describes the LALR(1) grammar that SQLite uses 
+     to parse SQL statements, and the actions that are taken at each step 
+     in the parsing process. 
+ 
+  *  **vdbe.c** - This file implements the virtual machine that runs 
+     prepared statements.  There are various helper files whose names 
+     begin with "vdbe".  The VDBE has access to the vdbeInt.h header file 
+     which defines internal data objects.  The rest of SQLite interacts 
+     with the VDBE through an interface defined by vdbe.h. 
+ 
+  *  **where.c** - This file (together with its helper files named 
+     by "where*.c") analyzes the WHERE clause and generates 
+     virtual machine code to run queries efficiently.  This file is 
+     sometimes called the "query optimizer".  It has its own private 
+     header file, whereInt.h, that defines data objects used internally. 
+ 
+  *  **btree.c** - This file contains the implementation of the B-Tree 
+     storage engine used by SQLite.  The interface to the rest of the system 
+     is defined by "btree.h".  The "btreeInt.h" header defines objects 
+     used internally by btree.c and not published to the rest of the system. 
+ 
+  *  **pager.c** - This file contains the "pager" implementation, the 
+     module that implements transactions.  The "pager.h" header file 
+     defines the interface between pager.c and the rest of the system. 
+ 
+  *  **os_unix.c** and **os_win.c** - These two files implement the interface 
+     between SQLite and the underlying operating system using the run-time 
+     pluggable VFS interface. 
+ 
+  *  **shell.c.in** - This file is not part of the core SQLite library.  This 
+     is the file that, when linked against sqlite3.a, generates the 
+     "sqlite3.exe" command-line shell.  The "shell.c.in" file is transformed 
+     into "shell.c" as part of the build process. 
+ 
+  *  **tclsqlite.c** - This file implements the Tcl bindings for SQLite.  It 
+     is not part of the core SQLite library.  But as most of the tests in this 
+     repository are written in Tcl, the Tcl language bindings are important. 
+ 
+  *  **test*.c** - Files in the src/ folder that begin with "test" go into 
+     building the "testfixture.exe" program.  The testfixture.exe program is 
+     an enhanced Tcl shell.  The testfixture.exe program runs scripts in the 
+     test/ folder to validate the core SQLite code.  The testfixture program 
+     (and some other test programs too) is build and run when you type 
+     "make test". 
+ 
+  *  **ext/misc/json1.c** - This file implements the various JSON functions 
+     that are build into SQLite. 
+ 
+There are many other source files.  Each has a succinct header comment that 
+describes its purpose and role within the larger system. 
+ 
+<a name="vauth"></a> 
+## Verifying Code Authenticity 
+ 
+The `manifest` file at the root directory of the source tree 
+contains either a SHA3-256 hash (for newer files) or a SHA1 hash (for  
+older files) for every source file in the repository. 
+The SHA3-256 hash of the `manifest` 
+file itself is the official name of the version of the source tree that you 
+have. The `manifest.uuid` file should contain the SHA3-256 hash of the 
+`manifest` file. If all of the above hash comparisons are correct, then 
+you can be confident that your source tree is authentic and unadulterated. 
+ 
+The format of the `manifest` file should be mostly self-explanatory, but 
+if you want details, they are available 
+[here](https://fossil-scm.org/fossil/doc/trunk/www/fileformat.wiki#manifest). 
+ 
+## Contacts 
+ 
+The main SQLite website is [http://www.sqlite.org/](http://www.sqlite.org/) 
+with geographically distributed backups at 
+[http://www2.sqlite.org/](http://www2.sqlite.org) and 
+[http://www3.sqlite.org/](http://www3.sqlite.org). 
diff --git a/contrib/libs/sqlite3/config.h b/contrib/libs/sqlite3/config.h
index 7b733f75a2..4e9efb77a4 100644
--- a/contrib/libs/sqlite3/config.h
+++ b/contrib/libs/sqlite3/config.h
@@ -1,132 +1,132 @@
-/* config.h.  Generated from config.h.in by configure.  */
-/* config.h.in.  Generated from configure.ac by autoheader.  */
-
-/* Define to 1 if you have the <dlfcn.h> header file. */
-#define HAVE_DLFCN_H 1
-
-/* Define to 1 if you have the `fdatasync' function. */
-#define HAVE_FDATASYNC 1
-
-/* Define to 1 if you have the `gmtime_r' function. */
-#define HAVE_GMTIME_R 1
-
-/* Define to 1 if the system has the type `int16_t'. */
-#define HAVE_INT16_T 1
-
-/* Define to 1 if the system has the type `int32_t'. */
-#define HAVE_INT32_T 1
-
-/* Define to 1 if the system has the type `int64_t'. */
-#define HAVE_INT64_T 1
-
-/* Define to 1 if the system has the type `int8_t'. */
-#define HAVE_INT8_T 1
-
-/* Define to 1 if the system has the type `intptr_t'. */
-#define HAVE_INTPTR_T 1
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#define HAVE_INTTYPES_H 1
-
-/* Define to 1 if you have the `isnan' function. */
-#define HAVE_ISNAN 1
-
-/* Define to 1 if you have the `localtime_r' function. */
-#define HAVE_LOCALTIME_R 1
-
-/* Define to 1 if you have the `localtime_s' function. */
-/* #undef HAVE_LOCALTIME_S */
-
-/* Define to 1 if you have the <malloc.h> header file. */
-#define HAVE_MALLOC_H 1
-
-/* Define to 1 if you have the `malloc_usable_size' function. */
-#define HAVE_MALLOC_USABLE_SIZE 1
-
-/* Define to 1 if you have the <memory.h> header file. */
-#define HAVE_MEMORY_H 1
-
-/* Define to 1 if you have the pread() function. */
-#define HAVE_PREAD 1
-
-/* Define to 1 if you have the pread64() function. */
-#define HAVE_PREAD64 1
-
-/* Define to 1 if you have the pwrite() function. */
-#define HAVE_PWRITE 1
-
-/* Define to 1 if you have the pwrite64() function. */
-#define HAVE_PWRITE64 1
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#define HAVE_STDINT_H 1
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#define HAVE_STDLIB_H 1
-
-/* Define to 1 if you have the strchrnul() function */
-#define HAVE_STRCHRNUL 1
-
-/* Define to 1 if you have the <strings.h> header file. */
-#define HAVE_STRINGS_H 1
-
-/* Define to 1 if you have the <string.h> header file. */
-#define HAVE_STRING_H 1
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#define HAVE_SYS_STAT_H 1
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#define HAVE_SYS_TYPES_H 1
-
-/* Define to 1 if the system has the type `uint16_t'. */
-#define HAVE_UINT16_T 1
-
-/* Define to 1 if the system has the type `uint32_t'. */
-#define HAVE_UINT32_T 1
-
-/* Define to 1 if the system has the type `uint64_t'. */
-#define HAVE_UINT64_T 1
-
-/* Define to 1 if the system has the type `uint8_t'. */
-#define HAVE_UINT8_T 1
-
-/* Define to 1 if the system has the type `uintptr_t'. */
-#define HAVE_UINTPTR_T 1
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#define HAVE_UNISTD_H 1
-
-/* Define to 1 if you have the `usleep' function. */
-#define HAVE_USLEEP 1
-
-/* Define to 1 if you have the utime() library function. */
-#define HAVE_UTIME 1
-
-/* Define to the sub-directory in which libtool stores uninstalled libraries.
-   */
-#define LT_OBJDIR ".libs/"
-
-/* Define to the address where bug reports for this package should be sent. */
-#define PACKAGE_BUGREPORT ""
-
-/* Define to the full name of this package. */
-#define PACKAGE_NAME "sqlite"
-
-/* Define to the full name and version of this package. */
+/* config.h.  Generated from config.h.in by configure.  */ 
+/* config.h.in.  Generated from configure.ac by autoheader.  */ 
+ 
+/* Define to 1 if you have the <dlfcn.h> header file. */ 
+#define HAVE_DLFCN_H 1 
+ 
+/* Define to 1 if you have the `fdatasync' function. */ 
+#define HAVE_FDATASYNC 1 
+ 
+/* Define to 1 if you have the `gmtime_r' function. */ 
+#define HAVE_GMTIME_R 1 
+ 
+/* Define to 1 if the system has the type `int16_t'. */ 
+#define HAVE_INT16_T 1 
+ 
+/* Define to 1 if the system has the type `int32_t'. */ 
+#define HAVE_INT32_T 1 
+ 
+/* Define to 1 if the system has the type `int64_t'. */ 
+#define HAVE_INT64_T 1 
+ 
+/* Define to 1 if the system has the type `int8_t'. */ 
+#define HAVE_INT8_T 1 
+ 
+/* Define to 1 if the system has the type `intptr_t'. */ 
+#define HAVE_INTPTR_T 1 
+ 
+/* Define to 1 if you have the <inttypes.h> header file. */ 
+#define HAVE_INTTYPES_H 1 
+ 
+/* Define to 1 if you have the `isnan' function. */ 
+#define HAVE_ISNAN 1 
+ 
+/* Define to 1 if you have the `localtime_r' function. */ 
+#define HAVE_LOCALTIME_R 1 
+ 
+/* Define to 1 if you have the `localtime_s' function. */ 
+/* #undef HAVE_LOCALTIME_S */ 
+ 
+/* Define to 1 if you have the <malloc.h> header file. */ 
+#define HAVE_MALLOC_H 1 
+ 
+/* Define to 1 if you have the `malloc_usable_size' function. */ 
+#define HAVE_MALLOC_USABLE_SIZE 1 
+ 
+/* Define to 1 if you have the <memory.h> header file. */ 
+#define HAVE_MEMORY_H 1 
+ 
+/* Define to 1 if you have the pread() function. */ 
+#define HAVE_PREAD 1 
+ 
+/* Define to 1 if you have the pread64() function. */ 
+#define HAVE_PREAD64 1 
+ 
+/* Define to 1 if you have the pwrite() function. */ 
+#define HAVE_PWRITE 1 
+ 
+/* Define to 1 if you have the pwrite64() function. */ 
+#define HAVE_PWRITE64 1 
+ 
+/* Define to 1 if you have the <stdint.h> header file. */ 
+#define HAVE_STDINT_H 1 
+ 
+/* Define to 1 if you have the <stdlib.h> header file. */ 
+#define HAVE_STDLIB_H 1 
+ 
+/* Define to 1 if you have the strchrnul() function */ 
+#define HAVE_STRCHRNUL 1 
+ 
+/* Define to 1 if you have the <strings.h> header file. */ 
+#define HAVE_STRINGS_H 1 
+ 
+/* Define to 1 if you have the <string.h> header file. */ 
+#define HAVE_STRING_H 1 
+ 
+/* Define to 1 if you have the <sys/stat.h> header file. */ 
+#define HAVE_SYS_STAT_H 1 
+ 
+/* Define to 1 if you have the <sys/types.h> header file. */ 
+#define HAVE_SYS_TYPES_H 1 
+ 
+/* Define to 1 if the system has the type `uint16_t'. */ 
+#define HAVE_UINT16_T 1 
+ 
+/* Define to 1 if the system has the type `uint32_t'. */ 
+#define HAVE_UINT32_T 1 
+ 
+/* Define to 1 if the system has the type `uint64_t'. */ 
+#define HAVE_UINT64_T 1 
+ 
+/* Define to 1 if the system has the type `uint8_t'. */ 
+#define HAVE_UINT8_T 1 
+ 
+/* Define to 1 if the system has the type `uintptr_t'. */ 
+#define HAVE_UINTPTR_T 1 
+ 
+/* Define to 1 if you have the <unistd.h> header file. */ 
+#define HAVE_UNISTD_H 1 
+ 
+/* Define to 1 if you have the `usleep' function. */ 
+#define HAVE_USLEEP 1 
+ 
+/* Define to 1 if you have the utime() library function. */ 
+#define HAVE_UTIME 1 
+ 
+/* Define to the sub-directory in which libtool stores uninstalled libraries. 
+   */ 
+#define LT_OBJDIR ".libs/" 
+ 
+/* Define to the address where bug reports for this package should be sent. */ 
+#define PACKAGE_BUGREPORT "" 
+ 
+/* Define to the full name of this package. */ 
+#define PACKAGE_NAME "sqlite" 
+ 
+/* Define to the full name and version of this package. */ 
 #define PACKAGE_STRING "sqlite 3.37.2"
-
-/* Define to the one symbol short name of this package. */
-#define PACKAGE_TARNAME "sqlite"
-
-/* Define to the version of this package. */
+ 
+/* Define to the one symbol short name of this package. */ 
+#define PACKAGE_TARNAME "sqlite" 
+ 
+/* Define to the version of this package. */ 
 #define PACKAGE_VERSION "3.37.2"
-
-/* Define to 1 if you have the ANSI C header files. */
-#define STDC_HEADERS 1
-
-/* Number of bits in a file offset, on hosts where this is settable. */
-/* #undef _FILE_OFFSET_BITS */
-
-/* Define for large files, on AIX-style hosts. */
-/* #undef _LARGE_FILES */
+ 
+/* Define to 1 if you have the ANSI C header files. */ 
+#define STDC_HEADERS 1 
+ 
+/* Number of bits in a file offset, on hosts where this is settable. */ 
+/* #undef _FILE_OFFSET_BITS */ 
+ 
+/* Define for large files, on AIX-style hosts. */ 
+/* #undef _LARGE_FILES */ 
diff --git a/contrib/libs/sqlite3/sqlite3.c b/contrib/libs/sqlite3/sqlite3.c
index 3b763874be..5d78975ff3 100644
--- a/contrib/libs/sqlite3/sqlite3.c
+++ b/contrib/libs/sqlite3/sqlite3.c
@@ -119,11 +119,11 @@
 #pragma warning(disable : 4706)
 #endif /* defined(_MSC_VER) */
 
-#if defined(_MSC_VER) && !defined(_WIN64)
-#undef SQLITE_4_BYTE_ALIGNED_MALLOC
-#define SQLITE_4_BYTE_ALIGNED_MALLOC
-#endif /* defined(_MSC_VER) && !defined(_WIN64) */
-
+#if defined(_MSC_VER) && !defined(_WIN64) 
+#undef SQLITE_4_BYTE_ALIGNED_MALLOC 
+#define SQLITE_4_BYTE_ALIGNED_MALLOC 
+#endif /* defined(_MSC_VER) && !defined(_WIN64) */ 
+ 
 #endif /* SQLITE_MSVC_H */
 
 /************** End of msvc.h ************************************************/
@@ -519,9 +519,9 @@ SQLITE_API int sqlite3_libversion_number(void);
 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
 SQLITE_API int sqlite3_compileoption_used(const char *zOptName);
 SQLITE_API const char *sqlite3_compileoption_get(int N);
-#else
-# define sqlite3_compileoption_used(X) 0
-# define sqlite3_compileoption_get(X)  ((void*)0)
+#else 
+# define sqlite3_compileoption_used(X) 0 
+# define sqlite3_compileoption_get(X)  ((void*)0) 
 #endif
 
 /*
@@ -801,7 +801,7 @@ SQLITE_API int sqlite3_exec(
 */
 #define SQLITE_ERROR_MISSING_COLLSEQ   (SQLITE_ERROR | (1<<8))
 #define SQLITE_ERROR_RETRY             (SQLITE_ERROR | (2<<8))
-#define SQLITE_ERROR_SNAPSHOT          (SQLITE_ERROR | (3<<8))
+#define SQLITE_ERROR_SNAPSHOT          (SQLITE_ERROR | (3<<8)) 
 #define SQLITE_IOERR_READ              (SQLITE_IOERR | (1<<8))
 #define SQLITE_IOERR_SHORT_READ        (SQLITE_IOERR | (2<<8))
 #define SQLITE_IOERR_WRITE             (SQLITE_IOERR | (3<<8))
@@ -836,7 +836,7 @@ SQLITE_API int sqlite3_exec(
 #define SQLITE_IOERR_DATA              (SQLITE_IOERR | (32<<8))
 #define SQLITE_IOERR_CORRUPTFS         (SQLITE_IOERR | (33<<8))
 #define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED |  (1<<8))
-#define SQLITE_LOCKED_VTAB             (SQLITE_LOCKED |  (2<<8))
+#define SQLITE_LOCKED_VTAB             (SQLITE_LOCKED |  (2<<8)) 
 #define SQLITE_BUSY_RECOVERY           (SQLITE_BUSY   |  (1<<8))
 #define SQLITE_BUSY_SNAPSHOT           (SQLITE_BUSY   |  (2<<8))
 #define SQLITE_BUSY_TIMEOUT            (SQLITE_BUSY   |  (3<<8))
@@ -844,10 +844,10 @@ SQLITE_API int sqlite3_exec(
 #define SQLITE_CANTOPEN_ISDIR          (SQLITE_CANTOPEN | (2<<8))
 #define SQLITE_CANTOPEN_FULLPATH       (SQLITE_CANTOPEN | (3<<8))
 #define SQLITE_CANTOPEN_CONVPATH       (SQLITE_CANTOPEN | (4<<8))
-#define SQLITE_CANTOPEN_DIRTYWAL       (SQLITE_CANTOPEN | (5<<8)) /* Not Used */
+#define SQLITE_CANTOPEN_DIRTYWAL       (SQLITE_CANTOPEN | (5<<8)) /* Not Used */ 
 #define SQLITE_CANTOPEN_SYMLINK        (SQLITE_CANTOPEN | (6<<8))
 #define SQLITE_CORRUPT_VTAB            (SQLITE_CORRUPT | (1<<8))
-#define SQLITE_CORRUPT_SEQUENCE        (SQLITE_CORRUPT | (2<<8))
+#define SQLITE_CORRUPT_SEQUENCE        (SQLITE_CORRUPT | (2<<8)) 
 #define SQLITE_CORRUPT_INDEX           (SQLITE_CORRUPT | (3<<8))
 #define SQLITE_READONLY_RECOVERY       (SQLITE_READONLY | (1<<8))
 #define SQLITE_READONLY_CANTLOCK       (SQLITE_READONLY | (2<<8))
@@ -1178,15 +1178,15 @@ struct sqlite3_io_methods {
 ** file space based on this hint in order to help writes to the database
 ** file run faster.
 **
-** <li>[[SQLITE_FCNTL_SIZE_LIMIT]]
-** The [SQLITE_FCNTL_SIZE_LIMIT] opcode is used by in-memory VFS that
-** implements [sqlite3_deserialize()] to set an upper bound on the size
-** of the in-memory database.  The argument is a pointer to a [sqlite3_int64].
-** If the integer pointed to is negative, then it is filled in with the
-** current limit.  Otherwise the limit is set to the larger of the value
-** of the integer pointed to and the current database size.  The integer
-** pointed to is set to the new limit.
-**
+** <li>[[SQLITE_FCNTL_SIZE_LIMIT]] 
+** The [SQLITE_FCNTL_SIZE_LIMIT] opcode is used by in-memory VFS that 
+** implements [sqlite3_deserialize()] to set an upper bound on the size 
+** of the in-memory database.  The argument is a pointer to a [sqlite3_int64]. 
+** If the integer pointed to is negative, then it is filled in with the 
+** current limit.  Otherwise the limit is set to the larger of the value 
+** of the integer pointed to and the current database size.  The integer 
+** pointed to is set to the new limit. 
+** 
 ** <li>[[SQLITE_FCNTL_CHUNK_SIZE]]
 ** The [SQLITE_FCNTL_CHUNK_SIZE] opcode is used to request that the VFS
 ** extends and truncates the database file in chunks of a size specified
@@ -1252,8 +1252,8 @@ struct sqlite3_io_methods {
 ** <li>[[SQLITE_FCNTL_PERSIST_WAL]]
 ** ^The [SQLITE_FCNTL_PERSIST_WAL] opcode is used to set or query the
 ** persistent [WAL | Write Ahead Log] setting.  By default, the auxiliary
-** write ahead log ([WAL file]) and shared memory
-** files used for transaction control
+** write ahead log ([WAL file]) and shared memory 
+** files used for transaction control 
 ** are automatically deleted when the latest connection to the database
 ** closes.  Setting persistent WAL mode causes those files to persist after
 ** close.  Persisting the files is useful when other processes that do not
@@ -1433,34 +1433,34 @@ struct sqlite3_io_methods {
 ** so that all subsequent write operations are independent.
 ** ^SQLite will never invoke SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE without
 ** a prior successful call to [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE].
-**
-** <li>[[SQLITE_FCNTL_LOCK_TIMEOUT]]
+** 
+** <li>[[SQLITE_FCNTL_LOCK_TIMEOUT]] 
 ** The [SQLITE_FCNTL_LOCK_TIMEOUT] opcode is used to configure a VFS
 ** to block for up to M milliseconds before failing when attempting to
 ** obtain a file lock using the xLock or xShmLock methods of the VFS.
 ** The parameter is a pointer to a 32-bit signed integer that contains
 ** the value that M is to be set to. Before returning, the 32-bit signed
 ** integer is overwritten with the previous value of M.
-**
-** <li>[[SQLITE_FCNTL_DATA_VERSION]]
-** The [SQLITE_FCNTL_DATA_VERSION] opcode is used to detect changes to
-** a database file.  The argument is a pointer to a 32-bit unsigned integer.
-** The "data version" for the pager is written into the pointer.  The
-** "data version" changes whenever any change occurs to the corresponding
-** database file, either through SQL statements on the same database
-** connection or through transactions committed by separate database
-** connections possibly in other processes. The [sqlite3_total_changes()]
-** interface can be used to find if any database on the connection has changed,
-** but that interface responds to changes on TEMP as well as MAIN and does
-** not provide a mechanism to detect changes to MAIN only.  Also, the
-** [sqlite3_total_changes()] interface responds to internal changes only and
-** omits changes made by other database connections.  The
+** 
+** <li>[[SQLITE_FCNTL_DATA_VERSION]] 
+** The [SQLITE_FCNTL_DATA_VERSION] opcode is used to detect changes to 
+** a database file.  The argument is a pointer to a 32-bit unsigned integer. 
+** The "data version" for the pager is written into the pointer.  The 
+** "data version" changes whenever any change occurs to the corresponding 
+** database file, either through SQL statements on the same database 
+** connection or through transactions committed by separate database 
+** connections possibly in other processes. The [sqlite3_total_changes()] 
+** interface can be used to find if any database on the connection has changed, 
+** but that interface responds to changes on TEMP as well as MAIN and does 
+** not provide a mechanism to detect changes to MAIN only.  Also, the 
+** [sqlite3_total_changes()] interface responds to internal changes only and 
+** omits changes made by other database connections.  The 
 ** [PRAGMA data_version] command provides a mechanism to detect changes to
-** a single attached database that occur due to other database connections,
-** but omits changes implemented by the database connection on which it is
-** called.  This file control is the only mechanism to detect changes that
-** happen either internally or externally and that are associated with
-** a particular attached database.
+** a single attached database that occur due to other database connections, 
+** but omits changes implemented by the database connection on which it is 
+** called.  This file control is the only mechanism to detect changes that 
+** happen either internally or externally and that are associated with 
+** a particular attached database. 
 **
 ** <li>[[SQLITE_FCNTL_CKPT_START]]
 ** The [SQLITE_FCNTL_CKPT_START] opcode is invoked from within a checkpoint
@@ -1523,9 +1523,9 @@ struct sqlite3_io_methods {
 #define SQLITE_FCNTL_BEGIN_ATOMIC_WRITE     31
 #define SQLITE_FCNTL_COMMIT_ATOMIC_WRITE    32
 #define SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE  33
-#define SQLITE_FCNTL_LOCK_TIMEOUT           34
-#define SQLITE_FCNTL_DATA_VERSION           35
-#define SQLITE_FCNTL_SIZE_LIMIT             36
+#define SQLITE_FCNTL_LOCK_TIMEOUT           34 
+#define SQLITE_FCNTL_DATA_VERSION           35 
+#define SQLITE_FCNTL_SIZE_LIMIT             36 
 #define SQLITE_FCNTL_CKPT_DONE              37
 #define SQLITE_FCNTL_RESERVE_BYTES          38
 #define SQLITE_FCNTL_CKPT_START             39
@@ -1683,13 +1683,13 @@ typedef struct sqlite3_api_routines sqlite3_api_routines;
 ** ^The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS]
 ** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to
 ** test whether a file is readable and writable, or [SQLITE_ACCESS_READ]
-** to test whether a file is at least readable.  The SQLITE_ACCESS_READ
-** flag is never actually used and is not implemented in the built-in
-** VFSes of SQLite.  The file is named by the second argument and can be a
-** directory. The xAccess method returns [SQLITE_OK] on success or some
-** non-zero error code if there is an I/O error or if the name of
-** the file given in the second argument is illegal.  If SQLITE_OK
-** is returned, then non-zero or zero is written into *pResOut to indicate
+** to test whether a file is at least readable.  The SQLITE_ACCESS_READ 
+** flag is never actually used and is not implemented in the built-in 
+** VFSes of SQLite.  The file is named by the second argument and can be a 
+** directory. The xAccess method returns [SQLITE_OK] on success or some 
+** non-zero error code if there is an I/O error or if the name of 
+** the file given in the second argument is illegal.  If SQLITE_OK 
+** is returned, then non-zero or zero is written into *pResOut to indicate 
 ** whether or not the file is accessible.
 **
 ** ^SQLite will always allocate at least mxPathname+1 bytes for the
@@ -2363,33 +2363,33 @@ struct sqlite3_mem_methods {
 ** I/O required to support statement rollback.
 ** The default value for this setting is controlled by the
 ** [SQLITE_STMTJRNL_SPILL] compile-time option.
-**
-** [[SQLITE_CONFIG_SORTERREF_SIZE]]
-** <dt>SQLITE_CONFIG_SORTERREF_SIZE
-** <dd>The SQLITE_CONFIG_SORTERREF_SIZE option accepts a single parameter
-** of type (int) - the new value of the sorter-reference size threshold.
-** Usually, when SQLite uses an external sort to order records according
-** to an ORDER BY clause, all fields required by the caller are present in the
-** sorted records. However, if SQLite determines based on the declared type
-** of a table column that its values are likely to be very large - larger
-** than the configured sorter-reference size threshold - then a reference
-** is stored in each sorted record and the required column values loaded
-** from the database as records are returned in sorted order. The default
+** 
+** [[SQLITE_CONFIG_SORTERREF_SIZE]] 
+** <dt>SQLITE_CONFIG_SORTERREF_SIZE 
+** <dd>The SQLITE_CONFIG_SORTERREF_SIZE option accepts a single parameter 
+** of type (int) - the new value of the sorter-reference size threshold. 
+** Usually, when SQLite uses an external sort to order records according 
+** to an ORDER BY clause, all fields required by the caller are present in the 
+** sorted records. However, if SQLite determines based on the declared type 
+** of a table column that its values are likely to be very large - larger 
+** than the configured sorter-reference size threshold - then a reference 
+** is stored in each sorted record and the required column values loaded 
+** from the database as records are returned in sorted order. The default 
 ** value for this option is to never use this optimization. Specifying a
-** negative value for this option restores the default behaviour.
-** This option is only available if SQLite is compiled with the
-** [SQLITE_ENABLE_SORTER_REFERENCES] compile-time option.
-**
-** [[SQLITE_CONFIG_MEMDB_MAXSIZE]]
-** <dt>SQLITE_CONFIG_MEMDB_MAXSIZE
-** <dd>The SQLITE_CONFIG_MEMDB_MAXSIZE option accepts a single parameter
-** [sqlite3_int64] parameter which is the default maximum size for an in-memory
-** database created using [sqlite3_deserialize()].  This default maximum
-** size can be adjusted up or down for individual databases using the
-** [SQLITE_FCNTL_SIZE_LIMIT] [sqlite3_file_control|file-control].  If this
-** configuration setting is never used, then the default maximum is determined
-** by the [SQLITE_MEMDB_DEFAULT_MAXSIZE] compile-time option.  If that
-** compile-time option is not set, then the default maximum is 1073741824.
+** negative value for this option restores the default behaviour. 
+** This option is only available if SQLite is compiled with the 
+** [SQLITE_ENABLE_SORTER_REFERENCES] compile-time option. 
+** 
+** [[SQLITE_CONFIG_MEMDB_MAXSIZE]] 
+** <dt>SQLITE_CONFIG_MEMDB_MAXSIZE 
+** <dd>The SQLITE_CONFIG_MEMDB_MAXSIZE option accepts a single parameter 
+** [sqlite3_int64] parameter which is the default maximum size for an in-memory 
+** database created using [sqlite3_deserialize()].  This default maximum 
+** size can be adjusted up or down for individual databases using the 
+** [SQLITE_FCNTL_SIZE_LIMIT] [sqlite3_file_control|file-control].  If this 
+** configuration setting is never used, then the default maximum is determined 
+** by the [SQLITE_MEMDB_DEFAULT_MAXSIZE] compile-time option.  If that 
+** compile-time option is not set, then the default maximum is 1073741824. 
 ** </dl>
 */
 #define SQLITE_CONFIG_SINGLETHREAD  1  /* nil */
@@ -2419,8 +2419,8 @@ struct sqlite3_mem_methods {
 #define SQLITE_CONFIG_PMASZ               25  /* unsigned int szPma */
 #define SQLITE_CONFIG_STMTJRNL_SPILL      26  /* int nByte */
 #define SQLITE_CONFIG_SMALL_MALLOC        27  /* boolean */
-#define SQLITE_CONFIG_SORTERREF_SIZE      28  /* int nByte */
-#define SQLITE_CONFIG_MEMDB_MAXSIZE       29  /* sqlite3_int64 */
+#define SQLITE_CONFIG_SORTERREF_SIZE      28  /* int nByte */ 
+#define SQLITE_CONFIG_MEMDB_MAXSIZE       29  /* sqlite3_int64 */ 
 
 /*
 ** CAPI3REF: Database Connection Configuration Options
@@ -2436,7 +2436,7 @@ struct sqlite3_mem_methods {
 ** is invoked.
 **
 ** <dl>
-** [[SQLITE_DBCONFIG_LOOKASIDE]]
+** [[SQLITE_DBCONFIG_LOOKASIDE]] 
 ** <dt>SQLITE_DBCONFIG_LOOKASIDE</dt>
 ** <dd> ^This option takes three additional arguments that determine the
 ** [lookaside memory allocator] configuration for the [database connection].
@@ -2459,7 +2459,7 @@ struct sqlite3_mem_methods {
 ** memory is in use leaves the configuration unchanged and returns
 ** [SQLITE_BUSY].)^</dd>
 **
-** [[SQLITE_DBCONFIG_ENABLE_FKEY]]
+** [[SQLITE_DBCONFIG_ENABLE_FKEY]] 
 ** <dt>SQLITE_DBCONFIG_ENABLE_FKEY</dt>
 ** <dd> ^This option is used to enable or disable the enforcement of
 ** [foreign key constraints].  There should be two additional arguments.
@@ -2470,7 +2470,7 @@ struct sqlite3_mem_methods {
 ** following this call.  The second parameter may be a NULL pointer, in
 ** which case the FK enforcement setting is not reported back. </dd>
 **
-** [[SQLITE_DBCONFIG_ENABLE_TRIGGER]]
+** [[SQLITE_DBCONFIG_ENABLE_TRIGGER]] 
 ** <dt>SQLITE_DBCONFIG_ENABLE_TRIGGER</dt>
 ** <dd> ^This option is used to enable or disable [CREATE TRIGGER | triggers].
 ** There should be two additional arguments.
@@ -2504,10 +2504,10 @@ struct sqlite3_mem_methods {
 ** views in the main database schema or in the schemas of ATTACH-ed
 ** databases.)^ </dd>
 **
-** [[SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER]]
+** [[SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER]] 
 ** <dt>SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER</dt>
-** <dd> ^This option is used to enable or disable the
-** [fts3_tokenizer()] function which is part of the
+** <dd> ^This option is used to enable or disable the 
+** [fts3_tokenizer()] function which is part of the 
 ** [FTS3] full-text search engine extension.
 ** There should be two additional arguments.
 ** The first argument is an integer which is 0 to disable fts3_tokenizer() or
@@ -2518,7 +2518,7 @@ struct sqlite3_mem_methods {
 ** following this call.  The second parameter may be a NULL pointer, in
 ** which case the new setting is not reported back. </dd>
 **
-** [[SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION]]
+** [[SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION]] 
 ** <dt>SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION</dt>
 ** <dd> ^This option is used to enable or disable the [sqlite3_load_extension()]
 ** interface independently of the [load_extension()] SQL function.
@@ -2536,7 +2536,7 @@ struct sqlite3_mem_methods {
 ** be a NULL pointer, in which case the new setting is not reported back.
 ** </dd>
 **
-** [[SQLITE_DBCONFIG_MAINDBNAME]] <dt>SQLITE_DBCONFIG_MAINDBNAME</dt>
+** [[SQLITE_DBCONFIG_MAINDBNAME]] <dt>SQLITE_DBCONFIG_MAINDBNAME</dt> 
 ** <dd> ^This option is used to change the name of the "main" database
 ** schema.  ^The sole argument is a pointer to a constant UTF8 string
 ** which will become the new schema name in place of "main".  ^SQLite
@@ -2552,14 +2552,14 @@ struct sqlite3_mem_methods {
 ** connections at all to the database. If so, it performs a checkpoint
 ** operation before closing the connection. This option may be used to
 ** override this behaviour. The first parameter passed to this operation
-** is an integer - positive to disable checkpoints-on-close, or zero (the
-** default) to enable them, and negative to leave the setting unchanged.
-** The second parameter is a pointer to an integer
+** is an integer - positive to disable checkpoints-on-close, or zero (the 
+** default) to enable them, and negative to leave the setting unchanged. 
+** The second parameter is a pointer to an integer 
 ** into which is written 0 or 1 to indicate whether checkpoints-on-close
 ** have been disabled - 0 if they are not disabled, 1 if they are.
 ** </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_QPSG]] <dt>SQLITE_DBCONFIG_ENABLE_QPSG</dt>
+** 
+** [[SQLITE_DBCONFIG_ENABLE_QPSG]] <dt>SQLITE_DBCONFIG_ENABLE_QPSG</dt> 
 ** <dd>^(The SQLITE_DBCONFIG_ENABLE_QPSG option activates or deactivates
 ** the [query planner stability guarantee] (QPSG).  When the QPSG is active,
 ** a single SQL query statement will always use the same algorithm regardless
@@ -2569,96 +2569,96 @@ struct sqlite3_mem_methods {
 ** the QPSG active, SQLite will always use the same query plan in the field as
 ** was used during testing in the lab.
 ** The first argument to this setting is an integer which is 0 to disable
-** the QPSG, positive to enable QPSG, or negative to leave the setting
-** unchanged. The second parameter is a pointer to an integer into which
-** is written 0 or 1 to indicate whether the QPSG is disabled or enabled
-** following this call.
+** the QPSG, positive to enable QPSG, or negative to leave the setting 
+** unchanged. The second parameter is a pointer to an integer into which 
+** is written 0 or 1 to indicate whether the QPSG is disabled or enabled 
+** following this call. 
 ** </dd>
-**
-** [[SQLITE_DBCONFIG_TRIGGER_EQP]] <dt>SQLITE_DBCONFIG_TRIGGER_EQP</dt>
+** 
+** [[SQLITE_DBCONFIG_TRIGGER_EQP]] <dt>SQLITE_DBCONFIG_TRIGGER_EQP</dt> 
 ** <dd> By default, the output of EXPLAIN QUERY PLAN commands does not
 ** include output for any operations performed by trigger programs. This
 ** option is used to set or clear (the default) a flag that governs this
 ** behavior. The first parameter passed to this operation is an integer -
-** positive to enable output for trigger programs, or zero to disable it,
-** or negative to leave the setting unchanged.
+** positive to enable output for trigger programs, or zero to disable it, 
+** or negative to leave the setting unchanged. 
 ** The second parameter is a pointer to an integer into which is written
 ** 0 or 1 to indicate whether output-for-triggers has been disabled - 0 if
 ** it is not disabled, 1 if it is.
 ** </dd>
-**
-** [[SQLITE_DBCONFIG_RESET_DATABASE]] <dt>SQLITE_DBCONFIG_RESET_DATABASE</dt>
-** <dd> Set the SQLITE_DBCONFIG_RESET_DATABASE flag and then run
-** [VACUUM] in order to reset a database back to an empty database
-** with no schema and no content. The following process works even for
-** a badly corrupted database file:
-** <ol>
-** <li> If the database connection is newly opened, make sure it has read the
-**      database schema by preparing then discarding some query against the
-**      database, or calling sqlite3_table_column_metadata(), ignoring any
-**      errors.  This step is only necessary if the application desires to keep
-**      the database in WAL mode after the reset if it was in WAL mode before
+** 
+** [[SQLITE_DBCONFIG_RESET_DATABASE]] <dt>SQLITE_DBCONFIG_RESET_DATABASE</dt> 
+** <dd> Set the SQLITE_DBCONFIG_RESET_DATABASE flag and then run 
+** [VACUUM] in order to reset a database back to an empty database 
+** with no schema and no content. The following process works even for 
+** a badly corrupted database file: 
+** <ol> 
+** <li> If the database connection is newly opened, make sure it has read the 
+**      database schema by preparing then discarding some query against the 
+**      database, or calling sqlite3_table_column_metadata(), ignoring any 
+**      errors.  This step is only necessary if the application desires to keep 
+**      the database in WAL mode after the reset if it was in WAL mode before 
 **      the reset.
-** <li> sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 1, 0);
-** <li> [sqlite3_exec](db, "[VACUUM]", 0, 0, 0);
-** <li> sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 0, 0);
-** </ol>
-** Because resetting a database is destructive and irreversible, the
-** process requires the use of this obscure API and multiple steps to help
-** ensure that it does not happen by accident.
-**
-** [[SQLITE_DBCONFIG_DEFENSIVE]] <dt>SQLITE_DBCONFIG_DEFENSIVE</dt>
-** <dd>The SQLITE_DBCONFIG_DEFENSIVE option activates or deactivates the
-** "defensive" flag for a database connection.  When the defensive
+** <li> sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 1, 0); 
+** <li> [sqlite3_exec](db, "[VACUUM]", 0, 0, 0); 
+** <li> sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 0, 0); 
+** </ol> 
+** Because resetting a database is destructive and irreversible, the 
+** process requires the use of this obscure API and multiple steps to help 
+** ensure that it does not happen by accident. 
+** 
+** [[SQLITE_DBCONFIG_DEFENSIVE]] <dt>SQLITE_DBCONFIG_DEFENSIVE</dt> 
+** <dd>The SQLITE_DBCONFIG_DEFENSIVE option activates or deactivates the 
+** "defensive" flag for a database connection.  When the defensive 
 ** flag is enabled, language features that allow ordinary SQL to
-** deliberately corrupt the database file are disabled.  The disabled
-** features include but are not limited to the following:
-** <ul>
-** <li> The [PRAGMA writable_schema=ON] statement.
-** <li> The [PRAGMA journal_mode=OFF] statement.
-** <li> Writes to the [sqlite_dbpage] virtual table.
-** <li> Direct writes to [shadow tables].
-** </ul>
-** </dd>
-**
-** [[SQLITE_DBCONFIG_WRITABLE_SCHEMA]] <dt>SQLITE_DBCONFIG_WRITABLE_SCHEMA</dt>
-** <dd>The SQLITE_DBCONFIG_WRITABLE_SCHEMA option activates or deactivates the
-** "writable_schema" flag. This has the same effect and is logically equivalent
-** to setting [PRAGMA writable_schema=ON] or [PRAGMA writable_schema=OFF].
+** deliberately corrupt the database file are disabled.  The disabled 
+** features include but are not limited to the following: 
+** <ul> 
+** <li> The [PRAGMA writable_schema=ON] statement. 
+** <li> The [PRAGMA journal_mode=OFF] statement. 
+** <li> Writes to the [sqlite_dbpage] virtual table. 
+** <li> Direct writes to [shadow tables]. 
+** </ul> 
+** </dd> 
+** 
+** [[SQLITE_DBCONFIG_WRITABLE_SCHEMA]] <dt>SQLITE_DBCONFIG_WRITABLE_SCHEMA</dt> 
+** <dd>The SQLITE_DBCONFIG_WRITABLE_SCHEMA option activates or deactivates the 
+** "writable_schema" flag. This has the same effect and is logically equivalent 
+** to setting [PRAGMA writable_schema=ON] or [PRAGMA writable_schema=OFF]. 
 ** The first argument to this setting is an integer which is 0 to disable
-** the writable_schema, positive to enable writable_schema, or negative to
-** leave the setting unchanged. The second parameter is a pointer to an
-** integer into which is written 0 or 1 to indicate whether the writable_schema
-** is enabled or disabled following this call.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_LEGACY_ALTER_TABLE]]
-** <dt>SQLITE_DBCONFIG_LEGACY_ALTER_TABLE</dt>
-** <dd>The SQLITE_DBCONFIG_LEGACY_ALTER_TABLE option activates or deactivates
-** the legacy behavior of the [ALTER TABLE RENAME] command such it
-** behaves as it did prior to [version 3.24.0] (2018-06-04).  See the
-** "Compatibility Notice" on the [ALTER TABLE RENAME documentation] for
-** additional information. This feature can also be turned on and off
-** using the [PRAGMA legacy_alter_table] statement.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_DQS_DML]]
-** <dt>SQLITE_DBCONFIG_DQS_DML</td>
-** <dd>The SQLITE_DBCONFIG_DQS_DML option activates or deactivates
+** the writable_schema, positive to enable writable_schema, or negative to 
+** leave the setting unchanged. The second parameter is a pointer to an 
+** integer into which is written 0 or 1 to indicate whether the writable_schema 
+** is enabled or disabled following this call. 
+** </dd> 
+** 
+** [[SQLITE_DBCONFIG_LEGACY_ALTER_TABLE]] 
+** <dt>SQLITE_DBCONFIG_LEGACY_ALTER_TABLE</dt> 
+** <dd>The SQLITE_DBCONFIG_LEGACY_ALTER_TABLE option activates or deactivates 
+** the legacy behavior of the [ALTER TABLE RENAME] command such it 
+** behaves as it did prior to [version 3.24.0] (2018-06-04).  See the 
+** "Compatibility Notice" on the [ALTER TABLE RENAME documentation] for 
+** additional information. This feature can also be turned on and off 
+** using the [PRAGMA legacy_alter_table] statement. 
+** </dd> 
+** 
+** [[SQLITE_DBCONFIG_DQS_DML]] 
+** <dt>SQLITE_DBCONFIG_DQS_DML</td> 
+** <dd>The SQLITE_DBCONFIG_DQS_DML option activates or deactivates 
 ** the legacy [double-quoted string literal] misfeature for DML statements
-** only, that is DELETE, INSERT, SELECT, and UPDATE statements. The
-** default value of this setting is determined by the [-DSQLITE_DQS]
-** compile-time option.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_DQS_DDL]]
-** <dt>SQLITE_DBCONFIG_DQS_DDL</td>
-** <dd>The SQLITE_DBCONFIG_DQS option activates or deactivates
-** the legacy [double-quoted string literal] misfeature for DDL statements,
-** such as CREATE TABLE and CREATE INDEX. The
-** default value of this setting is determined by the [-DSQLITE_DQS]
-** compile-time option.
-** </dd>
+** only, that is DELETE, INSERT, SELECT, and UPDATE statements. The 
+** default value of this setting is determined by the [-DSQLITE_DQS] 
+** compile-time option. 
+** </dd> 
+** 
+** [[SQLITE_DBCONFIG_DQS_DDL]] 
+** <dt>SQLITE_DBCONFIG_DQS_DDL</td> 
+** <dd>The SQLITE_DBCONFIG_DQS option activates or deactivates 
+** the legacy [double-quoted string literal] misfeature for DDL statements, 
+** such as CREATE TABLE and CREATE INDEX. The 
+** default value of this setting is determined by the [-DSQLITE_DQS] 
+** compile-time option. 
+** </dd> 
 **
 ** [[SQLITE_DBCONFIG_TRUSTED_SCHEMA]]
 ** <dt>SQLITE_DBCONFIG_TRUSTED_SCHEMA</td>
@@ -2712,12 +2712,12 @@ struct sqlite3_mem_methods {
 #define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE      1006 /* int int* */
 #define SQLITE_DBCONFIG_ENABLE_QPSG           1007 /* int int* */
 #define SQLITE_DBCONFIG_TRIGGER_EQP           1008 /* int int* */
-#define SQLITE_DBCONFIG_RESET_DATABASE        1009 /* int int* */
-#define SQLITE_DBCONFIG_DEFENSIVE             1010 /* int int* */
-#define SQLITE_DBCONFIG_WRITABLE_SCHEMA       1011 /* int int* */
-#define SQLITE_DBCONFIG_LEGACY_ALTER_TABLE    1012 /* int int* */
-#define SQLITE_DBCONFIG_DQS_DML               1013 /* int int* */
-#define SQLITE_DBCONFIG_DQS_DDL               1014 /* int int* */
+#define SQLITE_DBCONFIG_RESET_DATABASE        1009 /* int int* */ 
+#define SQLITE_DBCONFIG_DEFENSIVE             1010 /* int int* */ 
+#define SQLITE_DBCONFIG_WRITABLE_SCHEMA       1011 /* int int* */ 
+#define SQLITE_DBCONFIG_LEGACY_ALTER_TABLE    1012 /* int int* */ 
+#define SQLITE_DBCONFIG_DQS_DML               1013 /* int int* */ 
+#define SQLITE_DBCONFIG_DQS_DDL               1014 /* int int* */ 
 #define SQLITE_DBCONFIG_ENABLE_VIEW           1015 /* int int* */
 #define SQLITE_DBCONFIG_LEGACY_FILE_FORMAT    1016 /* int int* */
 #define SQLITE_DBCONFIG_TRUSTED_SCHEMA        1017 /* int int* */
@@ -2855,14 +2855,14 @@ SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64);
 ** If a separate thread makes changes on the same database connection
 ** while [sqlite3_changes()] is running then the value returned
 ** is unpredictable and not meaningful.
-**
-** See also:
-** <ul>
-** <li> the [sqlite3_total_changes()] interface
-** <li> the [count_changes pragma]
-** <li> the [changes() SQL function]
-** <li> the [data_version pragma]
-** </ul>
+** 
+** See also: 
+** <ul> 
+** <li> the [sqlite3_total_changes()] interface 
+** <li> the [count_changes pragma] 
+** <li> the [changes() SQL function] 
+** <li> the [data_version pragma] 
+** </ul> 
 */
 SQLITE_API int sqlite3_changes(sqlite3*);
 SQLITE_API sqlite3_int64 sqlite3_changes64(sqlite3*);
@@ -2885,26 +2885,26 @@ SQLITE_API sqlite3_int64 sqlite3_changes64(sqlite3*);
 ** count, but those made as part of REPLACE constraint resolution are
 ** not. ^Changes to a view that are intercepted by INSTEAD OF triggers
 ** are not counted.
-**
-** The [sqlite3_total_changes(D)] interface only reports the number
-** of rows that changed due to SQL statement run against database
-** connection D.  Any changes by other database connections are ignored.
-** To detect changes against a database file from other database
-** connections use the [PRAGMA data_version] command or the
-** [SQLITE_FCNTL_DATA_VERSION] [file control].
+** 
+** The [sqlite3_total_changes(D)] interface only reports the number 
+** of rows that changed due to SQL statement run against database 
+** connection D.  Any changes by other database connections are ignored. 
+** To detect changes against a database file from other database 
+** connections use the [PRAGMA data_version] command or the 
+** [SQLITE_FCNTL_DATA_VERSION] [file control]. 
 **
 ** If a separate thread makes changes on the same database connection
 ** while [sqlite3_total_changes()] is running then the value
 ** returned is unpredictable and not meaningful.
-**
-** See also:
-** <ul>
-** <li> the [sqlite3_changes()] interface
-** <li> the [count_changes pragma]
-** <li> the [changes() SQL function]
-** <li> the [data_version pragma]
-** <li> the [SQLITE_FCNTL_DATA_VERSION] [file control]
-** </ul>
+** 
+** See also: 
+** <ul> 
+** <li> the [sqlite3_changes()] interface 
+** <li> the [count_changes pragma] 
+** <li> the [changes() SQL function] 
+** <li> the [data_version pragma] 
+** <li> the [SQLITE_FCNTL_DATA_VERSION] [file control] 
+** </ul> 
 */
 SQLITE_API int sqlite3_total_changes(sqlite3*);
 SQLITE_API sqlite3_int64 sqlite3_total_changes64(sqlite3*);
@@ -3154,16 +3154,16 @@ SQLITE_API void sqlite3_free_table(char **result);
 **
 ** These routines are work-alikes of the "printf()" family of functions
 ** from the standard C library.
-** These routines understand most of the common formatting options from
+** These routines understand most of the common formatting options from 
 ** the standard library printf()
-** plus some additional non-standard formats ([%q], [%Q], [%w], and [%z]).
-** See the [built-in printf()] documentation for details.
+** plus some additional non-standard formats ([%q], [%Q], [%w], and [%z]). 
+** See the [built-in printf()] documentation for details. 
 **
 ** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their
-** results into memory obtained from [sqlite3_malloc64()].
+** results into memory obtained from [sqlite3_malloc64()]. 
 ** The strings returned by these two routines should be
 ** released by [sqlite3_free()].  ^Both routines return a
-** NULL pointer if [sqlite3_malloc64()] is unable to allocate enough
+** NULL pointer if [sqlite3_malloc64()] is unable to allocate enough 
 ** memory to hold the resulting string.
 **
 ** ^(The sqlite3_snprintf() routine is similar to "snprintf()" from
@@ -3187,7 +3187,7 @@ SQLITE_API void sqlite3_free_table(char **result);
 **
 ** ^The sqlite3_vsnprintf() routine is a varargs version of sqlite3_snprintf().
 **
-** See also:  [built-in printf()], [printf() SQL function]
+** See also:  [built-in printf()], [printf() SQL function] 
 */
 SQLITE_API char *sqlite3_mprintf(const char*,...);
 SQLITE_API char *sqlite3_vmprintf(const char*, va_list);
@@ -3518,9 +3518,9 @@ SQLITE_API int sqlite3_set_authorizer(
 ** time is in units of nanoseconds, however the current implementation
 ** is only capable of millisecond resolution so the six least significant
 ** digits in the time are meaningless.  Future versions of SQLite
-** might provide greater resolution on the profiler callback.  Invoking
-** either [sqlite3_trace()] or [sqlite3_trace_v2()] will cancel the
-** profile callback.
+** might provide greater resolution on the profiler callback.  Invoking 
+** either [sqlite3_trace()] or [sqlite3_trace_v2()] will cancel the 
+** profile callback. 
 */
 SQLITE_API SQLITE_DEPRECATED void *sqlite3_trace(sqlite3*,
    void(*xTrace)(void*,const char*), void*);
@@ -3994,7 +3994,7 @@ SQLITE_API int sqlite3_open_v2(
 ** is not a database file pathname pointer that the SQLite core passed
 ** into the xOpen VFS method, then the behavior of this routine is undefined
 ** and probably undesirable.
-**
+** 
 ** Beginning with SQLite [version 3.31.0] ([dateof:3.31.0]) the input F
 ** parameter can also be the name of a rollback journal file or WAL file
 ** in addition to the main database file.  Prior to version 3.31.0, these
@@ -4003,7 +4003,7 @@ SQLITE_API int sqlite3_open_v2(
 ** it has access to all the same query parameters as were found on the
 ** main database file.
 **
-** See the [URI filename] documentation for additional information.
+** See the [URI filename] documentation for additional information. 
 */
 SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam);
 SQLITE_API int sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault);
@@ -4127,19 +4127,19 @@ SQLITE_API void sqlite3_free_filename(char*);
 ** [extended result code] even when extended result codes are
 ** disabled.
 **
-** The values returned by sqlite3_errcode() and/or
-** sqlite3_extended_errcode() might change with each API call.
-** Except, there are some interfaces that are guaranteed to never
-** change the value of the error code.  The error-code preserving
-** interfaces are:
-**
-** <ul>
-** <li> sqlite3_errcode()
-** <li> sqlite3_extended_errcode()
-** <li> sqlite3_errmsg()
-** <li> sqlite3_errmsg16()
-** </ul>
-**
+** The values returned by sqlite3_errcode() and/or 
+** sqlite3_extended_errcode() might change with each API call. 
+** Except, there are some interfaces that are guaranteed to never 
+** change the value of the error code.  The error-code preserving 
+** interfaces are: 
+** 
+** <ul> 
+** <li> sqlite3_errcode() 
+** <li> sqlite3_extended_errcode() 
+** <li> sqlite3_errmsg() 
+** <li> sqlite3_errmsg16() 
+** </ul> 
+** 
 ** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language
 ** text that describes the error, as either UTF-8 or UTF-16 respectively.
 ** ^(Memory to hold the error message string is managed internally.
@@ -4329,24 +4329,24 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
 ** on this hint by avoiding the use of [lookaside memory] so as not to
 ** deplete the limited store of lookaside memory. Future versions of
 ** SQLite may act on this hint differently.
-**
-** [[SQLITE_PREPARE_NORMALIZE]] <dt>SQLITE_PREPARE_NORMALIZE</dt>
-** <dd>The SQLITE_PREPARE_NORMALIZE flag is a no-op. This flag used
-** to be required for any prepared statement that wanted to use the
-** [sqlite3_normalized_sql()] interface.  However, the
-** [sqlite3_normalized_sql()] interface is now available to all
-** prepared statements, regardless of whether or not they use this
-** flag.
-**
-** [[SQLITE_PREPARE_NO_VTAB]] <dt>SQLITE_PREPARE_NO_VTAB</dt>
-** <dd>The SQLITE_PREPARE_NO_VTAB flag causes the SQL compiler
-** to return an error (error code SQLITE_ERROR) if the statement uses
-** any virtual tables.
+** 
+** [[SQLITE_PREPARE_NORMALIZE]] <dt>SQLITE_PREPARE_NORMALIZE</dt> 
+** <dd>The SQLITE_PREPARE_NORMALIZE flag is a no-op. This flag used 
+** to be required for any prepared statement that wanted to use the 
+** [sqlite3_normalized_sql()] interface.  However, the 
+** [sqlite3_normalized_sql()] interface is now available to all 
+** prepared statements, regardless of whether or not they use this 
+** flag. 
+** 
+** [[SQLITE_PREPARE_NO_VTAB]] <dt>SQLITE_PREPARE_NO_VTAB</dt> 
+** <dd>The SQLITE_PREPARE_NO_VTAB flag causes the SQL compiler 
+** to return an error (error code SQLITE_ERROR) if the statement uses 
+** any virtual tables. 
 ** </dl>
 */
 #define SQLITE_PREPARE_PERSISTENT              0x01
-#define SQLITE_PREPARE_NORMALIZE               0x02
-#define SQLITE_PREPARE_NO_VTAB                 0x04
+#define SQLITE_PREPARE_NORMALIZE               0x02 
+#define SQLITE_PREPARE_NO_VTAB                 0x04 
 
 /*
 ** CAPI3REF: Compiling An SQL Statement
@@ -4440,7 +4440,7 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
 ** or [GLOB] operator or if the parameter is compared to an indexed column
 ** and the [SQLITE_ENABLE_STAT4] compile-time option is enabled.
 ** </li>
-** </ol>
+** </ol> 
 **
 ** <p>^sqlite3_prepare_v3() differs from sqlite3_prepare_v2() only in having
 ** the extra prepFlags parameter, which is a bit array consisting of zero or
@@ -4504,11 +4504,11 @@ SQLITE_API int sqlite3_prepare16_v3(
 ** ^The sqlite3_expanded_sql(P) interface returns a pointer to a UTF-8
 ** string containing the SQL text of prepared statement P with
 ** [bound parameters] expanded.
-** ^The sqlite3_normalized_sql(P) interface returns a pointer to a UTF-8
-** string containing the normalized SQL text of prepared statement P.  The
-** semantics used to normalize a SQL statement are unspecified and subject
-** to change.  At a minimum, literal values will be replaced with suitable
-** placeholders.
+** ^The sqlite3_normalized_sql(P) interface returns a pointer to a UTF-8 
+** string containing the normalized SQL text of prepared statement P.  The 
+** semantics used to normalize a SQL statement are unspecified and subject 
+** to change.  At a minimum, literal values will be replaced with suitable 
+** placeholders. 
 **
 ** ^(For example, if a prepared statement is created using the SQL
 ** text "SELECT $abc,:xyz" and if parameter $abc is bound to integer 2345
@@ -4524,9 +4524,9 @@ SQLITE_API int sqlite3_prepare16_v3(
 ** bound parameter expansions.  ^The [SQLITE_OMIT_TRACE] compile-time
 ** option causes sqlite3_expanded_sql() to always return NULL.
 **
-** ^The strings returned by sqlite3_sql(P) and sqlite3_normalized_sql(P)
-** are managed by SQLite and are automatically freed when the prepared
-** statement is finalized.
+** ^The strings returned by sqlite3_sql(P) and sqlite3_normalized_sql(P) 
+** are managed by SQLite and are automatically freed when the prepared 
+** statement is finalized. 
 ** ^The string returned by sqlite3_expanded_sql(P), on the other hand,
 ** is obtained from [sqlite3_malloc()] and must be freed by the application
 ** by passing it to [sqlite3_free()].
@@ -4537,7 +4537,7 @@ SQLITE_API int sqlite3_prepare16_v3(
 SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt);
 SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt);
 #ifdef SQLITE_ENABLE_NORMALIZE
-SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt);
+SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt); 
 #endif
 
 /*
@@ -4586,18 +4586,18 @@ SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt);
 SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
 
 /*
-** CAPI3REF: Query The EXPLAIN Setting For A Prepared Statement
-** METHOD: sqlite3_stmt
-**
-** ^The sqlite3_stmt_isexplain(S) interface returns 1 if the
-** prepared statement S is an EXPLAIN statement, or 2 if the
-** statement S is an EXPLAIN QUERY PLAN.
-** ^The sqlite3_stmt_isexplain(S) interface returns 0 if S is
-** an ordinary statement or a NULL pointer.
-*/
-SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt);
-
-/*
+** CAPI3REF: Query The EXPLAIN Setting For A Prepared Statement 
+** METHOD: sqlite3_stmt 
+** 
+** ^The sqlite3_stmt_isexplain(S) interface returns 1 if the 
+** prepared statement S is an EXPLAIN statement, or 2 if the 
+** statement S is an EXPLAIN QUERY PLAN. 
+** ^The sqlite3_stmt_isexplain(S) interface returns 0 if S is 
+** an ordinary statement or a NULL pointer. 
+*/ 
+SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt); 
+ 
+/* 
 ** CAPI3REF: Determine If A Prepared Statement Has Been Reset
 ** METHOD: sqlite3_stmt
 **
@@ -5361,25 +5361,25 @@ SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
 ** from [sqlite3_column_blob()], [sqlite3_column_text()], etc. into
 ** [sqlite3_free()].
 **
-** As long as the input parameters are correct, these routines will only
-** fail if an out-of-memory error occurs during a format conversion.
-** Only the following subset of interfaces are subject to out-of-memory
-** errors:
-**
-** <ul>
-** <li> sqlite3_column_blob()
-** <li> sqlite3_column_text()
-** <li> sqlite3_column_text16()
-** <li> sqlite3_column_bytes()
-** <li> sqlite3_column_bytes16()
-** </ul>
-**
-** If an out-of-memory error occurs, then the return value from these
-** routines is the same as if the column had contained an SQL NULL value.
-** Valid SQL NULL returns can be distinguished from out-of-memory errors
-** by invoking the [sqlite3_errcode()] immediately after the suspect
-** return value is obtained and before any
-** other SQLite interface is called on the same [database connection].
+** As long as the input parameters are correct, these routines will only 
+** fail if an out-of-memory error occurs during a format conversion. 
+** Only the following subset of interfaces are subject to out-of-memory 
+** errors: 
+** 
+** <ul> 
+** <li> sqlite3_column_blob() 
+** <li> sqlite3_column_text() 
+** <li> sqlite3_column_text16() 
+** <li> sqlite3_column_bytes() 
+** <li> sqlite3_column_bytes16() 
+** </ul> 
+** 
+** If an out-of-memory error occurs, then the return value from these 
+** routines is the same as if the column had contained an SQL NULL value. 
+** Valid SQL NULL returns can be distinguished from out-of-memory errors 
+** by invoking the [sqlite3_errcode()] immediately after the suspect 
+** return value is obtained and before any 
+** other SQLite interface is called on the same [database connection]. 
 */
 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
 SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);
@@ -5454,13 +5454,13 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
 **
 ** ^These functions (collectively known as "function creation routines")
 ** are used to add SQL functions or aggregates or to redefine the behavior
-** of existing SQL functions or aggregates. The only differences between
+** of existing SQL functions or aggregates. The only differences between 
 ** the three "sqlite3_create_function*" routines are the text encoding
 ** expected for the second parameter (the name of the function being
-** created) and the presence or absence of a destructor callback for
-** the application data pointer. Function sqlite3_create_window_function()
-** is similar, but allows the user to supply the extra callback functions
-** needed by [aggregate window functions].
+** created) and the presence or absence of a destructor callback for 
+** the application data pointer. Function sqlite3_create_window_function() 
+** is similar, but allows the user to supply the extra callback functions 
+** needed by [aggregate window functions]. 
 **
 ** ^The first parameter is the [database connection] to which the SQL
 ** function is to be added.  ^If an application uses more than one database
@@ -5521,8 +5521,8 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
 ** ^(The fifth parameter is an arbitrary pointer.  The implementation of the
 ** function can gain access to this pointer using [sqlite3_user_data()].)^
 **
-** ^The sixth, seventh and eighth parameters passed to the three
-** "sqlite3_create_function*" functions, xFunc, xStep and xFinal, are
+** ^The sixth, seventh and eighth parameters passed to the three 
+** "sqlite3_create_function*" functions, xFunc, xStep and xFinal, are 
 ** pointers to C-language functions that implement the SQL function or
 ** aggregate. ^A scalar SQL function requires an implementation of the xFunc
 ** callback only; NULL pointers must be passed as the xStep and xFinal
@@ -5532,24 +5532,24 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
 ** callbacks.
 **
 ** ^The sixth, seventh, eighth and ninth parameters (xStep, xFinal, xValue
-** and xInverse) passed to sqlite3_create_window_function are pointers to
-** C-language callbacks that implement the new function. xStep and xFinal
-** must both be non-NULL. xValue and xInverse may either both be NULL, in
+** and xInverse) passed to sqlite3_create_window_function are pointers to 
+** C-language callbacks that implement the new function. xStep and xFinal 
+** must both be non-NULL. xValue and xInverse may either both be NULL, in 
 ** which case a regular aggregate function is created, or must both be
-** non-NULL, in which case the new function may be used as either an aggregate
-** or aggregate window function. More details regarding the implementation
+** non-NULL, in which case the new function may be used as either an aggregate 
+** or aggregate window function. More details regarding the implementation 
 ** of aggregate window functions are
-** [user-defined window functions|available here].
+** [user-defined window functions|available here]. 
 **
-** ^(If the final parameter to sqlite3_create_function_v2() or
-** sqlite3_create_window_function() is not NULL, then it is destructor for
+** ^(If the final parameter to sqlite3_create_function_v2() or 
+** sqlite3_create_window_function() is not NULL, then it is destructor for 
 ** the application data pointer. The destructor is invoked when the function
 ** is deleted, either by being overloaded or when the database connection
 ** closes.)^ ^The destructor is also invoked if the call to
-** sqlite3_create_function_v2() fails.  ^When the destructor callback is
-** invoked, it is passed a single argument which is a copy of the application
-** data pointer which was the fifth parameter to sqlite3_create_function_v2().
-**
+** sqlite3_create_function_v2() fails.  ^When the destructor callback is 
+** invoked, it is passed a single argument which is a copy of the application 
+** data pointer which was the fifth parameter to sqlite3_create_function_v2(). 
+** 
 ** ^It is permitted to register multiple implementations of the same
 ** functions with the same name but with either differing numbers of
 ** arguments or differing preferred text encodings.  ^SQLite will use
@@ -5601,18 +5601,18 @@ SQLITE_API int sqlite3_create_function_v2(
   void (*xFinal)(sqlite3_context*),
   void(*xDestroy)(void*)
 );
-SQLITE_API int sqlite3_create_window_function(
-  sqlite3 *db,
-  const char *zFunctionName,
-  int nArg,
-  int eTextRep,
-  void *pApp,
-  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
-  void (*xFinal)(sqlite3_context*),
-  void (*xValue)(sqlite3_context*),
-  void (*xInverse)(sqlite3_context*,int,sqlite3_value**),
-  void(*xDestroy)(void*)
-);
+SQLITE_API int sqlite3_create_window_function( 
+  sqlite3 *db, 
+  const char *zFunctionName, 
+  int nArg, 
+  int eTextRep, 
+  void *pApp, 
+  void (*xStep)(sqlite3_context*,int,sqlite3_value**), 
+  void (*xFinal)(sqlite3_context*), 
+  void (*xValue)(sqlite3_context*), 
+  void (*xInverse)(sqlite3_context*,int,sqlite3_value**), 
+  void(*xDestroy)(void*) 
+); 
 
 /*
 ** CAPI3REF: Text Encodings
@@ -5746,8 +5746,8 @@ SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int6
 ** <tr><td><b>sqlite3_value_nochange&nbsp;&nbsp;</b>
 ** <td>&rarr;&nbsp;&nbsp;<td>True if the column is unchanged in an UPDATE
 ** against a virtual table.
-** <tr><td><b>sqlite3_value_frombind&nbsp;&nbsp;</b>
-** <td>&rarr;&nbsp;&nbsp;<td>True if value originated from a [bound parameter]
+** <tr><td><b>sqlite3_value_frombind&nbsp;&nbsp;</b> 
+** <td>&rarr;&nbsp;&nbsp;<td>True if value originated from a [bound parameter] 
 ** </table></blockquote>
 **
 ** <b>Details:</b>
@@ -5809,11 +5809,11 @@ SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int6
 ** than within an [xUpdate] method call for an UPDATE statement, then
 ** the return value is arbitrary and meaningless.
 **
-** ^The sqlite3_value_frombind(X) interface returns non-zero if the
-** value X originated from one of the [sqlite3_bind_int|sqlite3_bind()]
-** interfaces.  ^If X comes from an SQL literal value, or a table column,
+** ^The sqlite3_value_frombind(X) interface returns non-zero if the 
+** value X originated from one of the [sqlite3_bind_int|sqlite3_bind()] 
+** interfaces.  ^If X comes from an SQL literal value, or a table column, 
 ** or an expression, then sqlite3_value_frombind(X) returns zero.
-**
+** 
 ** Please pay particular attention to the fact that the pointer returned
 ** from [sqlite3_value_blob()], [sqlite3_value_text()], or
 ** [sqlite3_value_text16()] can be invalidated by a subsequent call to
@@ -5822,28 +5822,28 @@ SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int6
 **
 ** These routines must be called from the same thread as
 ** the SQL function that supplied the [sqlite3_value*] parameters.
-**
-** As long as the input parameter is correct, these routines can only
-** fail if an out-of-memory error occurs during a format conversion.
-** Only the following subset of interfaces are subject to out-of-memory
-** errors:
-**
-** <ul>
-** <li> sqlite3_value_blob()
-** <li> sqlite3_value_text()
-** <li> sqlite3_value_text16()
-** <li> sqlite3_value_text16le()
-** <li> sqlite3_value_text16be()
-** <li> sqlite3_value_bytes()
-** <li> sqlite3_value_bytes16()
-** </ul>
-**
-** If an out-of-memory error occurs, then the return value from these
-** routines is the same as if the column had contained an SQL NULL value.
-** Valid SQL NULL returns can be distinguished from out-of-memory errors
-** by invoking the [sqlite3_errcode()] immediately after the suspect
-** return value is obtained and before any
-** other SQLite interface is called on the same [database connection].
+** 
+** As long as the input parameter is correct, these routines can only 
+** fail if an out-of-memory error occurs during a format conversion. 
+** Only the following subset of interfaces are subject to out-of-memory 
+** errors: 
+** 
+** <ul> 
+** <li> sqlite3_value_blob() 
+** <li> sqlite3_value_text() 
+** <li> sqlite3_value_text16() 
+** <li> sqlite3_value_text16le() 
+** <li> sqlite3_value_text16be() 
+** <li> sqlite3_value_bytes() 
+** <li> sqlite3_value_bytes16() 
+** </ul> 
+** 
+** If an out-of-memory error occurs, then the return value from these 
+** routines is the same as if the column had contained an SQL NULL value. 
+** Valid SQL NULL returns can be distinguished from out-of-memory errors 
+** by invoking the [sqlite3_errcode()] immediately after the suspect 
+** return value is obtained and before any 
+** other SQLite interface is called on the same [database connection]. 
 */
 SQLITE_API const void *sqlite3_value_blob(sqlite3_value*);
 SQLITE_API double sqlite3_value_double(sqlite3_value*);
@@ -5859,7 +5859,7 @@ SQLITE_API int sqlite3_value_bytes16(sqlite3_value*);
 SQLITE_API int sqlite3_value_type(sqlite3_value*);
 SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*);
 SQLITE_API int sqlite3_value_nochange(sqlite3_value*);
-SQLITE_API int sqlite3_value_frombind(sqlite3_value*);
+SQLITE_API int sqlite3_value_frombind(sqlite3_value*); 
 
 /*
 ** CAPI3REF: Finding The Subtype Of SQL Values
@@ -6492,41 +6492,41 @@ SQLITE_API char *sqlite3_temp_directory;
 SQLITE_API char *sqlite3_data_directory;
 
 /*
-** CAPI3REF: Win32 Specific Interface
-**
-** These interfaces are available only on Windows.  The
-** [sqlite3_win32_set_directory] interface is used to set the value associated
-** with the [sqlite3_temp_directory] or [sqlite3_data_directory] variable, to
-** zValue, depending on the value of the type parameter.  The zValue parameter
-** should be NULL to cause the previous value to be freed via [sqlite3_free];
-** a non-NULL value will be copied into memory obtained from [sqlite3_malloc]
-** prior to being used.  The [sqlite3_win32_set_directory] interface returns
-** [SQLITE_OK] to indicate success, [SQLITE_ERROR] if the type is unsupported,
-** or [SQLITE_NOMEM] if memory could not be allocated.  The value of the
-** [sqlite3_data_directory] variable is intended to act as a replacement for
-** the current directory on the sub-platforms of Win32 where that concept is
-** not present, e.g. WinRT and UWP.  The [sqlite3_win32_set_directory8] and
-** [sqlite3_win32_set_directory16] interfaces behave exactly the same as the
-** sqlite3_win32_set_directory interface except the string parameter must be
-** UTF-8 or UTF-16, respectively.
-*/
-SQLITE_API int sqlite3_win32_set_directory(
-  unsigned long type, /* Identifier for directory being set or reset */
-  void *zValue        /* New value for directory being set or reset */
-);
-SQLITE_API int sqlite3_win32_set_directory8(unsigned long type, const char *zValue);
-SQLITE_API int sqlite3_win32_set_directory16(unsigned long type, const void *zValue);
-
-/*
-** CAPI3REF: Win32 Directory Types
-**
-** These macros are only available on Windows.  They define the allowed values
-** for the type argument to the [sqlite3_win32_set_directory] interface.
-*/
-#define SQLITE_WIN32_DATA_DIRECTORY_TYPE  1
-#define SQLITE_WIN32_TEMP_DIRECTORY_TYPE  2
-
-/*
+** CAPI3REF: Win32 Specific Interface 
+** 
+** These interfaces are available only on Windows.  The 
+** [sqlite3_win32_set_directory] interface is used to set the value associated 
+** with the [sqlite3_temp_directory] or [sqlite3_data_directory] variable, to 
+** zValue, depending on the value of the type parameter.  The zValue parameter 
+** should be NULL to cause the previous value to be freed via [sqlite3_free]; 
+** a non-NULL value will be copied into memory obtained from [sqlite3_malloc] 
+** prior to being used.  The [sqlite3_win32_set_directory] interface returns 
+** [SQLITE_OK] to indicate success, [SQLITE_ERROR] if the type is unsupported, 
+** or [SQLITE_NOMEM] if memory could not be allocated.  The value of the 
+** [sqlite3_data_directory] variable is intended to act as a replacement for 
+** the current directory on the sub-platforms of Win32 where that concept is 
+** not present, e.g. WinRT and UWP.  The [sqlite3_win32_set_directory8] and 
+** [sqlite3_win32_set_directory16] interfaces behave exactly the same as the 
+** sqlite3_win32_set_directory interface except the string parameter must be 
+** UTF-8 or UTF-16, respectively. 
+*/ 
+SQLITE_API int sqlite3_win32_set_directory( 
+  unsigned long type, /* Identifier for directory being set or reset */ 
+  void *zValue        /* New value for directory being set or reset */ 
+); 
+SQLITE_API int sqlite3_win32_set_directory8(unsigned long type, const char *zValue); 
+SQLITE_API int sqlite3_win32_set_directory16(unsigned long type, const void *zValue); 
+ 
+/* 
+** CAPI3REF: Win32 Directory Types 
+** 
+** These macros are only available on Windows.  They define the allowed values 
+** for the type argument to the [sqlite3_win32_set_directory] interface. 
+*/ 
+#define SQLITE_WIN32_DATA_DIRECTORY_TYPE  1 
+#define SQLITE_WIN32_TEMP_DIRECTORY_TYPE  2 
+ 
+/* 
 ** CAPI3REF: Test For Auto-Commit Mode
 ** KEYWORDS: {autocommit mode}
 ** METHOD: sqlite3
@@ -6571,7 +6571,7 @@ SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
 ** associated with database N of connection D.
 ** ^If there is no attached database N on the database
 ** connection D, or if database N is a temporary or in-memory database, then
-** this function will return either a NULL pointer or an empty string.
+** this function will return either a NULL pointer or an empty string. 
 **
 ** ^The string value returned by this routine is owned and managed by
 ** the database connection.  ^The value will be valid until the database N
@@ -7276,9 +7276,9 @@ struct sqlite3_module {
   int (*xSavepoint)(sqlite3_vtab *pVTab, int);
   int (*xRelease)(sqlite3_vtab *pVTab, int);
   int (*xRollbackTo)(sqlite3_vtab *pVTab, int);
-  /* The methods above are in versions 1 and 2 of the sqlite_module object.
-  ** Those below are for version 3 and greater. */
-  int (*xShadowName)(const char*);
+  /* The methods above are in versions 1 and 2 of the sqlite_module object. 
+  ** Those below are for version 3 and greater. */ 
+  int (*xShadowName)(const char*); 
 };
 
 /*
@@ -7417,10 +7417,10 @@ struct sqlite3_index_info {
 
 /*
 ** CAPI3REF: Virtual Table Scan Flags
-**
+** 
 ** Virtual table implementations are allowed to set the
-** [sqlite3_index_info].idxFlags field to some combination of
-** these bits.
+** [sqlite3_index_info].idxFlags field to some combination of 
+** these bits. 
 */
 #define SQLITE_INDEX_SCAN_UNIQUE      1     /* Scan visits at most 1 row */
 
@@ -7446,7 +7446,7 @@ struct sqlite3_index_info {
 #define SQLITE_INDEX_CONSTRAINT_ISNOTNULL 70
 #define SQLITE_INDEX_CONSTRAINT_ISNULL    71
 #define SQLITE_INDEX_CONSTRAINT_IS        72
-#define SQLITE_INDEX_CONSTRAINT_FUNCTION 150
+#define SQLITE_INDEX_CONSTRAINT_FUNCTION 150 
 
 /*
 ** CAPI3REF: Register A Virtual Table Implementation
@@ -8150,7 +8150,7 @@ SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*);
 /*
 ** CAPI3REF: Low-Level Control Of Database Files
 ** METHOD: sqlite3
-** KEYWORDS: {file control}
+** KEYWORDS: {file control} 
 **
 ** ^The [sqlite3_file_control()] interface makes a direct call to the
 ** xFileControl method for the [sqlite3_io_methods] object associated
@@ -8165,18 +8165,18 @@ SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*);
 ** the xFileControl method.  ^The return value of the xFileControl
 ** method becomes the return value of this routine.
 **
-** A few opcodes for [sqlite3_file_control()] are handled directly
+** A few opcodes for [sqlite3_file_control()] are handled directly 
 ** by the SQLite core and never invoke the
-** sqlite3_io_methods.xFileControl method.
+** sqlite3_io_methods.xFileControl method. 
 ** ^The [SQLITE_FCNTL_FILE_POINTER] value for the op parameter causes
 ** a pointer to the underlying [sqlite3_file] object to be written into
-** the space pointed to by the 4th parameter.  The
-** [SQLITE_FCNTL_JOURNAL_POINTER] works similarly except that it returns
-** the [sqlite3_file] object associated with the journal file instead of
-** the main database.  The [SQLITE_FCNTL_VFS_POINTER] opcode returns
-** a pointer to the underlying [sqlite3_vfs] object for the file.
-** The [SQLITE_FCNTL_DATA_VERSION] returns the data version counter
-** from the pager.
+** the space pointed to by the 4th parameter.  The 
+** [SQLITE_FCNTL_JOURNAL_POINTER] works similarly except that it returns 
+** the [sqlite3_file] object associated with the journal file instead of 
+** the main database.  The [SQLITE_FCNTL_VFS_POINTER] opcode returns 
+** a pointer to the underlying [sqlite3_vfs] object for the file. 
+** The [SQLITE_FCNTL_DATA_VERSION] returns the data version counter 
+** from the pager. 
 **
 ** ^If the second parameter (zDbName) does not match the name of any
 ** open database file, then SQLITE_ERROR is returned.  ^This error
@@ -8232,9 +8232,9 @@ SQLITE_API int sqlite3_test_control(int op, ...);
 #define SQLITE_TESTCTRL_ALWAYS                  13
 #define SQLITE_TESTCTRL_RESERVE                 14  /* NOT USED */
 #define SQLITE_TESTCTRL_OPTIMIZATIONS           15
-#define SQLITE_TESTCTRL_ISKEYWORD               16  /* NOT USED */
+#define SQLITE_TESTCTRL_ISKEYWORD               16  /* NOT USED */ 
 #define SQLITE_TESTCTRL_SCRATCHMALLOC           17  /* NOT USED */
-#define SQLITE_TESTCTRL_INTERNAL_FUNCTIONS      17
+#define SQLITE_TESTCTRL_INTERNAL_FUNCTIONS      17 
 #define SQLITE_TESTCTRL_LOCALTIME_FAULT         18
 #define SQLITE_TESTCTRL_EXPLAIN_STMT            19  /* NOT USED */
 #define SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD    19
@@ -8245,7 +8245,7 @@ SQLITE_API int sqlite3_test_control(int op, ...);
 #define SQLITE_TESTCTRL_SORTER_MMAP             24
 #define SQLITE_TESTCTRL_IMPOSTER                25
 #define SQLITE_TESTCTRL_PARSER_COVERAGE         26
-#define SQLITE_TESTCTRL_RESULT_INTREAL          27
+#define SQLITE_TESTCTRL_RESULT_INTREAL          27 
 #define SQLITE_TESTCTRL_PRNG_SEED               28
 #define SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS     29
 #define SQLITE_TESTCTRL_SEEK_COUNT              30
@@ -8254,189 +8254,189 @@ SQLITE_API int sqlite3_test_control(int op, ...);
 #define SQLITE_TESTCTRL_LAST                    32  /* Largest TESTCTRL */
 
 /*
-** CAPI3REF: SQL Keyword Checking
-**
+** CAPI3REF: SQL Keyword Checking 
+** 
 ** These routines provide access to the set of SQL language keywords
-** recognized by SQLite.  Applications can uses these routines to determine
-** whether or not a specific identifier needs to be escaped (for example,
-** by enclosing in double-quotes) so as not to confuse the parser.
-**
-** The sqlite3_keyword_count() interface returns the number of distinct
-** keywords understood by SQLite.
-**
-** The sqlite3_keyword_name(N,Z,L) interface finds the N-th keyword and
-** makes *Z point to that keyword expressed as UTF8 and writes the number
-** of bytes in the keyword into *L.  The string that *Z points to is not
-** zero-terminated.  The sqlite3_keyword_name(N,Z,L) routine returns
-** SQLITE_OK if N is within bounds and SQLITE_ERROR if not. If either Z
-** or L are NULL or invalid pointers then calls to
-** sqlite3_keyword_name(N,Z,L) result in undefined behavior.
-**
-** The sqlite3_keyword_check(Z,L) interface checks to see whether or not
-** the L-byte UTF8 identifier that Z points to is a keyword, returning non-zero
-** if it is and zero if not.
-**
-** The parser used by SQLite is forgiving.  It is often possible to use
-** a keyword as an identifier as long as such use does not result in a
-** parsing ambiguity.  For example, the statement
-** "CREATE TABLE BEGIN(REPLACE,PRAGMA,END);" is accepted by SQLite, and
-** creates a new table named "BEGIN" with three columns named
-** "REPLACE", "PRAGMA", and "END".  Nevertheless, best practice is to avoid
-** using keywords as identifiers.  Common techniques used to avoid keyword
-** name collisions include:
-** <ul>
-** <li> Put all identifier names inside double-quotes.  This is the official
-**      SQL way to escape identifier names.
-** <li> Put identifier names inside &#91;...&#93;.  This is not standard SQL,
-**      but it is what SQL Server does and so lots of programmers use this
-**      technique.
-** <li> Begin every identifier with the letter "Z" as no SQL keywords start
-**      with "Z".
-** <li> Include a digit somewhere in every identifier name.
-** </ul>
-**
-** Note that the number of keywords understood by SQLite can depend on
-** compile-time options.  For example, "VACUUM" is not a keyword if
-** SQLite is compiled with the [-DSQLITE_OMIT_VACUUM] option.  Also,
-** new keywords may be added to future releases of SQLite.
-*/
-SQLITE_API int sqlite3_keyword_count(void);
-SQLITE_API int sqlite3_keyword_name(int,const char**,int*);
-SQLITE_API int sqlite3_keyword_check(const char*,int);
-
-/*
-** CAPI3REF: Dynamic String Object
-** KEYWORDS: {dynamic string}
-**
-** An instance of the sqlite3_str object contains a dynamically-sized
-** string under construction.
-**
-** The lifecycle of an sqlite3_str object is as follows:
-** <ol>
-** <li> ^The sqlite3_str object is created using [sqlite3_str_new()].
-** <li> ^Text is appended to the sqlite3_str object using various
-** methods, such as [sqlite3_str_appendf()].
-** <li> ^The sqlite3_str object is destroyed and the string it created
-** is returned using the [sqlite3_str_finish()] interface.
-** </ol>
-*/
-typedef struct sqlite3_str sqlite3_str;
-
-/*
-** CAPI3REF: Create A New Dynamic String Object
-** CONSTRUCTOR: sqlite3_str
-**
-** ^The [sqlite3_str_new(D)] interface allocates and initializes
-** a new [sqlite3_str] object.  To avoid memory leaks, the object returned by
+** recognized by SQLite.  Applications can uses these routines to determine 
+** whether or not a specific identifier needs to be escaped (for example, 
+** by enclosing in double-quotes) so as not to confuse the parser. 
+** 
+** The sqlite3_keyword_count() interface returns the number of distinct 
+** keywords understood by SQLite. 
+** 
+** The sqlite3_keyword_name(N,Z,L) interface finds the N-th keyword and 
+** makes *Z point to that keyword expressed as UTF8 and writes the number 
+** of bytes in the keyword into *L.  The string that *Z points to is not 
+** zero-terminated.  The sqlite3_keyword_name(N,Z,L) routine returns 
+** SQLITE_OK if N is within bounds and SQLITE_ERROR if not. If either Z 
+** or L are NULL or invalid pointers then calls to 
+** sqlite3_keyword_name(N,Z,L) result in undefined behavior. 
+** 
+** The sqlite3_keyword_check(Z,L) interface checks to see whether or not 
+** the L-byte UTF8 identifier that Z points to is a keyword, returning non-zero 
+** if it is and zero if not. 
+** 
+** The parser used by SQLite is forgiving.  It is often possible to use 
+** a keyword as an identifier as long as such use does not result in a 
+** parsing ambiguity.  For example, the statement 
+** "CREATE TABLE BEGIN(REPLACE,PRAGMA,END);" is accepted by SQLite, and 
+** creates a new table named "BEGIN" with three columns named 
+** "REPLACE", "PRAGMA", and "END".  Nevertheless, best practice is to avoid 
+** using keywords as identifiers.  Common techniques used to avoid keyword 
+** name collisions include: 
+** <ul> 
+** <li> Put all identifier names inside double-quotes.  This is the official 
+**      SQL way to escape identifier names. 
+** <li> Put identifier names inside &#91;...&#93;.  This is not standard SQL, 
+**      but it is what SQL Server does and so lots of programmers use this 
+**      technique. 
+** <li> Begin every identifier with the letter "Z" as no SQL keywords start 
+**      with "Z". 
+** <li> Include a digit somewhere in every identifier name. 
+** </ul> 
+** 
+** Note that the number of keywords understood by SQLite can depend on 
+** compile-time options.  For example, "VACUUM" is not a keyword if 
+** SQLite is compiled with the [-DSQLITE_OMIT_VACUUM] option.  Also, 
+** new keywords may be added to future releases of SQLite. 
+*/ 
+SQLITE_API int sqlite3_keyword_count(void); 
+SQLITE_API int sqlite3_keyword_name(int,const char**,int*); 
+SQLITE_API int sqlite3_keyword_check(const char*,int); 
+ 
+/* 
+** CAPI3REF: Dynamic String Object 
+** KEYWORDS: {dynamic string} 
+** 
+** An instance of the sqlite3_str object contains a dynamically-sized 
+** string under construction. 
+** 
+** The lifecycle of an sqlite3_str object is as follows: 
+** <ol> 
+** <li> ^The sqlite3_str object is created using [sqlite3_str_new()]. 
+** <li> ^Text is appended to the sqlite3_str object using various 
+** methods, such as [sqlite3_str_appendf()]. 
+** <li> ^The sqlite3_str object is destroyed and the string it created 
+** is returned using the [sqlite3_str_finish()] interface. 
+** </ol> 
+*/ 
+typedef struct sqlite3_str sqlite3_str; 
+ 
+/* 
+** CAPI3REF: Create A New Dynamic String Object 
+** CONSTRUCTOR: sqlite3_str 
+** 
+** ^The [sqlite3_str_new(D)] interface allocates and initializes 
+** a new [sqlite3_str] object.  To avoid memory leaks, the object returned by 
 ** [sqlite3_str_new()] must be freed by a subsequent call to
-** [sqlite3_str_finish(X)].
-**
-** ^The [sqlite3_str_new(D)] interface always returns a pointer to a
-** valid [sqlite3_str] object, though in the event of an out-of-memory
-** error the returned object might be a special singleton that will
+** [sqlite3_str_finish(X)]. 
+** 
+** ^The [sqlite3_str_new(D)] interface always returns a pointer to a 
+** valid [sqlite3_str] object, though in the event of an out-of-memory 
+** error the returned object might be a special singleton that will 
 ** silently reject new text, always return SQLITE_NOMEM from
 ** [sqlite3_str_errcode()], always return 0 for
-** [sqlite3_str_length()], and always return NULL from
-** [sqlite3_str_finish(X)].  It is always safe to use the value
-** returned by [sqlite3_str_new(D)] as the sqlite3_str parameter
-** to any of the other [sqlite3_str] methods.
-**
-** The D parameter to [sqlite3_str_new(D)] may be NULL.  If the
-** D parameter in [sqlite3_str_new(D)] is not NULL, then the maximum
-** length of the string contained in the [sqlite3_str] object will be
-** the value set for [sqlite3_limit](D,[SQLITE_LIMIT_LENGTH]) instead
-** of [SQLITE_MAX_LENGTH].
-*/
-SQLITE_API sqlite3_str *sqlite3_str_new(sqlite3*);
-
-/*
-** CAPI3REF: Finalize A Dynamic String
-** DESTRUCTOR: sqlite3_str
-**
-** ^The [sqlite3_str_finish(X)] interface destroys the sqlite3_str object X
-** and returns a pointer to a memory buffer obtained from [sqlite3_malloc64()]
-** that contains the constructed string.  The calling application should
-** pass the returned value to [sqlite3_free()] to avoid a memory leak.
-** ^The [sqlite3_str_finish(X)] interface may return a NULL pointer if any
-** errors were encountered during construction of the string.  ^The
-** [sqlite3_str_finish(X)] interface will also return a NULL pointer if the
-** string in [sqlite3_str] object X is zero bytes long.
-*/
-SQLITE_API char *sqlite3_str_finish(sqlite3_str*);
-
-/*
-** CAPI3REF: Add Content To A Dynamic String
-** METHOD: sqlite3_str
-**
-** These interfaces add content to an sqlite3_str object previously obtained
-** from [sqlite3_str_new()].
-**
+** [sqlite3_str_length()], and always return NULL from 
+** [sqlite3_str_finish(X)].  It is always safe to use the value 
+** returned by [sqlite3_str_new(D)] as the sqlite3_str parameter 
+** to any of the other [sqlite3_str] methods. 
+** 
+** The D parameter to [sqlite3_str_new(D)] may be NULL.  If the 
+** D parameter in [sqlite3_str_new(D)] is not NULL, then the maximum 
+** length of the string contained in the [sqlite3_str] object will be 
+** the value set for [sqlite3_limit](D,[SQLITE_LIMIT_LENGTH]) instead 
+** of [SQLITE_MAX_LENGTH]. 
+*/ 
+SQLITE_API sqlite3_str *sqlite3_str_new(sqlite3*); 
+ 
+/* 
+** CAPI3REF: Finalize A Dynamic String 
+** DESTRUCTOR: sqlite3_str 
+** 
+** ^The [sqlite3_str_finish(X)] interface destroys the sqlite3_str object X 
+** and returns a pointer to a memory buffer obtained from [sqlite3_malloc64()] 
+** that contains the constructed string.  The calling application should 
+** pass the returned value to [sqlite3_free()] to avoid a memory leak. 
+** ^The [sqlite3_str_finish(X)] interface may return a NULL pointer if any 
+** errors were encountered during construction of the string.  ^The 
+** [sqlite3_str_finish(X)] interface will also return a NULL pointer if the 
+** string in [sqlite3_str] object X is zero bytes long. 
+*/ 
+SQLITE_API char *sqlite3_str_finish(sqlite3_str*); 
+ 
+/* 
+** CAPI3REF: Add Content To A Dynamic String 
+** METHOD: sqlite3_str 
+** 
+** These interfaces add content to an sqlite3_str object previously obtained 
+** from [sqlite3_str_new()]. 
+** 
 ** ^The [sqlite3_str_appendf(X,F,...)] and
-** [sqlite3_str_vappendf(X,F,V)] interfaces uses the [built-in printf]
+** [sqlite3_str_vappendf(X,F,V)] interfaces uses the [built-in printf] 
 ** functionality of SQLite to append formatted text onto the end of
-** [sqlite3_str] object X.
-**
-** ^The [sqlite3_str_append(X,S,N)] method appends exactly N bytes from string S
-** onto the end of the [sqlite3_str] object X.  N must be non-negative.
-** S must contain at least N non-zero bytes of content.  To append a
-** zero-terminated string in its entirety, use the [sqlite3_str_appendall()]
-** method instead.
-**
-** ^The [sqlite3_str_appendall(X,S)] method appends the complete content of
-** zero-terminated string S onto the end of [sqlite3_str] object X.
-**
-** ^The [sqlite3_str_appendchar(X,N,C)] method appends N copies of the
-** single-byte character C onto the end of [sqlite3_str] object X.
-** ^This method can be used, for example, to add whitespace indentation.
-**
-** ^The [sqlite3_str_reset(X)] method resets the string under construction
+** [sqlite3_str] object X. 
+** 
+** ^The [sqlite3_str_append(X,S,N)] method appends exactly N bytes from string S 
+** onto the end of the [sqlite3_str] object X.  N must be non-negative. 
+** S must contain at least N non-zero bytes of content.  To append a 
+** zero-terminated string in its entirety, use the [sqlite3_str_appendall()] 
+** method instead. 
+** 
+** ^The [sqlite3_str_appendall(X,S)] method appends the complete content of 
+** zero-terminated string S onto the end of [sqlite3_str] object X. 
+** 
+** ^The [sqlite3_str_appendchar(X,N,C)] method appends N copies of the 
+** single-byte character C onto the end of [sqlite3_str] object X. 
+** ^This method can be used, for example, to add whitespace indentation. 
+** 
+** ^The [sqlite3_str_reset(X)] method resets the string under construction 
 ** inside [sqlite3_str] object X back to zero bytes in length.
-**
-** These methods do not return a result code.  ^If an error occurs, that fact
-** is recorded in the [sqlite3_str] object and can be recovered by a
-** subsequent call to [sqlite3_str_errcode(X)].
-*/
-SQLITE_API void sqlite3_str_appendf(sqlite3_str*, const char *zFormat, ...);
-SQLITE_API void sqlite3_str_vappendf(sqlite3_str*, const char *zFormat, va_list);
-SQLITE_API void sqlite3_str_append(sqlite3_str*, const char *zIn, int N);
-SQLITE_API void sqlite3_str_appendall(sqlite3_str*, const char *zIn);
-SQLITE_API void sqlite3_str_appendchar(sqlite3_str*, int N, char C);
-SQLITE_API void sqlite3_str_reset(sqlite3_str*);
-
-/*
-** CAPI3REF: Status Of A Dynamic String
-** METHOD: sqlite3_str
-**
-** These interfaces return the current status of an [sqlite3_str] object.
-**
-** ^If any prior errors have occurred while constructing the dynamic string
-** in sqlite3_str X, then the [sqlite3_str_errcode(X)] method will return
-** an appropriate error code.  ^The [sqlite3_str_errcode(X)] method returns
-** [SQLITE_NOMEM] following any out-of-memory error, or
-** [SQLITE_TOOBIG] if the size of the dynamic string exceeds
-** [SQLITE_MAX_LENGTH], or [SQLITE_OK] if there have been no errors.
-**
-** ^The [sqlite3_str_length(X)] method returns the current length, in bytes,
-** of the dynamic string under construction in [sqlite3_str] object X.
-** ^The length returned by [sqlite3_str_length(X)] does not include the
-** zero-termination byte.
-**
-** ^The [sqlite3_str_value(X)] method returns a pointer to the current
-** content of the dynamic string under construction in X.  The value
-** returned by [sqlite3_str_value(X)] is managed by the sqlite3_str object X
-** and might be freed or altered by any subsequent method on the same
-** [sqlite3_str] object.  Applications must not used the pointer returned
-** [sqlite3_str_value(X)] after any subsequent method call on the same
-** object.  ^Applications may change the content of the string returned
-** by [sqlite3_str_value(X)] as long as they do not write into any bytes
-** outside the range of 0 to [sqlite3_str_length(X)] and do not read or
-** write any byte after any subsequent sqlite3_str method call.
-*/
-SQLITE_API int sqlite3_str_errcode(sqlite3_str*);
-SQLITE_API int sqlite3_str_length(sqlite3_str*);
-SQLITE_API char *sqlite3_str_value(sqlite3_str*);
-
-/*
+** 
+** These methods do not return a result code.  ^If an error occurs, that fact 
+** is recorded in the [sqlite3_str] object and can be recovered by a 
+** subsequent call to [sqlite3_str_errcode(X)]. 
+*/ 
+SQLITE_API void sqlite3_str_appendf(sqlite3_str*, const char *zFormat, ...); 
+SQLITE_API void sqlite3_str_vappendf(sqlite3_str*, const char *zFormat, va_list); 
+SQLITE_API void sqlite3_str_append(sqlite3_str*, const char *zIn, int N); 
+SQLITE_API void sqlite3_str_appendall(sqlite3_str*, const char *zIn); 
+SQLITE_API void sqlite3_str_appendchar(sqlite3_str*, int N, char C); 
+SQLITE_API void sqlite3_str_reset(sqlite3_str*); 
+ 
+/* 
+** CAPI3REF: Status Of A Dynamic String 
+** METHOD: sqlite3_str 
+** 
+** These interfaces return the current status of an [sqlite3_str] object. 
+** 
+** ^If any prior errors have occurred while constructing the dynamic string 
+** in sqlite3_str X, then the [sqlite3_str_errcode(X)] method will return 
+** an appropriate error code.  ^The [sqlite3_str_errcode(X)] method returns 
+** [SQLITE_NOMEM] following any out-of-memory error, or 
+** [SQLITE_TOOBIG] if the size of the dynamic string exceeds 
+** [SQLITE_MAX_LENGTH], or [SQLITE_OK] if there have been no errors. 
+** 
+** ^The [sqlite3_str_length(X)] method returns the current length, in bytes, 
+** of the dynamic string under construction in [sqlite3_str] object X. 
+** ^The length returned by [sqlite3_str_length(X)] does not include the 
+** zero-termination byte. 
+** 
+** ^The [sqlite3_str_value(X)] method returns a pointer to the current 
+** content of the dynamic string under construction in X.  The value 
+** returned by [sqlite3_str_value(X)] is managed by the sqlite3_str object X 
+** and might be freed or altered by any subsequent method on the same 
+** [sqlite3_str] object.  Applications must not used the pointer returned 
+** [sqlite3_str_value(X)] after any subsequent method call on the same 
+** object.  ^Applications may change the content of the string returned 
+** by [sqlite3_str_value(X)] as long as they do not write into any bytes 
+** outside the range of 0 to [sqlite3_str_length(X)] and do not read or 
+** write any byte after any subsequent sqlite3_str method call. 
+*/ 
+SQLITE_API int sqlite3_str_errcode(sqlite3_str*); 
+SQLITE_API int sqlite3_str_length(sqlite3_str*); 
+SQLITE_API char *sqlite3_str_value(sqlite3_str*); 
+ 
+/* 
 ** CAPI3REF: SQLite Runtime Status
 **
 ** ^These interfaces are used to retrieve runtime status information
@@ -8669,15 +8669,15 @@ SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int r
 ** highwater mark associated with SQLITE_DBSTATUS_CACHE_WRITE is always 0.
 ** </dd>
 **
-** [[SQLITE_DBSTATUS_CACHE_SPILL]] ^(<dt>SQLITE_DBSTATUS_CACHE_SPILL</dt>
-** <dd>This parameter returns the number of dirty cache entries that have
-** been written to disk in the middle of a transaction due to the page
-** cache overflowing. Transactions are more efficient if they are written
-** to disk all at once. When pages spill mid-transaction, that introduces
-** additional overhead. This parameter can be used help identify
+** [[SQLITE_DBSTATUS_CACHE_SPILL]] ^(<dt>SQLITE_DBSTATUS_CACHE_SPILL</dt> 
+** <dd>This parameter returns the number of dirty cache entries that have 
+** been written to disk in the middle of a transaction due to the page 
+** cache overflowing. Transactions are more efficient if they are written 
+** to disk all at once. When pages spill mid-transaction, that introduces 
+** additional overhead. This parameter can be used help identify 
 ** inefficiencies that can be resolved by increasing the cache size.
-** </dd>
-**
+** </dd> 
+** 
 ** [[SQLITE_DBSTATUS_DEFERRED_FKS]] ^(<dt>SQLITE_DBSTATUS_DEFERRED_FKS</dt>
 ** <dd>This parameter returns zero for the current value if and only if
 ** all foreign key constraints (deferred or immediate) have been
@@ -8697,8 +8697,8 @@ SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int r
 #define SQLITE_DBSTATUS_CACHE_WRITE          9
 #define SQLITE_DBSTATUS_DEFERRED_FKS        10
 #define SQLITE_DBSTATUS_CACHE_USED_SHARED   11
-#define SQLITE_DBSTATUS_CACHE_SPILL         12
-#define SQLITE_DBSTATUS_MAX                 12   /* Largest defined DBSTATUS */
+#define SQLITE_DBSTATUS_CACHE_SPILL         12 
+#define SQLITE_DBSTATUS_MAX                 12   /* Largest defined DBSTATUS */ 
 
 
 /*
@@ -9660,7 +9660,7 @@ SQLITE_API int sqlite3_vtab_config(sqlite3*, int op, ...);
 ** can use to customize and optimize their behavior.
 **
 ** <dl>
-** [[SQLITE_VTAB_CONSTRAINT_SUPPORT]]
+** [[SQLITE_VTAB_CONSTRAINT_SUPPORT]] 
 ** <dt>SQLITE_VTAB_CONSTRAINT_SUPPORT</dt>
 ** <dd>Calls of the form
 ** [sqlite3_vtab_config](db,SQLITE_VTAB_CONSTRAINT_SUPPORT,X) are supported,
@@ -9737,10 +9737,10 @@ SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *);
 ** column value will not change.  The virtual table implementation can use
 ** this hint as permission to substitute a return value that is less
 ** expensive to compute and that the corresponding
-** [xUpdate] method understands as a "no-change" value.
+** [xUpdate] method understands as a "no-change" value. 
 **
 ** If the [xColumn] method calls sqlite3_vtab_nochange() and finds that
-** the column is not changed by the UPDATE statement, then the xColumn
+** the column is not changed by the UPDATE statement, then the xColumn 
 ** method can optionally return without setting a result, without calling
 ** any of the [sqlite3_result_int|sqlite3_result_xxxxx() interfaces].
 ** In that case, [sqlite3_value_nochange(X)] will return true for the
@@ -10075,7 +10075,7 @@ typedef struct sqlite3_snapshot {
 
 /*
 ** CAPI3REF: Record A Database Snapshot
-** CONSTRUCTOR: sqlite3_snapshot
+** CONSTRUCTOR: sqlite3_snapshot 
 **
 ** ^The [sqlite3_snapshot_get(D,S,P)] interface attempts to make a
 ** new [sqlite3_snapshot] object that records the current state of
@@ -10091,7 +10091,7 @@ typedef struct sqlite3_snapshot {
 ** in this case.
 **
 ** <ul>
-**   <li> The database handle must not be in [autocommit mode].
+**   <li> The database handle must not be in [autocommit mode]. 
 **
 **   <li> Schema S of [database connection] D must be a [WAL mode] database.
 **
@@ -10114,7 +10114,7 @@ typedef struct sqlite3_snapshot {
 ** to avoid a memory leak.
 **
 ** The [sqlite3_snapshot_get()] interface is only available when the
-** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
+** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. 
 */
 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_get(
   sqlite3 *db,
@@ -10124,35 +10124,35 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_get(
 
 /*
 ** CAPI3REF: Start a read transaction on an historical snapshot
-** METHOD: sqlite3_snapshot
+** METHOD: sqlite3_snapshot 
 **
 ** ^The [sqlite3_snapshot_open(D,S,P)] interface either starts a new read
 ** transaction or upgrades an existing one for schema S of
 ** [database connection] D such that the read transaction refers to
 ** historical [snapshot] P, rather than the most recent change to the
 ** database. ^The [sqlite3_snapshot_open()] interface returns SQLITE_OK
-** on success or an appropriate [error code] if it fails.
+** on success or an appropriate [error code] if it fails. 
 **
 ** ^In order to succeed, the database connection must not be in
-** [autocommit mode] when [sqlite3_snapshot_open(D,S,P)] is called. If there
-** is already a read transaction open on schema S, then the database handle
-** must have no active statements (SELECT statements that have been passed
+** [autocommit mode] when [sqlite3_snapshot_open(D,S,P)] is called. If there 
+** is already a read transaction open on schema S, then the database handle 
+** must have no active statements (SELECT statements that have been passed 
 ** to sqlite3_step() but not sqlite3_reset() or sqlite3_finalize()).
-** SQLITE_ERROR is returned if either of these conditions is violated, or
-** if schema S does not exist, or if the snapshot object is invalid.
-**
-** ^A call to sqlite3_snapshot_open() will fail to open if the specified
+** SQLITE_ERROR is returned if either of these conditions is violated, or 
+** if schema S does not exist, or if the snapshot object is invalid. 
+** 
+** ^A call to sqlite3_snapshot_open() will fail to open if the specified 
 ** snapshot has been overwritten by a [checkpoint]. In this case
-** SQLITE_ERROR_SNAPSHOT is returned.
-**
+** SQLITE_ERROR_SNAPSHOT is returned. 
+** 
 ** If there is already a read transaction open when this function is
-** invoked, then the same read transaction remains open (on the same
-** database snapshot) if SQLITE_ERROR, SQLITE_BUSY or SQLITE_ERROR_SNAPSHOT
-** is returned. If another error code - for example SQLITE_PROTOCOL or an
-** SQLITE_IOERR error code - is returned, then the final state of the
+** invoked, then the same read transaction remains open (on the same 
+** database snapshot) if SQLITE_ERROR, SQLITE_BUSY or SQLITE_ERROR_SNAPSHOT 
+** is returned. If another error code - for example SQLITE_PROTOCOL or an 
+** SQLITE_IOERR error code - is returned, then the final state of the 
 ** read transaction is undefined. If SQLITE_OK is returned, then the
-** read transaction is now open on database snapshot P.
-**
+** read transaction is now open on database snapshot P. 
+** 
 ** ^(A call to [sqlite3_snapshot_open(D,S,P)] will fail if the
 ** database connection D does not know that the database file for
 ** schema S is in [WAL mode].  A database connection might not know
@@ -10163,7 +10163,7 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_get(
 ** database connection in order to make it ready to use snapshots.)
 **
 ** The [sqlite3_snapshot_open()] interface is only available when the
-** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
+** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. 
 */
 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_open(
   sqlite3 *db,
@@ -10173,20 +10173,20 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_open(
 
 /*
 ** CAPI3REF: Destroy a snapshot
-** DESTRUCTOR: sqlite3_snapshot
+** DESTRUCTOR: sqlite3_snapshot 
 **
 ** ^The [sqlite3_snapshot_free(P)] interface destroys [sqlite3_snapshot] P.
 ** The application must eventually free every [sqlite3_snapshot] object
 ** using this routine to avoid a memory leak.
 **
 ** The [sqlite3_snapshot_free()] interface is only available when the
-** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
+** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. 
 */
 SQLITE_API SQLITE_EXPERIMENTAL void sqlite3_snapshot_free(sqlite3_snapshot*);
 
 /*
 ** CAPI3REF: Compare the ages of two snapshot handles.
-** METHOD: sqlite3_snapshot
+** METHOD: sqlite3_snapshot 
 **
 ** The sqlite3_snapshot_cmp(P1, P2) interface is used to compare the ages
 ** of two valid snapshot handles.
@@ -10205,9 +10205,9 @@ SQLITE_API SQLITE_EXPERIMENTAL void sqlite3_snapshot_free(sqlite3_snapshot*);
 ** Otherwise, this API returns a negative value if P1 refers to an older
 ** snapshot than P2, zero if the two handles refer to the same database
 ** snapshot, and a positive value if P1 is a newer snapshot than P2.
-**
-** This interface is only available if SQLite is compiled with the
-** [SQLITE_ENABLE_SNAPSHOT] option.
+** 
+** This interface is only available if SQLite is compiled with the 
+** [SQLITE_ENABLE_SNAPSHOT] option. 
 */
 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_cmp(
   sqlite3_snapshot *p1,
@@ -10216,156 +10216,156 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_cmp(
 
 /*
 ** CAPI3REF: Recover snapshots from a wal file
-** METHOD: sqlite3_snapshot
+** METHOD: sqlite3_snapshot 
 **
-** If a [WAL file] remains on disk after all database connections close
-** (either through the use of the [SQLITE_FCNTL_PERSIST_WAL] [file control]
-** or because the last process to have the database opened exited without
-** calling [sqlite3_close()]) and a new connection is subsequently opened
-** on that database and [WAL file], the [sqlite3_snapshot_open()] interface
-** will only be able to open the last transaction added to the WAL file
-** even though the WAL file contains other valid transactions.
+** If a [WAL file] remains on disk after all database connections close 
+** (either through the use of the [SQLITE_FCNTL_PERSIST_WAL] [file control] 
+** or because the last process to have the database opened exited without 
+** calling [sqlite3_close()]) and a new connection is subsequently opened 
+** on that database and [WAL file], the [sqlite3_snapshot_open()] interface 
+** will only be able to open the last transaction added to the WAL file 
+** even though the WAL file contains other valid transactions. 
 **
-** This function attempts to scan the WAL file associated with database zDb
+** This function attempts to scan the WAL file associated with database zDb 
 ** of database handle db and make all valid snapshots available to
 ** sqlite3_snapshot_open(). It is an error if there is already a read
-** transaction open on the database, or if the database is not a WAL mode
+** transaction open on the database, or if the database is not a WAL mode 
 ** database.
 **
 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
-**
-** This interface is only available if SQLite is compiled with the
-** [SQLITE_ENABLE_SNAPSHOT] option.
+** 
+** This interface is only available if SQLite is compiled with the 
+** [SQLITE_ENABLE_SNAPSHOT] option. 
 */
 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb);
 
 /*
-** CAPI3REF: Serialize a database
-**
-** The sqlite3_serialize(D,S,P,F) interface returns a pointer to memory
-** that is a serialization of the S database on [database connection] D.
-** If P is not a NULL pointer, then the size of the database in bytes
-** is written into *P.
-**
-** For an ordinary on-disk database file, the serialization is just a
-** copy of the disk file.  For an in-memory database or a "TEMP" database,
-** the serialization is the same sequence of bytes which would be written
-** to disk if that database where backed up to disk.
-**
-** The usual case is that sqlite3_serialize() copies the serialization of
-** the database into memory obtained from [sqlite3_malloc64()] and returns
-** a pointer to that memory.  The caller is responsible for freeing the
-** returned value to avoid a memory leak.  However, if the F argument
-** contains the SQLITE_SERIALIZE_NOCOPY bit, then no memory allocations
-** are made, and the sqlite3_serialize() function will return a pointer
-** to the contiguous memory representation of the database that SQLite
-** is currently using for that database, or NULL if the no such contiguous
-** memory representation of the database exists.  A contiguous memory
-** representation of the database will usually only exist if there has
-** been a prior call to [sqlite3_deserialize(D,S,...)] with the same
-** values of D and S.
+** CAPI3REF: Serialize a database 
+** 
+** The sqlite3_serialize(D,S,P,F) interface returns a pointer to memory 
+** that is a serialization of the S database on [database connection] D. 
+** If P is not a NULL pointer, then the size of the database in bytes 
+** is written into *P. 
+** 
+** For an ordinary on-disk database file, the serialization is just a 
+** copy of the disk file.  For an in-memory database or a "TEMP" database, 
+** the serialization is the same sequence of bytes which would be written 
+** to disk if that database where backed up to disk. 
+** 
+** The usual case is that sqlite3_serialize() copies the serialization of 
+** the database into memory obtained from [sqlite3_malloc64()] and returns 
+** a pointer to that memory.  The caller is responsible for freeing the 
+** returned value to avoid a memory leak.  However, if the F argument 
+** contains the SQLITE_SERIALIZE_NOCOPY bit, then no memory allocations 
+** are made, and the sqlite3_serialize() function will return a pointer 
+** to the contiguous memory representation of the database that SQLite 
+** is currently using for that database, or NULL if the no such contiguous 
+** memory representation of the database exists.  A contiguous memory 
+** representation of the database will usually only exist if there has 
+** been a prior call to [sqlite3_deserialize(D,S,...)] with the same 
+** values of D and S. 
 ** The size of the database is written into *P even if the
-** SQLITE_SERIALIZE_NOCOPY bit is set but no contiguous copy
-** of the database exists.
-**
-** A call to sqlite3_serialize(D,S,P,F) might return NULL even if the
-** SQLITE_SERIALIZE_NOCOPY bit is omitted from argument F if a memory
-** allocation error occurs.
-**
+** SQLITE_SERIALIZE_NOCOPY bit is set but no contiguous copy 
+** of the database exists. 
+** 
+** A call to sqlite3_serialize(D,S,P,F) might return NULL even if the 
+** SQLITE_SERIALIZE_NOCOPY bit is omitted from argument F if a memory 
+** allocation error occurs. 
+** 
 ** This interface is omitted if SQLite is compiled with the
 ** [SQLITE_OMIT_DESERIALIZE] option.
-*/
-SQLITE_API unsigned char *sqlite3_serialize(
-  sqlite3 *db,           /* The database connection */
-  const char *zSchema,   /* Which DB to serialize. ex: "main", "temp", ... */
-  sqlite3_int64 *piSize, /* Write size of the DB here, if not NULL */
-  unsigned int mFlags    /* Zero or more SQLITE_SERIALIZE_* flags */
-);
-
-/*
-** CAPI3REF: Flags for sqlite3_serialize
-**
-** Zero or more of the following constants can be OR-ed together for
-** the F argument to [sqlite3_serialize(D,S,P,F)].
-**
-** SQLITE_SERIALIZE_NOCOPY means that [sqlite3_serialize()] will return
-** a pointer to contiguous in-memory database that it is currently using,
-** without making a copy of the database.  If SQLite is not currently using
-** a contiguous in-memory database, then this option causes
-** [sqlite3_serialize()] to return a NULL pointer.  SQLite will only be
-** using a contiguous in-memory database if it has been initialized by a
-** prior call to [sqlite3_deserialize()].
-*/
-#define SQLITE_SERIALIZE_NOCOPY 0x001   /* Do no memory allocations */
-
-/*
-** CAPI3REF: Deserialize a database
-**
+*/ 
+SQLITE_API unsigned char *sqlite3_serialize( 
+  sqlite3 *db,           /* The database connection */ 
+  const char *zSchema,   /* Which DB to serialize. ex: "main", "temp", ... */ 
+  sqlite3_int64 *piSize, /* Write size of the DB here, if not NULL */ 
+  unsigned int mFlags    /* Zero or more SQLITE_SERIALIZE_* flags */ 
+); 
+ 
+/* 
+** CAPI3REF: Flags for sqlite3_serialize 
+** 
+** Zero or more of the following constants can be OR-ed together for 
+** the F argument to [sqlite3_serialize(D,S,P,F)]. 
+** 
+** SQLITE_SERIALIZE_NOCOPY means that [sqlite3_serialize()] will return 
+** a pointer to contiguous in-memory database that it is currently using, 
+** without making a copy of the database.  If SQLite is not currently using 
+** a contiguous in-memory database, then this option causes 
+** [sqlite3_serialize()] to return a NULL pointer.  SQLite will only be 
+** using a contiguous in-memory database if it has been initialized by a 
+** prior call to [sqlite3_deserialize()]. 
+*/ 
+#define SQLITE_SERIALIZE_NOCOPY 0x001   /* Do no memory allocations */ 
+ 
+/* 
+** CAPI3REF: Deserialize a database 
+** 
 ** The sqlite3_deserialize(D,S,P,N,M,F) interface causes the
-** [database connection] D to disconnect from database S and then
-** reopen S as an in-memory database based on the serialization contained
-** in P.  The serialized database P is N bytes in size.  M is the size of
-** the buffer P, which might be larger than N.  If M is larger than N, and
-** the SQLITE_DESERIALIZE_READONLY bit is not set in F, then SQLite is
-** permitted to add content to the in-memory database as long as the total
-** size does not exceed M bytes.
-**
-** If the SQLITE_DESERIALIZE_FREEONCLOSE bit is set in F, then SQLite will
-** invoke sqlite3_free() on the serialization buffer when the database
-** connection closes.  If the SQLITE_DESERIALIZE_RESIZEABLE bit is set, then
-** SQLite will try to increase the buffer size using sqlite3_realloc64()
-** if writes on the database cause it to grow larger than M bytes.
-**
-** The sqlite3_deserialize() interface will fail with SQLITE_BUSY if the
-** database is currently in a read transaction or is involved in a backup
-** operation.
-**
+** [database connection] D to disconnect from database S and then 
+** reopen S as an in-memory database based on the serialization contained 
+** in P.  The serialized database P is N bytes in size.  M is the size of 
+** the buffer P, which might be larger than N.  If M is larger than N, and 
+** the SQLITE_DESERIALIZE_READONLY bit is not set in F, then SQLite is 
+** permitted to add content to the in-memory database as long as the total 
+** size does not exceed M bytes. 
+** 
+** If the SQLITE_DESERIALIZE_FREEONCLOSE bit is set in F, then SQLite will 
+** invoke sqlite3_free() on the serialization buffer when the database 
+** connection closes.  If the SQLITE_DESERIALIZE_RESIZEABLE bit is set, then 
+** SQLite will try to increase the buffer size using sqlite3_realloc64() 
+** if writes on the database cause it to grow larger than M bytes. 
+** 
+** The sqlite3_deserialize() interface will fail with SQLITE_BUSY if the 
+** database is currently in a read transaction or is involved in a backup 
+** operation. 
+** 
 ** It is not possible to deserialized into the TEMP database.  If the
 ** S argument to sqlite3_deserialize(D,S,P,N,M,F) is "temp" then the
 ** function returns SQLITE_ERROR.
 **
 ** If sqlite3_deserialize(D,S,P,N,M,F) fails for any reason and if the
-** SQLITE_DESERIALIZE_FREEONCLOSE bit is set in argument F, then
-** [sqlite3_free()] is invoked on argument P prior to returning.
-**
+** SQLITE_DESERIALIZE_FREEONCLOSE bit is set in argument F, then 
+** [sqlite3_free()] is invoked on argument P prior to returning. 
+** 
 ** This interface is omitted if SQLite is compiled with the
 ** [SQLITE_OMIT_DESERIALIZE] option.
-*/
-SQLITE_API int sqlite3_deserialize(
-  sqlite3 *db,            /* The database connection */
-  const char *zSchema,    /* Which DB to reopen with the deserialization */
-  unsigned char *pData,   /* The serialized database content */
-  sqlite3_int64 szDb,     /* Number bytes in the deserialization */
-  sqlite3_int64 szBuf,    /* Total size of buffer pData[] */
-  unsigned mFlags         /* Zero or more SQLITE_DESERIALIZE_* flags */
-);
-
-/*
-** CAPI3REF: Flags for sqlite3_deserialize()
-**
-** The following are allowed values for 6th argument (the F argument) to
-** the [sqlite3_deserialize(D,S,P,N,M,F)] interface.
-**
-** The SQLITE_DESERIALIZE_FREEONCLOSE means that the database serialization
-** in the P argument is held in memory obtained from [sqlite3_malloc64()]
-** and that SQLite should take ownership of this memory and automatically
-** free it when it has finished using it.  Without this flag, the caller
-** is responsible for freeing any dynamically allocated memory.
-**
-** The SQLITE_DESERIALIZE_RESIZEABLE flag means that SQLite is allowed to
-** grow the size of the database using calls to [sqlite3_realloc64()].  This
-** flag should only be used if SQLITE_DESERIALIZE_FREEONCLOSE is also used.
-** Without this flag, the deserialized database cannot increase in size beyond
-** the number of bytes specified by the M parameter.
-**
-** The SQLITE_DESERIALIZE_READONLY flag means that the deserialized database
-** should be treated as read-only.
-*/
-#define SQLITE_DESERIALIZE_FREEONCLOSE 1 /* Call sqlite3_free() on close */
-#define SQLITE_DESERIALIZE_RESIZEABLE  2 /* Resize using sqlite3_realloc64() */
-#define SQLITE_DESERIALIZE_READONLY    4 /* Database is read-only */
-
-/*
+*/ 
+SQLITE_API int sqlite3_deserialize( 
+  sqlite3 *db,            /* The database connection */ 
+  const char *zSchema,    /* Which DB to reopen with the deserialization */ 
+  unsigned char *pData,   /* The serialized database content */ 
+  sqlite3_int64 szDb,     /* Number bytes in the deserialization */ 
+  sqlite3_int64 szBuf,    /* Total size of buffer pData[] */ 
+  unsigned mFlags         /* Zero or more SQLITE_DESERIALIZE_* flags */ 
+); 
+ 
+/* 
+** CAPI3REF: Flags for sqlite3_deserialize() 
+** 
+** The following are allowed values for 6th argument (the F argument) to 
+** the [sqlite3_deserialize(D,S,P,N,M,F)] interface. 
+** 
+** The SQLITE_DESERIALIZE_FREEONCLOSE means that the database serialization 
+** in the P argument is held in memory obtained from [sqlite3_malloc64()] 
+** and that SQLite should take ownership of this memory and automatically 
+** free it when it has finished using it.  Without this flag, the caller 
+** is responsible for freeing any dynamically allocated memory. 
+** 
+** The SQLITE_DESERIALIZE_RESIZEABLE flag means that SQLite is allowed to 
+** grow the size of the database using calls to [sqlite3_realloc64()].  This 
+** flag should only be used if SQLITE_DESERIALIZE_FREEONCLOSE is also used. 
+** Without this flag, the deserialized database cannot increase in size beyond 
+** the number of bytes specified by the M parameter. 
+** 
+** The SQLITE_DESERIALIZE_READONLY flag means that the deserialized database 
+** should be treated as read-only. 
+*/ 
+#define SQLITE_DESERIALIZE_FREEONCLOSE 1 /* Call sqlite3_free() on close */ 
+#define SQLITE_DESERIALIZE_RESIZEABLE  2 /* Resize using sqlite3_realloc64() */ 
+#define SQLITE_DESERIALIZE_READONLY    4 /* Database is read-only */ 
+ 
+/* 
 ** Undo the hack that converts floating point types to integer for
 ** builds on processors without floating point support.
 */
@@ -10476,7 +10476,7 @@ struct sqlite3_rtree_query_info {
   sqlite3_int64 iRowid;             /* Rowid for current entry */
   sqlite3_rtree_dbl rParentScore;   /* Score of parent node */
   int eParentWithin;                /* Visibility of parent node */
-  int eWithin;                      /* OUT: Visibility */
+  int eWithin;                      /* OUT: Visibility */ 
   sqlite3_rtree_dbl rScore;         /* OUT: Write the score here */
   /* The following fields are only available in 3.8.11 and later */
   sqlite3_value **apSqlParam;       /* Original SQL values of parameters */
@@ -10512,23 +10512,23 @@ extern "C" {
 
 /*
 ** CAPI3REF: Session Object Handle
-**
-** An instance of this object is a [session] that can be used to
-** record changes to a database.
+** 
+** An instance of this object is a [session] that can be used to 
+** record changes to a database. 
 */
 typedef struct sqlite3_session sqlite3_session;
 
 /*
 ** CAPI3REF: Changeset Iterator Handle
-**
-** An instance of this object acts as a cursor for iterating
-** over the elements of a [changeset] or [patchset].
+** 
+** An instance of this object acts as a cursor for iterating 
+** over the elements of a [changeset] or [patchset]. 
 */
 typedef struct sqlite3_changeset_iter sqlite3_changeset_iter;
 
 /*
 ** CAPI3REF: Create A New Session Object
-** CONSTRUCTOR: sqlite3_session
+** CONSTRUCTOR: sqlite3_session 
 **
 ** Create a new session object attached to database handle db. If successful,
 ** a pointer to the new object is written to *ppSession and SQLITE_OK is
@@ -10565,7 +10565,7 @@ SQLITE_API int sqlite3session_create(
 
 /*
 ** CAPI3REF: Delete A Session Object
-** DESTRUCTOR: sqlite3_session
+** DESTRUCTOR: sqlite3_session 
 **
 ** Delete a session object previously allocated using
 ** [sqlite3session_create()]. Once a session object has been deleted, the
@@ -10613,7 +10613,7 @@ SQLITE_API int sqlite3session_object_config(sqlite3_session*, int op, void *pArg
 
 /*
 ** CAPI3REF: Enable Or Disable A Session Object
-** METHOD: sqlite3_session
+** METHOD: sqlite3_session 
 **
 ** Enable or disable the recording of changes by a session object. When
 ** enabled, a session object records changes made to the database. When
@@ -10633,7 +10633,7 @@ SQLITE_API int sqlite3session_enable(sqlite3_session *pSession, int bEnable);
 
 /*
 ** CAPI3REF: Set Or Clear the Indirect Change Flag
-** METHOD: sqlite3_session
+** METHOD: sqlite3_session 
 **
 ** Each change recorded by a session object is marked as either direct or
 ** indirect. A change is marked as indirect if either:
@@ -10663,7 +10663,7 @@ SQLITE_API int sqlite3session_indirect(sqlite3_session *pSession, int bIndirect)
 
 /*
 ** CAPI3REF: Attach A Table To A Session Object
-** METHOD: sqlite3_session
+** METHOD: sqlite3_session 
 **
 ** If argument zTab is not NULL, then it is the name of a table to attach
 ** to the session object passed as the first argument. All subsequent changes
@@ -10726,7 +10726,7 @@ SQLITE_API int sqlite3session_attach(
 
 /*
 ** CAPI3REF: Set a table filter on a Session Object.
-** METHOD: sqlite3_session
+** METHOD: sqlite3_session 
 **
 ** The second argument (xFilter) is the "filter callback". For changes to rows
 ** in tables that are not attached to the Session object, the filter is called
@@ -10745,7 +10745,7 @@ SQLITE_API void sqlite3session_table_filter(
 
 /*
 ** CAPI3REF: Generate A Changeset From A Session Object
-** METHOD: sqlite3_session
+** METHOD: sqlite3_session 
 **
 ** Obtain a changeset containing changes to the tables attached to the
 ** session object passed as the first argument. If successful,
@@ -10871,8 +10871,8 @@ SQLITE_API int sqlite3session_changeset(
 SQLITE_API sqlite3_int64 sqlite3session_changeset_size(sqlite3_session *pSession);
 
 /*
-** CAPI3REF: Load The Difference Between Tables Into A Session
-** METHOD: sqlite3_session
+** CAPI3REF: Load The Difference Between Tables Into A Session 
+** METHOD: sqlite3_session 
 **
 ** If it is not already attached to the session object passed as the first
 ** argument, this function attaches table zTbl in the same manner as the
@@ -10937,7 +10937,7 @@ SQLITE_API int sqlite3session_diff(
 
 /*
 ** CAPI3REF: Generate A Patchset From A Session Object
-** METHOD: sqlite3_session
+** METHOD: sqlite3_session 
 **
 ** The differences between a patchset and a changeset are that:
 **
@@ -10997,7 +10997,7 @@ SQLITE_API sqlite3_int64 sqlite3session_memory_used(sqlite3_session *pSession);
 
 /*
 ** CAPI3REF: Create An Iterator To Traverse A Changeset
-** CONSTRUCTOR: sqlite3_changeset_iter
+** CONSTRUCTOR: sqlite3_changeset_iter 
 **
 ** Create an iterator used to iterate through the contents of a changeset.
 ** If successful, *pp is set to point to the iterator handle and SQLITE_OK
@@ -11028,43 +11028,43 @@ SQLITE_API sqlite3_int64 sqlite3session_memory_used(sqlite3_session *pSession);
 ** consecutively. There is no chance that the iterator will visit a change
 ** the applies to table X, then one for table Y, and then later on visit
 ** another change for table X.
-**
-** The behavior of sqlite3changeset_start_v2() and its streaming equivalent
-** may be modified by passing a combination of
-** [SQLITE_CHANGESETSTART_INVERT | supported flags] as the 4th parameter.
-**
-** Note that the sqlite3changeset_start_v2() API is still <b>experimental</b>
-** and therefore subject to change.
+** 
+** The behavior of sqlite3changeset_start_v2() and its streaming equivalent 
+** may be modified by passing a combination of 
+** [SQLITE_CHANGESETSTART_INVERT | supported flags] as the 4th parameter. 
+** 
+** Note that the sqlite3changeset_start_v2() API is still <b>experimental</b> 
+** and therefore subject to change. 
 */
 SQLITE_API int sqlite3changeset_start(
   sqlite3_changeset_iter **pp,    /* OUT: New changeset iterator handle */
   int nChangeset,                 /* Size of changeset blob in bytes */
   void *pChangeset                /* Pointer to blob containing changeset */
 );
-SQLITE_API int sqlite3changeset_start_v2(
-  sqlite3_changeset_iter **pp,    /* OUT: New changeset iterator handle */
-  int nChangeset,                 /* Size of changeset blob in bytes */
-  void *pChangeset,               /* Pointer to blob containing changeset */
-  int flags                       /* SESSION_CHANGESETSTART_* flags */
-);
-
-/*
-** CAPI3REF: Flags for sqlite3changeset_start_v2
-**
-** The following flags may passed via the 4th parameter to
-** [sqlite3changeset_start_v2] and [sqlite3changeset_start_v2_strm]:
-**
-** <dt>SQLITE_CHANGESETAPPLY_INVERT <dd>
-**   Invert the changeset while iterating through it. This is equivalent to
-**   inverting a changeset using sqlite3changeset_invert() before applying it.
-**   It is an error to specify this flag with a patchset.
-*/
-#define SQLITE_CHANGESETSTART_INVERT        0x0002
-
-
+SQLITE_API int sqlite3changeset_start_v2( 
+  sqlite3_changeset_iter **pp,    /* OUT: New changeset iterator handle */ 
+  int nChangeset,                 /* Size of changeset blob in bytes */ 
+  void *pChangeset,               /* Pointer to blob containing changeset */ 
+  int flags                       /* SESSION_CHANGESETSTART_* flags */ 
+); 
+
+/* 
+** CAPI3REF: Flags for sqlite3changeset_start_v2 
+** 
+** The following flags may passed via the 4th parameter to 
+** [sqlite3changeset_start_v2] and [sqlite3changeset_start_v2_strm]: 
+** 
+** <dt>SQLITE_CHANGESETAPPLY_INVERT <dd> 
+**   Invert the changeset while iterating through it. This is equivalent to 
+**   inverting a changeset using sqlite3changeset_invert() before applying it. 
+**   It is an error to specify this flag with a patchset. 
+*/ 
+#define SQLITE_CHANGESETSTART_INVERT        0x0002 
+
+ 
 /*
 ** CAPI3REF: Advance A Changeset Iterator
-** METHOD: sqlite3_changeset_iter
+** METHOD: sqlite3_changeset_iter 
 **
 ** This function may only be used with iterators created by the function
 ** [sqlite3changeset_start()]. If it is called on an iterator passed to
@@ -11089,7 +11089,7 @@ SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *pIter);
 
 /*
 ** CAPI3REF: Obtain The Current Operation From A Changeset Iterator
-** METHOD: sqlite3_changeset_iter
+** METHOD: sqlite3_changeset_iter 
 **
 ** The pIter argument passed to this function may either be an iterator
 ** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator
@@ -11129,7 +11129,7 @@ SQLITE_API int sqlite3changeset_op(
 
 /*
 ** CAPI3REF: Obtain The Primary Key Definition Of A Table
-** METHOD: sqlite3_changeset_iter
+** METHOD: sqlite3_changeset_iter 
 **
 ** For each modified table, a changeset includes the following:
 **
@@ -11161,7 +11161,7 @@ SQLITE_API int sqlite3changeset_pk(
 
 /*
 ** CAPI3REF: Obtain old.* Values From A Changeset Iterator
-** METHOD: sqlite3_changeset_iter
+** METHOD: sqlite3_changeset_iter 
 **
 ** The pIter argument passed to this function may either be an iterator
 ** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator
@@ -11192,7 +11192,7 @@ SQLITE_API int sqlite3changeset_old(
 
 /*
 ** CAPI3REF: Obtain new.* Values From A Changeset Iterator
-** METHOD: sqlite3_changeset_iter
+** METHOD: sqlite3_changeset_iter 
 **
 ** The pIter argument passed to this function may either be an iterator
 ** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator
@@ -11226,7 +11226,7 @@ SQLITE_API int sqlite3changeset_new(
 
 /*
 ** CAPI3REF: Obtain Conflicting Row Values From A Changeset Iterator
-** METHOD: sqlite3_changeset_iter
+** METHOD: sqlite3_changeset_iter 
 **
 ** This function should only be used with iterator objects passed to a
 ** conflict-handler callback by [sqlite3changeset_apply()] with either
@@ -11254,7 +11254,7 @@ SQLITE_API int sqlite3changeset_conflict(
 
 /*
 ** CAPI3REF: Determine The Number Of Foreign Key Constraint Violations
-** METHOD: sqlite3_changeset_iter
+** METHOD: sqlite3_changeset_iter 
 **
 ** This function may only be called with an iterator passed to an
 ** SQLITE_CHANGESET_FOREIGN_KEY conflict handler callback. In this case
@@ -11271,7 +11271,7 @@ SQLITE_API int sqlite3changeset_fk_conflicts(
 
 /*
 ** CAPI3REF: Finalize A Changeset Iterator
-** METHOD: sqlite3_changeset_iter
+** METHOD: sqlite3_changeset_iter 
 **
 ** This function is used to finalize an iterator allocated with
 ** [sqlite3changeset_start()].
@@ -11288,7 +11288,7 @@ SQLITE_API int sqlite3changeset_fk_conflicts(
 ** to that error is returned by this function. Otherwise, SQLITE_OK is
 ** returned. This is to allow the following pattern (pseudo-code):
 **
-** <pre>
+** <pre> 
 **   sqlite3changeset_start();
 **   while( SQLITE_ROW==sqlite3changeset_next() ){
 **     // Do something with change.
@@ -11297,7 +11297,7 @@ SQLITE_API int sqlite3changeset_fk_conflicts(
 **   if( rc!=SQLITE_OK ){
 **     // An error has occurred
 **   }
-** </pre>
+** </pre> 
 */
 SQLITE_API int sqlite3changeset_finalize(sqlite3_changeset_iter *pIter);
 
@@ -11345,7 +11345,7 @@ SQLITE_API int sqlite3changeset_invert(
 ** sqlite3_changegroup object. Calling it produces similar results as the
 ** following code fragment:
 **
-** <pre>
+** <pre> 
 **   sqlite3_changegroup *pGrp;
 **   rc = sqlite3_changegroup_new(&pGrp);
 **   if( rc==SQLITE_OK ) rc = sqlite3changegroup_add(pGrp, nA, pA);
@@ -11356,7 +11356,7 @@ SQLITE_API int sqlite3changeset_invert(
 **     *ppOut = 0;
 **     *pnOut = 0;
 **   }
-** </pre>
+** </pre> 
 **
 ** Refer to the sqlite3_changegroup documentation below for details.
 */
@@ -11372,15 +11372,15 @@ SQLITE_API int sqlite3changeset_concat(
 
 /*
 ** CAPI3REF: Changegroup Handle
-**
+** 
 ** A changegroup is an object used to combine two or more
-** [changesets] or [patchsets]
+** [changesets] or [patchsets] 
 */
 typedef struct sqlite3_changegroup sqlite3_changegroup;
 
 /*
 ** CAPI3REF: Create A New Changegroup Object
-** CONSTRUCTOR: sqlite3_changegroup
+** CONSTRUCTOR: sqlite3_changegroup 
 **
 ** An sqlite3_changegroup object is used to combine two or more changesets
 ** (or patchsets) into a single changeset (or patchset). A single changegroup
@@ -11418,7 +11418,7 @@ SQLITE_API int sqlite3changegroup_new(sqlite3_changegroup **pp);
 
 /*
 ** CAPI3REF: Add A Changeset To A Changegroup
-** METHOD: sqlite3_changegroup
+** METHOD: sqlite3_changegroup 
 **
 ** Add all changes within the changeset (or patchset) in buffer pData (size
 ** nData bytes) to the changegroup.
@@ -11496,7 +11496,7 @@ SQLITE_API int sqlite3changegroup_add(sqlite3_changegroup*, int nData, void *pDa
 
 /*
 ** CAPI3REF: Obtain A Composite Changeset From A Changegroup
-** METHOD: sqlite3_changegroup
+** METHOD: sqlite3_changegroup 
 **
 ** Obtain a buffer containing a changeset (or patchset) representing the
 ** current contents of the changegroup. If the inputs to the changegroup
@@ -11527,25 +11527,25 @@ SQLITE_API int sqlite3changegroup_output(
 
 /*
 ** CAPI3REF: Delete A Changegroup Object
-** DESTRUCTOR: sqlite3_changegroup
+** DESTRUCTOR: sqlite3_changegroup 
 */
 SQLITE_API void sqlite3changegroup_delete(sqlite3_changegroup*);
 
 /*
 ** CAPI3REF: Apply A Changeset To A Database
 **
-** Apply a changeset or patchset to a database. These functions attempt to
-** update the "main" database attached to handle db with the changes found in
+** Apply a changeset or patchset to a database. These functions attempt to 
+** update the "main" database attached to handle db with the changes found in 
 ** the changeset passed via the second and third arguments.
 **
-** The fourth argument (xFilter) passed to these functions is the "filter
+** The fourth argument (xFilter) passed to these functions is the "filter 
 ** callback". If it is not NULL, then for each table affected by at least one
 ** change in the changeset, the filter callback is invoked with
 ** the table name as the second argument, and a copy of the context pointer
-** passed as the sixth argument as the first. If the "filter callback"
-** returns zero, then no attempt is made to apply any changes to the table.
-** Otherwise, if the return value is non-zero or the xFilter argument to
-** is NULL, all changes related to the table are attempted.
+** passed as the sixth argument as the first. If the "filter callback" 
+** returns zero, then no attempt is made to apply any changes to the table. 
+** Otherwise, if the return value is non-zero or the xFilter argument to 
+** is NULL, all changes related to the table are attempted. 
 **
 ** For each table that is not excluded by the filter callback, this function
 ** tests that the target database contains a compatible table. A table is
@@ -11666,28 +11666,28 @@ SQLITE_API void sqlite3changegroup_delete(sqlite3_changegroup*);
 ** This can be used to further customize the application's conflict
 ** resolution strategy.
 **
-** All changes made by these functions are enclosed in a savepoint transaction.
+** All changes made by these functions are enclosed in a savepoint transaction. 
 ** If any other error (aside from a constraint failure when attempting to
 ** write to the target database) occurs, then the savepoint transaction is
 ** rolled back, restoring the target database to its original state, and an
 ** SQLite error code returned.
-**
-** If the output parameters (ppRebase) and (pnRebase) are non-NULL and
-** the input is a changeset (not a patchset), then sqlite3changeset_apply_v2()
+** 
+** If the output parameters (ppRebase) and (pnRebase) are non-NULL and 
+** the input is a changeset (not a patchset), then sqlite3changeset_apply_v2() 
 ** may set (*ppRebase) to point to a "rebase" that may be used with the
-** sqlite3_rebaser APIs buffer before returning. In this case (*pnRebase)
-** is set to the size of the buffer in bytes. It is the responsibility of the
-** caller to eventually free any such buffer using sqlite3_free(). The buffer
-** is only allocated and populated if one or more conflicts were encountered
-** while applying the patchset. See comments surrounding the sqlite3_rebaser
-** APIs for further details.
-**
-** The behavior of sqlite3changeset_apply_v2() and its streaming equivalent
-** may be modified by passing a combination of
-** [SQLITE_CHANGESETAPPLY_NOSAVEPOINT | supported flags] as the 9th parameter.
-**
-** Note that the sqlite3changeset_apply_v2() API is still <b>experimental</b>
-** and therefore subject to change.
+** sqlite3_rebaser APIs buffer before returning. In this case (*pnRebase) 
+** is set to the size of the buffer in bytes. It is the responsibility of the 
+** caller to eventually free any such buffer using sqlite3_free(). The buffer 
+** is only allocated and populated if one or more conflicts were encountered 
+** while applying the patchset. See comments surrounding the sqlite3_rebaser 
+** APIs for further details. 
+** 
+** The behavior of sqlite3changeset_apply_v2() and its streaming equivalent 
+** may be modified by passing a combination of 
+** [SQLITE_CHANGESETAPPLY_NOSAVEPOINT | supported flags] as the 9th parameter. 
+** 
+** Note that the sqlite3changeset_apply_v2() API is still <b>experimental</b> 
+** and therefore subject to change. 
 */
 SQLITE_API int sqlite3changeset_apply(
   sqlite3 *db,                    /* Apply change to "main" db of this handle */
@@ -11704,48 +11704,48 @@ SQLITE_API int sqlite3changeset_apply(
   ),
   void *pCtx                      /* First argument passed to xConflict */
 );
-SQLITE_API int sqlite3changeset_apply_v2(
-  sqlite3 *db,                    /* Apply change to "main" db of this handle */
-  int nChangeset,                 /* Size of changeset in bytes */
-  void *pChangeset,               /* Changeset blob */
-  int(*xFilter)(
-    void *pCtx,                   /* Copy of sixth arg to _apply() */
-    const char *zTab              /* Table name */
-  ),
-  int(*xConflict)(
-    void *pCtx,                   /* Copy of sixth arg to _apply() */
-    int eConflict,                /* DATA, MISSING, CONFLICT, CONSTRAINT */
-    sqlite3_changeset_iter *p     /* Handle describing change and conflict */
-  ),
-  void *pCtx,                     /* First argument passed to xConflict */
-  void **ppRebase, int *pnRebase, /* OUT: Rebase data */
-  int flags                       /* SESSION_CHANGESETAPPLY_* flags */
-);
-
-/*
-** CAPI3REF: Flags for sqlite3changeset_apply_v2
-**
-** The following flags may passed via the 9th parameter to
-** [sqlite3changeset_apply_v2] and [sqlite3changeset_apply_v2_strm]:
-**
-** <dl>
-** <dt>SQLITE_CHANGESETAPPLY_NOSAVEPOINT <dd>
-**   Usually, the sessions module encloses all operations performed by
-**   a single call to apply_v2() or apply_v2_strm() in a [SAVEPOINT]. The
-**   SAVEPOINT is committed if the changeset or patchset is successfully
-**   applied, or rolled back if an error occurs. Specifying this flag
-**   causes the sessions module to omit this savepoint. In this case, if the
+SQLITE_API int sqlite3changeset_apply_v2( 
+  sqlite3 *db,                    /* Apply change to "main" db of this handle */ 
+  int nChangeset,                 /* Size of changeset in bytes */ 
+  void *pChangeset,               /* Changeset blob */ 
+  int(*xFilter)( 
+    void *pCtx,                   /* Copy of sixth arg to _apply() */ 
+    const char *zTab              /* Table name */ 
+  ), 
+  int(*xConflict)( 
+    void *pCtx,                   /* Copy of sixth arg to _apply() */ 
+    int eConflict,                /* DATA, MISSING, CONFLICT, CONSTRAINT */ 
+    sqlite3_changeset_iter *p     /* Handle describing change and conflict */ 
+  ), 
+  void *pCtx,                     /* First argument passed to xConflict */ 
+  void **ppRebase, int *pnRebase, /* OUT: Rebase data */ 
+  int flags                       /* SESSION_CHANGESETAPPLY_* flags */ 
+); 
+
+/* 
+** CAPI3REF: Flags for sqlite3changeset_apply_v2 
+** 
+** The following flags may passed via the 9th parameter to 
+** [sqlite3changeset_apply_v2] and [sqlite3changeset_apply_v2_strm]: 
+** 
+** <dl> 
+** <dt>SQLITE_CHANGESETAPPLY_NOSAVEPOINT <dd> 
+**   Usually, the sessions module encloses all operations performed by 
+**   a single call to apply_v2() or apply_v2_strm() in a [SAVEPOINT]. The 
+**   SAVEPOINT is committed if the changeset or patchset is successfully 
+**   applied, or rolled back if an error occurs. Specifying this flag 
+**   causes the sessions module to omit this savepoint. In this case, if the 
 **   caller has an open transaction or savepoint when apply_v2() is called,
-**   it may revert the partially applied changeset by rolling it back.
-**
-** <dt>SQLITE_CHANGESETAPPLY_INVERT <dd>
-**   Invert the changeset before applying it. This is equivalent to inverting
-**   a changeset using sqlite3changeset_invert() before applying it. It is
-**   an error to specify this flag with a patchset.
-*/
-#define SQLITE_CHANGESETAPPLY_NOSAVEPOINT   0x0001
-#define SQLITE_CHANGESETAPPLY_INVERT        0x0002
-
+**   it may revert the partially applied changeset by rolling it back. 
+** 
+** <dt>SQLITE_CHANGESETAPPLY_INVERT <dd> 
+**   Invert the changeset before applying it. This is equivalent to inverting 
+**   a changeset using sqlite3changeset_invert() before applying it. It is 
+**   an error to specify this flag with a patchset. 
+*/ 
+#define SQLITE_CHANGESETAPPLY_NOSAVEPOINT   0x0001 
+#define SQLITE_CHANGESETAPPLY_INVERT        0x0002 
+ 
 /*
 ** CAPI3REF: Constants Passed To The Conflict Handler
 **
@@ -11843,161 +11843,161 @@ SQLITE_API int sqlite3changeset_apply_v2(
 #define SQLITE_CHANGESET_ABORT      2
 
 /*
-** CAPI3REF: Rebasing changesets
-** EXPERIMENTAL
-**
-** Suppose there is a site hosting a database in state S0. And that
-** modifications are made that move that database to state S1 and a
-** changeset recorded (the "local" changeset). Then, a changeset based
+** CAPI3REF: Rebasing changesets 
+** EXPERIMENTAL 
+** 
+** Suppose there is a site hosting a database in state S0. And that 
+** modifications are made that move that database to state S1 and a 
+** changeset recorded (the "local" changeset). Then, a changeset based 
 ** on S0 is received from another site (the "remote" changeset) and
 ** applied to the database. The database is then in state
-** (S1+"remote"), where the exact state depends on any conflict
-** resolution decisions (OMIT or REPLACE) made while applying "remote".
+** (S1+"remote"), where the exact state depends on any conflict 
+** resolution decisions (OMIT or REPLACE) made while applying "remote". 
 ** Rebasing a changeset is to update it to take those conflict
-** resolution decisions into account, so that the same conflicts
+** resolution decisions into account, so that the same conflicts 
 ** do not have to be resolved elsewhere in the network.
-**
-** For example, if both the local and remote changesets contain an
-** INSERT of the same key on "CREATE TABLE t1(a PRIMARY KEY, b)":
-**
-**   local:  INSERT INTO t1 VALUES(1, 'v1');
-**   remote: INSERT INTO t1 VALUES(1, 'v2');
-**
-** and the conflict resolution is REPLACE, then the INSERT change is
-** removed from the local changeset (it was overridden). Or, if the
-** conflict resolution was "OMIT", then the local changeset is modified
-** to instead contain:
-**
-**           UPDATE t1 SET b = 'v2' WHERE a=1;
-**
-** Changes within the local changeset are rebased as follows:
-**
-** <dl>
-** <dt>Local INSERT<dd>
+** 
+** For example, if both the local and remote changesets contain an 
+** INSERT of the same key on "CREATE TABLE t1(a PRIMARY KEY, b)": 
+** 
+**   local:  INSERT INTO t1 VALUES(1, 'v1'); 
+**   remote: INSERT INTO t1 VALUES(1, 'v2'); 
+** 
+** and the conflict resolution is REPLACE, then the INSERT change is 
+** removed from the local changeset (it was overridden). Or, if the 
+** conflict resolution was "OMIT", then the local changeset is modified 
+** to instead contain: 
+** 
+**           UPDATE t1 SET b = 'v2' WHERE a=1; 
+** 
+** Changes within the local changeset are rebased as follows: 
+** 
+** <dl> 
+** <dt>Local INSERT<dd> 
 **   This may only conflict with a remote INSERT. If the conflict
-**   resolution was OMIT, then add an UPDATE change to the rebased
-**   changeset. Or, if the conflict resolution was REPLACE, add
-**   nothing to the rebased changeset.
-**
-** <dt>Local DELETE<dd>
-**   This may conflict with a remote UPDATE or DELETE. In both cases the
-**   only possible resolution is OMIT. If the remote operation was a
-**   DELETE, then add no change to the rebased changeset. If the remote
-**   operation was an UPDATE, then the old.* fields of change are updated
-**   to reflect the new.* values in the UPDATE.
-**
-** <dt>Local UPDATE<dd>
-**   This may conflict with a remote UPDATE or DELETE. If it conflicts
-**   with a DELETE, and the conflict resolution was OMIT, then the update
-**   is changed into an INSERT. Any undefined values in the new.* record
-**   from the update change are filled in using the old.* values from
-**   the conflicting DELETE. Or, if the conflict resolution was REPLACE,
-**   the UPDATE change is simply omitted from the rebased changeset.
-**
-**   If conflict is with a remote UPDATE and the resolution is OMIT, then
-**   the old.* values are rebased using the new.* values in the remote
-**   change. Or, if the resolution is REPLACE, then the change is copied
-**   into the rebased changeset with updates to columns also updated by
+**   resolution was OMIT, then add an UPDATE change to the rebased 
+**   changeset. Or, if the conflict resolution was REPLACE, add 
+**   nothing to the rebased changeset. 
+** 
+** <dt>Local DELETE<dd> 
+**   This may conflict with a remote UPDATE or DELETE. In both cases the 
+**   only possible resolution is OMIT. If the remote operation was a 
+**   DELETE, then add no change to the rebased changeset. If the remote 
+**   operation was an UPDATE, then the old.* fields of change are updated 
+**   to reflect the new.* values in the UPDATE. 
+** 
+** <dt>Local UPDATE<dd> 
+**   This may conflict with a remote UPDATE or DELETE. If it conflicts 
+**   with a DELETE, and the conflict resolution was OMIT, then the update 
+**   is changed into an INSERT. Any undefined values in the new.* record 
+**   from the update change are filled in using the old.* values from 
+**   the conflicting DELETE. Or, if the conflict resolution was REPLACE, 
+**   the UPDATE change is simply omitted from the rebased changeset. 
+** 
+**   If conflict is with a remote UPDATE and the resolution is OMIT, then 
+**   the old.* values are rebased using the new.* values in the remote 
+**   change. Or, if the resolution is REPLACE, then the change is copied 
+**   into the rebased changeset with updates to columns also updated by 
 **   the conflicting remote UPDATE removed. If this means no columns would
-**   be updated, the change is omitted.
-** </dl>
-**
+**   be updated, the change is omitted. 
+** </dl> 
+** 
 ** A local change may be rebased against multiple remote changes
 ** simultaneously. If a single key is modified by multiple remote
-** changesets, they are combined as follows before the local changeset
-** is rebased:
-**
-** <ul>
-**    <li> If there has been one or more REPLACE resolutions on a
-**         key, it is rebased according to a REPLACE.
-**
-**    <li> If there have been no REPLACE resolutions on a key, then
-**         the local changeset is rebased according to the most recent
-**         of the OMIT resolutions.
-** </ul>
-**
+** changesets, they are combined as follows before the local changeset 
+** is rebased: 
+** 
+** <ul> 
+**    <li> If there has been one or more REPLACE resolutions on a 
+**         key, it is rebased according to a REPLACE. 
+** 
+**    <li> If there have been no REPLACE resolutions on a key, then 
+**         the local changeset is rebased according to the most recent 
+**         of the OMIT resolutions. 
+** </ul> 
+** 
 ** Note that conflict resolutions from multiple remote changesets are
 ** combined on a per-field basis, not per-row. This means that in the
 ** case of multiple remote UPDATE operations, some fields of a single
 ** local change may be rebased for REPLACE while others are rebased for
-** OMIT.
-**
-** In order to rebase a local changeset, the remote changeset must first
-** be applied to the local database using sqlite3changeset_apply_v2() and
-** the buffer of rebase information captured. Then:
-**
-** <ol>
+** OMIT. 
+** 
+** In order to rebase a local changeset, the remote changeset must first 
+** be applied to the local database using sqlite3changeset_apply_v2() and 
+** the buffer of rebase information captured. Then: 
+** 
+** <ol> 
 **   <li> An sqlite3_rebaser object is created by calling
-**        sqlite3rebaser_create().
-**   <li> The new object is configured with the rebase buffer obtained from
-**        sqlite3changeset_apply_v2() by calling sqlite3rebaser_configure().
-**        If the local changeset is to be rebased against multiple remote
-**        changesets, then sqlite3rebaser_configure() should be called
-**        multiple times, in the same order that the multiple
-**        sqlite3changeset_apply_v2() calls were made.
-**   <li> Each local changeset is rebased by calling sqlite3rebaser_rebase().
-**   <li> The sqlite3_rebaser object is deleted by calling
-**        sqlite3rebaser_delete().
-** </ol>
-*/
-typedef struct sqlite3_rebaser sqlite3_rebaser;
-
-/*
-** CAPI3REF: Create a changeset rebaser object.
-** EXPERIMENTAL
-**
-** Allocate a new changeset rebaser object. If successful, set (*ppNew) to
-** point to the new object and return SQLITE_OK. Otherwise, if an error
+**        sqlite3rebaser_create(). 
+**   <li> The new object is configured with the rebase buffer obtained from 
+**        sqlite3changeset_apply_v2() by calling sqlite3rebaser_configure(). 
+**        If the local changeset is to be rebased against multiple remote 
+**        changesets, then sqlite3rebaser_configure() should be called 
+**        multiple times, in the same order that the multiple 
+**        sqlite3changeset_apply_v2() calls were made. 
+**   <li> Each local changeset is rebased by calling sqlite3rebaser_rebase(). 
+**   <li> The sqlite3_rebaser object is deleted by calling 
+**        sqlite3rebaser_delete(). 
+** </ol> 
+*/ 
+typedef struct sqlite3_rebaser sqlite3_rebaser; 
+ 
+/*
+** CAPI3REF: Create a changeset rebaser object. 
+** EXPERIMENTAL 
+** 
+** Allocate a new changeset rebaser object. If successful, set (*ppNew) to 
+** point to the new object and return SQLITE_OK. Otherwise, if an error 
 ** occurs, return an SQLite error code (e.g. SQLITE_NOMEM) and set (*ppNew)
 ** to NULL.
-*/
-SQLITE_API int sqlite3rebaser_create(sqlite3_rebaser **ppNew);
-
-/*
-** CAPI3REF: Configure a changeset rebaser object.
-** EXPERIMENTAL
-**
-** Configure the changeset rebaser object to rebase changesets according
-** to the conflict resolutions described by buffer pRebase (size nRebase
-** bytes), which must have been obtained from a previous call to
-** sqlite3changeset_apply_v2().
-*/
-SQLITE_API int sqlite3rebaser_configure(
+*/ 
+SQLITE_API int sqlite3rebaser_create(sqlite3_rebaser **ppNew); 
+ 
+/* 
+** CAPI3REF: Configure a changeset rebaser object. 
+** EXPERIMENTAL 
+** 
+** Configure the changeset rebaser object to rebase changesets according 
+** to the conflict resolutions described by buffer pRebase (size nRebase 
+** bytes), which must have been obtained from a previous call to 
+** sqlite3changeset_apply_v2(). 
+*/ 
+SQLITE_API int sqlite3rebaser_configure( 
   sqlite3_rebaser*,
-  int nRebase, const void *pRebase
+  int nRebase, const void *pRebase 
 );
-
-/*
-** CAPI3REF: Rebase a changeset
-** EXPERIMENTAL
-**
-** Argument pIn must point to a buffer containing a changeset nIn bytes
-** in size. This function allocates and populates a buffer with a copy
+ 
+/* 
+** CAPI3REF: Rebase a changeset 
+** EXPERIMENTAL 
+** 
+** Argument pIn must point to a buffer containing a changeset nIn bytes 
+** in size. This function allocates and populates a buffer with a copy 
 ** of the changeset rebased according to the configuration of the
-** rebaser object passed as the first argument. If successful, (*ppOut)
+** rebaser object passed as the first argument. If successful, (*ppOut) 
 ** is set to point to the new buffer containing the rebased changeset and
-** (*pnOut) to its size in bytes and SQLITE_OK returned. It is the
-** responsibility of the caller to eventually free the new buffer using
-** sqlite3_free(). Otherwise, if an error occurs, (*ppOut) and (*pnOut)
-** are set to zero and an SQLite error code returned.
-*/
-SQLITE_API int sqlite3rebaser_rebase(
-  sqlite3_rebaser*,
+** (*pnOut) to its size in bytes and SQLITE_OK returned. It is the 
+** responsibility of the caller to eventually free the new buffer using 
+** sqlite3_free(). Otherwise, if an error occurs, (*ppOut) and (*pnOut) 
+** are set to zero and an SQLite error code returned. 
+*/ 
+SQLITE_API int sqlite3rebaser_rebase( 
+  sqlite3_rebaser*, 
   int nIn, const void *pIn,
   int *pnOut, void **ppOut
-);
-
-/*
-** CAPI3REF: Delete a changeset rebaser object.
-** EXPERIMENTAL
-**
-** Delete the changeset rebaser object and all associated resources. There
-** should be one call to this function for each successful invocation
-** of sqlite3rebaser_create().
-*/
+); 
+ 
+/* 
+** CAPI3REF: Delete a changeset rebaser object. 
+** EXPERIMENTAL 
+** 
+** Delete the changeset rebaser object and all associated resources. There 
+** should be one call to this function for each successful invocation 
+** of sqlite3rebaser_create(). 
+*/ 
 SQLITE_API void sqlite3rebaser_delete(sqlite3_rebaser *p);
-
-/*
+ 
+/* 
 ** CAPI3REF: Streaming Versions of API functions.
 **
 ** The six streaming API xxx_strm() functions serve similar purposes to the
@@ -12102,23 +12102,23 @@ SQLITE_API int sqlite3changeset_apply_strm(
   ),
   void *pCtx                      /* First argument passed to xConflict */
 );
-SQLITE_API int sqlite3changeset_apply_v2_strm(
-  sqlite3 *db,                    /* Apply change to "main" db of this handle */
-  int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */
-  void *pIn,                                          /* First arg for xInput */
-  int(*xFilter)(
-    void *pCtx,                   /* Copy of sixth arg to _apply() */
-    const char *zTab              /* Table name */
-  ),
-  int(*xConflict)(
-    void *pCtx,                   /* Copy of sixth arg to _apply() */
-    int eConflict,                /* DATA, MISSING, CONFLICT, CONSTRAINT */
-    sqlite3_changeset_iter *p     /* Handle describing change and conflict */
-  ),
-  void *pCtx,                     /* First argument passed to xConflict */
-  void **ppRebase, int *pnRebase,
-  int flags
-);
+SQLITE_API int sqlite3changeset_apply_v2_strm( 
+  sqlite3 *db,                    /* Apply change to "main" db of this handle */ 
+  int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */ 
+  void *pIn,                                          /* First arg for xInput */ 
+  int(*xFilter)( 
+    void *pCtx,                   /* Copy of sixth arg to _apply() */ 
+    const char *zTab              /* Table name */ 
+  ), 
+  int(*xConflict)( 
+    void *pCtx,                   /* Copy of sixth arg to _apply() */ 
+    int eConflict,                /* DATA, MISSING, CONFLICT, CONSTRAINT */ 
+    sqlite3_changeset_iter *p     /* Handle describing change and conflict */ 
+  ), 
+  void *pCtx,                     /* First argument passed to xConflict */ 
+  void **ppRebase, int *pnRebase, 
+  int flags 
+); 
 SQLITE_API int sqlite3changeset_concat_strm(
   int (*xInputA)(void *pIn, void *pData, int *pnData),
   void *pInA,
@@ -12138,12 +12138,12 @@ SQLITE_API int sqlite3changeset_start_strm(
   int (*xInput)(void *pIn, void *pData, int *pnData),
   void *pIn
 );
-SQLITE_API int sqlite3changeset_start_v2_strm(
-  sqlite3_changeset_iter **pp,
-  int (*xInput)(void *pIn, void *pData, int *pnData),
-  void *pIn,
-  int flags
-);
+SQLITE_API int sqlite3changeset_start_v2_strm( 
+  sqlite3_changeset_iter **pp, 
+  int (*xInput)(void *pIn, void *pData, int *pnData), 
+  void *pIn, 
+  int flags 
+); 
 SQLITE_API int sqlite3session_changeset_strm(
   sqlite3_session *pSession,
   int (*xOutput)(void *pOut, const void *pData, int nData),
@@ -12162,55 +12162,55 @@ SQLITE_API int sqlite3changegroup_output_strm(sqlite3_changegroup*,
     int (*xOutput)(void *pOut, const void *pData, int nData),
     void *pOut
 );
-SQLITE_API int sqlite3rebaser_rebase_strm(
-  sqlite3_rebaser *pRebaser,
-  int (*xInput)(void *pIn, void *pData, int *pnData),
-  void *pIn,
-  int (*xOutput)(void *pOut, const void *pData, int nData),
-  void *pOut
-);
-
-/*
-** CAPI3REF: Configure global parameters
-**
-** The sqlite3session_config() interface is used to make global configuration
+SQLITE_API int sqlite3rebaser_rebase_strm( 
+  sqlite3_rebaser *pRebaser, 
+  int (*xInput)(void *pIn, void *pData, int *pnData), 
+  void *pIn, 
+  int (*xOutput)(void *pOut, const void *pData, int nData), 
+  void *pOut 
+); 
+
+/* 
+** CAPI3REF: Configure global parameters 
+** 
+** The sqlite3session_config() interface is used to make global configuration 
 ** changes to the sessions module in order to tune it to the specific needs
-** of the application.
-**
-** The sqlite3session_config() interface is not threadsafe. If it is invoked
-** while any other thread is inside any other sessions method then the
-** results are undefined. Furthermore, if it is invoked after any sessions
+** of the application. 
+** 
+** The sqlite3session_config() interface is not threadsafe. If it is invoked 
+** while any other thread is inside any other sessions method then the 
+** results are undefined. Furthermore, if it is invoked after any sessions 
 ** related objects have been created, the results are also undefined.
-**
-** The first argument to the sqlite3session_config() function must be one
+** 
+** The first argument to the sqlite3session_config() function must be one 
 ** of the SQLITE_SESSION_CONFIG_XXX constants defined below. The
-** interpretation of the (void*) value passed as the second parameter and
-** the effect of calling this function depends on the value of the first
-** parameter.
-**
-** <dl>
-** <dt>SQLITE_SESSION_CONFIG_STRMSIZE<dd>
-**    By default, the sessions module streaming interfaces attempt to input
-**    and output data in approximately 1 KiB chunks. This operand may be used
-**    to set and query the value of this configuration setting. The pointer
-**    passed as the second argument must point to a value of type (int).
-**    If this value is greater than 0, it is used as the new streaming data
-**    chunk size for both input and output. Before returning, the (int) value
-**    pointed to by pArg is set to the final value of the streaming interface
-**    chunk size.
-** </dl>
-**
-** This function returns SQLITE_OK if successful, or an SQLite error code
-** otherwise.
-*/
-SQLITE_API int sqlite3session_config(int op, void *pArg);
-
-/*
-** CAPI3REF: Values for sqlite3session_config().
-*/
-#define SQLITE_SESSION_CONFIG_STRMSIZE 1
-
-/*
+** interpretation of the (void*) value passed as the second parameter and 
+** the effect of calling this function depends on the value of the first 
+** parameter. 
+** 
+** <dl> 
+** <dt>SQLITE_SESSION_CONFIG_STRMSIZE<dd> 
+**    By default, the sessions module streaming interfaces attempt to input 
+**    and output data in approximately 1 KiB chunks. This operand may be used 
+**    to set and query the value of this configuration setting. The pointer 
+**    passed as the second argument must point to a value of type (int). 
+**    If this value is greater than 0, it is used as the new streaming data 
+**    chunk size for both input and output. Before returning, the (int) value 
+**    pointed to by pArg is set to the final value of the streaming interface 
+**    chunk size. 
+** </dl> 
+** 
+** This function returns SQLITE_OK if successful, or an SQLite error code 
+** otherwise. 
+*/ 
+SQLITE_API int sqlite3session_config(int op, void *pArg); 
+
+/*
+** CAPI3REF: Values for sqlite3session_config(). 
+*/ 
+#define SQLITE_SESSION_CONFIG_STRMSIZE 1 
+ 
+/* 
 ** Make sure we can call this stuff from C++.
 */
 #if 0
@@ -12342,8 +12342,8 @@ struct Fts5PhraseIter {
 **
 **   Usually, output parameter *piPhrase is set to the phrase number, *piCol
 **   to the column in which it occurs and *piOff the token offset of the
-**   first token of the phrase. Returns SQLITE_OK if successful, or an error
-**   code (i.e. SQLITE_NOMEM) if an error occurs.
+**   first token of the phrase. Returns SQLITE_OK if successful, or an error 
+**   code (i.e. SQLITE_NOMEM) if an error occurs. 
 **
 **   This API can be quite slow if used with an FTS5 table created with the
 **   "detail=none" or "detail=column" option.
@@ -12384,7 +12384,7 @@ struct Fts5PhraseIter {
 **   Save the pointer passed as the second argument as the extension function's
 **   "auxiliary data". The pointer may then be retrieved by the current or any
 **   future invocation of the same fts5 extension function made as part of
-**   the same MATCH query using the xGetAuxdata() API.
+**   the same MATCH query using the xGetAuxdata() API. 
 **
 **   Each extension function is allocated a single auxiliary data slot for
 **   each FTS query (MATCH expression). If the extension function is invoked
@@ -12399,7 +12399,7 @@ struct Fts5PhraseIter {
 **   The xDelete callback, if one is specified, is also invoked on the
 **   auxiliary data pointer after the FTS5 query has finished.
 **
-**   If an error (e.g. an OOM condition) occurs within this function,
+**   If an error (e.g. an OOM condition) occurs within this function, 
 **   the auxiliary data is set to NULL and an error code returned. If the
 **   xDelete parameter was not NULL, it is invoked on the auxiliary data
 **   pointer before returning.
@@ -12632,11 +12632,11 @@ struct Fts5ExtensionApi {
 **            the tokenizer substitutes "first" for "1st" and the query works
 **            as expected.
 **
-**       <li> By querying the index for all synonyms of each query term
-**            separately. In this case, when tokenizing query text, the
+**       <li> By querying the index for all synonyms of each query term 
+**            separately. In this case, when tokenizing query text, the 
 **            tokenizer may provide multiple synonyms for a single term
 **            within the document. FTS5 then queries the index for each
-**            synonym individually. For example, faced with the query:
+**            synonym individually. For example, faced with the query: 
 **
 **   <codeblock>
 **     ... MATCH 'first place'</codeblock>
@@ -12660,9 +12660,9 @@ struct Fts5ExtensionApi {
 **            "place".
 **
 **            This way, even if the tokenizer does not provide synonyms
-**            when tokenizing query text (it should not - to do so would be
+**            when tokenizing query text (it should not - to do so would be 
 **            inefficient), it doesn't matter if the user queries for
-**            'first + place' or '1st + place', as there are entries in the
+**            'first + place' or '1st + place', as there are entries in the 
 **            FTS index corresponding to both forms of the first token.
 **   </ol>
 **
@@ -12690,7 +12690,7 @@ struct Fts5ExtensionApi {
 **   extra data to the FTS index or require FTS5 to query for multiple terms,
 **   so it is efficient in terms of disk space and query speed. However, it
 **   does not support prefix queries very well. If, as suggested above, the
-**   token "first" is substituted for "1st" by the tokenizer, then the query:
+**   token "first" is substituted for "1st" by the tokenizer, then the query: 
 **
 **   <codeblock>
 **     ... MATCH '1s*'</codeblock>
@@ -13457,7 +13457,7 @@ struct Hash {
   unsigned int count;       /* Number of entries in this table */
   HashElem *first;          /* The first element of the array */
   struct _ht {              /* the hash table */
-    unsigned int count;        /* Number of entries with this hash */
+    unsigned int count;        /* Number of entries with this hash */ 
     HashElem *chain;           /* Pointer to first entry with this hash */
   } *ht;
 };
@@ -13571,27 +13571,27 @@ SQLITE_PRIVATE void sqlite3HashClear(Hash*);
 #define TK_ESCAPE                          58
 #define TK_ID                              59
 #define TK_COLUMNKW                        60
-#define TK_DO                              61
-#define TK_FOR                             62
-#define TK_IGNORE                          63
-#define TK_INITIALLY                       64
-#define TK_INSTEAD                         65
-#define TK_NO                              66
-#define TK_KEY                             67
-#define TK_OF                              68
-#define TK_OFFSET                          69
-#define TK_PRAGMA                          70
-#define TK_RAISE                           71
-#define TK_RECURSIVE                       72
-#define TK_REPLACE                         73
-#define TK_RESTRICT                        74
-#define TK_ROW                             75
-#define TK_ROWS                            76
-#define TK_TRIGGER                         77
-#define TK_VACUUM                          78
-#define TK_VIEW                            79
-#define TK_VIRTUAL                         80
-#define TK_WITH                            81
+#define TK_DO                              61 
+#define TK_FOR                             62 
+#define TK_IGNORE                          63 
+#define TK_INITIALLY                       64 
+#define TK_INSTEAD                         65 
+#define TK_NO                              66 
+#define TK_KEY                             67 
+#define TK_OF                              68 
+#define TK_OFFSET                          69 
+#define TK_PRAGMA                          70 
+#define TK_RAISE                           71 
+#define TK_RECURSIVE                       72 
+#define TK_REPLACE                         73 
+#define TK_RESTRICT                        74 
+#define TK_ROW                             75 
+#define TK_ROWS                            76 
+#define TK_TRIGGER                         77 
+#define TK_VACUUM                          78 
+#define TK_VIEW                            79 
+#define TK_VIRTUAL                         80 
+#define TK_WITH                            81 
 #define TK_NULLS                           82
 #define TK_FIRST                           83
 #define TK_LAST                            84
@@ -13807,13 +13807,13 @@ SQLITE_PRIVATE void sqlite3HashClear(Hash*);
 #endif
 
 /*
-** Default value for the SQLITE_CONFIG_SORTERREF_SIZE option.
-*/
-#ifndef SQLITE_DEFAULT_SORTERREF_SIZE
-# define SQLITE_DEFAULT_SORTERREF_SIZE 0x7fffffff
-#endif
-
-/*
+** Default value for the SQLITE_CONFIG_SORTERREF_SIZE option. 
+*/ 
+#ifndef SQLITE_DEFAULT_SORTERREF_SIZE 
+# define SQLITE_DEFAULT_SORTERREF_SIZE 0x7fffffff 
+#endif 
+ 
+/* 
 ** The compile-time options SQLITE_MMAP_READWRITE and
 ** SQLITE_ENABLE_BATCH_ATOMIC_WRITE are not compatible with one another.
 ** You must choose one or the other (or neither) but not both.
@@ -13960,9 +13960,9 @@ typedef INT16_TYPE LogEst;
 # if defined(__SIZEOF_POINTER__)
 #   define SQLITE_PTRSIZE __SIZEOF_POINTER__
 # elif defined(i386)     || defined(__i386__)   || defined(_M_IX86) ||    \
-       defined(_M_ARM)   || defined(__arm__)    || defined(__x86)   ||    \
+       defined(_M_ARM)   || defined(__arm__)    || defined(__x86)   ||    \ 
       (defined(__APPLE__) && defined(__POWERPC__)) ||                     \
-      (defined(__TOS_AIX__) && !defined(__64BIT__))
+      (defined(__TOS_AIX__) && !defined(__64BIT__)) 
 #   define SQLITE_PTRSIZE 4
 # else
 #   define SQLITE_PTRSIZE 8
@@ -14000,13 +14000,13 @@ typedef INT16_TYPE LogEst;
 ** at run-time.
 */
 #ifndef SQLITE_BYTEORDER
-# if defined(i386)      || defined(__i386__)      || defined(_M_IX86) ||    \
-     defined(__x86_64)  || defined(__x86_64__)    || defined(_M_X64)  ||    \
-     defined(_M_AMD64)  || defined(_M_ARM)        || defined(__x86)   ||    \
-     defined(__ARMEL__) || defined(__AARCH64EL__) || defined(_M_ARM64)
+# if defined(i386)      || defined(__i386__)      || defined(_M_IX86) ||    \ 
+     defined(__x86_64)  || defined(__x86_64__)    || defined(_M_X64)  ||    \ 
+     defined(_M_AMD64)  || defined(_M_ARM)        || defined(__x86)   ||    \ 
+     defined(__ARMEL__) || defined(__AARCH64EL__) || defined(_M_ARM64) 
 #   define SQLITE_BYTEORDER    1234
-# elif defined(sparc)     || defined(__ppc__) || \
-       defined(__ARMEB__) || defined(__AARCH64EB__)
+# elif defined(sparc)     || defined(__ppc__) || \ 
+       defined(__ARMEB__) || defined(__AARCH64EB__) 
 #   define SQLITE_BYTEORDER    4321
 # else
 #   define SQLITE_BYTEORDER 0
@@ -14149,9 +14149,9 @@ SQLITE_PRIVATE u32 sqlite3WhereTrace;
 */
 typedef struct BusyHandler BusyHandler;
 struct BusyHandler {
-  int (*xBusyHandler)(void *,int);  /* The busy callback */
-  void *pBusyArg;                   /* First arg to busy callback */
-  int nBusy;                        /* Incremented with each busy call */
+  int (*xBusyHandler)(void *,int);  /* The busy callback */ 
+  void *pBusyArg;                   /* First arg to busy callback */ 
+  int nBusy;                        /* Incremented with each busy call */ 
 };
 
 /*
@@ -14287,7 +14287,7 @@ typedef struct Parse Parse;
 typedef struct ParseCleanup ParseCleanup;
 typedef struct PreUpdate PreUpdate;
 typedef struct PrintfArguments PrintfArguments;
-typedef struct RenameToken RenameToken;
+typedef struct RenameToken RenameToken; 
 typedef struct Returning Returning;
 typedef struct RowSet RowSet;
 typedef struct Savepoint Savepoint;
@@ -14296,7 +14296,7 @@ typedef struct SQLiteThread SQLiteThread;
 typedef struct SelectDest SelectDest;
 typedef struct SrcItem SrcItem;
 typedef struct SrcList SrcList;
-typedef struct sqlite3_str StrAccum; /* Internal alias for sqlite3_str */
+typedef struct sqlite3_str StrAccum; /* Internal alias for sqlite3_str */ 
 typedef struct Table Table;
 typedef struct TableLock TableLock;
 typedef struct Token Token;
@@ -14305,41 +14305,41 @@ typedef struct Trigger Trigger;
 typedef struct TriggerPrg TriggerPrg;
 typedef struct TriggerStep TriggerStep;
 typedef struct UnpackedRecord UnpackedRecord;
-typedef struct Upsert Upsert;
+typedef struct Upsert Upsert; 
 typedef struct VTable VTable;
 typedef struct VtabCtx VtabCtx;
 typedef struct Walker Walker;
 typedef struct WhereInfo WhereInfo;
-typedef struct Window Window;
+typedef struct Window Window; 
 typedef struct With With;
 
-
-/*
-** The bitmask datatype defined below is used for various optimizations.
-**
-** Changing this from a 64-bit to a 32-bit type limits the number of
-** tables in a join to 32 instead of 64.  But it also reduces the size
-** of the library by 738 bytes on ix86.
-*/
-#ifdef SQLITE_BITMASK_TYPE
-  typedef SQLITE_BITMASK_TYPE Bitmask;
-#else
-  typedef u64 Bitmask;
-#endif
-
-/*
-** The number of bits in a Bitmask.  "BMS" means "BitMask Size".
-*/
-#define BMS  ((int)(sizeof(Bitmask)*8))
-
-/*
-** A bit in a Bitmask
-*/
-#define MASKBIT(n)   (((Bitmask)1)<<(n))
+ 
+/* 
+** The bitmask datatype defined below is used for various optimizations. 
+** 
+** Changing this from a 64-bit to a 32-bit type limits the number of 
+** tables in a join to 32 instead of 64.  But it also reduces the size 
+** of the library by 738 bytes on ix86. 
+*/ 
+#ifdef SQLITE_BITMASK_TYPE 
+  typedef SQLITE_BITMASK_TYPE Bitmask; 
+#else 
+  typedef u64 Bitmask; 
+#endif 
+ 
+/* 
+** The number of bits in a Bitmask.  "BMS" means "BitMask Size". 
+*/ 
+#define BMS  ((int)(sizeof(Bitmask)*8)) 
+ 
+/* 
+** A bit in a Bitmask 
+*/ 
+#define MASKBIT(n)   (((Bitmask)1)<<(n)) 
 #define MASKBIT64(n) (((u64)1)<<(n))
-#define MASKBIT32(n) (((unsigned int)1)<<(n))
-#define ALLBITS      ((Bitmask)-1)
-
+#define MASKBIT32(n) (((unsigned int)1)<<(n)) 
+#define ALLBITS      ((Bitmask)-1) 
+ 
 /* A VList object records a mapping between parameters/variables/wildcards
 ** in the SQL statement (such as $abc, @pqr, or :xyz) and the integer
 ** variable number associated with that parameter.  See the format description
@@ -14682,7 +14682,7 @@ SQLITE_PRIVATE int sqlite3BtreeGetRequestedReserve(Btree*);
 SQLITE_PRIVATE int sqlite3BtreeGetReserveNoMutex(Btree *p);
 SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum(Btree *, int);
 SQLITE_PRIVATE int sqlite3BtreeGetAutoVacuum(Btree *);
-SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree*,int,int*);
+SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree*,int,int*); 
 SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree*, const char*);
 SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree*, int);
 SQLITE_PRIVATE int sqlite3BtreeCommit(Btree*);
@@ -14876,29 +14876,29 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*, u8 flags);
 ** entry in either an index or table btree.
 **
 ** Index btrees (used for indexes and also WITHOUT ROWID tables) contain
-** an arbitrary key and no data.  These btrees have pKey,nKey set to the
-** key and the pData,nData,nZero fields are uninitialized.  The aMem,nMem
-** fields give an array of Mem objects that are a decomposition of the key.
-** The nMem field might be zero, indicating that no decomposition is available.
+** an arbitrary key and no data.  These btrees have pKey,nKey set to the 
+** key and the pData,nData,nZero fields are uninitialized.  The aMem,nMem 
+** fields give an array of Mem objects that are a decomposition of the key. 
+** The nMem field might be zero, indicating that no decomposition is available. 
 **
 ** Table btrees (used for rowid tables) contain an integer rowid used as
 ** the key and passed in the nKey field.  The pKey field is zero.
 ** pData,nData hold the content of the new entry.  nZero extra zero bytes
 ** are appended to the end of the content when constructing the entry.
-** The aMem,nMem fields are uninitialized for table btrees.
-**
-** Field usage summary:
-**
-**               Table BTrees                   Index Btrees
-**
-**   pKey        always NULL                    encoded key
-**   nKey        the ROWID                      length of pKey
-**   pData       data                           not used
-**   aMem        not used                       decomposed key value
-**   nMem        not used                       entries in aMem
-**   nData       length of pData                not used
-**   nZero       extra zeros after pData        not used
-**
+** The aMem,nMem fields are uninitialized for table btrees. 
+**
+** Field usage summary: 
+** 
+**               Table BTrees                   Index Btrees 
+** 
+**   pKey        always NULL                    encoded key 
+**   nKey        the ROWID                      length of pKey 
+**   pData       data                           not used 
+**   aMem        not used                       decomposed key value 
+**   nMem        not used                       entries in aMem 
+**   nData       length of pData                not used 
+**   nZero       extra zeros after pData        not used 
+** 
 ** This object is used to pass information into sqlite3BtreeInsert().  The
 ** same information used to be passed as five separate parameters.  But placing
 ** the information into this object helps to keep the interface more
@@ -14908,7 +14908,7 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*, u8 flags);
 struct BtreePayload {
   const void *pKey;       /* Key content for indexes.  NULL for tables */
   sqlite3_int64 nKey;     /* Size of pKey for indexes.  PRIMARY KEY for tabs */
-  const void *pData;      /* Data for tables. */
+  const void *pData;      /* Data for tables. */ 
   sqlite3_value *aMem;    /* First of nMem value in the unpacked pKey */
   u16 nMem;               /* Number of aMem[] value.  Might be zero */
   int nData;              /* Size of pData.  0 if none. */
@@ -14931,7 +14931,7 @@ SQLITE_PRIVATE i64 sqlite3BtreeOffset(BtCursor*);
 SQLITE_PRIVATE int sqlite3BtreePayload(BtCursor*, u32 offset, u32 amt, void*);
 SQLITE_PRIVATE const void *sqlite3BtreePayloadFetch(BtCursor*, u32 *pAmt);
 SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor*);
-SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeMaxRecordSize(BtCursor*);
+SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeMaxRecordSize(BtCursor*); 
 
 SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(sqlite3*,Btree*,Pgno*aRoot,int nRoot,int,int*);
 SQLITE_PRIVATE struct Pager *sqlite3BtreePager(Btree*);
@@ -15094,8 +15094,8 @@ struct VdbeOp {
   u64 cycles;              /* Total time spent executing this instruction */
 #endif
 #ifdef SQLITE_VDBE_COVERAGE
-  u32 iSrcLine;            /* Source-code line that generated this opcode
-                           ** with flags in the upper 8 bits */
+  u32 iSrcLine;            /* Source-code line that generated this opcode 
+                           ** with flags in the upper 8 bits */ 
 #endif
 };
 typedef struct VdbeOp VdbeOp;
@@ -15177,11 +15177,11 @@ typedef struct VdbeOpList VdbeOpList;
 #endif
 
 /*
-** The following macro converts a label returned by sqlite3VdbeMakeLabel()
-** into an index into the Parse.aLabel[] array that contains the resolved
-** address of that label.
+** The following macro converts a label returned by sqlite3VdbeMakeLabel() 
+** into an index into the Parse.aLabel[] array that contains the resolved 
+** address of that label. 
 */
-#define ADDR(X)  (~(X))
+#define ADDR(X)  (~(X)) 
 
 /*
 ** The makefile scans the vdbe.c source file and creates the "opcodes.h"
@@ -15195,23 +15195,23 @@ typedef struct VdbeOpList VdbeOpList;
 #define OP_AutoCommit      1
 #define OP_Transaction     2
 #define OP_SorterNext      3 /* jump                                       */
-#define OP_Prev            4 /* jump                                       */
-#define OP_Next            5 /* jump                                       */
-#define OP_Checkpoint      6
-#define OP_JournalMode     7
-#define OP_Vacuum          8
-#define OP_VFilter         9 /* jump, synopsis: iplan=r[P3] zplan='P4'     */
-#define OP_VUpdate        10 /* synopsis: data=r[P3@P2]                    */
-#define OP_Goto           11 /* jump                                       */
-#define OP_Gosub          12 /* jump                                       */
-#define OP_InitCoroutine  13 /* jump                                       */
-#define OP_Yield          14 /* jump                                       */
-#define OP_MustBeInt      15 /* jump                                       */
-#define OP_Jump           16 /* jump                                       */
-#define OP_Once           17 /* jump                                       */
-#define OP_If             18 /* jump                                       */
+#define OP_Prev            4 /* jump                                       */ 
+#define OP_Next            5 /* jump                                       */ 
+#define OP_Checkpoint      6 
+#define OP_JournalMode     7 
+#define OP_Vacuum          8 
+#define OP_VFilter         9 /* jump, synopsis: iplan=r[P3] zplan='P4'     */ 
+#define OP_VUpdate        10 /* synopsis: data=r[P3@P2]                    */ 
+#define OP_Goto           11 /* jump                                       */ 
+#define OP_Gosub          12 /* jump                                       */ 
+#define OP_InitCoroutine  13 /* jump                                       */ 
+#define OP_Yield          14 /* jump                                       */ 
+#define OP_MustBeInt      15 /* jump                                       */ 
+#define OP_Jump           16 /* jump                                       */ 
+#define OP_Once           17 /* jump                                       */ 
+#define OP_If             18 /* jump                                       */ 
 #define OP_Not            19 /* same as TK_NOT, synopsis: r[P2]= !r[P1]    */
-#define OP_IfNot          20 /* jump                                       */
+#define OP_IfNot          20 /* jump                                       */ 
 #define OP_IsNullOrType   21 /* jump, synopsis: if typeof(r[P1]) IN (P3,5) goto P2 */
 #define OP_IfNullRow      22 /* jump, synopsis: if P1.nullRow then r[P3]=NULL, goto P2 */
 #define OP_SeekLT         23 /* jump, synopsis: key=r[P3@P4]               */
@@ -15385,8 +15385,8 @@ typedef struct VdbeOpList VdbeOpList;
 #define OPFLG_OUT2        0x10  /* out2:  P2 is an output */
 #define OPFLG_OUT3        0x20  /* out3:  P3 is an output */
 #define OPFLG_INITIALIZER {\
-/*   0 */ 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x10,\
-/*   8 */ 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x03, 0x03,\
+/*   0 */ 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x10,\ 
+/*   8 */ 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x03, 0x03,\ 
 /*  16 */ 0x01, 0x01, 0x03, 0x12, 0x03, 0x03, 0x01, 0x09,\
 /*  24 */ 0x09, 0x09, 0x09, 0x01, 0x09, 0x09, 0x09, 0x09,\
 /*  32 */ 0x09, 0x09, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,\
@@ -15451,30 +15451,30 @@ SQLITE_PRIVATE   void sqlite3VdbeVerifyNoResultRow(Vdbe *p);
 # define sqlite3VdbeVerifyNoMallocRequired(A,B)
 # define sqlite3VdbeVerifyNoResultRow(A)
 #endif
-#if defined(SQLITE_DEBUG)
-SQLITE_PRIVATE   void sqlite3VdbeVerifyAbortable(Vdbe *p, int);
-#else
-# define sqlite3VdbeVerifyAbortable(A,B)
-#endif
-SQLITE_PRIVATE VdbeOp *sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp,int iLineno);
-#ifndef SQLITE_OMIT_EXPLAIN
-SQLITE_PRIVATE   void sqlite3VdbeExplain(Parse*,u8,const char*,...);
-SQLITE_PRIVATE   void sqlite3VdbeExplainPop(Parse*);
-SQLITE_PRIVATE   int sqlite3VdbeExplainParent(Parse*);
-# define ExplainQueryPlan(P)        sqlite3VdbeExplain P
-# define ExplainQueryPlanPop(P)     sqlite3VdbeExplainPop(P)
-# define ExplainQueryPlanParent(P)  sqlite3VdbeExplainParent(P)
-#else
-# define ExplainQueryPlan(P)
-# define ExplainQueryPlanPop(P)
-# define ExplainQueryPlanParent(P) 0
-# define sqlite3ExplainBreakpoint(A,B) /*no-op*/
-#endif
-#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_EXPLAIN)
-SQLITE_PRIVATE   void sqlite3ExplainBreakpoint(const char*,const char*);
-#else
-# define sqlite3ExplainBreakpoint(A,B) /*no-op*/
-#endif
+#if defined(SQLITE_DEBUG) 
+SQLITE_PRIVATE   void sqlite3VdbeVerifyAbortable(Vdbe *p, int); 
+#else 
+# define sqlite3VdbeVerifyAbortable(A,B) 
+#endif 
+SQLITE_PRIVATE VdbeOp *sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp,int iLineno); 
+#ifndef SQLITE_OMIT_EXPLAIN 
+SQLITE_PRIVATE   void sqlite3VdbeExplain(Parse*,u8,const char*,...); 
+SQLITE_PRIVATE   void sqlite3VdbeExplainPop(Parse*); 
+SQLITE_PRIVATE   int sqlite3VdbeExplainParent(Parse*); 
+# define ExplainQueryPlan(P)        sqlite3VdbeExplain P 
+# define ExplainQueryPlanPop(P)     sqlite3VdbeExplainPop(P) 
+# define ExplainQueryPlanParent(P)  sqlite3VdbeExplainParent(P) 
+#else 
+# define ExplainQueryPlan(P) 
+# define ExplainQueryPlanPop(P) 
+# define ExplainQueryPlanParent(P) 0 
+# define sqlite3ExplainBreakpoint(A,B) /*no-op*/ 
+#endif 
+#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_EXPLAIN) 
+SQLITE_PRIVATE   void sqlite3ExplainBreakpoint(const char*,const char*); 
+#else 
+# define sqlite3ExplainBreakpoint(A,B) /*no-op*/ 
+#endif 
 SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe*, int, char*, u16);
 SQLITE_PRIVATE void sqlite3VdbeChangeOpcode(Vdbe*, int addr, u8);
 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, int addr, int P1);
@@ -15495,7 +15495,7 @@ SQLITE_PRIVATE void sqlite3VdbeAppendP4(Vdbe*, void *pP4, int p4type);
 SQLITE_PRIVATE void sqlite3VdbeSetP4KeyInfo(Parse*, Index*);
 SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe*, int);
 SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe*, int);
-SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Parse*);
+SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Parse*); 
 SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce(Vdbe*);
 SQLITE_PRIVATE void sqlite3VdbeReusable(Vdbe*);
 SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe*);
@@ -15516,10 +15516,10 @@ SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe*);
 SQLITE_PRIVATE sqlite3 *sqlite3VdbeDb(Vdbe*);
 SQLITE_PRIVATE u8 sqlite3VdbePrepareFlags(Vdbe*);
 SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, u8);
-#ifdef SQLITE_ENABLE_NORMALIZE
-SQLITE_PRIVATE void sqlite3VdbeAddDblquoteStr(sqlite3*,Vdbe*,const char*);
-SQLITE_PRIVATE int sqlite3VdbeUsesDoubleQuotedString(Vdbe*,const char*);
-#endif
+#ifdef SQLITE_ENABLE_NORMALIZE 
+SQLITE_PRIVATE void sqlite3VdbeAddDblquoteStr(sqlite3*,Vdbe*,const char*); 
+SQLITE_PRIVATE int sqlite3VdbeUsesDoubleQuotedString(Vdbe*,const char*); 
+#endif 
 SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe*,Vdbe*);
 SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe*, int*, int*);
 SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe*, int, u8);
@@ -15528,7 +15528,7 @@ SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe*, int);
 SQLITE_PRIVATE   char *sqlite3VdbeExpandSql(Vdbe*, const char*);
 #endif
 SQLITE_PRIVATE int sqlite3MemCompare(const Mem*, const Mem*, const CollSeq*);
-SQLITE_PRIVATE int sqlite3BlobCompare(const Mem*, const Mem*);
+SQLITE_PRIVATE int sqlite3BlobCompare(const Mem*, const Mem*); 
 
 SQLITE_PRIVATE void sqlite3VdbeRecordUnpack(KeyInfo*,int,const void*,UnpackedRecord*);
 SQLITE_PRIVATE int sqlite3VdbeRecordCompare(int,const void*,UnpackedRecord*);
@@ -15586,52 +15586,52 @@ SQLITE_PRIVATE   void sqlite3VdbeNoopComment(Vdbe*, const char*, ...);
 **
 **    VdbeCoverageNeverTaken(v)        // Previous branch is never taken
 **
-**    VdbeCoverageNeverNull(v)         // Previous three-way branch is only
-**                                     // taken on the first two ways.  The
-**                                     // NULL option is not possible
-**
-**    VdbeCoverageEqNe(v)              // Previous OP_Jump is only interested
-**                                     // in distingishing equal and not-equal.
-**
+**    VdbeCoverageNeverNull(v)         // Previous three-way branch is only 
+**                                     // taken on the first two ways.  The 
+**                                     // NULL option is not possible 
+** 
+**    VdbeCoverageEqNe(v)              // Previous OP_Jump is only interested 
+**                                     // in distingishing equal and not-equal. 
+** 
 ** Every VDBE branch operation must be tagged with one of the macros above.
 ** If not, then when "make test" is run with -DSQLITE_VDBE_COVERAGE and
 ** -DSQLITE_DEBUG then an ALWAYS() will fail in the vdbeTakeBranch()
 ** routine in vdbe.c, alerting the developer to the missed tag.
-**
-** During testing, the test application will invoke
-** sqlite3_test_control(SQLITE_TESTCTRL_VDBE_COVERAGE,...) to set a callback
-** routine that is invoked as each bytecode branch is taken.  The callback
-** contains the sqlite3.c source line number ov the VdbeCoverage macro and
-** flags to indicate whether or not the branch was taken.  The test application
-** is responsible for keeping track of this and reporting byte-code branches
-** that are never taken.
-**
-** See the VdbeBranchTaken() macro and vdbeTakeBranch() function in the
-** vdbe.c source file for additional information.
+** 
+** During testing, the test application will invoke 
+** sqlite3_test_control(SQLITE_TESTCTRL_VDBE_COVERAGE,...) to set a callback 
+** routine that is invoked as each bytecode branch is taken.  The callback 
+** contains the sqlite3.c source line number ov the VdbeCoverage macro and 
+** flags to indicate whether or not the branch was taken.  The test application 
+** is responsible for keeping track of this and reporting byte-code branches 
+** that are never taken. 
+** 
+** See the VdbeBranchTaken() macro and vdbeTakeBranch() function in the 
+** vdbe.c source file for additional information. 
 */
 #ifdef SQLITE_VDBE_COVERAGE
 SQLITE_PRIVATE   void sqlite3VdbeSetLineNumber(Vdbe*,int);
 # define VdbeCoverage(v) sqlite3VdbeSetLineNumber(v,__LINE__)
 # define VdbeCoverageIf(v,x) if(x)sqlite3VdbeSetLineNumber(v,__LINE__)
-# define VdbeCoverageAlwaysTaken(v) \
-         sqlite3VdbeSetLineNumber(v,__LINE__|0x5000000);
-# define VdbeCoverageNeverTaken(v) \
-         sqlite3VdbeSetLineNumber(v,__LINE__|0x6000000);
-# define VdbeCoverageNeverNull(v) \
-         sqlite3VdbeSetLineNumber(v,__LINE__|0x4000000);
-# define VdbeCoverageNeverNullIf(v,x) \
-         if(x)sqlite3VdbeSetLineNumber(v,__LINE__|0x4000000);
-# define VdbeCoverageEqNe(v) \
-         sqlite3VdbeSetLineNumber(v,__LINE__|0x8000000);
+# define VdbeCoverageAlwaysTaken(v) \ 
+         sqlite3VdbeSetLineNumber(v,__LINE__|0x5000000); 
+# define VdbeCoverageNeverTaken(v) \ 
+         sqlite3VdbeSetLineNumber(v,__LINE__|0x6000000); 
+# define VdbeCoverageNeverNull(v) \ 
+         sqlite3VdbeSetLineNumber(v,__LINE__|0x4000000); 
+# define VdbeCoverageNeverNullIf(v,x) \ 
+         if(x)sqlite3VdbeSetLineNumber(v,__LINE__|0x4000000); 
+# define VdbeCoverageEqNe(v) \ 
+         sqlite3VdbeSetLineNumber(v,__LINE__|0x8000000); 
 # define VDBE_OFFSET_LINENO(x) (__LINE__+x)
 #else
 # define VdbeCoverage(v)
 # define VdbeCoverageIf(v,x)
 # define VdbeCoverageAlwaysTaken(v)
 # define VdbeCoverageNeverTaken(v)
-# define VdbeCoverageNeverNull(v)
-# define VdbeCoverageNeverNullIf(v,x)
-# define VdbeCoverageEqNe(v)
+# define VdbeCoverageNeverNull(v) 
+# define VdbeCoverageNeverNullIf(v,x) 
+# define VdbeCoverageEqNe(v) 
 # define VDBE_OFFSET_LINENO(x) 0
 #endif
 
@@ -15641,10 +15641,10 @@ SQLITE_PRIVATE void sqlite3VdbeScanStatus(Vdbe*, int, int, int, LogEst, const ch
 # define sqlite3VdbeScanStatus(a,b,c,d,e)
 #endif
 
-#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
-SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE*, int, VdbeOp*);
-#endif
-
+#if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) 
+SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE*, int, VdbeOp*); 
+#endif 
+ 
 #endif /* SQLITE_VDBE_H */
 
 /************** End of vdbe.h ************************************************/
@@ -15836,10 +15836,10 @@ SQLITE_PRIVATE int sqlite3HeaderSizePcache1(void);
 /* Number of dirty pages as a percentage of the configured cache size */
 SQLITE_PRIVATE int sqlite3PCachePercentDirty(PCache*);
 
-#ifdef SQLITE_DIRECT_OVERFLOW_READ
-SQLITE_PRIVATE int sqlite3PCacheIsDirty(PCache *pCache);
-#endif
-
+#ifdef SQLITE_DIRECT_OVERFLOW_READ 
+SQLITE_PRIVATE int sqlite3PCacheIsDirty(PCache *pCache); 
+#endif 
+ 
 #endif /* _PCACHE_H_ */
 
 /************** End of pcache.h **********************************************/
@@ -16394,14 +16394,14 @@ struct LookasideSlot {
 ** functions use a regular table table from hash.h.)
 **
 ** Hash each FuncDef structure into one of the FuncDefHash.a[] slots.
-** Collisions are on the FuncDef.u.pHash chain.  Use the SQLITE_FUNC_HASH()
-** macro to compute a hash on the function name.
+** Collisions are on the FuncDef.u.pHash chain.  Use the SQLITE_FUNC_HASH() 
+** macro to compute a hash on the function name. 
 */
 #define SQLITE_FUNC_HASH_SZ 23
 struct FuncDefHash {
   FuncDef *a[SQLITE_FUNC_HASH_SZ];       /* Hash table for functions */
 };
-#define SQLITE_FUNC_HASH(C,L) (((C)+(L))%SQLITE_FUNC_HASH_SZ)
+#define SQLITE_FUNC_HASH(C,L) (((C)+(L))%SQLITE_FUNC_HASH_SZ) 
 
 #ifdef SQLITE_USER_AUTHENTICATION
 /*
@@ -16445,13 +16445,13 @@ SQLITE_PRIVATE void sqlite3CryptFunc(sqlite3_context*,int,sqlite3_value**);
 /* This is an extra SQLITE_TRACE macro that indicates "legacy" tracing
 ** in the style of sqlite3_trace()
 */
-#define SQLITE_TRACE_LEGACY          0x40     /* Use the legacy xTrace */
-#define SQLITE_TRACE_XPROFILE        0x80     /* Use the legacy xProfile */
+#define SQLITE_TRACE_LEGACY          0x40     /* Use the legacy xTrace */ 
+#define SQLITE_TRACE_XPROFILE        0x80     /* Use the legacy xProfile */ 
 #else
-#define SQLITE_TRACE_LEGACY          0
-#define SQLITE_TRACE_XPROFILE        0
+#define SQLITE_TRACE_LEGACY          0 
+#define SQLITE_TRACE_XPROFILE        0 
 #endif /* SQLITE_OMIT_DEPRECATED */
-#define SQLITE_TRACE_NONLEGACY_MASK  0x0f     /* Normal flags */
+#define SQLITE_TRACE_NONLEGACY_MASK  0x0f     /* Normal flags */ 
 
 /*
 ** Maximum number of sqlite3.aDb[] entries.  This is the number of attached
@@ -16470,7 +16470,7 @@ struct sqlite3 {
   Db *aDb;                      /* All backends */
   int nDb;                      /* Number of backends currently in use */
   u32 mDbFlags;                 /* flags recording internal state */
-  u64 flags;                    /* flags settable by pragmas. See below */
+  u64 flags;                    /* flags settable by pragmas. See below */ 
   i64 lastRowid;                /* ROWID of most recent insert (see above) */
   i64 szMmap;                   /* Default mmap_size setting */
   u32 nSchemaLock;              /* Do not reset the schema when non-zero */
@@ -16490,7 +16490,7 @@ struct sqlite3 {
   u8 vtabOnConflict;            /* Value to return for s3_vtab_on_conflict() */
   u8 isTransactionSavepoint;    /* True if the outermost savepoint is a TS */
   u8 mTrace;                    /* zero or more SQLITE_TRACE flags */
-  u8 noSharedCache;             /* True if no shared-cache backends */
+  u8 noSharedCache;             /* True if no shared-cache backends */ 
   u8 nSqlExec;                  /* Number of pending OP_SqlExec opcodes */
   u8 eOpenState;                /* Current condition of the connection */
   int nextPagesize;             /* Pagesize after VACUUM if >0 */
@@ -16502,9 +16502,9 @@ struct sqlite3 {
     Pgno newTnum;               /* Rootpage of table being initialized */
     u8 iDb;                     /* Which db file is being initialized */
     u8 busy;                    /* TRUE if currently initializing */
-    unsigned orphanTrigger : 1; /* Last statement is orphaned TEMP trigger */
-    unsigned imposterTable : 1; /* Building an imposter table */
-    unsigned reopenMemdb : 1;   /* ATTACH is really a reopen using MemDB */
+    unsigned orphanTrigger : 1; /* Last statement is orphaned TEMP trigger */ 
+    unsigned imposterTable : 1; /* Building an imposter table */ 
+    unsigned reopenMemdb : 1;   /* ATTACH is really a reopen using MemDB */ 
     const char **azInit;        /* "type", "name", and "tbl_name" columns */
   } init;
   int nVdbeActive;              /* Number of VDBEs currently running */
@@ -16519,10 +16519,10 @@ struct sqlite3 {
     int (*xV2)(u32,void*,void*,void*);    /* All other mTrace values */
   } trace;
   void *pTraceArg;                        /* Argument to the trace function */
-#ifndef SQLITE_OMIT_DEPRECATED
+#ifndef SQLITE_OMIT_DEPRECATED 
   void (*xProfile)(void*,const char*,u64);  /* Profiling function */
   void *pProfileArg;                        /* Argument to profile function */
-#endif
+#endif 
   void *pCommitArg;                 /* Argument to xCommitCallback() */
   int (*xCommitCallback)(void*);    /* Invoked at every commit. */
   void *pRollbackArg;               /* Argument to xRollbackCallback() */
@@ -16532,7 +16532,7 @@ struct sqlite3 {
   void *pAutovacPagesArg;           /* Client argument to autovac_pages */
   void (*xAutovacDestr)(void*);     /* Destructor for pAutovacPAgesArg */
   unsigned int (*xAutovacPages)(void*,const char*,u32,u32,u32);
-  Parse *pParse;                /* Current parse */
+  Parse *pParse;                /* Current parse */ 
 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
   void *pPreUpdateArg;          /* First argument to xPreUpdateCallback */
   void (*xPreUpdateCallback)(   /* Registered using sqlite3_preupdate_hook() */
@@ -16651,12 +16651,12 @@ struct sqlite3 {
 #define SQLITE_Fts3Tokenizer  0x00400000  /* Enable fts3_tokenizer(2) */
 #define SQLITE_EnableQPSG     0x00800000  /* Query Planner Stability Guarantee*/
 #define SQLITE_TriggerEQP     0x01000000  /* Show trigger EXPLAIN QUERY PLAN */
-#define SQLITE_ResetDatabase  0x02000000  /* Reset the database */
-#define SQLITE_LegacyAlter    0x04000000  /* Legacy ALTER TABLE behaviour */
-#define SQLITE_NoSchemaError  0x08000000  /* Do not report schema parse errors*/
-#define SQLITE_Defensive      0x10000000  /* Input SQL is likely hostile */
-#define SQLITE_DqsDDL         0x20000000  /* dbl-quoted strings allowed in DDL*/
-#define SQLITE_DqsDML         0x40000000  /* dbl-quoted strings allowed in DML*/
+#define SQLITE_ResetDatabase  0x02000000  /* Reset the database */ 
+#define SQLITE_LegacyAlter    0x04000000  /* Legacy ALTER TABLE behaviour */ 
+#define SQLITE_NoSchemaError  0x08000000  /* Do not report schema parse errors*/ 
+#define SQLITE_Defensive      0x10000000  /* Input SQL is likely hostile */ 
+#define SQLITE_DqsDDL         0x20000000  /* dbl-quoted strings allowed in DDL*/ 
+#define SQLITE_DqsDML         0x40000000  /* dbl-quoted strings allowed in DML*/ 
 #define SQLITE_EnableView     0x80000000  /* Enable the use of views */
 #define SQLITE_CountRows      HI(0x00001) /* Count rows changed by INSERT, */
                                           /*   DELETE, or UPDATE and return */
@@ -16679,8 +16679,8 @@ struct sqlite3 {
 #define DBFLAG_SchemaChange   0x0001  /* Uncommitted Hash table changes */
 #define DBFLAG_PreferBuiltin  0x0002  /* Preference to built-in funcs */
 #define DBFLAG_Vacuum         0x0004  /* Currently in a VACUUM */
-#define DBFLAG_VacuumInto     0x0008  /* Currently running VACUUM INTO */
-#define DBFLAG_SchemaKnownOk  0x0010  /* Schema is known to be valid */
+#define DBFLAG_VacuumInto     0x0008  /* Currently running VACUUM INTO */ 
+#define DBFLAG_SchemaKnownOk  0x0010  /* Schema is known to be valid */ 
 #define DBFLAG_InternalFunc   0x0020  /* Allow use of internal functions */
 #define DBFLAG_EncodingFixed  0x0040  /* No longer possible to change enc. */
 
@@ -16747,13 +16747,13 @@ struct sqlite3 {
 */
 struct FuncDef {
   i8 nArg;             /* Number of arguments.  -1 means unlimited */
-  u32 funcFlags;       /* Some combination of SQLITE_FUNC_* */
+  u32 funcFlags;       /* Some combination of SQLITE_FUNC_* */ 
   void *pUserData;     /* User data parameter */
   FuncDef *pNext;      /* Next function with same name */
   void (*xSFunc)(sqlite3_context*,int,sqlite3_value**); /* func or agg-step */
   void (*xFinalize)(sqlite3_context*);                  /* Agg finalizer */
-  void (*xValue)(sqlite3_context*);                     /* Current agg value */
-  void (*xInverse)(sqlite3_context*,int,sqlite3_value**); /* inverse agg-step */
+  void (*xValue)(sqlite3_context*);                     /* Current agg value */ 
+  void (*xInverse)(sqlite3_context*,int,sqlite3_value**); /* inverse agg-step */ 
   const char *zName;   /* SQL name of the function. */
   union {
     FuncDef *pHash;      /* Next with a different name but the same hash */
@@ -16813,8 +16813,8 @@ struct FuncDestructor {
                                     ** single query - might change over time */
 #define SQLITE_FUNC_TEST     0x4000 /* Built-in testing functions */
 #define SQLITE_FUNC_OFFSET   0x8000 /* Built-in sqlite_offset() function */
-#define SQLITE_FUNC_WINDOW   0x00010000 /* Built-in window-only function */
-#define SQLITE_FUNC_INTERNAL 0x00040000 /* For use by NestedParse() only */
+#define SQLITE_FUNC_WINDOW   0x00010000 /* Built-in window-only function */ 
+#define SQLITE_FUNC_INTERNAL 0x00040000 /* For use by NestedParse() only */ 
 #define SQLITE_FUNC_DIRECT   0x00080000 /* Not for use in TRIGGERs or VIEWs */
 #define SQLITE_FUNC_SUBTYPE  0x00100000 /* Result likely to have sub-type */
 #define SQLITE_FUNC_UNSAFE   0x00200000 /* Function has side effects */
@@ -16883,12 +16883,12 @@ struct FuncDestructor {
 **     are interpreted in the same way as the first 4 parameters to
 **     FUNCTION().
 **
-**   WFUNCTION(zName, nArg, iArg, xStep, xFinal, xValue, xInverse)
-**     Used to create an aggregate function definition implemented by
-**     the C functions xStep and xFinal. The first four parameters
-**     are interpreted in the same way as the first 4 parameters to
-**     FUNCTION().
-**
+**   WFUNCTION(zName, nArg, iArg, xStep, xFinal, xValue, xInverse) 
+**     Used to create an aggregate function definition implemented by 
+**     the C functions xStep and xFinal. The first four parameters 
+**     are interpreted in the same way as the first 4 parameters to 
+**     FUNCTION(). 
+** 
 **   LIKEFUNC(zName, nArg, pArg, flags)
 **     Used to create a scalar function definition of a function zName
 **     that accepts nArg arguments and is implemented by a call to C
@@ -16900,10 +16900,10 @@ struct FuncDestructor {
 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
   {nArg, SQLITE_FUNC_BUILTIN|\
    SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
-   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
+   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } 
 #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \
   {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
-   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
+   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } 
 #define SFUNCTION(zName, nArg, iArg, bNC, xFunc) \
   {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_DIRECTONLY|SQLITE_FUNC_UNSAFE, \
    SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
@@ -16921,31 +16921,31 @@ struct FuncDestructor {
    SQLITE_INT_TO_PTR(iArg), 0, noopFunc, 0, 0, 0, #zName, {0} }
 #define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \
   {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_SLOCHNG|SQLITE_UTF8, \
-   0, 0, xFunc, 0, 0, 0, #zName, {0} }
+   0, 0, xFunc, 0, 0, 0, #zName, {0} } 
 #define PURE_DATE(zName, nArg, iArg, bNC, xFunc) \
   {nArg, SQLITE_FUNC_BUILTIN|\
          SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \
-   (void*)&sqlite3Config, 0, xFunc, 0, 0, 0, #zName, {0} }
+   (void*)&sqlite3Config, 0, xFunc, 0, 0, 0, #zName, {0} } 
 #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \
   {nArg, SQLITE_FUNC_BUILTIN|\
    SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\
-   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} }
+   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, 0, #zName, {0} } 
 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
   {nArg, SQLITE_FUNC_BUILTIN|\
    SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
-   pArg, 0, xFunc, 0, 0, 0, #zName, }
+   pArg, 0, xFunc, 0, 0, 0, #zName, } 
 #define LIKEFUNC(zName, nArg, arg, flags) \
   {nArg, SQLITE_FUNC_BUILTIN|SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \
-   (void *)arg, 0, likeFunc, 0, 0, 0, #zName, {0} }
-#define WAGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue, xInverse, f) \
+   (void *)arg, 0, likeFunc, 0, 0, 0, #zName, {0} } 
+#define WAGGREGATE(zName, nArg, arg, nc, xStep, xFinal, xValue, xInverse, f) \ 
   {nArg, SQLITE_FUNC_BUILTIN|SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|f, \
-   SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,xInverse,#zName, {0}}
-#define INTERNAL_FUNCTION(zName, nArg, xFunc) \
+   SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,xValue,xInverse,#zName, {0}} 
+#define INTERNAL_FUNCTION(zName, nArg, xFunc) \ 
   {nArg, SQLITE_FUNC_BUILTIN|\
    SQLITE_FUNC_INTERNAL|SQLITE_UTF8|SQLITE_FUNC_CONSTANT, \
-   0, 0, xFunc, 0, 0, 0, #zName, {0} }
-
+   0, 0, xFunc, 0, 0, 0, #zName, {0} } 
 
+ 
 /*
 ** All current savepoints are stored in a linked list starting at
 ** sqlite3.pSavepoint. The first element in the list is the most recently
@@ -17045,7 +17045,7 @@ struct Column {
 #define COLFLAG_HIDDEN    0x0002   /* A hidden column in a virtual table */
 #define COLFLAG_HASTYPE   0x0004   /* Type name follows column name */
 #define COLFLAG_UNIQUE    0x0008   /* Column def contains "UNIQUE" or "PK" */
-#define COLFLAG_SORTERREF 0x0010   /* Use sorter-refs with this column */
+#define COLFLAG_SORTERREF 0x0010   /* Use sorter-refs with this column */ 
 #define COLFLAG_VIRTUAL   0x0020   /* GENERATED ALWAYS AS ... VIRTUAL */
 #define COLFLAG_STORED    0x0040   /* GENERATED ALWAYS AS ... STORED */
 #define COLFLAG_NOTAVAIL  0x0080   /* STORED column not yet calculated */
@@ -17386,12 +17386,12 @@ struct FKey {
 #define OE_Fail     3   /* Stop the operation but leave all prior changes */
 #define OE_Ignore   4   /* Ignore the error. Do not do the INSERT or UPDATE */
 #define OE_Replace  5   /* Delete existing record, then do INSERT or UPDATE */
-#define OE_Update   6   /* Process as a DO UPDATE in an upsert */
-#define OE_Restrict 7   /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */
-#define OE_SetNull  8   /* Set the foreign key value to NULL */
-#define OE_SetDflt  9   /* Set the foreign key value to its default */
-#define OE_Cascade  10  /* Cascade the changes */
-#define OE_Default  11  /* Do whatever the default action is */
+#define OE_Update   6   /* Process as a DO UPDATE in an upsert */ 
+#define OE_Restrict 7   /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */ 
+#define OE_SetNull  8   /* Set the foreign key value to NULL */ 
+#define OE_SetDflt  9   /* Set the foreign key value to its default */ 
+#define OE_Cascade  10  /* Cascade the changes */ 
+#define OE_Default  11  /* Do whatever the default action is */ 
 
 
 /*
@@ -17517,7 +17517,7 @@ struct Index {
   u16 nKeyCol;             /* Number of columns forming the key */
   u16 nColumn;             /* Number of columns stored in the index */
   u8 onError;              /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */
-  unsigned idxType:2;      /* 0:Normal 1:UNIQUE, 2:PRIMARY KEY, 3:IPK */
+  unsigned idxType:2;      /* 0:Normal 1:UNIQUE, 2:PRIMARY KEY, 3:IPK */ 
   unsigned bUnordered:1;   /* Use this index for == or IN queries only */
   unsigned uniqNotNull:1;  /* True if UNIQUE and NOT NULL for all columns */
   unsigned isResized:1;    /* True if resizeIndexObject() has been called */
@@ -17525,7 +17525,7 @@ struct Index {
   unsigned noSkipScan:1;   /* Do not try to use skip-scan if true */
   unsigned hasStat1:1;     /* aiRowLogEst values come from sqlite_stat1 */
   unsigned bNoQuery:1;     /* Do not use this index to optimize queries */
-  unsigned bAscKeyBug:1;   /* True if the bba7b69f9849b5bf bug applies */
+  unsigned bAscKeyBug:1;   /* True if the bba7b69f9849b5bf bug applies */ 
   unsigned bHasVCol:1;     /* Index references one or more VIRTUAL columns */
 #ifdef SQLITE_ENABLE_STAT4
   int nSample;             /* Number of elements in aSample[] */
@@ -17535,7 +17535,7 @@ struct Index {
   tRowcnt *aiRowEst;       /* Non-logarithmic stat1 data for this index */
   tRowcnt nRowEst0;        /* Non-logarithmic number of rows in the index */
 #endif
-  Bitmask colNotIdxed;     /* 0 for unindexed columns in pTab */
+  Bitmask colNotIdxed;     /* 0 for unindexed columns in pTab */ 
 };
 
 /*
@@ -17544,7 +17544,7 @@ struct Index {
 #define SQLITE_IDXTYPE_APPDEF      0   /* Created using CREATE INDEX */
 #define SQLITE_IDXTYPE_UNIQUE      1   /* Implements a UNIQUE constraint */
 #define SQLITE_IDXTYPE_PRIMARYKEY  2   /* Is the PRIMARY KEY for the table */
-#define SQLITE_IDXTYPE_IPK         3   /* INTEGER PRIMARY KEY index */
+#define SQLITE_IDXTYPE_IPK         3   /* INTEGER PRIMARY KEY index */ 
 
 /* Return true if index X is a PRIMARY KEY index */
 #define IsPrimaryKeyIndex(X)  ((X)->idxType==SQLITE_IDXTYPE_PRIMARYKEY)
@@ -17572,20 +17572,20 @@ struct IndexSample {
 };
 
 /*
-** Possible values to use within the flags argument to sqlite3GetToken().
-*/
-#define SQLITE_TOKEN_QUOTED    0x1 /* Token is a quoted identifier. */
-#define SQLITE_TOKEN_KEYWORD   0x2 /* Token is a keyword. */
-
-/*
+** Possible values to use within the flags argument to sqlite3GetToken(). 
+*/ 
+#define SQLITE_TOKEN_QUOTED    0x1 /* Token is a quoted identifier. */ 
+#define SQLITE_TOKEN_KEYWORD   0x2 /* Token is a keyword. */ 
+ 
+/* 
 ** Each token coming out of the lexer is an instance of
 ** this structure.  Tokens are also used as part of an expression.
 **
-** The memory that "z" points to is owned by other objects.  Take care
-** that the owner of the "z" string does not deallocate the string before
-** the Token goes out of scope!  Very often, the "z" points to some place
-** in the middle of the Parse.zSql text.  But it might also point to a
-** static string.
+** The memory that "z" points to is owned by other objects.  Take care 
+** that the owner of the "z" string does not deallocate the string before 
+** the Token goes out of scope!  Very often, the "z" points to some place 
+** in the middle of the Parse.zSql text.  But it might also point to a 
+** static string. 
 */
 struct Token {
   const char *z;     /* Text of the token.  Not NULL-terminated! */
@@ -17766,22 +17766,22 @@ struct Expr {
   i16 iAgg;              /* Which entry in pAggInfo->aCol[] or ->aFunc[] */
   int iRightJoinTable;   /* If EP_FromJoin, the right table of the join */
   AggInfo *pAggInfo;     /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */
-  union {
-    Table *pTab;           /* TK_COLUMN: Table containing column. Can be NULL
-                           ** for a column of an index on an expression */
+  union { 
+    Table *pTab;           /* TK_COLUMN: Table containing column. Can be NULL 
+                           ** for a column of an index on an expression */ 
     Window *pWin;          /* EP_WinFunc: Window/Filter defn for a function */
-    struct {               /* TK_IN, TK_SELECT, and TK_EXISTS */
-      int iAddr;             /* Subroutine entry address */
-      int regReturn;         /* Register used to hold return address */
-    } sub;
-  } y;
+    struct {               /* TK_IN, TK_SELECT, and TK_EXISTS */ 
+      int iAddr;             /* Subroutine entry address */ 
+      int regReturn;         /* Register used to hold return address */ 
+    } sub; 
+  } y; 
 };
 
 /* The following are the meanings of bits in the Expr.flags field.
-** Value restrictions:
-**
-**          EP_Agg == NC_HasAgg == SF_HasAgg
-**          EP_Win == NC_HasWin
+** Value restrictions: 
+** 
+**          EP_Agg == NC_HasAgg == SF_HasAgg 
+**          EP_Win == NC_HasWin 
 */
 #define EP_FromJoin   0x000001 /* Originates in ON/USING clause of outer join */
 #define EP_Distinct   0x000002 /* Aggregate function with DISTINCT keyword */
@@ -17828,8 +17828,8 @@ struct Expr {
 #define ExprHasAllProperty(E,P)  (((E)->flags&(P))==(P))
 #define ExprSetProperty(E,P)     (E)->flags|=(P)
 #define ExprClearProperty(E,P)   (E)->flags&=~(P)
-#define ExprAlwaysTrue(E)   (((E)->flags&(EP_FromJoin|EP_IsTrue))==EP_IsTrue)
-#define ExprAlwaysFalse(E)  (((E)->flags&(EP_FromJoin|EP_IsFalse))==EP_IsFalse)
+#define ExprAlwaysTrue(E)   (((E)->flags&(EP_FromJoin|EP_IsTrue))==EP_IsTrue) 
+#define ExprAlwaysFalse(E)  (((E)->flags&(EP_FromJoin|EP_IsFalse))==EP_IsFalse) 
 
 /* Macros used to ensure that the correct members of unions are accessed
 ** in Expr.
@@ -17920,7 +17920,7 @@ struct ExprList {
     unsigned eEName :2;     /* Meaning of zEName */
     unsigned done :1;       /* A flag to indicate when processing is finished */
     unsigned reusable :1;   /* Constant expression is reusable */
-    unsigned bSorterRef :1; /* Defer evaluation until after sorting */
+    unsigned bSorterRef :1; /* Defer evaluation until after sorting */ 
     unsigned bNulls: 1;     /* True if explicit "NULLS FIRST/LAST" */
     union {
       struct {             /* Used by any ExprList other than Parse.pConsExpr */
@@ -18104,17 +18104,17 @@ struct SrcList {
 struct NameContext {
   Parse *pParse;       /* The parser */
   SrcList *pSrcList;   /* One or more tables used to resolve names */
-  union {
-    ExprList *pEList;    /* Optional list of result-set columns */
-    AggInfo *pAggInfo;   /* Information about aggregates at this level */
-    Upsert *pUpsert;     /* ON CONFLICT clause information from an upsert */
+  union { 
+    ExprList *pEList;    /* Optional list of result-set columns */ 
+    AggInfo *pAggInfo;   /* Information about aggregates at this level */ 
+    Upsert *pUpsert;     /* ON CONFLICT clause information from an upsert */ 
     int iBaseReg;        /* For TK_REGISTER when parsing RETURNING */
-  } uNC;
+  } uNC; 
   NameContext *pNext;  /* Next outer name context.  NULL for outermost */
   int nRef;            /* Number of names resolved by this context */
   int nNcErr;          /* Number of errors encountered while resolving names */
-  int ncFlags;         /* Zero or more NC_* flags defined below */
-  Select *pWinSelect;  /* SELECT statement for any window functions */
+  int ncFlags;         /* Zero or more NC_* flags defined below */ 
+  Select *pWinSelect;  /* SELECT statement for any window functions */ 
 };
 
 /*
@@ -18124,7 +18124,7 @@ struct NameContext {
 **    NC_HasAgg    == SF_HasAgg       == EP_Agg
 **    NC_MinMaxAgg == SF_MinMaxAgg    == SQLITE_FUNC_MINMAX
 **    NC_OrderAgg  == SF_OrderByReqd  == SQLITE_FUNC_ANYORDER
-**    NC_HasWin    == EP_Win
+**    NC_HasWin    == EP_Win 
 **
 */
 #define NC_AllowAgg  0x000001 /* Aggregate functions are allowed here */
@@ -18150,24 +18150,24 @@ struct NameContext {
 #define NC_OrderAgg 0x8000000 /* Has an aggregate other than count/min/max */
 
 /*
-** An instance of the following object describes a single ON CONFLICT
-** clause in an upsert.
-**
-** The pUpsertTarget field is only set if the ON CONFLICT clause includes
-** conflict-target clause.  (In "ON CONFLICT(a,b)" the "(a,b)" is the
-** conflict-target clause.)  The pUpsertTargetWhere is the optional
-** WHERE clause used to identify partial unique indexes.
-**
+** An instance of the following object describes a single ON CONFLICT 
+** clause in an upsert. 
+** 
+** The pUpsertTarget field is only set if the ON CONFLICT clause includes 
+** conflict-target clause.  (In "ON CONFLICT(a,b)" the "(a,b)" is the 
+** conflict-target clause.)  The pUpsertTargetWhere is the optional 
+** WHERE clause used to identify partial unique indexes. 
+** 
 ** pUpsertSet is the list of column=expr terms of the UPDATE statement.
-** The pUpsertSet field is NULL for a ON CONFLICT DO NOTHING.  The
-** pUpsertWhere is the WHERE clause for the UPDATE and is NULL if the
-** WHERE clause is omitted.
-*/
-struct Upsert {
+** The pUpsertSet field is NULL for a ON CONFLICT DO NOTHING.  The 
+** pUpsertWhere is the WHERE clause for the UPDATE and is NULL if the 
+** WHERE clause is omitted. 
+*/ 
+struct Upsert { 
   ExprList *pUpsertTarget;  /* Optional description of conflict target */
-  Expr *pUpsertTargetWhere; /* WHERE clause for partial index targets */
-  ExprList *pUpsertSet;     /* The SET clause from an ON CONFLICT UPDATE */
-  Expr *pUpsertWhere;       /* WHERE clause for the ON CONFLICT UPDATE */
+  Expr *pUpsertTargetWhere; /* WHERE clause for partial index targets */ 
+  ExprList *pUpsertSet;     /* The SET clause from an ON CONFLICT UPDATE */ 
+  Expr *pUpsertWhere;       /* WHERE clause for the ON CONFLICT UPDATE */ 
   Upsert *pNextUpsert;      /* Next ON CONFLICT clause in the list */
   u8 isDoUpdate;            /* True for DO UPDATE.  False for DO NOTHING */
   /* Above this point is the parse tree for the ON CONFLICT clauses.
@@ -18179,18 +18179,18 @@ struct Upsert {
   ** while generating code.  The fields below are owned by the INSERT
   ** statement and will be freed by INSERT processing. */
   Index *pUpsertIdx;        /* UNIQUE constraint specified by pUpsertTarget */
-  SrcList *pUpsertSrc;      /* Table to be updated */
-  int regData;              /* First register holding array of VALUES */
-  int iDataCur;             /* Index of the data cursor */
-  int iIdxCur;              /* Index of the first index cursor */
-};
-
-/*
+  SrcList *pUpsertSrc;      /* Table to be updated */ 
+  int regData;              /* First register holding array of VALUES */ 
+  int iDataCur;             /* Index of the data cursor */ 
+  int iIdxCur;              /* Index of the first index cursor */ 
+}; 
+ 
+/* 
 ** An instance of the following structure contains all information
 ** needed to generate code for a single SELECT statement.
 **
-** See the header comment on the computeLimitRegisters() routine for a
-** detailed description of the meaning of the iLimit and iOffset fields.
+** See the header comment on the computeLimitRegisters() routine for a 
+** detailed description of the meaning of the iLimit and iOffset fields. 
 **
 ** addrOpenEphm[] entries contain the address of OP_OpenEphemeral opcodes.
 ** These addresses must be stored so that we can go back and fill in
@@ -18207,7 +18207,7 @@ struct Select {
   LogEst nSelectRow;     /* Estimated number of result rows */
   u32 selFlags;          /* Various SF_* values */
   int iLimit, iOffset;   /* Memory registers holding LIMIT & OFFSET counters */
-  u32 selId;             /* Unique identifier number for this SELECT */
+  u32 selId;             /* Unique identifier number for this SELECT */ 
   int addrOpenEphm[2];   /* OP_OpenEphem opcodes related to this select */
   ExprList *pEList;      /* The fields of the result */
   SrcList *pSrc;         /* The FROM clause */
@@ -18219,10 +18219,10 @@ struct Select {
   Select *pNext;         /* Next select to the left in a compound */
   Expr *pLimit;          /* LIMIT expression. NULL means not used. */
   With *pWith;           /* WITH clause attached to this select. Or NULL. */
-#ifndef SQLITE_OMIT_WINDOWFUNC
-  Window *pWin;          /* List of window functions */
-  Window *pWinDefn;      /* List of named window definitions */
-#endif
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+  Window *pWin;          /* List of window functions */ 
+  Window *pWinDefn;      /* List of named window definitions */ 
+#endif 
 };
 
 /*
@@ -18474,7 +18474,7 @@ struct Parse {
   u8 hasCompound;      /* Need to invoke convertCompoundSelectToSubquery() */
   u8 okConstFactor;    /* OK to factor out constants */
   u8 disableLookaside; /* Number of times lookaside has been disabled */
-  u8 disableVtab;      /* Disable all virtual tables for this parse */
+  u8 disableVtab;      /* Disable all virtual tables for this parse */ 
 #if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
   u8 earlyCleanup;     /* OOM inside sqlite3ParserAddCleanup() */
 #endif
@@ -18486,8 +18486,8 @@ struct Parse {
   int szOpAlloc;       /* Bytes of memory space allocated for Vdbe.aOp[] */
   int iSelfTab;        /* Table associated with an index on expr, or negative
                        ** of the base register during check-constraint eval */
-  int nLabel;          /* The *negative* of the number of labels used */
-  int nLabelAlloc;     /* Number of slots in aLabel */
+  int nLabel;          /* The *negative* of the number of labels used */ 
+  int nLabelAlloc;     /* Number of slots in aLabel */ 
   int *aLabel;         /* Space to hold the labels */
   ExprList *pConstExpr;/* Constant expressions */
   Token constraintName;/* Name of the constraint currently being parsed */
@@ -18496,7 +18496,7 @@ struct Parse {
   int regRowid;        /* Register holding rowid of CREATE TABLE entry */
   int regRoot;         /* Register holding root page number for new objects */
   int nMaxArg;         /* Max args passed to user function by sub-program */
-  int nSelect;         /* Number of SELECT stmts. Counter for Select.selId */
+  int nSelect;         /* Number of SELECT stmts. Counter for Select.selId */ 
 #ifndef SQLITE_OMIT_SHARED_CACHE
   int nTableLock;        /* Number of locks in aTableLock */
   TableLock *aTableLock; /* Required table locks for shared-cache mode */
@@ -18522,7 +18522,7 @@ struct Parse {
   ** Fields above must be initialized to zero.  The fields that follow,
   ** down to the beginning of the recursive section, do not need to be
   ** initialized as they will be set before being used.  The boundary is
-  ** determined by offsetof(Parse,aTempReg).
+  ** determined by offsetof(Parse,aTempReg). 
   **************************************************************************/
 
   int aTempReg[8];        /* Holding area for temporary registers */
@@ -18539,21 +18539,21 @@ struct Parse {
   ynVar nVar;               /* Number of '?' variables seen in the SQL so far */
   u8 iPkSortOrder;          /* ASC or DESC for INTEGER PRIMARY KEY */
   u8 explain;               /* True if the EXPLAIN flag is found on the query */
-  u8 eParseMode;            /* PARSE_MODE_XXX constant */
+  u8 eParseMode;            /* PARSE_MODE_XXX constant */ 
 #ifndef SQLITE_OMIT_VIRTUALTABLE
   int nVtabLock;            /* Number of virtual tables to lock */
 #endif
   int nHeight;              /* Expression tree height of current sub-select */
 #ifndef SQLITE_OMIT_EXPLAIN
-  int addrExplain;          /* Address of current OP_Explain opcode */
+  int addrExplain;          /* Address of current OP_Explain opcode */ 
 #endif
   VList *pVList;            /* Mapping between variable names and numbers */
   Vdbe *pReprepare;         /* VM being reprepared (sqlite3Reprepare()) */
   const char *zTail;        /* All SQL text past the last semicolon parsed */
   Table *pNewTable;         /* A table being constructed by CREATE TABLE */
-  Index *pNewIndex;         /* An index being constructed by CREATE INDEX.
-                            ** Also used to hold redundant UNIQUE constraints
-                            ** during a RENAME COLUMN */
+  Index *pNewIndex;         /* An index being constructed by CREATE INDEX. 
+                            ** Also used to hold redundant UNIQUE constraints 
+                            ** during a RENAME COLUMN */ 
   Trigger *pNewTrigger;     /* Trigger under construct by a CREATE TRIGGER */
   const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */
 #ifndef SQLITE_OMIT_VIRTUALTABLE
@@ -18561,22 +18561,22 @@ struct Parse {
   Table **apVtabLock;       /* Pointer to virtual tables needing locking */
 #endif
   With *pWith;              /* Current WITH clause, or NULL */
-#ifndef SQLITE_OMIT_ALTERTABLE
-  RenameToken *pRename;     /* Tokens subject to renaming by ALTER TABLE */
-#endif
+#ifndef SQLITE_OMIT_ALTERTABLE 
+  RenameToken *pRename;     /* Tokens subject to renaming by ALTER TABLE */ 
+#endif 
 };
 
 /* Allowed values for Parse.eParseMode
 */
-#define PARSE_MODE_NORMAL        0
-#define PARSE_MODE_DECLARE_VTAB  1
+#define PARSE_MODE_NORMAL        0 
+#define PARSE_MODE_DECLARE_VTAB  1 
 #define PARSE_MODE_RENAME        2
 #define PARSE_MODE_UNMAP         3
-
+ 
 /*
 ** Sizes and pointers of various parts of the Parse object.
 */
-#define PARSE_HDR_SZ offsetof(Parse,aTempReg) /* Recursive part w/o aColCache*/
+#define PARSE_HDR_SZ offsetof(Parse,aTempReg) /* Recursive part w/o aColCache*/ 
 #define PARSE_RECURSE_SZ offsetof(Parse,sLastToken)    /* Recursive part */
 #define PARSE_TAIL_SZ (sizeof(Parse)-PARSE_RECURSE_SZ) /* Non-recursive part */
 #define PARSE_TAIL(X) (((char*)(X))+PARSE_RECURSE_SZ)  /* Pointer to tail */
@@ -18587,21 +18587,21 @@ struct Parse {
 #ifdef SQLITE_OMIT_VIRTUALTABLE
   #define IN_DECLARE_VTAB 0
 #else
-  #define IN_DECLARE_VTAB (pParse->eParseMode==PARSE_MODE_DECLARE_VTAB)
+  #define IN_DECLARE_VTAB (pParse->eParseMode==PARSE_MODE_DECLARE_VTAB) 
 #endif
 
-#if defined(SQLITE_OMIT_ALTERTABLE)
-  #define IN_RENAME_OBJECT 0
-#else
+#if defined(SQLITE_OMIT_ALTERTABLE) 
+  #define IN_RENAME_OBJECT 0 
+#else 
   #define IN_RENAME_OBJECT (pParse->eParseMode>=PARSE_MODE_RENAME)
-#endif
-
-#if defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_OMIT_ALTERTABLE)
-  #define IN_SPECIAL_PARSE 0
-#else
-  #define IN_SPECIAL_PARSE (pParse->eParseMode!=PARSE_MODE_NORMAL)
-#endif
-
+#endif 
+ 
+#if defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_OMIT_ALTERTABLE) 
+  #define IN_SPECIAL_PARSE 0 
+#else 
+  #define IN_SPECIAL_PARSE (pParse->eParseMode!=PARSE_MODE_NORMAL) 
+#endif 
+ 
 /*
 ** An instance of the following structure can be declared on a stack and used
 ** to save the Parse.zAuthContext value so that it can be restored later.
@@ -18625,7 +18625,7 @@ struct AuthContext {
 */
 #define OPFLAG_NCHANGE       0x01    /* OP_Insert: Set to update db->nChange */
                                      /* Also used in P2 (not P5) of OP_Delete */
-#define OPFLAG_NOCHNG        0x01    /* OP_VColumn nochange for UPDATE */
+#define OPFLAG_NOCHNG        0x01    /* OP_VColumn nochange for UPDATE */ 
 #define OPFLAG_EPHEM         0x01    /* OP_Column: Ephemeral output is ok */
 #define OPFLAG_LASTROWID     0x20    /* Set to update db->lastRowid */
 #define OPFLAG_ISUPDATE      0x04    /* This OP_Insert is an sql UPDATE */
@@ -18733,7 +18733,7 @@ struct TriggerStep {
   Expr *pWhere;        /* The WHERE clause for DELETE or UPDATE steps */
   ExprList *pExprList; /* SET clause for UPDATE, or RETURNING clause */
   IdList *pIdList;     /* Column names for INSERT */
-  Upsert *pUpsert;     /* Upsert clauses on an INSERT */
+  Upsert *pUpsert;     /* Upsert clauses on an INSERT */ 
   char *zSpan;         /* Original SQL text of this command */
   TriggerStep *pNext;  /* Next in the link-list */
   TriggerStep *pLast;  /* Last element in link-list. Valid for 1st elem only */
@@ -18756,13 +18756,13 @@ struct Returning {
 ** An objected used to accumulate the text of a string where we
 ** do not necessarily know how big the string will be in the end.
 */
-struct sqlite3_str {
+struct sqlite3_str { 
   sqlite3 *db;         /* Optional database for lookaside.  Can be NULL */
   char *zText;         /* The string collected so far */
   u32  nAlloc;         /* Amount of space allocated in zText */
   u32  mxAlloc;        /* Maximum allowed allocation.  0 for no malloc usage */
   u32  nChar;          /* Length of the string so far */
-  u8   accError;       /* SQLITE_NOMEM or SQLITE_TOOBIG */
+  u8   accError;       /* SQLITE_NOMEM or SQLITE_TOOBIG */ 
   u8   printfFlags;    /* SQLITE_PRINTF flags below */
 };
 #define SQLITE_PRINTF_INTERNAL 0x01  /* Internal-use-only converters allowed */
@@ -18781,19 +18781,19 @@ typedef struct {
   char **pzErrMsg;    /* Error message stored here */
   int iDb;            /* 0 for main database.  1 for TEMP, 2.. for ATTACHed */
   int rc;             /* Result code stored here */
-  u32 mInitFlags;     /* Flags controlling error messages */
-  u32 nInitRow;       /* Number of rows processed */
+  u32 mInitFlags;     /* Flags controlling error messages */ 
+  u32 nInitRow;       /* Number of rows processed */ 
   Pgno mxPage;        /* Maximum page number.  0 for no limit. */
 } InitData;
 
 /*
-** Allowed values for mInitFlags
-*/
+** Allowed values for mInitFlags 
+*/ 
 #define INITFLAG_AlterMask     0x0003  /* Types of ALTER */
 #define INITFLAG_AlterRename   0x0001  /* Reparse after a RENAME */
 #define INITFLAG_AlterDrop     0x0002  /* Reparse after a DROP COLUMN */
 #define INITFLAG_AlterAdd      0x0003  /* Reparse after an ADD COLUMN */
-
+ 
 /* Tuning parameters are set using SQLITE_TESTCTRL_TUNE and are controlled
 ** on debug-builds of the CLI using ".testctrl tune ID VALUE".  Tuning
 ** parameters are for temporary use during development, to help find
@@ -18810,7 +18810,7 @@ typedef struct {
 # define Tuning(X)  0
 #endif
 
-/*
+/* 
 ** Structure containing global configuration data for the SQLite library.
 **
 ** This structure also contains some state information.
@@ -18861,18 +18861,18 @@ struct Sqlite3Config {
   /* The following callback (if not NULL) is invoked on every VDBE branch
   ** operation.  Set the callback using SQLITE_TESTCTRL_VDBE_COVERAGE.
   */
-  void (*xVdbeBranch)(void*,unsigned iSrcLine,u8 eThis,u8 eMx);  /* Callback */
+  void (*xVdbeBranch)(void*,unsigned iSrcLine,u8 eThis,u8 eMx);  /* Callback */ 
   void *pVdbeBranchArg;                                     /* 1st argument */
 #endif
 #ifndef SQLITE_OMIT_DESERIALIZE
-  sqlite3_int64 mxMemdbSize;        /* Default max memdb size */
-#endif
+  sqlite3_int64 mxMemdbSize;        /* Default max memdb size */ 
+#endif 
 #ifndef SQLITE_UNTESTABLE
   int (*xTestCallback)(int);        /* Invoked by sqlite3FaultSim() */
 #endif
   int bLocaltimeFault;              /* True to fail localtime() calls */
   int iOnceResetThreshold;          /* When to reset OP_Once counters */
-  u32 szSorterRef;                  /* Min size in bytes to use sorter-refs */
+  u32 szSorterRef;                  /* Min size in bytes to use sorter-refs */ 
   unsigned int iPrngSeed;           /* Alternative fixed seed for the PRNG */
   /* vvvv--- must be last ---vvv */
 #ifdef SQLITE_DEBUG
@@ -18917,12 +18917,12 @@ struct Walker {
     struct RefSrcList *pRefSrcList;           /* sqlite3ReferencesSrcList() */
     int *aiCol;                               /* array of column indexes */
     struct IdxCover *pIdxCover;               /* Check for index coverage */
-    struct IdxExprTrans *pIdxTrans;           /* Convert idxed expr to column */
+    struct IdxExprTrans *pIdxTrans;           /* Convert idxed expr to column */ 
     ExprList *pGroupBy;                       /* GROUP BY clause */
-    Select *pSelect;                          /* HAVING to WHERE clause ctx */
-    struct WindowRewrite *pRewrite;           /* Window rewrite context */
-    struct WhereConst *pConst;                /* WHERE clause constants */
-    struct RenameCtx *pRename;                /* RENAME COLUMN context */
+    Select *pSelect;                          /* HAVING to WHERE clause ctx */ 
+    struct WindowRewrite *pRewrite;           /* Window rewrite context */ 
+    struct WhereConst *pConst;                /* WHERE clause constants */ 
+    struct RenameCtx *pRename;                /* RENAME COLUMN context */ 
     struct Table *pTab;                       /* Table of generated column */
     SrcItem *pSrcItem;                        /* A single FROM clause item */
     DbFixer *pFix;
@@ -19040,82 +19040,82 @@ struct TreeView {
 /*
 ** This object is used in various ways, most (but not all) related to window
 ** functions.
-**
-**   (1) A single instance of this structure is attached to the
+** 
+**   (1) A single instance of this structure is attached to the 
 **       the Expr.y.pWin field for each window function in an expression tree.
-**       This object holds the information contained in the OVER clause,
-**       plus additional fields used during code generation.
-**
-**   (2) All window functions in a single SELECT form a linked-list
-**       attached to Select.pWin.  The Window.pFunc and Window.pExpr
-**       fields point back to the expression that is the window function.
-**
-**   (3) The terms of the WINDOW clause of a SELECT are instances of this
-**       object on a linked list attached to Select.pWinDefn.
-**
+**       This object holds the information contained in the OVER clause, 
+**       plus additional fields used during code generation. 
+** 
+**   (2) All window functions in a single SELECT form a linked-list 
+**       attached to Select.pWin.  The Window.pFunc and Window.pExpr 
+**       fields point back to the expression that is the window function. 
+** 
+**   (3) The terms of the WINDOW clause of a SELECT are instances of this 
+**       object on a linked list attached to Select.pWinDefn. 
+** 
 **   (4) For an aggregate function with a FILTER clause, an instance
 **       of this object is stored in Expr.y.pWin with eFrmType set to
 **       TK_FILTER. In this case the only field used is Window.pFilter.
 **
-** The uses (1) and (2) are really the same Window object that just happens
-** to be accessible in two different ways.  Use case (3) are separate objects.
-*/
-struct Window {
-  char *zName;            /* Name of window (may be NULL) */
-  char *zBase;            /* Name of base window for chaining (may be NULL) */
-  ExprList *pPartition;   /* PARTITION BY clause */
-  ExprList *pOrderBy;     /* ORDER BY clause */
-  u8 eFrmType;            /* TK_RANGE, TK_GROUPS, TK_ROWS, or 0 */
-  u8 eStart;              /* UNBOUNDED, CURRENT, PRECEDING or FOLLOWING */
-  u8 eEnd;                /* UNBOUNDED, CURRENT, PRECEDING or FOLLOWING */
-  u8 bImplicitFrame;      /* True if frame was implicitly specified */
-  u8 eExclude;            /* TK_NO, TK_CURRENT, TK_TIES, TK_GROUP, or 0 */
-  Expr *pStart;           /* Expression for "<expr> PRECEDING" */
-  Expr *pEnd;             /* Expression for "<expr> FOLLOWING" */
+** The uses (1) and (2) are really the same Window object that just happens 
+** to be accessible in two different ways.  Use case (3) are separate objects. 
+*/ 
+struct Window { 
+  char *zName;            /* Name of window (may be NULL) */ 
+  char *zBase;            /* Name of base window for chaining (may be NULL) */ 
+  ExprList *pPartition;   /* PARTITION BY clause */ 
+  ExprList *pOrderBy;     /* ORDER BY clause */ 
+  u8 eFrmType;            /* TK_RANGE, TK_GROUPS, TK_ROWS, or 0 */ 
+  u8 eStart;              /* UNBOUNDED, CURRENT, PRECEDING or FOLLOWING */ 
+  u8 eEnd;                /* UNBOUNDED, CURRENT, PRECEDING or FOLLOWING */ 
+  u8 bImplicitFrame;      /* True if frame was implicitly specified */ 
+  u8 eExclude;            /* TK_NO, TK_CURRENT, TK_TIES, TK_GROUP, or 0 */ 
+  Expr *pStart;           /* Expression for "<expr> PRECEDING" */ 
+  Expr *pEnd;             /* Expression for "<expr> FOLLOWING" */ 
   Window **ppThis;        /* Pointer to this object in Select.pWin list */
-  Window *pNextWin;       /* Next window function belonging to this SELECT */
-  Expr *pFilter;          /* The FILTER expression */
-  FuncDef *pFunc;         /* The function */
-  int iEphCsr;            /* Partition buffer or Peer buffer */
+  Window *pNextWin;       /* Next window function belonging to this SELECT */ 
+  Expr *pFilter;          /* The FILTER expression */ 
+  FuncDef *pFunc;         /* The function */ 
+  int iEphCsr;            /* Partition buffer or Peer buffer */ 
   int regAccum;           /* Accumulator */
   int regResult;          /* Interim result */
-  int csrApp;             /* Function cursor (used by min/max) */
-  int regApp;             /* Function register (also used by min/max) */
-  int regPart;            /* Array of registers for PARTITION BY values */
-  Expr *pOwner;           /* Expression object this window is attached to */
-  int nBufferCol;         /* Number of columns in buffer table */
-  int iArgCol;            /* Offset of first argument for this function */
-  int regOne;             /* Register containing constant value 1 */
-  int regStartRowid;
-  int regEndRowid;
+  int csrApp;             /* Function cursor (used by min/max) */ 
+  int regApp;             /* Function register (also used by min/max) */ 
+  int regPart;            /* Array of registers for PARTITION BY values */ 
+  Expr *pOwner;           /* Expression object this window is attached to */ 
+  int nBufferCol;         /* Number of columns in buffer table */ 
+  int iArgCol;            /* Offset of first argument for this function */ 
+  int regOne;             /* Register containing constant value 1 */ 
+  int regStartRowid; 
+  int regEndRowid; 
   u8 bExprArgs;           /* Defer evaluation of window function arguments
                           ** due to the SQLITE_SUBTYPE flag */
-};
-
-#ifndef SQLITE_OMIT_WINDOWFUNC
-SQLITE_PRIVATE void sqlite3WindowDelete(sqlite3*, Window*);
+}; 
+ 
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+SQLITE_PRIVATE void sqlite3WindowDelete(sqlite3*, Window*); 
 SQLITE_PRIVATE void sqlite3WindowUnlinkFromSelect(Window*);
-SQLITE_PRIVATE void sqlite3WindowListDelete(sqlite3 *db, Window *p);
-SQLITE_PRIVATE Window *sqlite3WindowAlloc(Parse*, int, int, Expr*, int , Expr*, u8);
-SQLITE_PRIVATE void sqlite3WindowAttach(Parse*, Expr*, Window*);
+SQLITE_PRIVATE void sqlite3WindowListDelete(sqlite3 *db, Window *p); 
+SQLITE_PRIVATE Window *sqlite3WindowAlloc(Parse*, int, int, Expr*, int , Expr*, u8); 
+SQLITE_PRIVATE void sqlite3WindowAttach(Parse*, Expr*, Window*); 
 SQLITE_PRIVATE void sqlite3WindowLink(Select *pSel, Window *pWin);
 SQLITE_PRIVATE int sqlite3WindowCompare(const Parse*, const Window*, const Window*, int);
 SQLITE_PRIVATE void sqlite3WindowCodeInit(Parse*, Select*);
-SQLITE_PRIVATE void sqlite3WindowCodeStep(Parse*, Select*, WhereInfo*, int, int);
-SQLITE_PRIVATE int sqlite3WindowRewrite(Parse*, Select*);
-SQLITE_PRIVATE void sqlite3WindowUpdate(Parse*, Window*, Window*, FuncDef*);
-SQLITE_PRIVATE Window *sqlite3WindowDup(sqlite3 *db, Expr *pOwner, Window *p);
-SQLITE_PRIVATE Window *sqlite3WindowListDup(sqlite3 *db, Window *p);
-SQLITE_PRIVATE void sqlite3WindowFunctions(void);
-SQLITE_PRIVATE void sqlite3WindowChain(Parse*, Window*, Window*);
-SQLITE_PRIVATE Window *sqlite3WindowAssemble(Parse*, Window*, ExprList*, ExprList*, Token*);
-#else
-# define sqlite3WindowDelete(a,b)
-# define sqlite3WindowFunctions()
-# define sqlite3WindowAttach(a,b,c)
-#endif
-
-/*
+SQLITE_PRIVATE void sqlite3WindowCodeStep(Parse*, Select*, WhereInfo*, int, int); 
+SQLITE_PRIVATE int sqlite3WindowRewrite(Parse*, Select*); 
+SQLITE_PRIVATE void sqlite3WindowUpdate(Parse*, Window*, Window*, FuncDef*); 
+SQLITE_PRIVATE Window *sqlite3WindowDup(sqlite3 *db, Expr *pOwner, Window *p); 
+SQLITE_PRIVATE Window *sqlite3WindowListDup(sqlite3 *db, Window *p); 
+SQLITE_PRIVATE void sqlite3WindowFunctions(void); 
+SQLITE_PRIVATE void sqlite3WindowChain(Parse*, Window*, Window*); 
+SQLITE_PRIVATE Window *sqlite3WindowAssemble(Parse*, Window*, ExprList*, ExprList*, Token*); 
+#else 
+# define sqlite3WindowDelete(a,b) 
+# define sqlite3WindowFunctions() 
+# define sqlite3WindowAttach(a,b,c) 
+#endif 
+ 
+/* 
 ** Assuming zIn points to the first byte of a UTF-8 character,
 ** advance zIn to point to the first byte of the next UTF-8 character.
 */
@@ -19212,7 +19212,7 @@ SQLITE_PRIVATE int sqlite3IsIdChar(u8);
 */
 SQLITE_PRIVATE int sqlite3StrICmp(const char*,const char*);
 SQLITE_PRIVATE int sqlite3Strlen30(const char*);
-#define sqlite3Strlen30NN(C) (strlen(C)&0x3fffffff)
+#define sqlite3Strlen30NN(C) (strlen(C)&0x3fffffff) 
 SQLITE_PRIVATE char *sqlite3ColumnType(Column*,char*);
 #define sqlite3StrNICmp sqlite3_strnicmp
 
@@ -19301,12 +19301,12 @@ SQLITE_PRIVATE void sqlite3MutexWarnOnContention(sqlite3_mutex*);
 #endif
 
 #ifndef SQLITE_OMIT_FLOATING_POINT
-# define EXP754 (((u64)0x7ff)<<52)
-# define MAN754 ((((u64)1)<<52)-1)
-# define IsNaN(X) (((X)&EXP754)==EXP754 && ((X)&MAN754)!=0)
+# define EXP754 (((u64)0x7ff)<<52) 
+# define MAN754 ((((u64)1)<<52)-1) 
+# define IsNaN(X) (((X)&EXP754)==EXP754 && ((X)&MAN754)!=0) 
 SQLITE_PRIVATE   int sqlite3IsNaN(double);
 #else
-# define IsNaN(X)         0
+# define IsNaN(X)         0 
 # define sqlite3IsNaN(X)  0
 #endif
 
@@ -19333,21 +19333,21 @@ SQLITE_PRIVATE   void *sqlite3TestTextToPtr(const char*);
 SQLITE_PRIVATE   void sqlite3TreeViewExpr(TreeView*, const Expr*, u8);
 SQLITE_PRIVATE   void sqlite3TreeViewBareExprList(TreeView*, const ExprList*, const char*);
 SQLITE_PRIVATE   void sqlite3TreeViewExprList(TreeView*, const ExprList*, u8, const char*);
-SQLITE_PRIVATE   void sqlite3TreeViewSrcList(TreeView*, const SrcList*);
+SQLITE_PRIVATE   void sqlite3TreeViewSrcList(TreeView*, const SrcList*); 
 SQLITE_PRIVATE   void sqlite3TreeViewSelect(TreeView*, const Select*, u8);
 SQLITE_PRIVATE   void sqlite3TreeViewWith(TreeView*, const With*, u8);
-#ifndef SQLITE_OMIT_WINDOWFUNC
-SQLITE_PRIVATE   void sqlite3TreeViewWindow(TreeView*, const Window*, u8);
-SQLITE_PRIVATE   void sqlite3TreeViewWinFunc(TreeView*, const Window*, u8);
-#endif
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+SQLITE_PRIVATE   void sqlite3TreeViewWindow(TreeView*, const Window*, u8); 
+SQLITE_PRIVATE   void sqlite3TreeViewWinFunc(TreeView*, const Window*, u8); 
 #endif
+#endif 
 
 
 SQLITE_PRIVATE void sqlite3SetString(char **, sqlite3*, const char*);
 SQLITE_PRIVATE void sqlite3ErrorMsg(Parse*, const char*, ...);
-SQLITE_PRIVATE int sqlite3ErrorToParser(sqlite3*,int);
+SQLITE_PRIVATE int sqlite3ErrorToParser(sqlite3*,int); 
 SQLITE_PRIVATE void sqlite3Dequote(char*);
-SQLITE_PRIVATE void sqlite3DequoteExpr(Expr*);
+SQLITE_PRIVATE void sqlite3DequoteExpr(Expr*); 
 SQLITE_PRIVATE void sqlite3DequoteToken(Token*);
 SQLITE_PRIVATE void sqlite3TokenInit(Token*,char*);
 SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char*, int);
@@ -19366,14 +19366,14 @@ SQLITE_PRIVATE Expr *sqlite3Expr(sqlite3*,int,const char*);
 SQLITE_PRIVATE void sqlite3ExprAttachSubtrees(sqlite3*,Expr*,Expr*,Expr*);
 SQLITE_PRIVATE Expr *sqlite3PExpr(Parse*, int, Expr*, Expr*);
 SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse*, Expr*, Select*);
-SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse*,Expr*, Expr*);
-SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr*);
+SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse*,Expr*, Expr*); 
+SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr*); 
 SQLITE_PRIVATE Expr *sqlite3ExprFunction(Parse*,ExprList*, const Token*, int);
 SQLITE_PRIVATE void sqlite3ExprFunctionUsable(Parse*,const Expr*,const FuncDef*);
 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse*, Expr*, u32);
 SQLITE_PRIVATE void sqlite3ExprDelete(sqlite3*, Expr*);
 SQLITE_PRIVATE void sqlite3ExprDeferredDelete(Parse*, Expr*);
-SQLITE_PRIVATE void sqlite3ExprUnmapAndDelete(Parse*, Expr*);
+SQLITE_PRIVATE void sqlite3ExprUnmapAndDelete(Parse*, Expr*); 
 SQLITE_PRIVATE ExprList *sqlite3ExprListAppend(Parse*,ExprList*,Expr*);
 SQLITE_PRIVATE ExprList *sqlite3ExprListAppendVector(Parse*,ExprList*,IdList*,Expr*);
 SQLITE_PRIVATE Select *sqlite3ExprListToValues(Parse*, int, ExprList*);
@@ -19382,10 +19382,10 @@ SQLITE_PRIVATE void sqlite3ExprListSetName(Parse*,ExprList*,const Token*,int);
 SQLITE_PRIVATE void sqlite3ExprListSetSpan(Parse*,ExprList*,const char*,const char*);
 SQLITE_PRIVATE void sqlite3ExprListDelete(sqlite3*, ExprList*);
 SQLITE_PRIVATE u32 sqlite3ExprListFlags(const ExprList*);
-SQLITE_PRIVATE int sqlite3IndexHasDuplicateRootPage(Index*);
+SQLITE_PRIVATE int sqlite3IndexHasDuplicateRootPage(Index*); 
 SQLITE_PRIVATE int sqlite3Init(sqlite3*, char**);
 SQLITE_PRIVATE int sqlite3InitCallback(void*, int, char**, char**);
-SQLITE_PRIVATE int sqlite3InitOne(sqlite3*, int, char**, u32);
+SQLITE_PRIVATE int sqlite3InitOne(sqlite3*, int, char**, u32); 
 SQLITE_PRIVATE void sqlite3Pragma(Parse*,Token*,Token*,Token*,int);
 #ifndef SQLITE_OMIT_VIRTUALTABLE
 SQLITE_PRIVATE Module *sqlite3PragmaVtabRegister(sqlite3*,const char *zName);
@@ -19450,9 +19450,9 @@ SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec*);
 SQLITE_PRIVATE int sqlite3BitvecBuiltinTest(int,int*);
 #endif
 
-SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3*);
-SQLITE_PRIVATE void sqlite3RowSetDelete(void*);
-SQLITE_PRIVATE void sqlite3RowSetClear(void*);
+SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3*); 
+SQLITE_PRIVATE void sqlite3RowSetDelete(void*); 
+SQLITE_PRIVATE void sqlite3RowSetClear(void*); 
 SQLITE_PRIVATE void sqlite3RowSetInsert(RowSet*, i64);
 SQLITE_PRIVATE int sqlite3RowSetTest(RowSet*, int iBatch, i64);
 SQLITE_PRIVATE int sqlite3RowSetNext(RowSet*, i64*);
@@ -19471,7 +19471,7 @@ SQLITE_PRIVATE   int sqlite3DbMaskAllZero(yDbMask);
 SQLITE_PRIVATE void sqlite3DropTable(Parse*, SrcList*, int, int);
 SQLITE_PRIVATE void sqlite3CodeDropTable(Parse*, Table*, int, int);
 SQLITE_PRIVATE void sqlite3DeleteTable(sqlite3*, Table*);
-SQLITE_PRIVATE void sqlite3FreeIndex(sqlite3*, Index*);
+SQLITE_PRIVATE void sqlite3FreeIndex(sqlite3*, Index*); 
 #ifndef SQLITE_OMIT_AUTOINCREMENT
 SQLITE_PRIVATE   void sqlite3AutoincrementBegin(Parse *pParse);
 SQLITE_PRIVATE   void sqlite3AutoincrementEnd(Parse *pParse);
@@ -19479,16 +19479,16 @@ SQLITE_PRIVATE   void sqlite3AutoincrementEnd(Parse *pParse);
 # define sqlite3AutoincrementBegin(X)
 # define sqlite3AutoincrementEnd(X)
 #endif
-SQLITE_PRIVATE void sqlite3Insert(Parse*, SrcList*, Select*, IdList*, int, Upsert*);
+SQLITE_PRIVATE void sqlite3Insert(Parse*, SrcList*, Select*, IdList*, int, Upsert*); 
 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
 SQLITE_PRIVATE   void sqlite3ComputeGeneratedColumns(Parse*, int, Table*);
 #endif
 SQLITE_PRIVATE void *sqlite3ArrayAllocate(sqlite3*,void*,int,int*,int*);
-SQLITE_PRIVATE IdList *sqlite3IdListAppend(Parse*, IdList*, Token*);
+SQLITE_PRIVATE IdList *sqlite3IdListAppend(Parse*, IdList*, Token*); 
 SQLITE_PRIVATE int sqlite3IdListIndex(IdList*,const char*);
-SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(Parse*, SrcList*, int, int);
+SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(Parse*, SrcList*, int, int); 
 SQLITE_PRIVATE SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2);
-SQLITE_PRIVATE SrcList *sqlite3SrcListAppend(Parse*, SrcList*, Token*, Token*);
+SQLITE_PRIVATE SrcList *sqlite3SrcListAppend(Parse*, SrcList*, Token*, Token*); 
 SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, Token*,
                                       Token*, Select*, Expr*, IdList*);
 SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *);
@@ -19513,14 +19513,14 @@ SQLITE_PRIVATE void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int);
 SQLITE_PRIVATE Expr *sqlite3LimitWhere(Parse*,SrcList*,Expr*,ExprList*,Expr*,char*);
 #endif
 SQLITE_PRIVATE void sqlite3DeleteFrom(Parse*, SrcList*, Expr*, ExprList*, Expr*);
-SQLITE_PRIVATE void sqlite3Update(Parse*, SrcList*, ExprList*,Expr*,int,ExprList*,Expr*,
-                   Upsert*);
+SQLITE_PRIVATE void sqlite3Update(Parse*, SrcList*, ExprList*,Expr*,int,ExprList*,Expr*, 
+                   Upsert*); 
 SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(Parse*,SrcList*,Expr*,ExprList*,ExprList*,u16,int);
 SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo*);
 SQLITE_PRIVATE LogEst sqlite3WhereOutputRowCount(WhereInfo*);
 SQLITE_PRIVATE int sqlite3WhereIsDistinct(WhereInfo*);
 SQLITE_PRIVATE int sqlite3WhereIsOrdered(WhereInfo*);
-SQLITE_PRIVATE int sqlite3WhereOrderByLimitOptLabel(WhereInfo*);
+SQLITE_PRIVATE int sqlite3WhereOrderByLimitOptLabel(WhereInfo*); 
 SQLITE_PRIVATE void sqlite3WhereMinMaxOptEarlyOut(Vdbe*,WhereInfo*);
 SQLITE_PRIVATE int sqlite3WhereIsSorted(WhereInfo*);
 SQLITE_PRIVATE int sqlite3WhereContinueLabel(WhereInfo*);
@@ -19560,14 +19560,14 @@ SQLITE_PRIVATE Table *sqlite3LocateTableItem(Parse*,u32 flags,SrcItem *);
 SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3*,const char*, const char*);
 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteTable(sqlite3*,int,const char*);
 SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3*,int,const char*);
-SQLITE_PRIVATE void sqlite3Vacuum(Parse*,Token*,Expr*);
-SQLITE_PRIVATE int sqlite3RunVacuum(char**, sqlite3*, int, sqlite3_value*);
+SQLITE_PRIVATE void sqlite3Vacuum(Parse*,Token*,Expr*); 
+SQLITE_PRIVATE int sqlite3RunVacuum(char**, sqlite3*, int, sqlite3_value*); 
 SQLITE_PRIVATE char *sqlite3NameFromToken(sqlite3*, const Token*);
 SQLITE_PRIVATE int sqlite3ExprCompare(const Parse*,const Expr*,const Expr*, int);
 SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr*,Expr*,int);
 SQLITE_PRIVATE int sqlite3ExprListCompare(const ExprList*,const ExprList*, int);
 SQLITE_PRIVATE int sqlite3ExprImpliesExpr(const Parse*,const Expr*,const Expr*, int);
-SQLITE_PRIVATE int sqlite3ExprImpliesNonNullRow(Expr*,int);
+SQLITE_PRIVATE int sqlite3ExprImpliesNonNullRow(Expr*,int); 
 SQLITE_PRIVATE void sqlite3AggInfoPersistWalkerInit(Walker*,Parse*);
 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext*, Expr*);
 SQLITE_PRIVATE void sqlite3ExprAnalyzeAggList(NameContext*,ExprList*);
@@ -19587,8 +19587,8 @@ SQLITE_PRIVATE void sqlite3Savepoint(Parse*, int, Token*);
 SQLITE_PRIVATE void sqlite3CloseSavepoints(sqlite3 *);
 SQLITE_PRIVATE void sqlite3LeaveMutexAndCloseZombie(sqlite3*);
 SQLITE_PRIVATE u32 sqlite3IsTrueOrFalse(const char*);
-SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr*);
-SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr*);
+SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr*); 
+SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr*); 
 SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr*);
 SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr*);
 SQLITE_PRIVATE int sqlite3ExprIsConstantOrFunction(Expr*, u8);
@@ -19606,9 +19606,9 @@ SQLITE_PRIVATE void sqlite3GenerateRowDelete(
 SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete(Parse*, Table*, int, int, int*, int);
 SQLITE_PRIVATE int sqlite3GenerateIndexKey(Parse*, Index*, int, int, int, int*,Index*,int);
 SQLITE_PRIVATE void sqlite3ResolvePartIdxLabel(Parse*,int);
-SQLITE_PRIVATE int sqlite3ExprReferencesUpdatedColumn(Expr*,int*,int);
+SQLITE_PRIVATE int sqlite3ExprReferencesUpdatedColumn(Expr*,int*,int); 
 SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(Parse*,Table*,int*,int,int,int,int,
-                                     u8,u8,int,int*,int*,Upsert*);
+                                     u8,u8,int,int*,int*,Upsert*); 
 #ifdef SQLITE_ENABLE_NULL_TRIM
 SQLITE_PRIVATE   void sqlite3SetMakeRecordP5(Vdbe*,Table*);
 #else
@@ -19627,7 +19627,7 @@ SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3*,const ExprList*,int);
 SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3*,const SrcList*,int);
 SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3*,const IdList*);
 SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3*,const Select*,int);
-SQLITE_PRIVATE FuncDef *sqlite3FunctionSearch(int,const char*);
+SQLITE_PRIVATE FuncDef *sqlite3FunctionSearch(int,const char*); 
 SQLITE_PRIVATE void sqlite3InsertBuiltinFuncs(FuncDef*,int);
 SQLITE_PRIVATE FuncDef *sqlite3FindFunction(sqlite3*,const char*,int,u8,u8);
 SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void);
@@ -19657,13 +19657,13 @@ SQLITE_PRIVATE   void sqlite3CodeRowTriggerDirect(Parse *, Trigger *, Table *, i
 SQLITE_PRIVATE   void sqlite3DeleteTriggerStep(sqlite3*, TriggerStep*);
 SQLITE_PRIVATE   TriggerStep *sqlite3TriggerSelectStep(sqlite3*,Select*,
                                         const char*,const char*);
-SQLITE_PRIVATE   TriggerStep *sqlite3TriggerInsertStep(Parse*,Token*, IdList*,
-                                        Select*,u8,Upsert*,
+SQLITE_PRIVATE   TriggerStep *sqlite3TriggerInsertStep(Parse*,Token*, IdList*, 
+                                        Select*,u8,Upsert*, 
                                         const char*,const char*);
 SQLITE_PRIVATE   TriggerStep *sqlite3TriggerUpdateStep(Parse*,Token*,SrcList*,ExprList*,
                                         Expr*, u8, const char*,const char*);
-SQLITE_PRIVATE   TriggerStep *sqlite3TriggerDeleteStep(Parse*,Token*, Expr*,
-                                        const char*,const char*);
+SQLITE_PRIVATE   TriggerStep *sqlite3TriggerDeleteStep(Parse*,Token*, Expr*, 
+                                        const char*,const char*); 
 SQLITE_PRIVATE   void sqlite3DeleteTrigger(sqlite3*, Trigger*);
 SQLITE_PRIVATE   void sqlite3UnlinkAndDeleteTrigger(sqlite3*,int,const char*);
 SQLITE_PRIVATE   u32 sqlite3TriggerColmask(Parse*,Trigger*,ExprList*,int,int,Table*,int);
@@ -19709,7 +19709,7 @@ SQLITE_PRIVATE int sqlite3FixSrcList(DbFixer*, SrcList*);
 SQLITE_PRIVATE int sqlite3FixSelect(DbFixer*, Select*);
 SQLITE_PRIVATE int sqlite3FixExpr(DbFixer*, Expr*);
 SQLITE_PRIVATE int sqlite3FixTriggerStep(DbFixer*, TriggerStep*);
-SQLITE_PRIVATE int sqlite3RealSameAsInt(double,sqlite3_int64);
+SQLITE_PRIVATE int sqlite3RealSameAsInt(double,sqlite3_int64); 
 SQLITE_PRIVATE void sqlite3Int64ToText(i64,char*);
 SQLITE_PRIVATE int sqlite3AtoF(const char *z, double*, int, u8);
 SQLITE_PRIVATE int sqlite3GetInt32(const char *, int*);
@@ -19781,13 +19781,13 @@ SQLITE_PRIVATE const char *sqlite3ErrName(int);
 #endif
 
 #ifndef SQLITE_OMIT_DESERIALIZE
-SQLITE_PRIVATE int sqlite3MemdbInit(void);
-#endif
-
+SQLITE_PRIVATE int sqlite3MemdbInit(void); 
+#endif 
+ 
 SQLITE_PRIVATE const char *sqlite3ErrStr(int);
 SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse);
 SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq(sqlite3*,u8 enc, const char*,int);
-SQLITE_PRIVATE int sqlite3IsBinary(const CollSeq*);
+SQLITE_PRIVATE int sqlite3IsBinary(const CollSeq*); 
 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName);
 SQLITE_PRIVATE void sqlite3SetTextEncoding(sqlite3 *db, u8);
 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr);
@@ -19798,7 +19798,7 @@ SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(const Parse*,Expr*,const char*)
 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr*);
 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr*);
 SQLITE_PRIVATE int sqlite3CheckCollSeq(Parse *, CollSeq *);
-SQLITE_PRIVATE int sqlite3WritableSchema(sqlite3*);
+SQLITE_PRIVATE int sqlite3WritableSchema(sqlite3*); 
 SQLITE_PRIVATE int sqlite3CheckObjectName(Parse*, const char*,const char*,const char*);
 SQLITE_PRIVATE void sqlite3VdbeSetChanges(sqlite3 *, i64);
 SQLITE_PRIVATE int sqlite3AddInt64(i64*,i64);
@@ -19818,9 +19818,9 @@ SQLITE_PRIVATE void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8,
                         void(*)(void*));
 SQLITE_PRIVATE void sqlite3ValueSetNull(sqlite3_value*);
 SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value*);
-#ifndef SQLITE_UNTESTABLE
-SQLITE_PRIVATE void sqlite3ResultIntReal(sqlite3_context*);
-#endif
+#ifndef SQLITE_UNTESTABLE 
+SQLITE_PRIVATE void sqlite3ResultIntReal(sqlite3_context*); 
+#endif 
 SQLITE_PRIVATE sqlite3_value *sqlite3ValueNew(sqlite3 *);
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *, const void*, int, u8);
@@ -19845,19 +19845,19 @@ SQLITE_PRIVATE FuncDefHash sqlite3BuiltinFunctions;
 SQLITE_PRIVATE int sqlite3PendingByte;
 #endif
 #endif /* SQLITE_AMALGAMATION */
-#ifdef VDBE_PROFILE
-SQLITE_PRIVATE sqlite3_uint64 sqlite3NProfileCnt;
-#endif
+#ifdef VDBE_PROFILE 
+SQLITE_PRIVATE sqlite3_uint64 sqlite3NProfileCnt; 
+#endif 
 SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3*, int, Pgno, Pgno);
 SQLITE_PRIVATE void sqlite3Reindex(Parse*, Token*, Token*);
 SQLITE_PRIVATE void sqlite3AlterFunctions(void);
 SQLITE_PRIVATE void sqlite3AlterRenameTable(Parse*, SrcList*, Token*);
-SQLITE_PRIVATE void sqlite3AlterRenameColumn(Parse*, SrcList*, Token*, Token*);
+SQLITE_PRIVATE void sqlite3AlterRenameColumn(Parse*, SrcList*, Token*, Token*); 
 SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *, int *);
 SQLITE_PRIVATE void sqlite3NestedParse(Parse*, const char*, ...);
-SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3*, int);
-SQLITE_PRIVATE void sqlite3CodeRhsOfIN(Parse*, Expr*, int);
-SQLITE_PRIVATE int sqlite3CodeSubselect(Parse*, Expr*);
+SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3*, int); 
+SQLITE_PRIVATE void sqlite3CodeRhsOfIN(Parse*, Expr*, int); 
+SQLITE_PRIVATE int sqlite3CodeSubselect(Parse*, Expr*); 
 SQLITE_PRIVATE void sqlite3SelectPrep(Parse*, Select*, NameContext*);
 SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse*, SrcItem*);
 SQLITE_PRIVATE void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p);
@@ -19872,7 +19872,7 @@ SQLITE_PRIVATE u8 sqlite3StrIHash(const char*);
 SQLITE_PRIVATE int sqlite3ResolveExprNames(NameContext*, Expr*);
 SQLITE_PRIVATE int sqlite3ResolveExprListNames(NameContext*, ExprList*);
 SQLITE_PRIVATE void sqlite3ResolveSelectNames(Parse*, Select*, NameContext*);
-SQLITE_PRIVATE int sqlite3ResolveSelfReference(Parse*,Table*,int,Expr*,ExprList*);
+SQLITE_PRIVATE int sqlite3ResolveSelfReference(Parse*,Table*,int,Expr*,ExprList*); 
 SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy(Parse*, Select*, ExprList*, const char*);
 SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *, Table *, int, int);
 SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *, Token *);
@@ -19880,10 +19880,10 @@ SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *, SrcList *);
 SQLITE_PRIVATE void sqlite3AlterDropColumn(Parse*, SrcList*, const Token*);
 SQLITE_PRIVATE const void *sqlite3RenameTokenMap(Parse*, const void*, const Token*);
 SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse*, const void *pTo, const void *pFrom);
-SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse*, Expr*);
-SQLITE_PRIVATE void sqlite3RenameExprlistUnmap(Parse*, ExprList*);
+SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse*, Expr*); 
+SQLITE_PRIVATE void sqlite3RenameExprlistUnmap(Parse*, ExprList*); 
 SQLITE_PRIVATE CollSeq *sqlite3GetCollSeq(Parse*, u8, CollSeq *, const char*);
-SQLITE_PRIVATE char sqlite3AffinityType(const char*, Column*);
+SQLITE_PRIVATE char sqlite3AffinityType(const char*, Column*); 
 SQLITE_PRIVATE void sqlite3Analyze(Parse*, Token*, Token*);
 SQLITE_PRIVATE int sqlite3InvokeBusyHandler(BusyHandler*);
 SQLITE_PRIVATE int sqlite3FindDb(sqlite3*, Token*);
@@ -19900,22 +19900,22 @@ SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3*,int,int);
 SQLITE_PRIVATE void sqlite3KeyInfoUnref(KeyInfo*);
 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoRef(KeyInfo*);
 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse*, Index*);
-SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoFromExprList(Parse*, ExprList*, int, int);
+SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoFromExprList(Parse*, ExprList*, int, int); 
 SQLITE_PRIVATE const char *sqlite3SelectOpName(int);
 SQLITE_PRIVATE int sqlite3HasExplicitNulls(Parse*, ExprList*);
-
+ 
 #ifdef SQLITE_DEBUG
 SQLITE_PRIVATE int sqlite3KeyInfoIsWriteable(KeyInfo*);
 #endif
 SQLITE_PRIVATE int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *,
   void (*)(sqlite3_context*,int,sqlite3_value **),
   void (*)(sqlite3_context*,int,sqlite3_value **),
-  void (*)(sqlite3_context*),
-  void (*)(sqlite3_context*),
+  void (*)(sqlite3_context*), 
+  void (*)(sqlite3_context*), 
   void (*)(sqlite3_context*,int,sqlite3_value **),
   FuncDestructor *pDestructor
 );
-SQLITE_PRIVATE void sqlite3NoopDestructor(void*);
+SQLITE_PRIVATE void sqlite3NoopDestructor(void*); 
 SQLITE_PRIVATE void sqlite3OomFault(sqlite3*);
 SQLITE_PRIVATE void sqlite3OomClear(sqlite3*);
 SQLITE_PRIVATE int sqlite3ApiExit(sqlite3 *db, int);
@@ -19950,11 +19950,11 @@ SQLITE_PRIVATE char sqlite3IndexColumnAffinity(sqlite3*, Index*, int);
 ** The interface to the LEMON-generated parser
 */
 #ifndef SQLITE_AMALGAMATION
-SQLITE_PRIVATE   void *sqlite3ParserAlloc(void*(*)(u64), Parse*);
+SQLITE_PRIVATE   void *sqlite3ParserAlloc(void*(*)(u64), Parse*); 
 SQLITE_PRIVATE   void sqlite3ParserFree(void*, void(*)(void*));
 #endif
-SQLITE_PRIVATE void sqlite3Parser(void*, int, Token);
-SQLITE_PRIVATE int sqlite3ParserFallback(int);
+SQLITE_PRIVATE void sqlite3Parser(void*, int, Token); 
+SQLITE_PRIVATE int sqlite3ParserFallback(int); 
 #ifdef YYTRACKMAXSTACKDEPTH
 SQLITE_PRIVATE   int sqlite3ParserStackPeak(void*);
 #endif
@@ -20037,9 +20037,9 @@ SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe*, const char*, int);
 SQLITE_PRIVATE int sqlite3TransferBindings(sqlite3_stmt *, sqlite3_stmt *);
 SQLITE_PRIVATE void sqlite3ParserReset(Parse*);
 SQLITE_PRIVATE void *sqlite3ParserAddCleanup(Parse*,void(*)(sqlite3*,void*),void*);
-#ifdef SQLITE_ENABLE_NORMALIZE
-SQLITE_PRIVATE char *sqlite3Normalize(Vdbe*, const char*);
-#endif
+#ifdef SQLITE_ENABLE_NORMALIZE 
+SQLITE_PRIVATE char *sqlite3Normalize(Vdbe*, const char*); 
+#endif 
 SQLITE_PRIVATE int sqlite3Reprepare(Vdbe*);
 SQLITE_PRIVATE void sqlite3ExprListCheckLength(Parse*, ExprList*, const char*);
 SQLITE_PRIVATE CollSeq *sqlite3ExprCompareCollSeq(Parse*,const Expr*);
@@ -20063,23 +20063,23 @@ SQLITE_PRIVATE   With *sqlite3WithPush(Parse*, With*, u8);
 # define sqlite3WithDelete(x,y)
 # define sqlite3WithPush(x,y,z) ((void*)0)
 #endif
-#ifndef SQLITE_OMIT_UPSERT
+#ifndef SQLITE_OMIT_UPSERT 
 SQLITE_PRIVATE   Upsert *sqlite3UpsertNew(sqlite3*,ExprList*,Expr*,ExprList*,Expr*,Upsert*);
-SQLITE_PRIVATE   void sqlite3UpsertDelete(sqlite3*,Upsert*);
-SQLITE_PRIVATE   Upsert *sqlite3UpsertDup(sqlite3*,Upsert*);
-SQLITE_PRIVATE   int sqlite3UpsertAnalyzeTarget(Parse*,SrcList*,Upsert*);
-SQLITE_PRIVATE   void sqlite3UpsertDoUpdate(Parse*,Upsert*,Table*,Index*,int);
+SQLITE_PRIVATE   void sqlite3UpsertDelete(sqlite3*,Upsert*); 
+SQLITE_PRIVATE   Upsert *sqlite3UpsertDup(sqlite3*,Upsert*); 
+SQLITE_PRIVATE   int sqlite3UpsertAnalyzeTarget(Parse*,SrcList*,Upsert*); 
+SQLITE_PRIVATE   void sqlite3UpsertDoUpdate(Parse*,Upsert*,Table*,Index*,int); 
 SQLITE_PRIVATE   Upsert *sqlite3UpsertOfIndex(Upsert*,Index*);
 SQLITE_PRIVATE   int sqlite3UpsertNextIsIPK(Upsert*);
-#else
+#else 
 #define sqlite3UpsertNew(u,v,w,x,y,z) ((Upsert*)0)
-#define sqlite3UpsertDelete(x,y)
+#define sqlite3UpsertDelete(x,y) 
 #define sqlite3UpsertDup(x,y)         ((Upsert*)0)
 #define sqlite3UpsertOfIndex(x,y)     ((Upsert*)0)
 #define sqlite3UpsertNextIsIPK(x)     0
-#endif
-
+#endif 
 
+ 
 /* Declarations for functions in fkey.c. All of these are replaced by
 ** no-op macros if OMIT_FOREIGN_KEY is defined. In this case no foreign
 ** key functionality is available. If OMIT_TRIGGER is defined but
@@ -20146,7 +20146,7 @@ SQLITE_PRIVATE   void sqlite3EndBenignMalloc(void);
 #define IN_INDEX_NOOP_OK     0x0001  /* OK to return IN_INDEX_NOOP */
 #define IN_INDEX_MEMBERSHIP  0x0002  /* IN operator used for membership test */
 #define IN_INDEX_LOOP        0x0004  /* IN operator used as a loop */
-SQLITE_PRIVATE int sqlite3FindInIndex(Parse *, Expr *, u32, int*, int*, int*);
+SQLITE_PRIVATE int sqlite3FindInIndex(Parse *, Expr *, u32, int*, int*, int*); 
 
 SQLITE_PRIVATE int sqlite3JournalOpen(sqlite3_vfs *, const char *, sqlite3_file *, int, int);
 SQLITE_PRIVATE int sqlite3JournalSize(sqlite3_vfs *);
@@ -21429,15 +21429,15 @@ SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[256] = {
 ** SQLITE_ALLOW_COVERING_INDEX_SCAN compile-time option, or is "on" if
 ** that compile-time option is omitted.
 */
-#if !defined(SQLITE_ALLOW_COVERING_INDEX_SCAN)
+#if !defined(SQLITE_ALLOW_COVERING_INDEX_SCAN) 
 # define SQLITE_ALLOW_COVERING_INDEX_SCAN 1
-#else
+#else 
 # if !SQLITE_ALLOW_COVERING_INDEX_SCAN
-#   error "Compile-time disabling of covering index scan using the\
- -DSQLITE_ALLOW_COVERING_INDEX_SCAN=0 option is deprecated.\
- Contact SQLite developers if this is a problem for you, and\
- delete this #error macro to continue with your build."
-# endif
+#   error "Compile-time disabling of covering index scan using the\ 
+ -DSQLITE_ALLOW_COVERING_INDEX_SCAN=0 option is deprecated.\ 
+ Contact SQLite developers if this is a problem for you, and\ 
+ delete this #error macro to continue with your build." 
+# endif 
 #endif
 
 /* The minimum PMA size is set to this value multiplied by the database
@@ -21481,13 +21481,13 @@ SQLITE_PRIVATE const unsigned char sqlite3CtypeMap[256] = {
 #endif
 
 
-/* The default maximum size of an in-memory database created using
-** sqlite3_deserialize()
-*/
-#ifndef SQLITE_MEMDB_DEFAULT_MAXSIZE
-# define SQLITE_MEMDB_DEFAULT_MAXSIZE 1073741824
-#endif
-
+/* The default maximum size of an in-memory database created using 
+** sqlite3_deserialize() 
+*/ 
+#ifndef SQLITE_MEMDB_DEFAULT_MAXSIZE 
+# define SQLITE_MEMDB_DEFAULT_MAXSIZE 1073741824 
+#endif 
+ 
 /*
 ** The following singleton contains the global configuration for
 ** the SQLite library.
@@ -21537,14 +21537,14 @@ SQLITE_PRIVATE SQLITE_WSD struct Sqlite3Config sqlite3Config = {
    0,                         /* pVbeBranchArg */
 #endif
 #ifndef SQLITE_OMIT_DESERIALIZE
-   SQLITE_MEMDB_DEFAULT_MAXSIZE,   /* mxMemdbSize */
-#endif
+   SQLITE_MEMDB_DEFAULT_MAXSIZE,   /* mxMemdbSize */ 
+#endif 
 #ifndef SQLITE_UNTESTABLE
    0,                         /* xTestCallback */
 #endif
    0,                         /* bLocaltimeFault */
-   0x7ffffffe,                /* iOnceResetThreshold */
-   SQLITE_DEFAULT_SORTERREF_SIZE,   /* szSorterRef */
+   0x7ffffffe,                /* iOnceResetThreshold */ 
+   SQLITE_DEFAULT_SORTERREF_SIZE,   /* szSorterRef */ 
    0,                         /* iPrngSeed */
 };
 
@@ -21567,13 +21567,13 @@ SQLITE_PRIVATE FuncDefHash sqlite3BuiltinFunctions;
 SQLITE_PRIVATE unsigned int sqlite3CoverageCounter;
 #endif /* SQLITE_COVERAGE_TEST || SQLITE_DEBUG */
 
-#ifdef VDBE_PROFILE
-/*
-** The following performance counter can be used in place of
-** sqlite3Hwtime() for profiling.  This is a no-op on standard builds.
-*/
-SQLITE_PRIVATE sqlite3_uint64 sqlite3NProfileCnt = 0;
-#endif
+#ifdef VDBE_PROFILE 
+/* 
+** The following performance counter can be used in place of 
+** sqlite3Hwtime() for profiling.  This is a no-op on standard builds. 
+*/ 
+SQLITE_PRIVATE sqlite3_uint64 sqlite3NProfileCnt = 0; 
+#endif 
 
 /*
 ** The value of the "pending" byte must be 0x40000000 (1 byte past the
@@ -21852,9 +21852,9 @@ struct VdbeFrame {
   void *token;            /* Copy of SubProgram.token */
   i64 lastRowid;          /* Last insert rowid (sqlite3.lastRowid) */
   AuxData *pAuxData;      /* Linked list of auxdata allocations */
-#if SQLITE_DEBUG
-  u32 iFrameMagic;        /* magic number for sanity checking */
-#endif
+#if SQLITE_DEBUG 
+  u32 iFrameMagic;        /* magic number for sanity checking */ 
+#endif 
   int nCursor;            /* Number of entries in apCsr */
   int pc;                 /* Program Counter in parent (calling) frame */
   int nOp;                /* Size of aOp array */
@@ -21865,13 +21865,13 @@ struct VdbeFrame {
   i64 nDbChange;          /* Value of db->nChange */
 };
 
-/* Magic number for sanity checking on VdbeFrame objects */
-#define SQLITE_FRAME_MAGIC 0x879fb71e
-
-/*
-** Return a pointer to the array of registers allocated for use
-** by a VdbeFrame.
-*/
+/* Magic number for sanity checking on VdbeFrame objects */ 
+#define SQLITE_FRAME_MAGIC 0x879fb71e 
+ 
+/* 
+** Return a pointer to the array of registers allocated for use 
+** by a VdbeFrame. 
+*/ 
 #define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))])
 
 /*
@@ -21900,7 +21900,7 @@ struct sqlite3_value {
   void (*xDel)(void*);/* Destructor for Mem.z - only valid if MEM_Dyn */
 #ifdef SQLITE_DEBUG
   Mem *pScopyFrom;    /* This Mem is a shallow copy of pScopyFrom */
-  u16 mScopyFlags;    /* flags value immediately after the shallow copy */
+  u16 mScopyFlags;    /* flags value immediately after the shallow copy */ 
 #endif
 };
 
@@ -21928,12 +21928,12 @@ struct sqlite3_value {
 #define MEM_Int       0x0004   /* Value is an integer */
 #define MEM_Real      0x0008   /* Value is a real number */
 #define MEM_Blob      0x0010   /* Value is a BLOB */
-#define MEM_IntReal   0x0020   /* MEM_Int that stringifies like MEM_Real */
-#define MEM_AffMask   0x003f   /* Mask of affinity bits */
-#define MEM_FromBind  0x0040   /* Value originates from sqlite3_bind() */
+#define MEM_IntReal   0x0020   /* MEM_Int that stringifies like MEM_Real */ 
+#define MEM_AffMask   0x003f   /* Mask of affinity bits */ 
+#define MEM_FromBind  0x0040   /* Value originates from sqlite3_bind() */ 
 #define MEM_Undefined 0x0080   /* Value is undefined */
 #define MEM_Cleared   0x0100   /* NULL set by OP_Null, not from data */
-#define MEM_TypeMask  0xc1bf   /* Mask of type bits */
+#define MEM_TypeMask  0xc1bf   /* Mask of type bits */ 
 
 
 /* Whenever Mem contains a valid string or blob representation, one of
@@ -21957,7 +21957,7 @@ struct sqlite3_value {
 ** that needs to be deallocated to avoid a leak.
 */
 #define VdbeMemDynamic(X)  \
-  (((X)->flags&(MEM_Agg|MEM_Dyn))!=0)
+  (((X)->flags&(MEM_Agg|MEM_Dyn))!=0) 
 
 /*
 ** Clear any existing type flags from a Mem and replace them with f
@@ -21966,13 +21966,13 @@ struct sqlite3_value {
    ((p)->flags = ((p)->flags&~(MEM_TypeMask|MEM_Zero))|f)
 
 /*
-** True if Mem X is a NULL-nochng type.
-*/
-#define MemNullNochng(X) \
+** True if Mem X is a NULL-nochng type. 
+*/ 
+#define MemNullNochng(X) \ 
   (((X)->flags&MEM_TypeMask)==(MEM_Null|MEM_Zero) \
     && (X)->n==0 && (X)->u.nZero==0)
-
-/*
+ 
+/* 
 ** Return true if a memory cell is not marked as invalid.  This macro
 ** is for use inside assert() statements only.
 */
@@ -22025,9 +22025,9 @@ struct sqlite3_context {
 */
 typedef unsigned bft;  /* Bit Field Type */
 
-/* The ScanStatus object holds a single value for the
-** sqlite3_stmt_scanstatus() interface.
-*/
+/* The ScanStatus object holds a single value for the 
+** sqlite3_stmt_scanstatus() interface. 
+*/ 
 typedef struct ScanStatus ScanStatus;
 struct ScanStatus {
   int addrExplain;                /* OP_Explain for loop */
@@ -22038,19 +22038,19 @@ struct ScanStatus {
   char *zName;                    /* Name of table or index */
 };
 
-/* The DblquoteStr object holds the text of a double-quoted
-** string for a prepared statement.  A linked list of these objects
-** is constructed during statement parsing and is held on Vdbe.pDblStr.
-** When computing a normalized SQL statement for an SQL statement, that
-** list is consulted for each double-quoted identifier to see if the
-** identifier should really be a string literal.
-*/
-typedef struct DblquoteStr DblquoteStr;
-struct DblquoteStr {
-  DblquoteStr *pNextStr;   /* Next string literal in the list */
-  char z[8];               /* Dequoted value for the string */
-};
-
+/* The DblquoteStr object holds the text of a double-quoted 
+** string for a prepared statement.  A linked list of these objects 
+** is constructed during statement parsing and is held on Vdbe.pDblStr. 
+** When computing a normalized SQL statement for an SQL statement, that 
+** list is consulted for each double-quoted identifier to see if the 
+** identifier should really be a string literal. 
+*/ 
+typedef struct DblquoteStr DblquoteStr; 
+struct DblquoteStr { 
+  DblquoteStr *pNextStr;   /* Next string literal in the list */ 
+  char z[8];               /* Dequoted value for the string */ 
+}; 
+ 
 /*
 ** An instance of the virtual machine.  This structure contains the complete
 ** state of the virtual machine.
@@ -22070,22 +22070,22 @@ struct Vdbe {
   int pc;                 /* The program counter */
   int rc;                 /* Value to return */
   i64 nChange;            /* Number of db changes made since last reset */
-  int iStatement;         /* Statement number (or 0 if has no opened stmt) */
+  int iStatement;         /* Statement number (or 0 if has no opened stmt) */ 
   i64 iCurrentTime;       /* Value of julianday('now') for this statement */
   i64 nFkConstraint;      /* Number of imm. FK constraints this VM */
   i64 nStmtDefCons;       /* Number of def. constraints when stmt started */
   i64 nStmtDefImmCons;    /* Number of def. imm constraints when stmt started */
-  Mem *aMem;              /* The memory locations */
-  Mem **apArg;            /* Arguments to currently executing user function */
-  VdbeCursor **apCsr;     /* One element of this array for each open cursor */
-  Mem *aVar;              /* Values for the OP_Variable opcode. */
+  Mem *aMem;              /* The memory locations */ 
+  Mem **apArg;            /* Arguments to currently executing user function */ 
+  VdbeCursor **apCsr;     /* One element of this array for each open cursor */ 
+  Mem *aVar;              /* Values for the OP_Variable opcode. */ 
 
   /* When allocating a new Vdbe object, all of the fields below should be
   ** initialized to zero or NULL */
 
   Op *aOp;                /* Space to hold the virtual machine's program */
-  int nOp;                /* Number of instructions in the program */
-  int nOpAlloc;           /* Slots allocated for aOp[] */
+  int nOp;                /* Number of instructions in the program */ 
+  int nOpAlloc;           /* Slots allocated for aOp[] */ 
   Mem *aColName;          /* Column names to return */
   Mem *pResultSet;        /* Pointer to an array of results */
   char *zErrMsg;          /* Error message written here */
@@ -22095,15 +22095,15 @@ struct Vdbe {
 #endif
 #ifdef SQLITE_DEBUG
   int rcApp;              /* errcode set by sqlite3_result_error_code() */
-  u32 nWrite;             /* Number of write operations that have occurred */
+  u32 nWrite;             /* Number of write operations that have occurred */ 
 #endif
   u16 nResColumn;         /* Number of columns in one row of the result set */
   u8 errorAction;         /* Recovery action to do in case of an error */
   u8 minWriteFileFormat;  /* Minimum file format for writable database files */
   u8 prepFlags;           /* SQLITE_PREPARE_* flags */
   u8 doingRerun;          /* True if rerunning after an auto-reprepare */
-  bft expired:2;          /* 1: recompile VM immediately  2: when convenient */
-  bft explain:2;          /* True if EXPLAIN present on SQL command */
+  bft expired:2;          /* 1: recompile VM immediately  2: when convenient */ 
+  bft explain:2;          /* True if EXPLAIN present on SQL command */ 
   bft changeCntOn:1;      /* True to update the change-counter */
   bft runOnlyOnce:1;      /* Automatically expire on reset */
   bft usesStmtJournal:1;  /* True if uses a statement journal */
@@ -22113,10 +22113,10 @@ struct Vdbe {
   yDbMask lockMask;       /* Subset of btreeMask that requires a lock */
   u32 aCounter[7];        /* Counters used by sqlite3_stmt_status() */
   char *zSql;             /* Text of the SQL statement that generated this */
-#ifdef SQLITE_ENABLE_NORMALIZE
-  char *zNormSql;         /* Normalization of the associated SQL statement */
-  DblquoteStr *pDblStr;   /* List of double-quoted string literals */
-#endif
+#ifdef SQLITE_ENABLE_NORMALIZE 
+  char *zNormSql;         /* Normalization of the associated SQL statement */ 
+  DblquoteStr *pDblStr;   /* List of double-quoted string literals */ 
+#endif 
   void *pFree;            /* Free this when deleting the vdbe */
   VdbeFrame *pFrame;      /* Parent frame */
   VdbeFrame *pDelFrame;   /* List of frame objects to free on VM reset */
@@ -22189,7 +22189,7 @@ SQLITE_PRIVATE char *sqlite3VdbeDisplayComment(sqlite3*,const Op*,const char*);
 #endif
 #if !defined(SQLITE_OMIT_EXPLAIN)
 SQLITE_PRIVATE int sqlite3VdbeList(Vdbe*);
-#endif
+#endif 
 SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe*);
 SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *, int);
 SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem*);
@@ -22212,17 +22212,17 @@ SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem*,int);
 #else
 SQLITE_PRIVATE int sqlite3VdbeMemSetZeroBlob(Mem*,int);
 #endif
-#ifdef SQLITE_DEBUG
-SQLITE_PRIVATE int sqlite3VdbeMemIsRowSet(const Mem*);
-#endif
-SQLITE_PRIVATE int sqlite3VdbeMemSetRowSet(Mem*);
+#ifdef SQLITE_DEBUG 
+SQLITE_PRIVATE int sqlite3VdbeMemIsRowSet(const Mem*); 
+#endif 
+SQLITE_PRIVATE int sqlite3VdbeMemSetRowSet(Mem*); 
 SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem*);
 SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem*, u8, u8);
 SQLITE_PRIVATE int sqlite3IntFloatCompare(i64,double);
 SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem*);
 SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem*);
 SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem*);
-SQLITE_PRIVATE int sqlite3VdbeBooleanValue(Mem*, int ifNull);
+SQLITE_PRIVATE int sqlite3VdbeBooleanValue(Mem*, int ifNull); 
 SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem*);
 SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem*);
 SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem*);
@@ -22231,20 +22231,20 @@ SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(BtCursor*,u32,u32,Mem*);
 SQLITE_PRIVATE int sqlite3VdbeMemFromBtreeZeroOffset(BtCursor*,u32,Mem*);
 SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p);
 SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
-#ifndef SQLITE_OMIT_WINDOWFUNC
-SQLITE_PRIVATE int sqlite3VdbeMemAggValue(Mem*, Mem*, FuncDef*);
-#endif
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+SQLITE_PRIVATE int sqlite3VdbeMemAggValue(Mem*, Mem*, FuncDef*); 
+#endif 
 #if !defined(SQLITE_OMIT_EXPLAIN) || defined(SQLITE_ENABLE_BYTECODE_VTAB)
 SQLITE_PRIVATE const char *sqlite3OpcodeName(int);
-#endif
+#endif 
 SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve);
 SQLITE_PRIVATE int sqlite3VdbeMemClearAndResize(Mem *pMem, int n);
 SQLITE_PRIVATE int sqlite3VdbeCloseStatement(Vdbe *, int);
-#ifdef SQLITE_DEBUG
-SQLITE_PRIVATE int sqlite3VdbeFrameIsValid(VdbeFrame*);
-#endif
-SQLITE_PRIVATE void sqlite3VdbeFrameMemDel(void*);      /* Destructor on Mem */
-SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame*); /* Actually deletes the Frame */
+#ifdef SQLITE_DEBUG 
+SQLITE_PRIVATE int sqlite3VdbeFrameIsValid(VdbeFrame*); 
+#endif 
+SQLITE_PRIVATE void sqlite3VdbeFrameMemDel(void*);      /* Destructor on Mem */ 
+SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame*); /* Actually deletes the Frame */ 
 SQLITE_PRIVATE int sqlite3VdbeFrameRestore(VdbeFrame *);
 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
 SQLITE_PRIVATE void sqlite3VdbePreUpdateHook(
@@ -22261,14 +22261,14 @@ SQLITE_PRIVATE int sqlite3VdbeSorterRewind(const VdbeCursor *, int *);
 SQLITE_PRIVATE int sqlite3VdbeSorterWrite(const VdbeCursor *, Mem *);
 SQLITE_PRIVATE int sqlite3VdbeSorterCompare(const VdbeCursor *, Mem *, int, int *);
 
-#ifdef SQLITE_DEBUG
-SQLITE_PRIVATE   void sqlite3VdbeIncrWriteCounter(Vdbe*, VdbeCursor*);
-SQLITE_PRIVATE   void sqlite3VdbeAssertAbortable(Vdbe*);
-#else
-# define sqlite3VdbeIncrWriteCounter(V,C)
-# define sqlite3VdbeAssertAbortable(V)
-#endif
-
+#ifdef SQLITE_DEBUG 
+SQLITE_PRIVATE   void sqlite3VdbeIncrWriteCounter(Vdbe*, VdbeCursor*); 
+SQLITE_PRIVATE   void sqlite3VdbeAssertAbortable(Vdbe*); 
+#else 
+# define sqlite3VdbeIncrWriteCounter(V,C) 
+# define sqlite3VdbeAssertAbortable(V) 
+#endif 
+ 
 #if !defined(SQLITE_OMIT_SHARED_CACHE)
 SQLITE_PRIVATE   void sqlite3VdbeEnter(Vdbe*);
 #else
@@ -22648,8 +22648,8 @@ SQLITE_API int sqlite3_db_status(
     ** pagers the database handle is connected to. *pHighwater is always set
     ** to zero.
     */
-    case SQLITE_DBSTATUS_CACHE_SPILL:
-      op = SQLITE_DBSTATUS_CACHE_WRITE+1;
+    case SQLITE_DBSTATUS_CACHE_SPILL: 
+      op = SQLITE_DBSTATUS_CACHE_WRITE+1; 
       /* no break */ deliberate_fall_through
     case SQLITE_DBSTATUS_CACHE_HIT:
     case SQLITE_DBSTATUS_CACHE_MISS:
@@ -23082,7 +23082,7 @@ static int parseDateOrTime(
     return 0;
   }else if( sqlite3StrICmp(zDate,"now")==0 && sqlite3NotPureFunc(context) ){
     return setDateTimeToCurrent(context, p);
-  }else if( sqlite3AtoF(zDate, &r, sqlite3Strlen30(zDate), SQLITE_UTF8)>0 ){
+  }else if( sqlite3AtoF(zDate, &r, sqlite3Strlen30(zDate), SQLITE_UTF8)>0 ){ 
     setRawDateNumber(p, r);
     return 0;
   }
@@ -23416,7 +23416,7 @@ static int parseModifier(
       ** date is already on the appropriate weekday, this is a no-op.
       */
       if( sqlite3_strnicmp(z, "weekday ", 8)==0
-               && sqlite3AtoF(&z[8], &r, sqlite3Strlen30(&z[8]), SQLITE_UTF8)>0
+               && sqlite3AtoF(&z[8], &r, sqlite3Strlen30(&z[8]), SQLITE_UTF8)>0 
                && (n=(int)r)==r && n>=0 && r<7 ){
         sqlite3_int64 Z;
         computeYMD_HMS(p);
@@ -23475,7 +23475,7 @@ static int parseModifier(
       double rRounder;
       int i;
       for(n=1; z[n] && z[n]!=':' && !sqlite3Isspace(z[n]); n++){}
-      if( sqlite3AtoF(z, &r, n, SQLITE_UTF8)<=0 ){
+      if( sqlite3AtoF(z, &r, n, SQLITE_UTF8)<=0 ){ 
         rc = 1;
         break;
       }
@@ -24041,13 +24041,13 @@ SQLITE_PRIVATE int sqlite3OsCheckReservedLock(sqlite3_file *id, int *pResOut){
 ** routine has no return value since the return value would be meaningless.
 */
 SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
-  if( id->pMethods==0 ) return SQLITE_NOTFOUND;
+  if( id->pMethods==0 ) return SQLITE_NOTFOUND; 
 #ifdef SQLITE_TEST
-  if( op!=SQLITE_FCNTL_COMMIT_PHASETWO
-   && op!=SQLITE_FCNTL_LOCK_TIMEOUT
+  if( op!=SQLITE_FCNTL_COMMIT_PHASETWO 
+   && op!=SQLITE_FCNTL_LOCK_TIMEOUT 
    && op!=SQLITE_FCNTL_CKPT_DONE
    && op!=SQLITE_FCNTL_CKPT_START
-  ){
+  ){ 
     /* Faults are not injected into COMMIT_PHASETWO because, assuming SQLite
     ** is using a regular VFS, it is called after the corresponding
     ** transaction has been committed. Injecting a fault at this point
@@ -24069,7 +24069,7 @@ SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
   return id->pMethods->xFileControl(id, op, pArg);
 }
 SQLITE_PRIVATE void sqlite3OsFileControlHint(sqlite3_file *id, int op, void *pArg){
-  if( id->pMethods ) (void)id->pMethods->xFileControl(id, op, pArg);
+  if( id->pMethods ) (void)id->pMethods->xFileControl(id, op, pArg); 
 }
 
 SQLITE_PRIVATE int sqlite3OsSectorSize(sqlite3_file *id){
@@ -24347,10 +24347,10 @@ SQLITE_API int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){
 ** Unregister a VFS so that it is no longer accessible.
 */
 SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){
-  MUTEX_LOGIC(sqlite3_mutex *mutex;)
-#ifndef SQLITE_OMIT_AUTOINIT
-  int rc = sqlite3_initialize();
-  if( rc ) return rc;
+  MUTEX_LOGIC(sqlite3_mutex *mutex;) 
+#ifndef SQLITE_OMIT_AUTOINIT 
+  int rc = sqlite3_initialize(); 
+  if( rc ) return rc; 
 #endif
   MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); )
   sqlite3_mutex_enter(mutex);
@@ -27242,12 +27242,12 @@ struct sqlite3_mutex {
 #endif
 };
 #if SQLITE_MUTEX_NREF
-# define SQLITE3_MUTEX_INITIALIZER(id) \
-     {PTHREAD_MUTEX_INITIALIZER,id,0,(pthread_t)0,0}
+# define SQLITE3_MUTEX_INITIALIZER(id) \ 
+     {PTHREAD_MUTEX_INITIALIZER,id,0,(pthread_t)0,0} 
 #elif defined(SQLITE_ENABLE_API_ARMOR)
-# define SQLITE3_MUTEX_INITIALIZER(id) { PTHREAD_MUTEX_INITIALIZER, id }
+# define SQLITE3_MUTEX_INITIALIZER(id) { PTHREAD_MUTEX_INITIALIZER, id } 
 #else
-#define SQLITE3_MUTEX_INITIALIZER(id) { PTHREAD_MUTEX_INITIALIZER }
+#define SQLITE3_MUTEX_INITIALIZER(id) { PTHREAD_MUTEX_INITIALIZER } 
 #endif
 
 /*
@@ -27344,18 +27344,18 @@ static int pthreadMutexEnd(void){ return SQLITE_OK; }
 */
 static sqlite3_mutex *pthreadMutexAlloc(int iType){
   static sqlite3_mutex staticMutexes[] = {
-    SQLITE3_MUTEX_INITIALIZER(2),
-    SQLITE3_MUTEX_INITIALIZER(3),
-    SQLITE3_MUTEX_INITIALIZER(4),
-    SQLITE3_MUTEX_INITIALIZER(5),
-    SQLITE3_MUTEX_INITIALIZER(6),
-    SQLITE3_MUTEX_INITIALIZER(7),
-    SQLITE3_MUTEX_INITIALIZER(8),
-    SQLITE3_MUTEX_INITIALIZER(9),
-    SQLITE3_MUTEX_INITIALIZER(10),
-    SQLITE3_MUTEX_INITIALIZER(11),
-    SQLITE3_MUTEX_INITIALIZER(12),
-    SQLITE3_MUTEX_INITIALIZER(13)
+    SQLITE3_MUTEX_INITIALIZER(2), 
+    SQLITE3_MUTEX_INITIALIZER(3), 
+    SQLITE3_MUTEX_INITIALIZER(4), 
+    SQLITE3_MUTEX_INITIALIZER(5), 
+    SQLITE3_MUTEX_INITIALIZER(6), 
+    SQLITE3_MUTEX_INITIALIZER(7), 
+    SQLITE3_MUTEX_INITIALIZER(8), 
+    SQLITE3_MUTEX_INITIALIZER(9), 
+    SQLITE3_MUTEX_INITIALIZER(10), 
+    SQLITE3_MUTEX_INITIALIZER(11), 
+    SQLITE3_MUTEX_INITIALIZER(12), 
+    SQLITE3_MUTEX_INITIALIZER(13) 
   };
   sqlite3_mutex *p;
   switch( iType ){
@@ -27374,9 +27374,9 @@ static sqlite3_mutex *pthreadMutexAlloc(int iType){
         pthread_mutex_init(&p->mutex, &recursiveAttr);
         pthread_mutexattr_destroy(&recursiveAttr);
 #endif
-#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR)
-        p->id = SQLITE_MUTEX_RECURSIVE;
-#endif
+#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR) 
+        p->id = SQLITE_MUTEX_RECURSIVE; 
+#endif 
       }
       break;
     }
@@ -27384,9 +27384,9 @@ static sqlite3_mutex *pthreadMutexAlloc(int iType){
       p = sqlite3MallocZero( sizeof(*p) );
       if( p ){
         pthread_mutex_init(&p->mutex, 0);
-#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR)
-        p->id = SQLITE_MUTEX_FAST;
-#endif
+#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR) 
+        p->id = SQLITE_MUTEX_FAST; 
+#endif 
       }
       break;
     }
@@ -27402,7 +27402,7 @@ static sqlite3_mutex *pthreadMutexAlloc(int iType){
     }
   }
 #if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR)
-  assert( p==0 || p->id==iType );
+  assert( p==0 || p->id==iType ); 
 #endif
   return p;
 }
@@ -27721,7 +27721,7 @@ struct sqlite3_mutex {
 #ifdef SQLITE_DEBUG
   volatile int nRef;         /* Number of enterances */
   volatile DWORD owner;      /* Thread holding this mutex */
-  volatile LONG trace;       /* True to trace changes */
+  volatile LONG trace;       /* True to trace changes */ 
 #endif
 };
 
@@ -27733,10 +27733,10 @@ struct sqlite3_mutex {
 #define SQLITE_W32_MUTEX_INITIALIZER { 0 }
 
 #ifdef SQLITE_DEBUG
-#define SQLITE3_MUTEX_INITIALIZER(id) { SQLITE_W32_MUTEX_INITIALIZER, id, \
+#define SQLITE3_MUTEX_INITIALIZER(id) { SQLITE_W32_MUTEX_INITIALIZER, id, \ 
                                     0L, (DWORD)0, 0 }
 #else
-#define SQLITE3_MUTEX_INITIALIZER(id) { SQLITE_W32_MUTEX_INITIALIZER, id }
+#define SQLITE3_MUTEX_INITIALIZER(id) { SQLITE_W32_MUTEX_INITIALIZER, id } 
 #endif
 
 #ifdef SQLITE_DEBUG
@@ -27779,18 +27779,18 @@ SQLITE_PRIVATE void sqlite3MemoryBarrier(void){
 ** Initialize and deinitialize the mutex subsystem.
 */
 static sqlite3_mutex winMutex_staticMutexes[] = {
-  SQLITE3_MUTEX_INITIALIZER(2),
-  SQLITE3_MUTEX_INITIALIZER(3),
-  SQLITE3_MUTEX_INITIALIZER(4),
-  SQLITE3_MUTEX_INITIALIZER(5),
-  SQLITE3_MUTEX_INITIALIZER(6),
-  SQLITE3_MUTEX_INITIALIZER(7),
-  SQLITE3_MUTEX_INITIALIZER(8),
-  SQLITE3_MUTEX_INITIALIZER(9),
-  SQLITE3_MUTEX_INITIALIZER(10),
-  SQLITE3_MUTEX_INITIALIZER(11),
-  SQLITE3_MUTEX_INITIALIZER(12),
-  SQLITE3_MUTEX_INITIALIZER(13)
+  SQLITE3_MUTEX_INITIALIZER(2), 
+  SQLITE3_MUTEX_INITIALIZER(3), 
+  SQLITE3_MUTEX_INITIALIZER(4), 
+  SQLITE3_MUTEX_INITIALIZER(5), 
+  SQLITE3_MUTEX_INITIALIZER(6), 
+  SQLITE3_MUTEX_INITIALIZER(7), 
+  SQLITE3_MUTEX_INITIALIZER(8), 
+  SQLITE3_MUTEX_INITIALIZER(9), 
+  SQLITE3_MUTEX_INITIALIZER(10), 
+  SQLITE3_MUTEX_INITIALIZER(11), 
+  SQLITE3_MUTEX_INITIALIZER(12), 
+  SQLITE3_MUTEX_INITIALIZER(13) 
 };
 
 static int winMutex_isInit = 0;
@@ -27922,13 +27922,13 @@ static sqlite3_mutex *winMutexAlloc(int iType){
       p = &winMutex_staticMutexes[iType-2];
 #ifdef SQLITE_DEBUG
 #ifdef SQLITE_WIN32_MUTEX_TRACE_STATIC
-      InterlockedCompareExchange(&p->trace, 1, 0);
+      InterlockedCompareExchange(&p->trace, 1, 0); 
 #endif
 #endif
       break;
     }
   }
-  assert( p==0 || p->id==iType );
+  assert( p==0 || p->id==iType ); 
   return p;
 }
 
@@ -28850,9 +28850,9 @@ SQLITE_PRIVATE void sqlite3OomFault(sqlite3 *db){
       AtomicStore(&db->u1.isInterrupted, 1);
     }
     DisableLookaside;
-    if( db->pParse ){
-      db->pParse->rc = SQLITE_NOMEM_BKPT;
-    }
+    if( db->pParse ){ 
+      db->pParse->rc = SQLITE_NOMEM_BKPT; 
+    } 
   }
 }
 
@@ -29018,12 +29018,12 @@ static const et_info fmtinfo[] = {
 **    %!S   Like %S but prefer the zName over the zAlias
 */
 
-/* Floating point constants used for rounding */
-static const double arRound[] = {
-  5.0e-01, 5.0e-02, 5.0e-03, 5.0e-04, 5.0e-05,
-  5.0e-06, 5.0e-07, 5.0e-08, 5.0e-09, 5.0e-10,
-};
-
+/* Floating point constants used for rounding */ 
+static const double arRound[] = { 
+  5.0e-01, 5.0e-02, 5.0e-03, 5.0e-04, 5.0e-05, 
+  5.0e-06, 5.0e-07, 5.0e-08, 5.0e-09, 5.0e-10, 
+}; 
+ 
 /*
 ** If SQLITE_OMIT_FLOATING_POINT is defined, then none of the floating point
 ** conversions will work.
@@ -29059,10 +29059,10 @@ static char et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){
 ** Set the StrAccum object to an error mode.
 */
 SQLITE_PRIVATE void sqlite3StrAccumSetError(StrAccum *p, u8 eError){
-  assert( eError==SQLITE_NOMEM || eError==SQLITE_TOOBIG );
+  assert( eError==SQLITE_NOMEM || eError==SQLITE_TOOBIG ); 
   p->accError = eError;
-  if( p->mxAlloc ) sqlite3_str_reset(p);
-  if( eError==SQLITE_TOOBIG ) sqlite3ErrorToParser(p->db, eError);
+  if( p->mxAlloc ) sqlite3_str_reset(p); 
+  if( eError==SQLITE_TOOBIG ) sqlite3ErrorToParser(p->db, eError); 
 }
 
 /*
@@ -29081,28 +29081,28 @@ static char *getTextArg(PrintfArguments *p){
   return (char*)sqlite3_value_text(p->apArg[p->nUsed++]);
 }
 
-/*
-** Allocate memory for a temporary buffer needed for printf rendering.
-**
-** If the requested size of the temp buffer is larger than the size
-** of the output buffer in pAccum, then cause an SQLITE_TOOBIG error.
-** Do the size check before the memory allocation to prevent rogue
-** SQL from requesting large allocations using the precision or width
-** field of the printf() function.
-*/
-static char *printfTempBuf(sqlite3_str *pAccum, sqlite3_int64 n){
-  char *z;
-  if( pAccum->accError ) return 0;
-  if( n>pAccum->nAlloc && n>pAccum->mxAlloc ){
+/* 
+** Allocate memory for a temporary buffer needed for printf rendering. 
+** 
+** If the requested size of the temp buffer is larger than the size 
+** of the output buffer in pAccum, then cause an SQLITE_TOOBIG error. 
+** Do the size check before the memory allocation to prevent rogue 
+** SQL from requesting large allocations using the precision or width 
+** field of the printf() function. 
+*/ 
+static char *printfTempBuf(sqlite3_str *pAccum, sqlite3_int64 n){ 
+  char *z; 
+  if( pAccum->accError ) return 0; 
+  if( n>pAccum->nAlloc && n>pAccum->mxAlloc ){ 
     sqlite3StrAccumSetError(pAccum, SQLITE_TOOBIG);
-    return 0;
-  }
-  z = sqlite3DbMallocRaw(pAccum->db, n);
-  if( z==0 ){
+    return 0; 
+  } 
+  z = sqlite3DbMallocRaw(pAccum->db, n); 
+  if( z==0 ){ 
     sqlite3StrAccumSetError(pAccum, SQLITE_NOMEM);
-  }
-  return z;
-}
+  } 
+  return z; 
+} 
 
 /*
 ** On machines with a small stack size, you can redefine the
@@ -29123,8 +29123,8 @@ static char *printfTempBuf(sqlite3_str *pAccum, sqlite3_int64 n){
 /*
 ** Render a string given by "fmt" into the StrAccum object.
 */
-SQLITE_API void sqlite3_str_vappendf(
-  sqlite3_str *pAccum,       /* Accumulate results here */
+SQLITE_API void sqlite3_str_vappendf( 
+  sqlite3_str *pAccum,       /* Accumulate results here */ 
   const char *fmt,           /* Format string */
   va_list ap                 /* arguments */
 ){
@@ -29162,10 +29162,10 @@ SQLITE_API void sqlite3_str_vappendf(
   char buf[etBUFSIZE];       /* Conversion buffer */
 
   /* pAccum never starts out with an empty buffer that was obtained from
-  ** malloc().  This precondition is required by the mprintf("%z...")
-  ** optimization. */
-  assert( pAccum->nChar>0 || (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 );
-
+  ** malloc().  This precondition is required by the mprintf("%z...") 
+  ** optimization. */ 
+  assert( pAccum->nChar>0 || (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 ); 
+ 
   bufpt = 0;
   if( (pAccum->printfFlags & SQLITE_PRINTF_SQLFUNC)!=0 ){
     pArgList = va_arg(ap, PrintfArguments*);
@@ -29181,20 +29181,20 @@ SQLITE_API void sqlite3_str_vappendf(
 #else
       do{ fmt++; }while( *fmt && *fmt != '%' );
 #endif
-      sqlite3_str_append(pAccum, bufpt, (int)(fmt - bufpt));
+      sqlite3_str_append(pAccum, bufpt, (int)(fmt - bufpt)); 
       if( *fmt==0 ) break;
     }
     if( (c=(*++fmt))==0 ){
-      sqlite3_str_append(pAccum, "%", 1);
+      sqlite3_str_append(pAccum, "%", 1); 
       break;
     }
     /* Find out what flags are present */
     flag_leftjustify = flag_prefix = cThousand =
      flag_alternateform = flag_altform2 = flag_zeropad = 0;
     done = 0;
-    width = 0;
-    flag_long = 0;
-    precision = -1;
+    width = 0; 
+    flag_long = 0; 
+    precision = -1; 
     do{
       switch( c ){
         case '-':   flag_leftjustify = 1;     break;
@@ -29205,92 +29205,92 @@ SQLITE_API void sqlite3_str_vappendf(
         case '0':   flag_zeropad = 1;         break;
         case ',':   cThousand = ',';          break;
         default:    done = 1;                 break;
-        case 'l': {
-          flag_long = 1;
-          c = *++fmt;
-          if( c=='l' ){
-            c = *++fmt;
-            flag_long = 2;
-          }
-          done = 1;
-          break;
-        }
-        case '1': case '2': case '3': case '4': case '5':
-        case '6': case '7': case '8': case '9': {
-          unsigned wx = c - '0';
-          while( (c = *++fmt)>='0' && c<='9' ){
-            wx = wx*10 + c - '0';
-          }
-          testcase( wx>0x7fffffff );
-          width = wx & 0x7fffffff;
+        case 'l': { 
+          flag_long = 1; 
+          c = *++fmt; 
+          if( c=='l' ){ 
+            c = *++fmt; 
+            flag_long = 2; 
+          } 
+          done = 1; 
+          break; 
+        } 
+        case '1': case '2': case '3': case '4': case '5': 
+        case '6': case '7': case '8': case '9': { 
+          unsigned wx = c - '0'; 
+          while( (c = *++fmt)>='0' && c<='9' ){ 
+            wx = wx*10 + c - '0'; 
+          } 
+          testcase( wx>0x7fffffff ); 
+          width = wx & 0x7fffffff; 
 #ifdef SQLITE_PRINTF_PRECISION_LIMIT
-          if( width>SQLITE_PRINTF_PRECISION_LIMIT ){
-            width = SQLITE_PRINTF_PRECISION_LIMIT;
-          }
-#endif
-          if( c!='.' && c!='l' ){
-            done = 1;
-          }else{
-            fmt--;
-          }
-          break;
-        }
-        case '*': {
-          if( bArgList ){
-            width = (int)getIntArg(pArgList);
-          }else{
-            width = va_arg(ap,int);
-          }
-          if( width<0 ){
-            flag_leftjustify = 1;
-            width = width >= -2147483647 ? -width : 0;
-          }
-#ifdef SQLITE_PRINTF_PRECISION_LIMIT
-          if( width>SQLITE_PRINTF_PRECISION_LIMIT ){
-            width = SQLITE_PRINTF_PRECISION_LIMIT;
-          }
-#endif
-          if( (c = fmt[1])!='.' && c!='l' ){
-            c = *++fmt;
-            done = 1;
-          }
-          break;
-        }
-        case '.': {
+          if( width>SQLITE_PRINTF_PRECISION_LIMIT ){ 
+            width = SQLITE_PRINTF_PRECISION_LIMIT; 
+          } 
+#endif
+          if( c!='.' && c!='l' ){ 
+            done = 1; 
+          }else{ 
+            fmt--; 
+          } 
+          break; 
+        }
+        case '*': { 
+          if( bArgList ){ 
+            width = (int)getIntArg(pArgList); 
+          }else{ 
+            width = va_arg(ap,int); 
+          } 
+          if( width<0 ){ 
+            flag_leftjustify = 1; 
+            width = width >= -2147483647 ? -width : 0; 
+          } 
+#ifdef SQLITE_PRINTF_PRECISION_LIMIT 
+          if( width>SQLITE_PRINTF_PRECISION_LIMIT ){ 
+            width = SQLITE_PRINTF_PRECISION_LIMIT; 
+          } 
+#endif 
+          if( (c = fmt[1])!='.' && c!='l' ){ 
+            c = *++fmt; 
+            done = 1; 
+          } 
+          break; 
+        }
+        case '.': { 
           c = *++fmt;
-          if( c=='*' ){
-            if( bArgList ){
-              precision = (int)getIntArg(pArgList);
-            }else{
-              precision = va_arg(ap,int);
-            }
-            if( precision<0 ){
-              precision = precision >= -2147483647 ? -precision : -1;
-            }
-            c = *++fmt;
-          }else{
-            unsigned px = 0;
-            while( c>='0' && c<='9' ){
-              px = px*10 + c - '0';
-              c = *++fmt;
-            }
-            testcase( px>0x7fffffff );
-            precision = px & 0x7fffffff;
-          }
-#ifdef SQLITE_PRINTF_PRECISION_LIMIT
-          if( precision>SQLITE_PRINTF_PRECISION_LIMIT ){
-            precision = SQLITE_PRINTF_PRECISION_LIMIT;
-          }
-#endif
-          if( c=='l' ){
-            --fmt;
-          }else{
-            done = 1;
-          }
-          break;
-        }
-      }
-    }while( !done && (c=(*++fmt))!=0 );
+          if( c=='*' ){ 
+            if( bArgList ){ 
+              precision = (int)getIntArg(pArgList); 
+            }else{ 
+              precision = va_arg(ap,int); 
+            } 
+            if( precision<0 ){ 
+              precision = precision >= -2147483647 ? -precision : -1; 
+            } 
+            c = *++fmt; 
+          }else{ 
+            unsigned px = 0; 
+            while( c>='0' && c<='9' ){ 
+              px = px*10 + c - '0'; 
+              c = *++fmt; 
+            } 
+            testcase( px>0x7fffffff ); 
+            precision = px & 0x7fffffff; 
+          } 
+#ifdef SQLITE_PRINTF_PRECISION_LIMIT 
+          if( precision>SQLITE_PRINTF_PRECISION_LIMIT ){ 
+            precision = SQLITE_PRINTF_PRECISION_LIMIT; 
+          } 
+#endif 
+          if( c=='l' ){ 
+            --fmt; 
+          }else{ 
+            done = 1; 
+          } 
+          break; 
+        }
+      }
+    }while( !done && (c=(*++fmt))!=0 ); 
 
     /* Fetch the info entry for the field */
     infop = &fmtinfo[0];
@@ -29377,11 +29377,11 @@ SQLITE_API void sqlite3_str_vappendf(
           nOut = etBUFSIZE;
           zOut = buf;
         }else{
-          u64 n;
-          n = (u64)precision + 10;
-          if( cThousand ) n += precision/3;
-          zOut = zExtra = printfTempBuf(pAccum, n);
-          if( zOut==0 ) return;
+          u64 n; 
+          n = (u64)precision + 10; 
+          if( cThousand ) n += precision/3; 
+          zOut = zExtra = printfTempBuf(pAccum, n); 
+          if( zOut==0 ) return; 
           nOut = (int)n;
         }
         bufpt = &zOut[nOut-1];
@@ -29455,18 +29455,18 @@ SQLITE_API void sqlite3_str_vappendf(
         }
         if( xtype==etGENERIC && precision>0 ) precision--;
         testcase( precision>0xfff );
-        idx = precision & 0xfff;
-        rounder = arRound[idx%10];
-        while( idx>=10 ){ rounder *= 1.0e-10; idx -= 10; }
-        if( xtype==etFLOAT ){
-          double rx = (double)realvalue;
-          sqlite3_uint64 u;
-          int ex;
-          memcpy(&u, &rx, sizeof(u));
-          ex = -1023 + (int)((u>>52)&0x7ff);
-          if( precision+(ex/3) < 15 ) rounder += realvalue*3e-16;
-          realvalue += rounder;
-        }
+        idx = precision & 0xfff; 
+        rounder = arRound[idx%10]; 
+        while( idx>=10 ){ rounder *= 1.0e-10; idx -= 10; } 
+        if( xtype==etFLOAT ){ 
+          double rx = (double)realvalue; 
+          sqlite3_uint64 u; 
+          int ex; 
+          memcpy(&u, &rx, sizeof(u)); 
+          ex = -1023 + (int)((u>>52)&0x7ff); 
+          if( precision+(ex/3) < 15 ) rounder += realvalue*3e-16; 
+          realvalue += rounder; 
+        } 
         /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */
         exp = 0;
         if( sqlite3IsNaN((double)realvalue) ){
@@ -29515,12 +29515,12 @@ SQLITE_API void sqlite3_str_vappendf(
         }else{
           e2 = exp;
         }
-        {
-          i64 szBufNeeded;           /* Size of a temporary buffer needed */
-          szBufNeeded = MAX(e2,0)+(i64)precision+(i64)width+15;
-          if( szBufNeeded > etBUFSIZE ){
-            bufpt = zExtra = printfTempBuf(pAccum, szBufNeeded);
-            if( bufpt==0 ) return;
+        { 
+          i64 szBufNeeded;           /* Size of a temporary buffer needed */ 
+          szBufNeeded = MAX(e2,0)+(i64)precision+(i64)width+15; 
+          if( szBufNeeded > etBUFSIZE ){ 
+            bufpt = zExtra = printfTempBuf(pAccum, szBufNeeded); 
+            if( bufpt==0 ) return; 
           }
         }
         zOut = bufpt;
@@ -29615,52 +29615,52 @@ SQLITE_API void sqlite3_str_vappendf(
       case etCHARX:
         if( bArgList ){
           bufpt = getTextArg(pArgList);
-          length = 1;
-          if( bufpt ){
-            buf[0] = c = *(bufpt++);
-            if( (c&0xc0)==0xc0 ){
-              while( length<4 && (bufpt[0]&0xc0)==0x80 ){
-                buf[length++] = *(bufpt++);
-              }
-            }
-          }else{
-            buf[0] = 0;
-          }
+          length = 1; 
+          if( bufpt ){ 
+            buf[0] = c = *(bufpt++); 
+            if( (c&0xc0)==0xc0 ){ 
+              while( length<4 && (bufpt[0]&0xc0)==0x80 ){ 
+                buf[length++] = *(bufpt++); 
+              } 
+            } 
+          }else{ 
+            buf[0] = 0; 
+          } 
         }else{
-          unsigned int ch = va_arg(ap,unsigned int);
-          if( ch<0x00080 ){
-            buf[0] = ch & 0xff;
-            length = 1;
-          }else if( ch<0x00800 ){
-            buf[0] = 0xc0 + (u8)((ch>>6)&0x1f);
-            buf[1] = 0x80 + (u8)(ch & 0x3f);
-            length = 2;
-          }else if( ch<0x10000 ){
-            buf[0] = 0xe0 + (u8)((ch>>12)&0x0f);
-            buf[1] = 0x80 + (u8)((ch>>6) & 0x3f);
-            buf[2] = 0x80 + (u8)(ch & 0x3f);
-            length = 3;
-          }else{
-            buf[0] = 0xf0 + (u8)((ch>>18) & 0x07);
-            buf[1] = 0x80 + (u8)((ch>>12) & 0x3f);
-            buf[2] = 0x80 + (u8)((ch>>6) & 0x3f);
-            buf[3] = 0x80 + (u8)(ch & 0x3f);
-            length = 4;
-          }
+          unsigned int ch = va_arg(ap,unsigned int); 
+          if( ch<0x00080 ){ 
+            buf[0] = ch & 0xff; 
+            length = 1; 
+          }else if( ch<0x00800 ){ 
+            buf[0] = 0xc0 + (u8)((ch>>6)&0x1f); 
+            buf[1] = 0x80 + (u8)(ch & 0x3f); 
+            length = 2; 
+          }else if( ch<0x10000 ){ 
+            buf[0] = 0xe0 + (u8)((ch>>12)&0x0f); 
+            buf[1] = 0x80 + (u8)((ch>>6) & 0x3f); 
+            buf[2] = 0x80 + (u8)(ch & 0x3f); 
+            length = 3; 
+          }else{ 
+            buf[0] = 0xf0 + (u8)((ch>>18) & 0x07); 
+            buf[1] = 0x80 + (u8)((ch>>12) & 0x3f); 
+            buf[2] = 0x80 + (u8)((ch>>6) & 0x3f); 
+            buf[3] = 0x80 + (u8)(ch & 0x3f); 
+            length = 4; 
+          } 
         }
         if( precision>1 ){
           width -= precision-1;
           if( width>1 && !flag_leftjustify ){
-            sqlite3_str_appendchar(pAccum, width-1, ' ');
+            sqlite3_str_appendchar(pAccum, width-1, ' '); 
             width = 0;
           }
-          while( precision-- > 1 ){
-            sqlite3_str_append(pAccum, buf, length);
-          }
+          while( precision-- > 1 ){ 
+            sqlite3_str_append(pAccum, buf, length); 
+          } 
         }
         bufpt = buf;
-        flag_altform2 = 1;
-        goto adjust_width_for_utf8;
+        flag_altform2 = 1; 
+        goto adjust_width_for_utf8; 
       case etSTRING:
       case etDYNSTRING:
         if( bArgList ){
@@ -29672,50 +29672,50 @@ SQLITE_API void sqlite3_str_vappendf(
         if( bufpt==0 ){
           bufpt = "";
         }else if( xtype==etDYNSTRING ){
-          if( pAccum->nChar==0
-           && pAccum->mxAlloc
-           && width==0
-           && precision<0
-           && pAccum->accError==0
-          ){
-            /* Special optimization for sqlite3_mprintf("%z..."):
-            ** Extend an existing memory allocation rather than creating
-            ** a new one. */
-            assert( (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 );
-            pAccum->zText = bufpt;
-            pAccum->nAlloc = sqlite3DbMallocSize(pAccum->db, bufpt);
-            pAccum->nChar = 0x7fffffff & (int)strlen(bufpt);
-            pAccum->printfFlags |= SQLITE_PRINTF_MALLOCED;
-            length = 0;
-            break;
-          }
+          if( pAccum->nChar==0 
+           && pAccum->mxAlloc 
+           && width==0 
+           && precision<0 
+           && pAccum->accError==0 
+          ){ 
+            /* Special optimization for sqlite3_mprintf("%z..."): 
+            ** Extend an existing memory allocation rather than creating 
+            ** a new one. */ 
+            assert( (pAccum->printfFlags&SQLITE_PRINTF_MALLOCED)==0 ); 
+            pAccum->zText = bufpt; 
+            pAccum->nAlloc = sqlite3DbMallocSize(pAccum->db, bufpt); 
+            pAccum->nChar = 0x7fffffff & (int)strlen(bufpt); 
+            pAccum->printfFlags |= SQLITE_PRINTF_MALLOCED; 
+            length = 0; 
+            break; 
+          } 
           zExtra = bufpt;
         }
         if( precision>=0 ){
-          if( flag_altform2 ){
-            /* Set length to the number of bytes needed in order to display
-            ** precision characters */
-            unsigned char *z = (unsigned char*)bufpt;
-            while( precision-- > 0 && z[0] ){
-              SQLITE_SKIP_UTF8(z);
-            }
-            length = (int)(z - (unsigned char*)bufpt);
-          }else{
-            for(length=0; length<precision && bufpt[length]; length++){}
-          }
+          if( flag_altform2 ){ 
+            /* Set length to the number of bytes needed in order to display 
+            ** precision characters */ 
+            unsigned char *z = (unsigned char*)bufpt; 
+            while( precision-- > 0 && z[0] ){ 
+              SQLITE_SKIP_UTF8(z); 
+            } 
+            length = (int)(z - (unsigned char*)bufpt); 
+          }else{ 
+            for(length=0; length<precision && bufpt[length]; length++){} 
+          } 
         }else{
           length = 0x7fffffff & (int)strlen(bufpt);
         }
-      adjust_width_for_utf8:
-        if( flag_altform2 && width>0 ){
-          /* Adjust width to account for extra bytes in UTF-8 characters */
-          int ii = length - 1;
-          while( ii>=0 ) if( (bufpt[ii--] & 0xc0)==0x80 ) width++;
-        }
+      adjust_width_for_utf8: 
+        if( flag_altform2 && width>0 ){ 
+          /* Adjust width to account for extra bytes in UTF-8 characters */ 
+          int ii = length - 1; 
+          while( ii>=0 ) if( (bufpt[ii--] & 0xc0)==0x80 ) width++; 
+        } 
         break;
-      case etSQLESCAPE:           /* %q: Escape ' characters */
-      case etSQLESCAPE2:          /* %Q: Escape ' and enclose in '...' */
-      case etSQLESCAPE3: {        /* %w: Escape " characters */
+      case etSQLESCAPE:           /* %q: Escape ' characters */ 
+      case etSQLESCAPE2:          /* %Q: Escape ' and enclose in '...' */ 
+      case etSQLESCAPE3: {        /* %w: Escape " characters */ 
         int i, j, k, n, isnull;
         int needQuote;
         char ch;
@@ -29730,22 +29730,22 @@ SQLITE_API void sqlite3_str_vappendf(
         isnull = escarg==0;
         if( isnull ) escarg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)");
         /* For %q, %Q, and %w, the precision is the number of bytes (or
-        ** characters if the ! flags is present) to use from the input.
-        ** Because of the extra quoting characters inserted, the number
-        ** of output characters may be larger than the precision.
-        */
+        ** characters if the ! flags is present) to use from the input. 
+        ** Because of the extra quoting characters inserted, the number 
+        ** of output characters may be larger than the precision. 
+        */ 
         k = precision;
         for(i=n=0; k!=0 && (ch=escarg[i])!=0; i++, k--){
           if( ch==q )  n++;
-          if( flag_altform2 && (ch&0xc0)==0xc0 ){
-            while( (escarg[i+1]&0xc0)==0x80 ){ i++; }
-          }
+          if( flag_altform2 && (ch&0xc0)==0xc0 ){ 
+            while( (escarg[i+1]&0xc0)==0x80 ){ i++; } 
+          } 
         }
         needQuote = !isnull && xtype==etSQLESCAPE2;
         n += i + 3;
         if( n>etBUFSIZE ){
-          bufpt = zExtra = printfTempBuf(pAccum, n);
-          if( bufpt==0 ) return;
+          bufpt = zExtra = printfTempBuf(pAccum, n); 
+          if( bufpt==0 ) return; 
         }else{
           bufpt = buf;
         }
@@ -29759,7 +29759,7 @@ SQLITE_API void sqlite3_str_vappendf(
         if( needQuote ) bufpt[j++] = q;
         bufpt[j] = 0;
         length = j;
-        goto adjust_width_for_utf8;
+        goto adjust_width_for_utf8; 
       }
       case etTOKEN: {
         Token *pToken;
@@ -29767,7 +29767,7 @@ SQLITE_API void sqlite3_str_vappendf(
         pToken = va_arg(ap, Token*);
         assert( bArgList==0 );
         if( pToken && pToken->n ){
-          sqlite3_str_append(pAccum, (const char*)pToken->z, pToken->n);
+          sqlite3_str_append(pAccum, (const char*)pToken->z, pToken->n); 
         }
         length = width = 0;
         break;
@@ -29801,18 +29801,18 @@ SQLITE_API void sqlite3_str_vappendf(
     /*
     ** The text of the conversion is pointed to by "bufpt" and is
     ** "length" characters long.  The field width is "width".  Do
-    ** the output.  Both length and width are in bytes, not characters,
-    ** at this point.  If the "!" flag was present on string conversions
-    ** indicating that width and precision should be expressed in characters,
-    ** then the values have been translated prior to reaching this point.
+    ** the output.  Both length and width are in bytes, not characters, 
+    ** at this point.  If the "!" flag was present on string conversions 
+    ** indicating that width and precision should be expressed in characters, 
+    ** then the values have been translated prior to reaching this point. 
     */
     width -= length;
     if( width>0 ){
-      if( !flag_leftjustify ) sqlite3_str_appendchar(pAccum, width, ' ');
-      sqlite3_str_append(pAccum, bufpt, length);
-      if( flag_leftjustify ) sqlite3_str_appendchar(pAccum, width, ' ');
+      if( !flag_leftjustify ) sqlite3_str_appendchar(pAccum, width, ' '); 
+      sqlite3_str_append(pAccum, bufpt, length); 
+      if( flag_leftjustify ) sqlite3_str_appendchar(pAccum, width, ' '); 
     }else{
-      sqlite3_str_append(pAccum, bufpt, length);
+      sqlite3_str_append(pAccum, bufpt, length); 
     }
 
     if( zExtra ){
@@ -29833,13 +29833,13 @@ static int sqlite3StrAccumEnlarge(StrAccum *p, int N){
   char *zNew;
   assert( p->nChar+(i64)N >= p->nAlloc ); /* Only called if really needed */
   if( p->accError ){
-    testcase(p->accError==SQLITE_TOOBIG);
-    testcase(p->accError==SQLITE_NOMEM);
+    testcase(p->accError==SQLITE_TOOBIG); 
+    testcase(p->accError==SQLITE_NOMEM); 
     return 0;
   }
   if( p->mxAlloc==0 ){
     sqlite3StrAccumSetError(p, SQLITE_TOOBIG);
-    return p->nAlloc - p->nChar - 1;
+    return p->nAlloc - p->nChar - 1; 
   }else{
     char *zOld = isMalloced(p) ? p->zText : 0;
     i64 szNew = p->nChar;
@@ -29850,7 +29850,7 @@ static int sqlite3StrAccumEnlarge(StrAccum *p, int N){
       szNew += p->nChar;
     }
     if( szNew > p->mxAlloc ){
-      sqlite3_str_reset(p);
+      sqlite3_str_reset(p); 
       sqlite3StrAccumSetError(p, SQLITE_TOOBIG);
       return 0;
     }else{
@@ -29868,7 +29868,7 @@ static int sqlite3StrAccumEnlarge(StrAccum *p, int N){
       p->nAlloc = sqlite3DbMallocSize(p->db, zNew);
       p->printfFlags |= SQLITE_PRINTF_MALLOCED;
     }else{
-      sqlite3_str_reset(p);
+      sqlite3_str_reset(p); 
       sqlite3StrAccumSetError(p, SQLITE_NOMEM);
       return 0;
     }
@@ -29879,7 +29879,7 @@ static int sqlite3StrAccumEnlarge(StrAccum *p, int N){
 /*
 ** Append N copies of character c to the given string buffer.
 */
-SQLITE_API void sqlite3_str_appendchar(sqlite3_str *p, int N, char c){
+SQLITE_API void sqlite3_str_appendchar(sqlite3_str *p, int N, char c){ 
   testcase( p->nChar + (i64)N > 0x7fffffff );
   if( p->nChar+(i64)N >= p->nAlloc && (N = sqlite3StrAccumEnlarge(p, N))<=0 ){
     return;
@@ -29891,9 +29891,9 @@ SQLITE_API void sqlite3_str_appendchar(sqlite3_str *p, int N, char c){
 ** The StrAccum "p" is not large enough to accept N new bytes of z[].
 ** So enlarge if first, then do the append.
 **
-** This is a helper routine to sqlite3_str_append() that does special-case
+** This is a helper routine to sqlite3_str_append() that does special-case 
 ** work (enlarging the buffer) using tail recursion, so that the
-** sqlite3_str_append() routine can use fast calling semantics.
+** sqlite3_str_append() routine can use fast calling semantics. 
 */
 static void SQLITE_NOINLINE enlargeAndAppend(StrAccum *p, const char *z, int N){
   N = sqlite3StrAccumEnlarge(p, N);
@@ -29907,11 +29907,11 @@ static void SQLITE_NOINLINE enlargeAndAppend(StrAccum *p, const char *z, int N){
 ** Append N bytes of text from z to the StrAccum object.  Increase the
 ** size of the memory allocation for StrAccum if necessary.
 */
-SQLITE_API void sqlite3_str_append(sqlite3_str *p, const char *z, int N){
+SQLITE_API void sqlite3_str_append(sqlite3_str *p, const char *z, int N){ 
   assert( z!=0 || N==0 );
   assert( p->zText!=0 || p->nChar==0 || p->accError );
   assert( N>=0 );
-  assert( p->accError==0 || p->nAlloc==0 || p->mxAlloc==0 );
+  assert( p->accError==0 || p->nAlloc==0 || p->mxAlloc==0 ); 
   if( p->nChar+N >= p->nAlloc ){
     enlargeAndAppend(p,z,N);
   }else if( N ){
@@ -29924,8 +29924,8 @@ SQLITE_API void sqlite3_str_append(sqlite3_str *p, const char *z, int N){
 /*
 ** Append the complete text of zero-terminated string z[] to the p string.
 */
-SQLITE_API void sqlite3_str_appendall(sqlite3_str *p, const char *z){
-  sqlite3_str_append(p, z, sqlite3Strlen30(z));
+SQLITE_API void sqlite3_str_appendall(sqlite3_str *p, const char *z){ 
+  sqlite3_str_append(p, z, sqlite3Strlen30(z)); 
 }
 
 
@@ -29974,55 +29974,55 @@ SQLITE_PRIVATE void sqlite3ResultStrAccum(sqlite3_context *pCtx, StrAccum *p){
 }
 
 /*
-** This singleton is an sqlite3_str object that is returned if
-** sqlite3_malloc() fails to provide space for a real one.  This
-** sqlite3_str object accepts no new text and always returns
-** an SQLITE_NOMEM error.
-*/
-static sqlite3_str sqlite3OomStr = {
-   0, 0, 0, 0, 0, SQLITE_NOMEM, 0
-};
-
-/* Finalize a string created using sqlite3_str_new().
-*/
-SQLITE_API char *sqlite3_str_finish(sqlite3_str *p){
-  char *z;
-  if( p!=0 && p!=&sqlite3OomStr ){
-    z = sqlite3StrAccumFinish(p);
-    sqlite3_free(p);
-  }else{
-    z = 0;
-  }
-  return z;
-}
-
-/* Return any error code associated with p */
-SQLITE_API int sqlite3_str_errcode(sqlite3_str *p){
-  return p ? p->accError : SQLITE_NOMEM;
-}
-
-/* Return the current length of p in bytes */
-SQLITE_API int sqlite3_str_length(sqlite3_str *p){
-  return p ? p->nChar : 0;
-}
-
-/* Return the current value for p */
-SQLITE_API char *sqlite3_str_value(sqlite3_str *p){
-  if( p==0 || p->nChar==0 ) return 0;
-  p->zText[p->nChar] = 0;
-  return p->zText;
-}
-
-/*
+** This singleton is an sqlite3_str object that is returned if 
+** sqlite3_malloc() fails to provide space for a real one.  This 
+** sqlite3_str object accepts no new text and always returns 
+** an SQLITE_NOMEM error. 
+*/ 
+static sqlite3_str sqlite3OomStr = { 
+   0, 0, 0, 0, 0, SQLITE_NOMEM, 0 
+}; 
+ 
+/* Finalize a string created using sqlite3_str_new(). 
+*/ 
+SQLITE_API char *sqlite3_str_finish(sqlite3_str *p){ 
+  char *z; 
+  if( p!=0 && p!=&sqlite3OomStr ){ 
+    z = sqlite3StrAccumFinish(p); 
+    sqlite3_free(p); 
+  }else{ 
+    z = 0; 
+  } 
+  return z; 
+} 
+ 
+/* Return any error code associated with p */ 
+SQLITE_API int sqlite3_str_errcode(sqlite3_str *p){ 
+  return p ? p->accError : SQLITE_NOMEM; 
+} 
+ 
+/* Return the current length of p in bytes */ 
+SQLITE_API int sqlite3_str_length(sqlite3_str *p){ 
+  return p ? p->nChar : 0; 
+} 
+ 
+/* Return the current value for p */ 
+SQLITE_API char *sqlite3_str_value(sqlite3_str *p){ 
+  if( p==0 || p->nChar==0 ) return 0; 
+  p->zText[p->nChar] = 0; 
+  return p->zText; 
+} 
+ 
+/* 
 ** Reset an StrAccum string.  Reclaim all malloced memory.
 */
-SQLITE_API void sqlite3_str_reset(StrAccum *p){
+SQLITE_API void sqlite3_str_reset(StrAccum *p){ 
   if( isMalloced(p) ){
     sqlite3DbFree(p->db, p->zText);
     p->printfFlags &= ~SQLITE_PRINTF_MALLOCED;
   }
-  p->nAlloc = 0;
-  p->nChar = 0;
+  p->nAlloc = 0; 
+  p->nChar = 0; 
   p->zText = 0;
 }
 
@@ -30050,18 +30050,18 @@ SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum *p, sqlite3 *db, char *zBase, i
   p->printfFlags = 0;
 }
 
-/* Allocate and initialize a new dynamic string object */
-SQLITE_API sqlite3_str *sqlite3_str_new(sqlite3 *db){
-  sqlite3_str *p = sqlite3_malloc64(sizeof(*p));
-  if( p ){
-    sqlite3StrAccumInit(p, 0, 0, 0,
-            db ? db->aLimit[SQLITE_LIMIT_LENGTH] : SQLITE_MAX_LENGTH);
-  }else{
-    p = &sqlite3OomStr;
-  }
-  return p;
-}
-
+/* Allocate and initialize a new dynamic string object */ 
+SQLITE_API sqlite3_str *sqlite3_str_new(sqlite3 *db){ 
+  sqlite3_str *p = sqlite3_malloc64(sizeof(*p)); 
+  if( p ){ 
+    sqlite3StrAccumInit(p, 0, 0, 0, 
+            db ? db->aLimit[SQLITE_LIMIT_LENGTH] : SQLITE_MAX_LENGTH); 
+  }else{ 
+    p = &sqlite3OomStr; 
+  } 
+  return p; 
+} 
+ 
 /*
 ** Print into memory obtained from sqliteMalloc().  Use the internal
 ** %-conversion extensions.
@@ -30074,9 +30074,9 @@ SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list a
   sqlite3StrAccumInit(&acc, db, zBase, sizeof(zBase),
                       db->aLimit[SQLITE_LIMIT_LENGTH]);
   acc.printfFlags = SQLITE_PRINTF_INTERNAL;
-  sqlite3_str_vappendf(&acc, zFormat, ap);
+  sqlite3_str_vappendf(&acc, zFormat, ap); 
   z = sqlite3StrAccumFinish(&acc);
-  if( acc.accError==SQLITE_NOMEM ){
+  if( acc.accError==SQLITE_NOMEM ){ 
     sqlite3OomFault(db);
   }
   return z;
@@ -30114,7 +30114,7 @@ SQLITE_API char *sqlite3_vmprintf(const char *zFormat, va_list ap){
   if( sqlite3_initialize() ) return 0;
 #endif
   sqlite3StrAccumInit(&acc, 0, zBase, sizeof(zBase), SQLITE_MAX_LENGTH);
-  sqlite3_str_vappendf(&acc, zFormat, ap);
+  sqlite3_str_vappendf(&acc, zFormat, ap); 
   z = sqlite3StrAccumFinish(&acc);
   return z;
 }
@@ -30159,7 +30159,7 @@ SQLITE_API char *sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_li
   }
 #endif
   sqlite3StrAccumInit(&acc, 0, zBuf, n, 0);
-  sqlite3_str_vappendf(&acc, zFormat, ap);
+  sqlite3_str_vappendf(&acc, zFormat, ap); 
   zBuf[acc.nChar] = 0;
   return zBuf;
 }
@@ -30181,7 +30181,7 @@ SQLITE_API char *sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){
 ** allocate memory because it might be called while the memory allocator
 ** mutex is held.
 **
-** sqlite3_str_vappendf() might ask for *temporary* memory allocations for
+** sqlite3_str_vappendf() might ask for *temporary* memory allocations for 
 ** certain format characters (%q) or for very large precisions or widths.
 ** Care must be taken that any sqlite3_log() calls that occur while the
 ** memory mutex is held do not use these mechanisms.
@@ -30191,7 +30191,7 @@ static void renderLogMsg(int iErrCode, const char *zFormat, va_list ap){
   char zMsg[SQLITE_PRINT_BUF_SIZE*3];    /* Complete log message */
 
   sqlite3StrAccumInit(&acc, 0, zMsg, sizeof(zMsg), 0);
-  sqlite3_str_vappendf(&acc, zFormat, ap);
+  sqlite3_str_vappendf(&acc, zFormat, ap); 
   sqlite3GlobalConfig.xLog(sqlite3GlobalConfig.pLogArg, iErrCode,
                            sqlite3StrAccumFinish(&acc));
 }
@@ -30220,7 +30220,7 @@ SQLITE_PRIVATE void sqlite3DebugPrintf(const char *zFormat, ...){
   char zBuf[SQLITE_PRINT_BUF_SIZE*10];
   sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0);
   va_start(ap,zFormat);
-  sqlite3_str_vappendf(&acc, zFormat, ap);
+  sqlite3_str_vappendf(&acc, zFormat, ap); 
   va_end(ap);
   sqlite3StrAccumFinish(&acc);
 #ifdef SQLITE_OS_TRACE_PROC
@@ -30237,13 +30237,13 @@ SQLITE_PRIVATE void sqlite3DebugPrintf(const char *zFormat, ...){
 
 
 /*
-** variable-argument wrapper around sqlite3_str_vappendf(). The bFlags argument
+** variable-argument wrapper around sqlite3_str_vappendf(). The bFlags argument 
 ** can contain the bit SQLITE_PRINTF_INTERNAL enable internal formats.
 */
-SQLITE_API void sqlite3_str_appendf(StrAccum *p, const char *zFormat, ...){
+SQLITE_API void sqlite3_str_appendf(StrAccum *p, const char *zFormat, ...){ 
   va_list ap;
   va_start(ap,zFormat);
-  sqlite3_str_vappendf(p, zFormat, ap);
+  sqlite3_str_vappendf(p, zFormat, ap); 
   va_end(ap);
 }
 
@@ -30309,17 +30309,17 @@ static void sqlite3TreeViewLine(TreeView *p, const char *zFormat, ...){
   sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0);
   if( p ){
     for(i=0; i<p->iLevel && i<sizeof(p->bLine)-1; i++){
-      sqlite3_str_append(&acc, p->bLine[i] ? "|   " : "    ", 4);
+      sqlite3_str_append(&acc, p->bLine[i] ? "|   " : "    ", 4); 
     }
-    sqlite3_str_append(&acc, p->bLine[i] ? "|-- " : "'-- ", 4);
+    sqlite3_str_append(&acc, p->bLine[i] ? "|-- " : "'-- ", 4); 
   }
-  if( zFormat!=0 ){
-    va_start(ap, zFormat);
-    sqlite3_str_vappendf(&acc, zFormat, ap);
-    va_end(ap);
+  if( zFormat!=0 ){ 
+    va_start(ap, zFormat); 
+    sqlite3_str_vappendf(&acc, zFormat, ap); 
+    va_end(ap); 
     assert( acc.nChar>0 || acc.accError );
-    sqlite3_str_append(&acc, "\n", 1);
-  }
+    sqlite3_str_append(&acc, "\n", 1); 
+  } 
   sqlite3StrAccumFinish(&acc);
   fprintf(stdout,"%s", zBuf);
   fflush(stdout);
@@ -30352,7 +30352,7 @@ SQLITE_PRIVATE void sqlite3TreeViewWith(TreeView *pView, const With *pWith, u8 m
       char zLine[1000];
       const struct Cte *pCte = &pWith->a[i];
       sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0);
-      sqlite3_str_appendf(&x, "%s", pCte->zName);
+      sqlite3_str_appendf(&x, "%s", pCte->zName); 
       if( pCte->pCols && pCte->pCols->nExpr>0 ){
         char cSep = '(';
         int j;
@@ -30360,7 +30360,7 @@ SQLITE_PRIVATE void sqlite3TreeViewWith(TreeView *pView, const With *pWith, u8 m
           sqlite3_str_appendf(&x, "%c%s", cSep, pCte->pCols->a[j].zEName);
           cSep = ',';
         }
-        sqlite3_str_appendf(&x, ")");
+        sqlite3_str_appendf(&x, ")"); 
       }
       if( pCte->pUse ){
         sqlite3_str_appendf(&x, " (pUse=0x%p, nUse=%d)", pCte->pUse,
@@ -30375,44 +30375,44 @@ SQLITE_PRIVATE void sqlite3TreeViewWith(TreeView *pView, const With *pWith, u8 m
   }
 }
 
-/*
-** Generate a human-readable description of a SrcList object.
-*/
-SQLITE_PRIVATE void sqlite3TreeViewSrcList(TreeView *pView, const SrcList *pSrc){
-  int i;
-  for(i=0; i<pSrc->nSrc; i++){
+/* 
+** Generate a human-readable description of a SrcList object. 
+*/ 
+SQLITE_PRIVATE void sqlite3TreeViewSrcList(TreeView *pView, const SrcList *pSrc){ 
+  int i; 
+  for(i=0; i<pSrc->nSrc; i++){ 
     const SrcItem *pItem = &pSrc->a[i];
-    StrAccum x;
-    char zLine[100];
-    sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0);
+    StrAccum x; 
+    char zLine[100]; 
+    sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0); 
     x.printfFlags |= SQLITE_PRINTF_INTERNAL;
     sqlite3_str_appendf(&x, "{%d:*} %!S", pItem->iCursor, pItem);
-    if( pItem->pTab ){
+    if( pItem->pTab ){ 
       sqlite3_str_appendf(&x, " tab=%Q nCol=%d ptr=%p used=%llx",
            pItem->pTab->zName, pItem->pTab->nCol, pItem->pTab, pItem->colUsed);
-    }
-    if( pItem->fg.jointype & JT_LEFT ){
-      sqlite3_str_appendf(&x, " LEFT-JOIN");
+    } 
+    if( pItem->fg.jointype & JT_LEFT ){ 
+      sqlite3_str_appendf(&x, " LEFT-JOIN"); 
     }else if( pItem->fg.jointype & JT_CROSS ){
       sqlite3_str_appendf(&x, " CROSS-JOIN");
-    }
+    } 
     if( pItem->fg.fromDDL ){
       sqlite3_str_appendf(&x, " DDL");
     }
     if( pItem->fg.isCte ){
       sqlite3_str_appendf(&x, " CteUse=0x%p", pItem->u2.pCteUse);
     }
-    sqlite3StrAccumFinish(&x);
+    sqlite3StrAccumFinish(&x); 
     sqlite3TreeViewItem(pView, zLine, i<pSrc->nSrc-1);
-    if( pItem->pSelect ){
-      sqlite3TreeViewSelect(pView, pItem->pSelect, 0);
-    }
-    if( pItem->fg.isTabFunc ){
-      sqlite3TreeViewExprList(pView, pItem->u1.pFuncArg, 0, "func-args:");
-    }
-    sqlite3TreeViewPop(pView);
-  }
-}
+    if( pItem->pSelect ){ 
+      sqlite3TreeViewSelect(pView, pItem->pSelect, 0); 
+    } 
+    if( pItem->fg.isTabFunc ){ 
+      sqlite3TreeViewExprList(pView, pItem->u1.pFuncArg, 0, "func-args:"); 
+    } 
+    sqlite3TreeViewPop(pView); 
+  } 
+} 
 
 /*
 ** Generate a human-readable description of a Select object.
@@ -30453,30 +30453,30 @@ SQLITE_PRIVATE void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 m
       if( p->pHaving ) n++;
       if( p->pOrderBy ) n++;
       if( p->pLimit ) n++;
-#ifndef SQLITE_OMIT_WINDOWFUNC
-      if( p->pWin ) n++;
-      if( p->pWinDefn ) n++;
-#endif
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+      if( p->pWin ) n++; 
+      if( p->pWinDefn ) n++; 
+#endif 
     }
     if( p->pEList ){
       sqlite3TreeViewExprList(pView, p->pEList, n>0, "result-set");
     }
     n--;
-#ifndef SQLITE_OMIT_WINDOWFUNC
-    if( p->pWin ){
-      Window *pX;
-      pView = sqlite3TreeViewPush(pView, (n--)>0);
-      sqlite3TreeViewLine(pView, "window-functions");
-      for(pX=p->pWin; pX; pX=pX->pNextWin){
-        sqlite3TreeViewWinFunc(pView, pX, pX->pNextWin!=0);
-      }
-      sqlite3TreeViewPop(pView);
-    }
-#endif
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+    if( p->pWin ){ 
+      Window *pX; 
+      pView = sqlite3TreeViewPush(pView, (n--)>0); 
+      sqlite3TreeViewLine(pView, "window-functions"); 
+      for(pX=p->pWin; pX; pX=pX->pNextWin){ 
+        sqlite3TreeViewWinFunc(pView, pX, pX->pNextWin!=0); 
+      } 
+      sqlite3TreeViewPop(pView); 
+    } 
+#endif 
     if( p->pSrc && p->pSrc->nSrc ){
       pView = sqlite3TreeViewPush(pView, (n--)>0);
       sqlite3TreeViewLine(pView, "FROM");
-      sqlite3TreeViewSrcList(pView, p->pSrc);
+      sqlite3TreeViewSrcList(pView, p->pSrc); 
       sqlite3TreeViewPop(pView);
     }
     if( p->pWhere ){
@@ -30492,16 +30492,16 @@ SQLITE_PRIVATE void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 m
       sqlite3TreeViewExpr(pView, p->pHaving, 0);
       sqlite3TreeViewPop(pView);
     }
-#ifndef SQLITE_OMIT_WINDOWFUNC
-    if( p->pWinDefn ){
-      Window *pX;
-      sqlite3TreeViewItem(pView, "WINDOW", (n--)>0);
-      for(pX=p->pWinDefn; pX; pX=pX->pNextWin){
-        sqlite3TreeViewWindow(pView, pX, pX->pNextWin!=0);
-      }
-      sqlite3TreeViewPop(pView);
-    }
-#endif
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+    if( p->pWinDefn ){ 
+      Window *pX; 
+      sqlite3TreeViewItem(pView, "WINDOW", (n--)>0); 
+      for(pX=p->pWinDefn; pX; pX=pX->pNextWin){ 
+        sqlite3TreeViewWindow(pView, pX, pX->pNextWin!=0); 
+      } 
+      sqlite3TreeViewPop(pView); 
+    } 
+#endif 
     if( p->pOrderBy ){
       sqlite3TreeViewExprList(pView, p->pOrderBy, (n--)>0, "ORDERBY");
     }
@@ -30529,122 +30529,122 @@ SQLITE_PRIVATE void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 m
   sqlite3TreeViewPop(pView);
 }
 
-#ifndef SQLITE_OMIT_WINDOWFUNC
-/*
-** Generate a description of starting or stopping bounds
-*/
-SQLITE_PRIVATE void sqlite3TreeViewBound(
-  TreeView *pView,        /* View context */
-  u8 eBound,              /* UNBOUNDED, CURRENT, PRECEDING, FOLLOWING */
-  Expr *pExpr,            /* Value for PRECEDING or FOLLOWING */
-  u8 moreToFollow         /* True if more to follow */
-){
-  switch( eBound ){
-    case TK_UNBOUNDED: {
-      sqlite3TreeViewItem(pView, "UNBOUNDED", moreToFollow);
-      sqlite3TreeViewPop(pView);
-      break;
-    }
-    case TK_CURRENT: {
-      sqlite3TreeViewItem(pView, "CURRENT", moreToFollow);
-      sqlite3TreeViewPop(pView);
-      break;
-    }
-    case TK_PRECEDING: {
-      sqlite3TreeViewItem(pView, "PRECEDING", moreToFollow);
-      sqlite3TreeViewExpr(pView, pExpr, 0);
-      sqlite3TreeViewPop(pView);
-      break;
-    }
-    case TK_FOLLOWING: {
-      sqlite3TreeViewItem(pView, "FOLLOWING", moreToFollow);
-      sqlite3TreeViewExpr(pView, pExpr, 0);
-      sqlite3TreeViewPop(pView);
-      break;
-    }
-  }
-}
-#endif /* SQLITE_OMIT_WINDOWFUNC */
-
-#ifndef SQLITE_OMIT_WINDOWFUNC
-/*
-** Generate a human-readable explanation for a Window object
-*/
-SQLITE_PRIVATE void sqlite3TreeViewWindow(TreeView *pView, const Window *pWin, u8 more){
-  int nElement = 0;
-  if( pWin->pFilter ){
-    sqlite3TreeViewItem(pView, "FILTER", 1);
-    sqlite3TreeViewExpr(pView, pWin->pFilter, 0);
-    sqlite3TreeViewPop(pView);
-  }
-  pView = sqlite3TreeViewPush(pView, more);
-  if( pWin->zName ){
-    sqlite3TreeViewLine(pView, "OVER %s (%p)", pWin->zName, pWin);
-  }else{
-    sqlite3TreeViewLine(pView, "OVER (%p)", pWin);
-  }
-  if( pWin->zBase )    nElement++;
-  if( pWin->pOrderBy ) nElement++;
-  if( pWin->eFrmType ) nElement++;
-  if( pWin->eExclude ) nElement++;
-  if( pWin->zBase ){
-    sqlite3TreeViewPush(pView, (--nElement)>0);
-    sqlite3TreeViewLine(pView, "window: %s", pWin->zBase);
-    sqlite3TreeViewPop(pView);
-  }
-  if( pWin->pPartition ){
-    sqlite3TreeViewExprList(pView, pWin->pPartition, nElement>0,"PARTITION-BY");
-  }
-  if( pWin->pOrderBy ){
-    sqlite3TreeViewExprList(pView, pWin->pOrderBy, (--nElement)>0, "ORDER-BY");
-  }
-  if( pWin->eFrmType ){
-    char zBuf[30];
-    const char *zFrmType = "ROWS";
-    if( pWin->eFrmType==TK_RANGE ) zFrmType = "RANGE";
-    if( pWin->eFrmType==TK_GROUPS ) zFrmType = "GROUPS";
-    sqlite3_snprintf(sizeof(zBuf),zBuf,"%s%s",zFrmType,
-        pWin->bImplicitFrame ? " (implied)" : "");
-    sqlite3TreeViewItem(pView, zBuf, (--nElement)>0);
-    sqlite3TreeViewBound(pView, pWin->eStart, pWin->pStart, 1);
-    sqlite3TreeViewBound(pView, pWin->eEnd, pWin->pEnd, 0);
-    sqlite3TreeViewPop(pView);
-  }
-  if( pWin->eExclude ){
-    char zBuf[30];
-    const char *zExclude;
-    switch( pWin->eExclude ){
-      case TK_NO:      zExclude = "NO OTHERS";   break;
-      case TK_CURRENT: zExclude = "CURRENT ROW"; break;
-      case TK_GROUP:   zExclude = "GROUP";       break;
-      case TK_TIES:    zExclude = "TIES";        break;
-      default:
-        sqlite3_snprintf(sizeof(zBuf),zBuf,"invalid(%d)", pWin->eExclude);
-        zExclude = zBuf;
-        break;
-    }
-    sqlite3TreeViewPush(pView, 0);
-    sqlite3TreeViewLine(pView, "EXCLUDE %s", zExclude);
-    sqlite3TreeViewPop(pView);
-  }
-  sqlite3TreeViewPop(pView);
-}
-#endif /* SQLITE_OMIT_WINDOWFUNC */
-
-#ifndef SQLITE_OMIT_WINDOWFUNC
-/*
-** Generate a human-readable explanation for a Window Function object
-*/
-SQLITE_PRIVATE void sqlite3TreeViewWinFunc(TreeView *pView, const Window *pWin, u8 more){
-  pView = sqlite3TreeViewPush(pView, more);
-  sqlite3TreeViewLine(pView, "WINFUNC %s(%d)",
-                       pWin->pFunc->zName, pWin->pFunc->nArg);
-  sqlite3TreeViewWindow(pView, pWin, 0);
-  sqlite3TreeViewPop(pView);
-}
-#endif /* SQLITE_OMIT_WINDOWFUNC */
-
-/*
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+/*
+** Generate a description of starting or stopping bounds 
+*/ 
+SQLITE_PRIVATE void sqlite3TreeViewBound( 
+  TreeView *pView,        /* View context */ 
+  u8 eBound,              /* UNBOUNDED, CURRENT, PRECEDING, FOLLOWING */ 
+  Expr *pExpr,            /* Value for PRECEDING or FOLLOWING */ 
+  u8 moreToFollow         /* True if more to follow */ 
+){ 
+  switch( eBound ){ 
+    case TK_UNBOUNDED: { 
+      sqlite3TreeViewItem(pView, "UNBOUNDED", moreToFollow); 
+      sqlite3TreeViewPop(pView); 
+      break; 
+    } 
+    case TK_CURRENT: { 
+      sqlite3TreeViewItem(pView, "CURRENT", moreToFollow); 
+      sqlite3TreeViewPop(pView); 
+      break; 
+    } 
+    case TK_PRECEDING: { 
+      sqlite3TreeViewItem(pView, "PRECEDING", moreToFollow); 
+      sqlite3TreeViewExpr(pView, pExpr, 0); 
+      sqlite3TreeViewPop(pView); 
+      break; 
+    } 
+    case TK_FOLLOWING: { 
+      sqlite3TreeViewItem(pView, "FOLLOWING", moreToFollow); 
+      sqlite3TreeViewExpr(pView, pExpr, 0); 
+      sqlite3TreeViewPop(pView); 
+      break; 
+    } 
+  } 
+} 
+#endif /* SQLITE_OMIT_WINDOWFUNC */ 
+ 
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+/* 
+** Generate a human-readable explanation for a Window object 
+*/ 
+SQLITE_PRIVATE void sqlite3TreeViewWindow(TreeView *pView, const Window *pWin, u8 more){ 
+  int nElement = 0; 
+  if( pWin->pFilter ){ 
+    sqlite3TreeViewItem(pView, "FILTER", 1); 
+    sqlite3TreeViewExpr(pView, pWin->pFilter, 0); 
+    sqlite3TreeViewPop(pView); 
+  } 
+  pView = sqlite3TreeViewPush(pView, more); 
+  if( pWin->zName ){ 
+    sqlite3TreeViewLine(pView, "OVER %s (%p)", pWin->zName, pWin); 
+  }else{ 
+    sqlite3TreeViewLine(pView, "OVER (%p)", pWin); 
+  } 
+  if( pWin->zBase )    nElement++; 
+  if( pWin->pOrderBy ) nElement++; 
+  if( pWin->eFrmType ) nElement++; 
+  if( pWin->eExclude ) nElement++; 
+  if( pWin->zBase ){ 
+    sqlite3TreeViewPush(pView, (--nElement)>0); 
+    sqlite3TreeViewLine(pView, "window: %s", pWin->zBase); 
+    sqlite3TreeViewPop(pView); 
+  } 
+  if( pWin->pPartition ){ 
+    sqlite3TreeViewExprList(pView, pWin->pPartition, nElement>0,"PARTITION-BY"); 
+  } 
+  if( pWin->pOrderBy ){ 
+    sqlite3TreeViewExprList(pView, pWin->pOrderBy, (--nElement)>0, "ORDER-BY"); 
+  } 
+  if( pWin->eFrmType ){ 
+    char zBuf[30]; 
+    const char *zFrmType = "ROWS"; 
+    if( pWin->eFrmType==TK_RANGE ) zFrmType = "RANGE"; 
+    if( pWin->eFrmType==TK_GROUPS ) zFrmType = "GROUPS"; 
+    sqlite3_snprintf(sizeof(zBuf),zBuf,"%s%s",zFrmType, 
+        pWin->bImplicitFrame ? " (implied)" : ""); 
+    sqlite3TreeViewItem(pView, zBuf, (--nElement)>0); 
+    sqlite3TreeViewBound(pView, pWin->eStart, pWin->pStart, 1); 
+    sqlite3TreeViewBound(pView, pWin->eEnd, pWin->pEnd, 0); 
+    sqlite3TreeViewPop(pView); 
+  } 
+  if( pWin->eExclude ){ 
+    char zBuf[30]; 
+    const char *zExclude; 
+    switch( pWin->eExclude ){ 
+      case TK_NO:      zExclude = "NO OTHERS";   break; 
+      case TK_CURRENT: zExclude = "CURRENT ROW"; break; 
+      case TK_GROUP:   zExclude = "GROUP";       break; 
+      case TK_TIES:    zExclude = "TIES";        break; 
+      default: 
+        sqlite3_snprintf(sizeof(zBuf),zBuf,"invalid(%d)", pWin->eExclude); 
+        zExclude = zBuf; 
+        break; 
+    } 
+    sqlite3TreeViewPush(pView, 0); 
+    sqlite3TreeViewLine(pView, "EXCLUDE %s", zExclude); 
+    sqlite3TreeViewPop(pView); 
+  } 
+  sqlite3TreeViewPop(pView); 
+} 
+#endif /* SQLITE_OMIT_WINDOWFUNC */ 
+ 
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+/* 
+** Generate a human-readable explanation for a Window Function object 
+*/ 
+SQLITE_PRIVATE void sqlite3TreeViewWinFunc(TreeView *pView, const Window *pWin, u8 more){ 
+  pView = sqlite3TreeViewPush(pView, more); 
+  sqlite3TreeViewLine(pView, "WINFUNC %s(%d)", 
+                       pWin->pFunc->zName, pWin->pFunc->nArg); 
+  sqlite3TreeViewWindow(pView, pWin, 0); 
+  sqlite3TreeViewPop(pView); 
+} 
+#endif /* SQLITE_OMIT_WINDOWFUNC */ 
+ 
+/* 
 ** Generate a human-readable explanation of an expression tree.
 */
 SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 moreToFollow){
@@ -30698,9 +30698,9 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
                         pExpr->iTable, pExpr->iColumn,
                         pExpr->y.pTab, zFlgs);
       }
-      if( ExprHasProperty(pExpr, EP_FixedCol) ){
-        sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
-      }
+      if( ExprHasProperty(pExpr, EP_FixedCol) ){ 
+        sqlite3TreeViewExpr(pView, pExpr->pLeft, 0); 
+      } 
       break;
     }
     case TK_INTEGER: {
@@ -30727,11 +30727,11 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
       sqlite3TreeViewLine(pView,"NULL");
       break;
     }
-    case TK_TRUEFALSE: {
+    case TK_TRUEFALSE: { 
       sqlite3TreeViewLine(pView,"%s%s",
          sqlite3ExprTruthValue(pExpr) ? "TRUE" : "FALSE", zFlgs);
-      break;
-    }
+      break; 
+    } 
 #ifndef SQLITE_OMIT_BLOB_LITERAL
     case TK_BLOB: {
       assert( !ExprHasProperty(pExpr, EP_IntValue) );
@@ -30793,19 +30793,19 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
     case TK_ISNULL:  zUniOp = "ISNULL"; break;
     case TK_NOTNULL: zUniOp = "NOTNULL"; break;
 
-    case TK_TRUTH: {
-      int x;
-      const char *azOp[] = {
-         "IS-FALSE", "IS-TRUE", "IS-NOT-FALSE", "IS-NOT-TRUE"
-      };
-      assert( pExpr->op2==TK_IS || pExpr->op2==TK_ISNOT );
-      assert( pExpr->pRight );
-      assert( sqlite3ExprSkipCollate(pExpr->pRight)->op==TK_TRUEFALSE );
-      x = (pExpr->op2==TK_ISNOT)*2 + sqlite3ExprTruthValue(pExpr->pRight);
-      zUniOp = azOp[x];
-      break;
-    }
-
+    case TK_TRUTH: { 
+      int x; 
+      const char *azOp[] = { 
+         "IS-FALSE", "IS-TRUE", "IS-NOT-FALSE", "IS-NOT-TRUE" 
+      }; 
+      assert( pExpr->op2==TK_IS || pExpr->op2==TK_ISNOT ); 
+      assert( pExpr->pRight ); 
+      assert( sqlite3ExprSkipCollate(pExpr->pRight)->op==TK_TRUEFALSE ); 
+      x = (pExpr->op2==TK_ISNOT)*2 + sqlite3ExprTruthValue(pExpr->pRight); 
+      zUniOp = azOp[x]; 
+      break; 
+    } 
+ 
     case TK_SPAN: {
       assert( !ExprHasProperty(pExpr, EP_IntValue) );
       sqlite3TreeViewLine(pView, "SPAN %Q", pExpr->u.zToken);
@@ -30830,17 +30830,17 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
     case TK_AGG_FUNCTION:
     case TK_FUNCTION: {
       ExprList *pFarg;       /* List of function arguments */
-      Window *pWin;
+      Window *pWin; 
       if( ExprHasProperty(pExpr, EP_TokenOnly) ){
         pFarg = 0;
-        pWin = 0;
+        pWin = 0; 
       }else{
         assert( ExprUseXList(pExpr) );
         pFarg = pExpr->x.pList;
-#ifndef SQLITE_OMIT_WINDOWFUNC
+#ifndef SQLITE_OMIT_WINDOWFUNC 
         pWin = ExprHasProperty(pExpr, EP_WinFunc) ? pExpr->y.pWin : 0;
-#else
-        pWin = 0;
+#else 
+        pWin = 0; 
 #endif
       }
       assert( !ExprHasProperty(pExpr, EP_IntValue) );
@@ -30864,13 +30864,13 @@ SQLITE_PRIVATE void sqlite3TreeViewExpr(TreeView *pView, const Expr *pExpr, u8 m
         sqlite3TreeViewLine(pView, "FUNCTION %Q%s", pExpr->u.zToken, zFlgs);
       }
       if( pFarg ){
-        sqlite3TreeViewExprList(pView, pFarg, pWin!=0, 0);
+        sqlite3TreeViewExprList(pView, pFarg, pWin!=0, 0); 
       }
-#ifndef SQLITE_OMIT_WINDOWFUNC
-      if( pWin ){
-        sqlite3TreeViewWindow(pView, pWin, 0);
-      }
-#endif
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+      if( pWin ){ 
+        sqlite3TreeViewWindow(pView, pWin, 0); 
+      } 
+#endif 
       break;
     }
 #ifndef SQLITE_OMIT_SUBQUERY
@@ -31032,22 +31032,22 @@ SQLITE_PRIVATE void sqlite3TreeViewBareExprList(
     for(i=0; i<pList->nExpr; i++){
       int j = pList->a[i].u.x.iOrderByCol;
       char *zName = pList->a[i].zEName;
-      int moreToFollow = i<pList->nExpr - 1;
+      int moreToFollow = i<pList->nExpr - 1; 
       if( pList->a[i].eEName!=ENAME_NAME ) zName = 0;
       if( j || zName ){
-        sqlite3TreeViewPush(pView, moreToFollow);
-        moreToFollow = 0;
-        sqlite3TreeViewLine(pView, 0);
-        if( zName ){
-          fprintf(stdout, "AS %s ", zName);
-        }
-        if( j ){
-          fprintf(stdout, "iOrderByCol=%d", j);
-        }
-        fprintf(stdout, "\n");
-        fflush(stdout);
-      }
-      sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow);
+        sqlite3TreeViewPush(pView, moreToFollow); 
+        moreToFollow = 0; 
+        sqlite3TreeViewLine(pView, 0); 
+        if( zName ){ 
+          fprintf(stdout, "AS %s ", zName); 
+        } 
+        if( j ){ 
+          fprintf(stdout, "iOrderByCol=%d", j); 
+        } 
+        fprintf(stdout, "\n"); 
+        fflush(stdout); 
+      }
+      sqlite3TreeViewExpr(pView, pList->a[i].pExpr, moreToFollow); 
       if( j || zName ){
         sqlite3TreeViewPop(pView);
       }
@@ -31670,11 +31670,11 @@ SQLITE_PRIVATE u32 sqlite3Utf8Read(
 ** encoding, or if *pMem does not contain a string value.
 */
 SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){
-  sqlite3_int64 len;          /* Maximum length of output string in bytes */
-  unsigned char *zOut;        /* Output buffer */
-  unsigned char *zIn;         /* Input iterator */
-  unsigned char *zTerm;       /* End of input */
-  unsigned char *z;           /* Output iterator */
+  sqlite3_int64 len;          /* Maximum length of output string in bytes */ 
+  unsigned char *zOut;        /* Output buffer */ 
+  unsigned char *zIn;         /* Input iterator */ 
+  unsigned char *zTerm;       /* End of input */ 
+  unsigned char *z;           /* Output iterator */ 
   unsigned int c;
 
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
@@ -31725,14 +31725,14 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemTranslate(Mem *pMem, u8 desired
     ** nul-terminator.
     */
     pMem->n &= ~1;
-    len = 2 * (sqlite3_int64)pMem->n + 1;
+    len = 2 * (sqlite3_int64)pMem->n + 1; 
   }else{
     /* When converting from UTF-8 to UTF-16 the maximum growth is caused
     ** when a 1-byte UTF-8 character is translated into a 2-byte UTF-16
     ** character. Two bytes are required in the output buffer for the
     ** nul-terminator.
     */
-    len = 2 * (sqlite3_int64)pMem->n + 2;
+    len = 2 * (sqlite3_int64)pMem->n + 2; 
   }
 
   /* Set zIn to point at the start of the input buffer and zTerm to point 1
@@ -32046,27 +32046,27 @@ SQLITE_PRIVATE void sqlite3UtfSelfTest(void){
 /* #include "sqliteInt.h" */
 /* #include <stdarg.h> */
 #ifndef SQLITE_OMIT_FLOATING_POINT
-#include <math.h>
+#include <math.h> 
 #endif
 
 /*
-** Calls to sqlite3FaultSim() are used to simulate a failure during testing,
+** Calls to sqlite3FaultSim() are used to simulate a failure during testing, 
 ** or to bypass normal error detection during testing in order to let
-** execute proceed futher downstream.
-**
-** In deployment, sqlite3FaultSim() *always* return SQLITE_OK (0).  The
-** sqlite3FaultSim() function only returns non-zero during testing.
-**
-** During testing, if the test harness has set a fault-sim callback using
-** a call to sqlite3_test_control(SQLITE_TESTCTRL_FAULT_INSTALL), then
-** each call to sqlite3FaultSim() is relayed to that application-supplied
-** callback and the integer return value form the application-supplied
-** callback is returned by sqlite3FaultSim().
-**
-** The integer argument to sqlite3FaultSim() is a code to identify which
-** sqlite3FaultSim() instance is being invoked. Each call to sqlite3FaultSim()
-** should have a unique code.  To prevent legacy testing applications from
-** breaking, the codes should not be changed or reused.
+** execute proceed futher downstream. 
+**
+** In deployment, sqlite3FaultSim() *always* return SQLITE_OK (0).  The 
+** sqlite3FaultSim() function only returns non-zero during testing. 
+**
+** During testing, if the test harness has set a fault-sim callback using 
+** a call to sqlite3_test_control(SQLITE_TESTCTRL_FAULT_INSTALL), then 
+** each call to sqlite3FaultSim() is relayed to that application-supplied 
+** callback and the integer return value form the application-supplied 
+** callback is returned by sqlite3FaultSim(). 
+** 
+** The integer argument to sqlite3FaultSim() is a code to identify which 
+** sqlite3FaultSim() instance is being invoked. Each call to sqlite3FaultSim() 
+** should have a unique code.  To prevent legacy testing applications from 
+** breaking, the codes should not be changed or reused. 
 */
 #ifndef SQLITE_UNTESTABLE
 SQLITE_PRIVATE int sqlite3FaultSim(int iTest){
@@ -32085,8 +32085,8 @@ SQLITE_PRIVATE int sqlite3FaultSim(int iTest){
 SQLITE_PRIVATE int sqlite3IsNaN(double x){
   int rc;   /* The value return */
 #if !SQLITE_HAVE_ISNAN && !HAVE_ISNAN
-  u64 y;
-  memcpy(&y,&x,sizeof(y));
+  u64 y; 
+  memcpy(&y,&x,sizeof(y)); 
   rc = IsNaN(y);
 #else
   rc = isnan(x);
@@ -32243,19 +32243,19 @@ SQLITE_PRIVATE void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
 }
 
 /*
-** If database connection db is currently parsing SQL, then transfer
-** error code errCode to that parser if the parser has not already
-** encountered some other kind of error.
-*/
-SQLITE_PRIVATE int sqlite3ErrorToParser(sqlite3 *db, int errCode){
-  Parse *pParse;
-  if( db==0 || (pParse = db->pParse)==0 ) return errCode;
-  pParse->rc = errCode;
-  pParse->nErr++;
-  return errCode;
-}
-
-/*
+** If database connection db is currently parsing SQL, then transfer 
+** error code errCode to that parser if the parser has not already 
+** encountered some other kind of error. 
+*/ 
+SQLITE_PRIVATE int sqlite3ErrorToParser(sqlite3 *db, int errCode){ 
+  Parse *pParse; 
+  if( db==0 || (pParse = db->pParse)==0 ) return errCode; 
+  pParse->rc = errCode; 
+  pParse->nErr++; 
+  return errCode; 
+} 
+ 
+/* 
 ** Convert an SQL-style quoted string into a normal string by removing
 ** the quote characters.  The conversion is done in-place.  If the
 ** input does not begin with a quote character, then this routine
@@ -32268,7 +32268,7 @@ SQLITE_PRIVATE int sqlite3ErrorToParser(sqlite3 *db, int errCode){
 ** dequoted string, exclusive of the zero terminator, if dequoting does
 ** occur.
 **
-** 2002-02-14: This routine is extended to remove MS-Access style
+** 2002-02-14: This routine is extended to remove MS-Access style 
 ** brackets from around identifiers.  For example:  "[a-b-c]" becomes
 ** "a-b-c".
 */
@@ -32294,12 +32294,12 @@ SQLITE_PRIVATE void sqlite3Dequote(char *z){
   }
   z[j] = 0;
 }
-SQLITE_PRIVATE void sqlite3DequoteExpr(Expr *p){
+SQLITE_PRIVATE void sqlite3DequoteExpr(Expr *p){ 
   assert( !ExprHasProperty(p, EP_IntValue) );
-  assert( sqlite3Isquote(p->u.zToken[0]) );
-  p->flags |= p->u.zToken[0]=='"' ? EP_Quoted|EP_DblQuoted : EP_Quoted;
-  sqlite3Dequote(p->u.zToken);
-}
+  assert( sqlite3Isquote(p->u.zToken[0]) ); 
+  p->flags |= p->u.zToken[0]=='"' ? EP_Quoted|EP_DblQuoted : EP_Quoted; 
+  sqlite3Dequote(p->u.zToken); 
+} 
 
 /*
 ** If the input token p is quoted, try to adjust the token to remove
@@ -32354,25 +32354,25 @@ SQLITE_API int sqlite3_stricmp(const char *zLeft, const char *zRight){
 }
 SQLITE_PRIVATE int sqlite3StrICmp(const char *zLeft, const char *zRight){
   unsigned char *a, *b;
-  int c, x;
+  int c, x; 
   a = (unsigned char *)zLeft;
   b = (unsigned char *)zRight;
   for(;;){
-    c = *a;
-    x = *b;
-    if( c==x ){
-      if( c==0 ) break;
-    }else{
-      c = (int)UpperToLower[c] - (int)UpperToLower[x];
-      if( c ) break;
-    }
+    c = *a; 
+    x = *b; 
+    if( c==x ){ 
+      if( c==0 ) break; 
+    }else{ 
+      c = (int)UpperToLower[c] - (int)UpperToLower[x]; 
+      if( c ) break; 
+    } 
     a++;
     b++;
   }
   return c;
 }
 SQLITE_API int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){
-  register unsigned char *a, *b;
+  register unsigned char *a, *b; 
   if( zLeft==0 ){
     return zRight ? -1 : 0;
   }else if( zRight==0 ){
@@ -32406,15 +32406,15 @@ SQLITE_PRIVATE u8 sqlite3StrIHash(const char *z){
 static LONGDOUBLE_TYPE sqlite3Pow10(int E){
 #if defined(_MSC_VER)
   static const LONGDOUBLE_TYPE x[] = {
-    1.0e+001L,
-    1.0e+002L,
-    1.0e+004L,
-    1.0e+008L,
-    1.0e+016L,
-    1.0e+032L,
-    1.0e+064L,
-    1.0e+128L,
-    1.0e+256L
+    1.0e+001L, 
+    1.0e+002L, 
+    1.0e+004L, 
+    1.0e+008L, 
+    1.0e+016L, 
+    1.0e+032L, 
+    1.0e+064L, 
+    1.0e+128L, 
+    1.0e+256L 
   };
   LONGDOUBLE_TYPE r = 1.0;
   int i;
@@ -32444,16 +32444,16 @@ static LONGDOUBLE_TYPE sqlite3Pow10(int E){
 ** uses the encoding enc.  The string is not necessarily zero-terminated.
 **
 ** Return TRUE if the result is a valid real number (or integer) and FALSE
-** if the string is empty or contains extraneous text.  More specifically
-** return
-**      1          =>  The input string is a pure integer
-**      2 or more  =>  The input has a decimal point or eNNN clause
-**      0 or less  =>  The input string is not a valid number
+** if the string is empty or contains extraneous text.  More specifically 
+** return 
+**      1          =>  The input string is a pure integer 
+**      2 or more  =>  The input has a decimal point or eNNN clause 
+**      0 or less  =>  The input string is not a valid number 
 **     -1          =>  Not a valid number, but has a valid prefix which
-**                     includes a decimal point and/or an eNNN clause
-**
-** Valid numbers are in one of these formats:
+**                     includes a decimal point and/or an eNNN clause 
 **
+** Valid numbers are in one of these formats: 
+** 
 **    [+-]digits[E[+-]digits]
 **    [+-]digits.[digits][E[+-]digits]
 **    [+-].digits[E[+-]digits]
@@ -32480,8 +32480,8 @@ SQLITE_PRIVATE int sqlite3AtoF(const char *z, double *pResult, int length, u8 en
   int e = 0;       /* exponent */
   int eValid = 1;  /* True exponent is either not used or is well-formed */
   double result;
-  int nDigit = 0;  /* Number of digits processed */
-  int eType = 1;   /* 1: pure integer,  2+: fractional  -1 or less: bad UTF16 */
+  int nDigit = 0;  /* Number of digits processed */ 
+  int eType = 1;   /* 1: pure integer,  2+: fractional  -1 or less: bad UTF16 */ 
 
   assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
   *pResult = 0.0;   /* Default return value, in case of an error */
@@ -32495,10 +32495,10 @@ SQLITE_PRIVATE int sqlite3AtoF(const char *z, double *pResult, int length, u8 en
     incr = 2;
     length &= ~1;
     assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
-    testcase( enc==SQLITE_UTF16LE );
-    testcase( enc==SQLITE_UTF16BE );
+    testcase( enc==SQLITE_UTF16LE ); 
+    testcase( enc==SQLITE_UTF16BE ); 
     for(i=3-enc; i<length && z[i]==0; i+=2){}
-    if( i<length ) eType = -100;
+    if( i<length ) eType = -100; 
     zEnd = &z[i^1];
     z += (enc&1);
   }
@@ -32516,30 +32516,30 @@ SQLITE_PRIVATE int sqlite3AtoF(const char *z, double *pResult, int length, u8 en
   }
 
   /* copy max significant digits to significand */
-  while( z<zEnd && sqlite3Isdigit(*z) ){
+  while( z<zEnd && sqlite3Isdigit(*z) ){ 
     s = s*10 + (*z - '0');
-    z+=incr; nDigit++;
-    if( s>=((LARGEST_INT64-9)/10) ){
-      /* skip non-significant significand digits
-      ** (increase exponent by d to shift decimal left) */
-      while( z<zEnd && sqlite3Isdigit(*z) ){ z+=incr; d++; }
-    }
+    z+=incr; nDigit++; 
+    if( s>=((LARGEST_INT64-9)/10) ){ 
+      /* skip non-significant significand digits 
+      ** (increase exponent by d to shift decimal left) */ 
+      while( z<zEnd && sqlite3Isdigit(*z) ){ z+=incr; d++; } 
+    } 
   }
   if( z>=zEnd ) goto do_atof_calc;
 
   /* if decimal point is present */
   if( *z=='.' ){
     z+=incr;
-    eType++;
+    eType++; 
     /* copy digits from after decimal to significand
     ** (decrease exponent by d to shift decimal right) */
     while( z<zEnd && sqlite3Isdigit(*z) ){
       if( s<((LARGEST_INT64-9)/10) ){
         s = s*10 + (*z - '0');
         d--;
-        nDigit++;
+        nDigit++; 
       }
-      z+=incr;
+      z+=incr; 
     }
   }
   if( z>=zEnd ) goto do_atof_calc;
@@ -32548,7 +32548,7 @@ SQLITE_PRIVATE int sqlite3AtoF(const char *z, double *pResult, int length, u8 en
   if( *z=='e' || *z=='E' ){
     z+=incr;
     eValid = 0;
-    eType++;
+    eType++; 
 
     /* This branch is needed to avoid a (harmless) buffer overread.  The
     ** special comment alerts the mutation tester that the correct answer
@@ -32647,13 +32647,13 @@ do_atof_calc:
   *pResult = result;
 
   /* return true if number and no extra non-whitespace chracters after */
-  if( z==zEnd && nDigit>0 && eValid && eType>0 ){
-    return eType;
-  }else if( eType>=2 && (eType==3 || eValid) && nDigit>0 ){
-    return -1;
-  }else{
-    return 0;
-  }
+  if( z==zEnd && nDigit>0 && eValid && eType>0 ){ 
+    return eType; 
+  }else if( eType>=2 && (eType==3 || eValid) && nDigit>0 ){ 
+    return -1; 
+  }else{ 
+    return 0; 
+  } 
 #else
   return !sqlite3Atoi64(z, pResult, length, enc);
 #endif /* SQLITE_OMIT_FLOATING_POINT */
@@ -32723,9 +32723,9 @@ static int compare2pow63(const char *zNum, int incr){
 **
 ** Returns:
 **
-**    -1    Not even a prefix of the input text looks like an integer
+**    -1    Not even a prefix of the input text looks like an integer 
 **     0    Successful transformation.  Fits in a 64-bit signed integer.
-**     1    Excess non-space text after the integer value
+**     1    Excess non-space text after the integer value 
 **     2    Integer too large for a 64-bit signed integer or is malformed
 **     3    Special case of 9223372036854775808
 **
@@ -32769,57 +32769,57 @@ SQLITE_PRIVATE int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc
   for(i=0; &zNum[i]<zEnd && (c=zNum[i])>='0' && c<='9'; i+=incr){
     u = u*10 + c - '0';
   }
-  testcase( i==18*incr );
-  testcase( i==19*incr );
-  testcase( i==20*incr );
+  testcase( i==18*incr ); 
+  testcase( i==19*incr ); 
+  testcase( i==20*incr ); 
   if( u>LARGEST_INT64 ){
-    /* This test and assignment is needed only to suppress UB warnings
-    ** from clang and -fsanitize=undefined.  This test and assignment make
-    ** the code a little larger and slower, and no harm comes from omitting
-    ** them, but we must appaise the undefined-behavior pharisees. */
+    /* This test and assignment is needed only to suppress UB warnings 
+    ** from clang and -fsanitize=undefined.  This test and assignment make 
+    ** the code a little larger and slower, and no harm comes from omitting 
+    ** them, but we must appaise the undefined-behavior pharisees. */ 
     *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64;
   }else if( neg ){
     *pNum = -(i64)u;
   }else{
     *pNum = (i64)u;
   }
-  rc = 0;
-  if( i==0 && zStart==zNum ){    /* No digits */
-    rc = -1;
-  }else if( nonNum ){            /* UTF16 with high-order bytes non-zero */
+  rc = 0; 
+  if( i==0 && zStart==zNum ){    /* No digits */ 
+    rc = -1; 
+  }else if( nonNum ){            /* UTF16 with high-order bytes non-zero */ 
     rc = 1;
-  }else if( &zNum[i]<zEnd ){     /* Extra bytes at the end */
-    int jj = i;
-    do{
-      if( !sqlite3Isspace(zNum[jj]) ){
-        rc = 1;          /* Extra non-space text after the integer */
-        break;
-      }
-      jj += incr;
-    }while( &zNum[jj]<zEnd );
-  }
-  if( i<19*incr ){
+  }else if( &zNum[i]<zEnd ){     /* Extra bytes at the end */ 
+    int jj = i; 
+    do{ 
+      if( !sqlite3Isspace(zNum[jj]) ){ 
+        rc = 1;          /* Extra non-space text after the integer */ 
+        break; 
+      } 
+      jj += incr; 
+    }while( &zNum[jj]<zEnd ); 
+  }
+  if( i<19*incr ){ 
     /* Less than 19 digits, so we know that it fits in 64 bits */
     assert( u<=LARGEST_INT64 );
     return rc;
   }else{
     /* zNum is a 19-digit numbers.  Compare it against 9223372036854775808. */
-    c = i>19*incr ? 1 : compare2pow63(zNum, incr);
+    c = i>19*incr ? 1 : compare2pow63(zNum, incr); 
     if( c<0 ){
       /* zNum is less than 9223372036854775808 so it fits */
       assert( u<=LARGEST_INT64 );
       return rc;
     }else{
-      *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64;
-      if( c>0 ){
-        /* zNum is greater than 9223372036854775808 so it overflows */
-        return 2;
-      }else{
-        /* zNum is exactly 9223372036854775808.  Fits if negative.  The
-        ** special case 2 overflow if positive */
-        assert( u-1==LARGEST_INT64 );
-        return neg ? rc : 3;
-      }
+      *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64; 
+      if( c>0 ){ 
+        /* zNum is greater than 9223372036854775808 so it overflows */ 
+        return 2; 
+      }else{ 
+        /* zNum is exactly 9223372036854775808.  Fits if negative.  The 
+        ** special case 2 overflow if positive */ 
+        assert( u-1==LARGEST_INT64 ); 
+        return neg ? rc : 3; 
+      } 
     }
   }
 }
@@ -33035,12 +33035,12 @@ SQLITE_PRIVATE int sqlite3PutVarint(unsigned char *p, u64 v){
 SQLITE_PRIVATE u8 sqlite3GetVarint(const unsigned char *p, u64 *v){
   u32 a,b,s;
 
-  if( ((signed char*)p)[0]>=0 ){
-    *v = *p;
+  if( ((signed char*)p)[0]>=0 ){ 
+    *v = *p; 
     return 1;
   }
-  if( ((signed char*)p)[1]>=0 ){
-    *v = ((u32)(p[0]&0x7f)<<7) | p[1];
+  if( ((signed char*)p)[1]>=0 ){ 
+    *v = ((u32)(p[0]&0x7f)<<7) | p[1]; 
     return 2;
   }
 
@@ -33048,9 +33048,9 @@ SQLITE_PRIVATE u8 sqlite3GetVarint(const unsigned char *p, u64 *v){
   assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) );
   assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) );
 
-  a = ((u32)p[0])<<14;
-  b = p[1];
-  p += 2;
+  a = ((u32)p[0])<<14; 
+  b = p[1]; 
+  p += 2; 
   a |= *p;
   /* a: p0<<14 | p2 (unmasked) */
   if (!(a&0x80))
@@ -33709,7 +33709,7 @@ SQLITE_PRIVATE VList *sqlite3VListAdd(
   assert( pIn==0 || pIn[0]>=3 );  /* Verify ok to add new elements */
   if( pIn==0 || pIn[1]+nInt > pIn[0] ){
     /* Enlarge the allocation */
-    sqlite3_int64 nAlloc = (pIn ? 2*(sqlite3_int64)pIn[0] : 10) + nInt;
+    sqlite3_int64 nAlloc = (pIn ? 2*(sqlite3_int64)pIn[0] : 10) + nInt; 
     VList *pOut = sqlite3DbRealloc(db, pIn, nAlloc*sizeof(int));
     if( pOut==0 ) return pIn;
     if( pIn==0 ) pOut[1] = 2;
@@ -33915,7 +33915,7 @@ static HashElem *findElementWithHash(
   unsigned int *pHash /* Write the hash value here */
 ){
   HashElem *elem;                /* Used to loop thru the element list */
-  unsigned int count;            /* Number of elements left to test */
+  unsigned int count;            /* Number of elements left to test */ 
   unsigned int h;                /* The computed hash */
   static HashElem nullElement = { 0, 0, 0, 0 };
 
@@ -33963,7 +33963,7 @@ static void removeElementGivenHash(
     if( pEntry->chain==elem ){
       pEntry->chain = elem->next;
     }
-    assert( pEntry->count>0 );
+    assert( pEntry->count>0 ); 
     pEntry->count--;
   }
   sqlite3_free( elem );
@@ -34051,23 +34051,23 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){
     /*   1 */ "AutoCommit"       OpHelp(""),
     /*   2 */ "Transaction"      OpHelp(""),
     /*   3 */ "SorterNext"       OpHelp(""),
-    /*   4 */ "Prev"             OpHelp(""),
-    /*   5 */ "Next"             OpHelp(""),
-    /*   6 */ "Checkpoint"       OpHelp(""),
-    /*   7 */ "JournalMode"      OpHelp(""),
-    /*   8 */ "Vacuum"           OpHelp(""),
-    /*   9 */ "VFilter"          OpHelp("iplan=r[P3] zplan='P4'"),
-    /*  10 */ "VUpdate"          OpHelp("data=r[P3@P2]"),
-    /*  11 */ "Goto"             OpHelp(""),
-    /*  12 */ "Gosub"            OpHelp(""),
-    /*  13 */ "InitCoroutine"    OpHelp(""),
-    /*  14 */ "Yield"            OpHelp(""),
-    /*  15 */ "MustBeInt"        OpHelp(""),
-    /*  16 */ "Jump"             OpHelp(""),
-    /*  17 */ "Once"             OpHelp(""),
-    /*  18 */ "If"               OpHelp(""),
+    /*   4 */ "Prev"             OpHelp(""), 
+    /*   5 */ "Next"             OpHelp(""), 
+    /*   6 */ "Checkpoint"       OpHelp(""), 
+    /*   7 */ "JournalMode"      OpHelp(""), 
+    /*   8 */ "Vacuum"           OpHelp(""), 
+    /*   9 */ "VFilter"          OpHelp("iplan=r[P3] zplan='P4'"), 
+    /*  10 */ "VUpdate"          OpHelp("data=r[P3@P2]"), 
+    /*  11 */ "Goto"             OpHelp(""), 
+    /*  12 */ "Gosub"            OpHelp(""), 
+    /*  13 */ "InitCoroutine"    OpHelp(""), 
+    /*  14 */ "Yield"            OpHelp(""), 
+    /*  15 */ "MustBeInt"        OpHelp(""), 
+    /*  16 */ "Jump"             OpHelp(""), 
+    /*  17 */ "Once"             OpHelp(""), 
+    /*  18 */ "If"               OpHelp(""), 
     /*  19 */ "Not"              OpHelp("r[P2]= !r[P1]"),
-    /*  20 */ "IfNot"            OpHelp(""),
+    /*  20 */ "IfNot"            OpHelp(""), 
     /*  21 */ "IsNullOrType"     OpHelp("if typeof(r[P1]) IN (P3,5) goto P2"),
     /*  22 */ "IfNullRow"        OpHelp("if P1.nullRow then r[P3]=NULL, goto P2"),
     /*  23 */ "SeekLT"           OpHelp("key=r[P3@P4]"),
@@ -34391,7 +34391,7 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){
 #define SQLITE_FSFLAGS_IS_MSDOS     0x1
 
 /*
-** If we are to be thread-safe, include the pthreads header.
+** If we are to be thread-safe, include the pthreads header. 
 */
 #if SQLITE_THREADSAFE
 /* # include <pthread.h> */
@@ -34482,9 +34482,9 @@ struct unixFile {
 #if SQLITE_ENABLE_LOCKING_STYLE || defined(__APPLE__)
   unsigned fsFlags;                   /* cached details from statfs() */
 #endif
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-  unsigned iBusyTimeout;              /* Wait this many millisec on locks */
-#endif
+#ifdef SQLITE_ENABLE_SETLK_TIMEOUT 
+  unsigned iBusyTimeout;              /* Wait this many millisec on locks */ 
+#endif 
 #if OS_VXWORKS
   struct vxworksFileId *pId;          /* Unique file ID */
 #endif
@@ -34724,11 +34724,11 @@ static struct unix_syscall {
 #endif
 #define osFchown    ((int(*)(int,uid_t,gid_t))aSyscall[20].pCurrent)
 
-#if defined(HAVE_FCHOWN)
+#if defined(HAVE_FCHOWN) 
   { "geteuid",      (sqlite3_syscall_ptr)geteuid,         0 },
-#else
-  { "geteuid",      (sqlite3_syscall_ptr)0,               0 },
-#endif
+#else 
+  { "geteuid",      (sqlite3_syscall_ptr)0,               0 }, 
+#endif 
 #define osGeteuid   ((uid_t(*)(void))aSyscall[21].pCurrent)
 
 #if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0
@@ -34774,13 +34774,13 @@ static struct unix_syscall {
 #define osLstat      ((int(*)(const char*,struct stat*))aSyscall[27].pCurrent)
 
 #if defined(__linux__) && defined(SQLITE_ENABLE_BATCH_ATOMIC_WRITE)
-# ifdef __ANDROID__
-  { "ioctl", (sqlite3_syscall_ptr)(int(*)(int, int, ...))ioctl, 0 },
+# ifdef __ANDROID__ 
+  { "ioctl", (sqlite3_syscall_ptr)(int(*)(int, int, ...))ioctl, 0 }, 
 #define osIoctl ((int(*)(int,int,...))aSyscall[28].pCurrent)
-# else
+# else 
   { "ioctl",         (sqlite3_syscall_ptr)ioctl,          0 },
 #define osIoctl ((int(*)(int,unsigned long,...))aSyscall[28].pCurrent)
-# endif
+# endif 
 #else
   { "ioctl",         (sqlite3_syscall_ptr)0,              0 },
 #endif
@@ -34960,30 +34960,30 @@ static int robust_open(const char *z, int f, mode_t m){
 **   unixEnterMutex()
 **     assert( unixMutexHeld() );
 **   unixEnterLeave()
-**
-** To prevent deadlock, the global unixBigLock must must be acquired
-** before the unixInodeInfo.pLockMutex mutex, if both are held.  It is
-** OK to get the pLockMutex without holding unixBigLock first, but if
-** that happens, the unixBigLock mutex must not be acquired until after
-** pLockMutex is released.
-**
-**      OK:     enter(unixBigLock),  enter(pLockInfo)
-**      OK:     enter(unixBigLock)
-**      OK:     enter(pLockInfo)
-**   ERROR:     enter(pLockInfo), enter(unixBigLock)
-*/
-static sqlite3_mutex *unixBigLock = 0;
+** 
+** To prevent deadlock, the global unixBigLock must must be acquired 
+** before the unixInodeInfo.pLockMutex mutex, if both are held.  It is 
+** OK to get the pLockMutex without holding unixBigLock first, but if 
+** that happens, the unixBigLock mutex must not be acquired until after 
+** pLockMutex is released. 
+** 
+**      OK:     enter(unixBigLock),  enter(pLockInfo) 
+**      OK:     enter(unixBigLock) 
+**      OK:     enter(pLockInfo) 
+**   ERROR:     enter(pLockInfo), enter(unixBigLock) 
+*/
+static sqlite3_mutex *unixBigLock = 0; 
 static void unixEnterMutex(void){
-  assert( sqlite3_mutex_notheld(unixBigLock) );  /* Not a recursive mutex */
-  sqlite3_mutex_enter(unixBigLock);
+  assert( sqlite3_mutex_notheld(unixBigLock) );  /* Not a recursive mutex */ 
+  sqlite3_mutex_enter(unixBigLock); 
 }
 static void unixLeaveMutex(void){
-  assert( sqlite3_mutex_held(unixBigLock) );
-  sqlite3_mutex_leave(unixBigLock);
+  assert( sqlite3_mutex_held(unixBigLock) ); 
+  sqlite3_mutex_leave(unixBigLock); 
 }
 #ifdef SQLITE_DEBUG
 static int unixMutexHeld(void) {
-  return sqlite3_mutex_held(unixBigLock);
+  return sqlite3_mutex_held(unixBigLock); 
 }
 #endif
 
@@ -35373,37 +35373,37 @@ struct unixFileId {
 
 /*
 ** An instance of the following structure is allocated for each open
-** inode.
+** inode. 
 **
 ** A single inode can have multiple file descriptors, so each unixFile
 ** structure contains a pointer to an instance of this object and this
 ** object keeps a count of the number of unixFile pointing to it.
-**
-** Mutex rules:
-**
-**  (1) Only the pLockMutex mutex must be held in order to read or write
-**      any of the locking fields:
-**          nShared, nLock, eFileLock, bProcessLock, pUnused
-**
-**  (2) When nRef>0, then the following fields are unchanging and can
-**      be read (but not written) without holding any mutex:
-**          fileId, pLockMutex
-**
-**  (3) With the exceptions above, all the fields may only be read
-**      or written while holding the global unixBigLock mutex.
-**
-** Deadlock prevention:  The global unixBigLock mutex may not
-** be acquired while holding the pLockMutex mutex.  If both unixBigLock
-** and pLockMutex are needed, then unixBigLock must be acquired first.
+** 
+** Mutex rules: 
+** 
+**  (1) Only the pLockMutex mutex must be held in order to read or write 
+**      any of the locking fields: 
+**          nShared, nLock, eFileLock, bProcessLock, pUnused 
+** 
+**  (2) When nRef>0, then the following fields are unchanging and can 
+**      be read (but not written) without holding any mutex: 
+**          fileId, pLockMutex 
+** 
+**  (3) With the exceptions above, all the fields may only be read 
+**      or written while holding the global unixBigLock mutex. 
+** 
+** Deadlock prevention:  The global unixBigLock mutex may not 
+** be acquired while holding the pLockMutex mutex.  If both unixBigLock 
+** and pLockMutex are needed, then unixBigLock must be acquired first. 
 */
 struct unixInodeInfo {
   struct unixFileId fileId;       /* The lookup key */
-  sqlite3_mutex *pLockMutex;      /* Hold this mutex for... */
-  int nShared;                      /* Number of SHARED locks held */
-  int nLock;                        /* Number of outstanding file locks */
-  unsigned char eFileLock;          /* One of SHARED_LOCK, RESERVED_LOCK etc. */
-  unsigned char bProcessLock;       /* An exclusive process lock is held */
-  UnixUnusedFd *pUnused;            /* Unused file descriptors to close */
+  sqlite3_mutex *pLockMutex;      /* Hold this mutex for... */ 
+  int nShared;                      /* Number of SHARED locks held */ 
+  int nLock;                        /* Number of outstanding file locks */ 
+  unsigned char eFileLock;          /* One of SHARED_LOCK, RESERVED_LOCK etc. */ 
+  unsigned char bProcessLock;       /* An exclusive process lock is held */ 
+  UnixUnusedFd *pUnused;            /* Unused file descriptors to close */ 
   int nRef;                       /* Number of pointers to this structure */
   unixShmNode *pShmNode;          /* Shared memory associated with this inode */
   unixInodeInfo *pNext;           /* List of all unixInodeInfo objects */
@@ -35419,28 +35419,28 @@ struct unixInodeInfo {
 
 /*
 ** A lists of all unixInodeInfo objects.
-**
-** Must hold unixBigLock in order to read or write this variable.
+** 
+** Must hold unixBigLock in order to read or write this variable. 
 */
 static unixInodeInfo *inodeList = 0;  /* All unixInodeInfo objects */
 
-#ifdef SQLITE_DEBUG
-/*
-** True if the inode mutex (on the unixFile.pFileMutex field) is held, or not.
-** This routine is used only within assert() to help verify correct mutex
-** usage.
-*/
-int unixFileMutexHeld(unixFile *pFile){
-  assert( pFile->pInode );
-  return sqlite3_mutex_held(pFile->pInode->pLockMutex);
-}
-int unixFileMutexNotheld(unixFile *pFile){
-  assert( pFile->pInode );
-  return sqlite3_mutex_notheld(pFile->pInode->pLockMutex);
-}
-#endif
-
-/*
+#ifdef SQLITE_DEBUG 
+/*
+** True if the inode mutex (on the unixFile.pFileMutex field) is held, or not. 
+** This routine is used only within assert() to help verify correct mutex 
+** usage. 
+*/ 
+int unixFileMutexHeld(unixFile *pFile){ 
+  assert( pFile->pInode ); 
+  return sqlite3_mutex_held(pFile->pInode->pLockMutex); 
+} 
+int unixFileMutexNotheld(unixFile *pFile){ 
+  assert( pFile->pInode ); 
+  return sqlite3_mutex_notheld(pFile->pInode->pLockMutex); 
+} 
+#endif 
+ 
+/* 
 **
 ** This function - unixLogErrorAtLine(), is only ever called via the macro
 ** unixLogError().
@@ -35544,7 +35544,7 @@ static void closePendingFds(unixFile *pFile){
   unixInodeInfo *pInode = pFile->pInode;
   UnixUnusedFd *p;
   UnixUnusedFd *pNext;
-  assert( unixFileMutexHeld(pFile) );
+  assert( unixFileMutexHeld(pFile) ); 
   for(p=pInode->pUnused; p; p=pNext){
     pNext = p->pNext;
     robust_close(pFile, p->fd, __LINE__);
@@ -35556,20 +35556,20 @@ static void closePendingFds(unixFile *pFile){
 /*
 ** Release a unixInodeInfo structure previously allocated by findInodeInfo().
 **
-** The global mutex must be held when this routine is called, but the mutex
-** on the inode being deleted must NOT be held.
+** The global mutex must be held when this routine is called, but the mutex 
+** on the inode being deleted must NOT be held. 
 */
 static void releaseInodeInfo(unixFile *pFile){
   unixInodeInfo *pInode = pFile->pInode;
   assert( unixMutexHeld() );
-  assert( unixFileMutexNotheld(pFile) );
+  assert( unixFileMutexNotheld(pFile) ); 
   if( ALWAYS(pInode) ){
     pInode->nRef--;
     if( pInode->nRef==0 ){
       assert( pInode->pShmNode==0 );
-      sqlite3_mutex_enter(pInode->pLockMutex);
+      sqlite3_mutex_enter(pInode->pLockMutex); 
       closePendingFds(pFile);
-      sqlite3_mutex_leave(pInode->pLockMutex);
+      sqlite3_mutex_leave(pInode->pLockMutex); 
       if( pInode->pPrev ){
         assert( pInode->pPrev->pNext==pInode );
         pInode->pPrev->pNext = pInode->pNext;
@@ -35581,7 +35581,7 @@ static void releaseInodeInfo(unixFile *pFile){
         assert( pInode->pNext->pPrev==pInode );
         pInode->pNext->pPrev = pInode->pPrev;
       }
-      sqlite3_mutex_free(pInode->pLockMutex);
+      sqlite3_mutex_free(pInode->pLockMutex); 
       sqlite3_free(pInode);
     }
   }
@@ -35592,7 +35592,7 @@ static void releaseInodeInfo(unixFile *pFile){
 ** describes that file descriptor.  Create a new one if necessary.  The
 ** return value might be uninitialized if an error occurs.
 **
-** The global mutex must held when calling this routine.
+** The global mutex must held when calling this routine. 
 **
 ** Return an appropriate error code.
 */
@@ -35653,7 +35653,7 @@ static int findInodeInfo(
 #else
   fileId.ino = (u64)statbuf.st_ino;
 #endif
-  assert( unixMutexHeld() );
+  assert( unixMutexHeld() ); 
   pInode = inodeList;
   while( pInode && memcmp(&fileId, &pInode->fileId, sizeof(fileId)) ){
     pInode = pInode->pNext;
@@ -35665,15 +35665,15 @@ static int findInodeInfo(
     }
     memset(pInode, 0, sizeof(*pInode));
     memcpy(&pInode->fileId, &fileId, sizeof(fileId));
-    if( sqlite3GlobalConfig.bCoreMutex ){
-      pInode->pLockMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
-      if( pInode->pLockMutex==0 ){
-        sqlite3_free(pInode);
-        return SQLITE_NOMEM_BKPT;
-      }
-    }
+    if( sqlite3GlobalConfig.bCoreMutex ){ 
+      pInode->pLockMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST); 
+      if( pInode->pLockMutex==0 ){ 
+        sqlite3_free(pInode); 
+        return SQLITE_NOMEM_BKPT; 
+      } 
+    } 
     pInode->nRef = 1;
-    assert( unixMutexHeld() );
+    assert( unixMutexHeld() ); 
     pInode->pNext = inodeList;
     pInode->pPrev = 0;
     if( inodeList ) inodeList->pPrev = pInode;
@@ -35751,7 +35751,7 @@ static int unixCheckReservedLock(sqlite3_file *id, int *pResOut){
 
   assert( pFile );
   assert( pFile->eFileLock<=SHARED_LOCK );
-  sqlite3_mutex_enter(pFile->pInode->pLockMutex);
+  sqlite3_mutex_enter(pFile->pInode->pLockMutex); 
 
   /* Check if a thread in this process holds such a lock */
   if( pFile->pInode->eFileLock>SHARED_LOCK ){
@@ -35776,7 +35776,7 @@ static int unixCheckReservedLock(sqlite3_file *id, int *pResOut){
   }
 #endif
 
-  sqlite3_mutex_leave(pFile->pInode->pLockMutex);
+  sqlite3_mutex_leave(pFile->pInode->pLockMutex); 
   OSTRACE(("TEST WR-LOCK %d %d %d (unix)\n", pFile->h, rc, reserved));
 
   *pResOut = reserved;
@@ -35787,44 +35787,44 @@ static int unixCheckReservedLock(sqlite3_file *id, int *pResOut){
 static int unixSleep(sqlite3_vfs*,int);
 
 /*
-** Set a posix-advisory-lock.
-**
-** There are two versions of this routine.  If compiled with
-** SQLITE_ENABLE_SETLK_TIMEOUT then the routine has an extra parameter
-** which is a pointer to a unixFile.  If the unixFile->iBusyTimeout
-** value is set, then it is the number of milliseconds to wait before
-** failing the lock.  The iBusyTimeout value is always reset back to
-** zero on each call.
-**
-** If SQLITE_ENABLE_SETLK_TIMEOUT is not defined, then do a non-blocking
-** attempt to set the lock.
-*/
-#ifndef SQLITE_ENABLE_SETLK_TIMEOUT
-# define osSetPosixAdvisoryLock(h,x,t) osFcntl(h,F_SETLK,x)
-#else
-static int osSetPosixAdvisoryLock(
-  int h,                /* The file descriptor on which to take the lock */
-  struct flock *pLock,  /* The description of the lock */
-  unixFile *pFile       /* Structure holding timeout value */
-){
+** Set a posix-advisory-lock. 
+** 
+** There are two versions of this routine.  If compiled with 
+** SQLITE_ENABLE_SETLK_TIMEOUT then the routine has an extra parameter 
+** which is a pointer to a unixFile.  If the unixFile->iBusyTimeout 
+** value is set, then it is the number of milliseconds to wait before 
+** failing the lock.  The iBusyTimeout value is always reset back to 
+** zero on each call. 
+** 
+** If SQLITE_ENABLE_SETLK_TIMEOUT is not defined, then do a non-blocking 
+** attempt to set the lock. 
+*/ 
+#ifndef SQLITE_ENABLE_SETLK_TIMEOUT 
+# define osSetPosixAdvisoryLock(h,x,t) osFcntl(h,F_SETLK,x) 
+#else 
+static int osSetPosixAdvisoryLock( 
+  int h,                /* The file descriptor on which to take the lock */ 
+  struct flock *pLock,  /* The description of the lock */ 
+  unixFile *pFile       /* Structure holding timeout value */ 
+){ 
   int tm = pFile->iBusyTimeout;
-  int rc = osFcntl(h,F_SETLK,pLock);
+  int rc = osFcntl(h,F_SETLK,pLock); 
   while( rc<0 && tm>0 ){
-    /* On systems that support some kind of blocking file lock with a timeout,
-    ** make appropriate changes here to invoke that blocking file lock.  On
-    ** generic posix, however, there is no such API.  So we simply try the
-    ** lock once every millisecond until either the timeout expires, or until
-    ** the lock is obtained. */
+    /* On systems that support some kind of blocking file lock with a timeout, 
+    ** make appropriate changes here to invoke that blocking file lock.  On 
+    ** generic posix, however, there is no such API.  So we simply try the 
+    ** lock once every millisecond until either the timeout expires, or until 
+    ** the lock is obtained. */ 
     unixSleep(0,1000);
-    rc = osFcntl(h,F_SETLK,pLock);
+    rc = osFcntl(h,F_SETLK,pLock); 
     tm--;
-  }
-  return rc;
-}
-#endif /* SQLITE_ENABLE_SETLK_TIMEOUT */
-
-
-/*
+  } 
+  return rc; 
+} 
+#endif /* SQLITE_ENABLE_SETLK_TIMEOUT */ 
+ 
+ 
+/* 
 ** Attempt to set a system-lock on the file pFile.  The lock is
 ** described by pLock.
 **
@@ -35847,7 +35847,7 @@ static int unixFileLock(unixFile *pFile, struct flock *pLock){
   int rc;
   unixInodeInfo *pInode = pFile->pInode;
   assert( pInode!=0 );
-  assert( sqlite3_mutex_held(pInode->pLockMutex) );
+  assert( sqlite3_mutex_held(pInode->pLockMutex) ); 
   if( (pFile->ctrlFlags & (UNIXFILE_EXCL|UNIXFILE_RDONLY))==UNIXFILE_EXCL ){
     if( pInode->bProcessLock==0 ){
       struct flock lock;
@@ -35856,7 +35856,7 @@ static int unixFileLock(unixFile *pFile, struct flock *pLock){
       lock.l_start = SHARED_FIRST;
       lock.l_len = SHARED_SIZE;
       lock.l_type = F_WRLCK;
-      rc = osSetPosixAdvisoryLock(pFile->h, &lock, pFile);
+      rc = osSetPosixAdvisoryLock(pFile->h, &lock, pFile); 
       if( rc<0 ) return rc;
       pInode->bProcessLock = 1;
       pInode->nLock++;
@@ -35864,7 +35864,7 @@ static int unixFileLock(unixFile *pFile, struct flock *pLock){
       rc = 0;
     }
   }else{
-    rc = osSetPosixAdvisoryLock(pFile->h, pLock, pFile);
+    rc = osSetPosixAdvisoryLock(pFile->h, pLock, pFile); 
   }
   return rc;
 }
@@ -35967,7 +35967,7 @@ static int unixLock(sqlite3_file *id, int eFileLock){
   /* This mutex is needed because pFile->pInode is shared across threads
   */
   pInode = pFile->pInode;
-  sqlite3_mutex_enter(pInode->pLockMutex);
+  sqlite3_mutex_enter(pInode->pLockMutex); 
 
   /* If some thread using this PID has a lock via a different unixFile*
   ** handle that precludes the requested lock, return BUSY.
@@ -36110,7 +36110,7 @@ static int unixLock(sqlite3_file *id, int eFileLock){
   }
 
 end_lock:
-  sqlite3_mutex_leave(pInode->pLockMutex);
+  sqlite3_mutex_leave(pInode->pLockMutex); 
   OSTRACE(("LOCK    %d %s %s (unix)\n", pFile->h, azFileLock(eFileLock),
       rc==SQLITE_OK ? "ok" : "failed"));
   return rc;
@@ -36123,7 +36123,7 @@ end_lock:
 static void setPendingFd(unixFile *pFile){
   unixInodeInfo *pInode = pFile->pInode;
   UnixUnusedFd *p = pFile->pPreallocatedUnused;
-  assert( unixFileMutexHeld(pFile) );
+  assert( unixFileMutexHeld(pFile) ); 
   p->pNext = pInode->pUnused;
   pInode->pUnused = p;
   pFile->h = -1;
@@ -36159,7 +36159,7 @@ static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){
     return SQLITE_OK;
   }
   pInode = pFile->pInode;
-  sqlite3_mutex_enter(pInode->pLockMutex);
+  sqlite3_mutex_enter(pInode->pLockMutex); 
   assert( pInode->nShared!=0 );
   if( pFile->eFileLock>SHARED_LOCK ){
     assert( pInode->eFileLock==pFile->eFileLock );
@@ -36285,14 +36285,14 @@ static int posixUnlock(sqlite3_file *id, int eFileLock, int handleNFSUnlock){
     */
     pInode->nLock--;
     assert( pInode->nLock>=0 );
-    if( pInode->nLock==0 ) closePendingFds(pFile);
+    if( pInode->nLock==0 ) closePendingFds(pFile); 
   }
 
 end_unlock:
-  sqlite3_mutex_leave(pInode->pLockMutex);
-  if( rc==SQLITE_OK ){
-    pFile->eFileLock = eFileLock;
-  }
+  sqlite3_mutex_leave(pInode->pLockMutex); 
+  if( rc==SQLITE_OK ){ 
+    pFile->eFileLock = eFileLock; 
+  } 
   return rc;
 }
 
@@ -36363,20 +36363,20 @@ static int closeUnixFile(sqlite3_file *id){
 static int unixClose(sqlite3_file *id){
   int rc = SQLITE_OK;
   unixFile *pFile = (unixFile *)id;
-  unixInodeInfo *pInode = pFile->pInode;
-
-  assert( pInode!=0 );
+  unixInodeInfo *pInode = pFile->pInode; 
+ 
+  assert( pInode!=0 ); 
   verifyDbFile(pFile);
   unixUnlock(id, NO_LOCK);
-  assert( unixFileMutexNotheld(pFile) );
+  assert( unixFileMutexNotheld(pFile) ); 
   unixEnterMutex();
 
   /* unixFile.pInode is always valid here. Otherwise, a different close
   ** routine (e.g. nolockClose()) would be called instead.
   */
   assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
-  sqlite3_mutex_enter(pInode->pLockMutex);
-  if( pInode->nLock ){
+  sqlite3_mutex_enter(pInode->pLockMutex); 
+  if( pInode->nLock ){ 
     /* If there are outstanding locks, do not actually close the file just
     ** yet because that would clear those locks.  Instead, add the file
     ** descriptor to pInode->pUnused list.  It will be automatically closed
@@ -36384,7 +36384,7 @@ static int unixClose(sqlite3_file *id){
     */
     setPendingFd(pFile);
   }
-  sqlite3_mutex_leave(pInode->pLockMutex);
+  sqlite3_mutex_leave(pInode->pLockMutex); 
   releaseInodeInfo(pFile);
   assert( pFile->pShm==0 );
   rc = closeUnixFile(id);
@@ -36983,7 +36983,7 @@ static int semXClose(sqlite3_file *id) {
     unixFile *pFile = (unixFile*)id;
     semXUnlock(id, NO_LOCK);
     assert( pFile );
-    assert( unixFileMutexNotheld(pFile) );
+    assert( unixFileMutexNotheld(pFile) ); 
     unixEnterMutex();
     releaseInodeInfo(pFile);
     unixLeaveMutex();
@@ -37098,7 +37098,7 @@ static int afpCheckReservedLock(sqlite3_file *id, int *pResOut){
     *pResOut = 1;
     return SQLITE_OK;
   }
-  sqlite3_mutex_enter(pFile->pInode->pLockMutex);
+  sqlite3_mutex_enter(pFile->pInode->pLockMutex); 
   /* Check if a thread in this process holds such a lock */
   if( pFile->pInode->eFileLock>SHARED_LOCK ){
     reserved = 1;
@@ -37122,7 +37122,7 @@ static int afpCheckReservedLock(sqlite3_file *id, int *pResOut){
     }
   }
 
-  sqlite3_mutex_leave(pFile->pInode->pLockMutex);
+  sqlite3_mutex_leave(pFile->pInode->pLockMutex); 
   OSTRACE(("TEST WR-LOCK %d %d %d (afp)\n", pFile->h, rc, reserved));
 
   *pResOut = reserved;
@@ -37186,7 +37186,7 @@ static int afpLock(sqlite3_file *id, int eFileLock){
   /* This mutex is needed because pFile->pInode is shared across threads
   */
   pInode = pFile->pInode;
-  sqlite3_mutex_enter(pInode->pLockMutex);
+  sqlite3_mutex_enter(pInode->pLockMutex); 
 
   /* If some thread using this PID has a lock via a different unixFile*
   ** handle that precludes the requested lock, return BUSY.
@@ -37322,7 +37322,7 @@ static int afpLock(sqlite3_file *id, int eFileLock){
   }
 
 afp_end_lock:
-  sqlite3_mutex_leave(pInode->pLockMutex);
+  sqlite3_mutex_leave(pInode->pLockMutex); 
   OSTRACE(("LOCK    %d %s %s (afp)\n", pFile->h, azFileLock(eFileLock),
          rc==SQLITE_OK ? "ok" : "failed"));
   return rc;
@@ -37355,7 +37355,7 @@ static int afpUnlock(sqlite3_file *id, int eFileLock) {
     return SQLITE_OK;
   }
   pInode = pFile->pInode;
-  sqlite3_mutex_enter(pInode->pLockMutex);
+  sqlite3_mutex_enter(pInode->pLockMutex); 
   assert( pInode->nShared!=0 );
   if( pFile->eFileLock>SHARED_LOCK ){
     assert( pInode->eFileLock==pFile->eFileLock );
@@ -37424,14 +37424,14 @@ static int afpUnlock(sqlite3_file *id, int eFileLock) {
     if( rc==SQLITE_OK ){
       pInode->nLock--;
       assert( pInode->nLock>=0 );
-      if( pInode->nLock==0 ) closePendingFds(pFile);
+      if( pInode->nLock==0 ) closePendingFds(pFile); 
     }
   }
 
-  sqlite3_mutex_leave(pInode->pLockMutex);
-  if( rc==SQLITE_OK ){
-    pFile->eFileLock = eFileLock;
-  }
+  sqlite3_mutex_leave(pInode->pLockMutex); 
+  if( rc==SQLITE_OK ){ 
+    pFile->eFileLock = eFileLock; 
+  } 
   return rc;
 }
 
@@ -37443,20 +37443,20 @@ static int afpClose(sqlite3_file *id) {
   unixFile *pFile = (unixFile*)id;
   assert( id!=0 );
   afpUnlock(id, NO_LOCK);
-  assert( unixFileMutexNotheld(pFile) );
+  assert( unixFileMutexNotheld(pFile) ); 
   unixEnterMutex();
-  if( pFile->pInode ){
-    unixInodeInfo *pInode = pFile->pInode;
-    sqlite3_mutex_enter(pInode->pLockMutex);
-    if( pInode->nLock ){
-      /* If there are outstanding locks, do not actually close the file just
-      ** yet because that would clear those locks.  Instead, add the file
-      ** descriptor to pInode->aPending.  It will be automatically closed when
-      ** the last lock is cleared.
-      */
-      setPendingFd(pFile);
-    }
-    sqlite3_mutex_leave(pInode->pLockMutex);
+  if( pFile->pInode ){ 
+    unixInodeInfo *pInode = pFile->pInode; 
+    sqlite3_mutex_enter(pInode->pLockMutex); 
+    if( pInode->nLock ){ 
+      /* If there are outstanding locks, do not actually close the file just 
+      ** yet because that would clear those locks.  Instead, add the file 
+      ** descriptor to pInode->aPending.  It will be automatically closed when 
+      ** the last lock is cleared. 
+      */ 
+      setPendingFd(pFile); 
+    } 
+    sqlite3_mutex_leave(pInode->pLockMutex); 
   }
   releaseInodeInfo(pFile);
   sqlite3_free(pFile->lockingContext);
@@ -38128,7 +38128,7 @@ static int fcntlSizeHint(unixFile *pFile, i64 nByte){
       do{
         err = osFallocate(pFile->h, buf.st_size, nSize-buf.st_size);
       }while( err==EINTR );
-      if( err && err!=EINVAL ) return SQLITE_IOERR_WRITE;
+      if( err && err!=EINVAL ) return SQLITE_IOERR_WRITE; 
 #else
       /* If the OS does not have posix_fallocate(), fake it. Write a
       ** single byte to the last byte in each block that falls entirely
@@ -38257,14 +38257,14 @@ static int unixFileControl(sqlite3_file *id, int op, void *pArg){
       *(int*)pArg = fileHasMoved(pFile);
       return SQLITE_OK;
     }
-#ifdef SQLITE_ENABLE_SETLK_TIMEOUT
-    case SQLITE_FCNTL_LOCK_TIMEOUT: {
+#ifdef SQLITE_ENABLE_SETLK_TIMEOUT 
+    case SQLITE_FCNTL_LOCK_TIMEOUT: { 
       int iOld = pFile->iBusyTimeout;
-      pFile->iBusyTimeout = *(int*)pArg;
+      pFile->iBusyTimeout = *(int*)pArg; 
       *(int*)pArg = iOld;
-      return SQLITE_OK;
-    }
-#endif
+      return SQLITE_OK; 
+    } 
+#endif 
 #if SQLITE_MAX_MMAP_SIZE>0
     case SQLITE_FCNTL_MMAP_SIZE: {
       i64 newLimit = *(i64*)pArg;
@@ -38507,18 +38507,18 @@ static int unixGetpagesize(void){
 **
 ** The following fields are read-only after the object is created:
 **
-**      hShm
+**      hShm 
 **      zFilename
 **
-** Either unixShmNode.pShmMutex must be held or unixShmNode.nRef==0 and
+** Either unixShmNode.pShmMutex must be held or unixShmNode.nRef==0 and 
 ** unixMutexHeld() is true when reading or writing any other field
 ** in this structure.
 */
 struct unixShmNode {
   unixInodeInfo *pInode;     /* unixInodeInfo that owns this SHM node */
-  sqlite3_mutex *pShmMutex;  /* Mutex to access this object */
+  sqlite3_mutex *pShmMutex;  /* Mutex to access this object */ 
   char *zFilename;           /* Name of the mmapped file */
-  int hShm;                  /* Open file descriptor */
+  int hShm;                  /* Open file descriptor */ 
   int szRegion;              /* Size of shared-memory regions */
   u16 nRegion;               /* Size of array apRegion */
   u8 isReadonly;             /* True if read-only */
@@ -38541,16 +38541,16 @@ struct unixShmNode {
 ** The following fields are initialized when this object is created and
 ** are read-only thereafter:
 **
-**    unixShm.pShmNode
+**    unixShm.pShmNode 
 **    unixShm.id
 **
-** All other fields are read/write.  The unixShm.pShmNode->pShmMutex must
-** be held while accessing any read/write fields.
+** All other fields are read/write.  The unixShm.pShmNode->pShmMutex must 
+** be held while accessing any read/write fields. 
 */
 struct unixShm {
   unixShmNode *pShmNode;     /* The underlying unixShmNode object */
   unixShm *pNext;            /* Next unixShm with the same unixShmNode */
-  u8 hasMutex;               /* True if holding the unixShmNode->pShmMutex */
+  u8 hasMutex;               /* True if holding the unixShmNode->pShmMutex */ 
   u8 id;                     /* Id of this connection within its unixShmNode */
   u16 sharedMask;            /* Mask of shared locks held */
   u16 exclMask;              /* Mask of exclusive locks held */
@@ -38614,8 +38614,8 @@ static int unixShmSystemLock(
 
   /* Access to the unixShmNode object is serialized by the caller */
   pShmNode = pFile->pInode->pShmNode;
-  assert( pShmNode->nRef==0 || sqlite3_mutex_held(pShmNode->pShmMutex) );
-  assert( pShmNode->nRef>0 || unixMutexHeld() );
+  assert( pShmNode->nRef==0 || sqlite3_mutex_held(pShmNode->pShmMutex) ); 
+  assert( pShmNode->nRef>0 || unixMutexHeld() ); 
 
   /* Shared locks never span more than one byte */
   assert( n==1 || lockType!=F_RDLCK );
@@ -38623,7 +38623,7 @@ static int unixShmSystemLock(
   /* Locks are within range */
   assert( n>=1 && n<=SQLITE_SHM_NLOCK );
 
-  if( pShmNode->hShm>=0 ){
+  if( pShmNode->hShm>=0 ){ 
     int res;
     /* Initialize the locking parameters */
     f.l_type = lockType;
@@ -38708,18 +38708,18 @@ static void unixShmPurge(unixFile *pFd){
     int nShmPerMap = unixShmRegionPerMap();
     int i;
     assert( p->pInode==pFd->pInode );
-    sqlite3_mutex_free(p->pShmMutex);
+    sqlite3_mutex_free(p->pShmMutex); 
     for(i=0; i<p->nRegion; i+=nShmPerMap){
-      if( p->hShm>=0 ){
+      if( p->hShm>=0 ){ 
         osMunmap(p->apRegion[i], p->szRegion);
       }else{
         sqlite3_free(p->apRegion[i]);
       }
     }
     sqlite3_free(p->apRegion);
-    if( p->hShm>=0 ){
-      robust_close(pFd, p->hShm, __LINE__);
-      p->hShm = -1;
+    if( p->hShm>=0 ){ 
+      robust_close(pFd, p->hShm, __LINE__); 
+      p->hShm = -1; 
     }
     p->pInode->pShmNode = 0;
     sqlite3_free(p);
@@ -38761,7 +38761,7 @@ static int unixLockSharedMemory(unixFile *pDbFd, unixShmNode *pShmNode){
   lock.l_start = UNIX_SHM_DMS;
   lock.l_len = 1;
   lock.l_type = F_WRLCK;
-  if( osFcntl(pShmNode->hShm, F_GETLK, &lock)!=0 ) {
+  if( osFcntl(pShmNode->hShm, F_GETLK, &lock)!=0 ) { 
     rc = SQLITE_IOERR_LOCK;
   }else if( lock.l_type==F_UNLCK ){
     if( pShmNode->isReadonly ){
@@ -38769,12 +38769,12 @@ static int unixLockSharedMemory(unixFile *pDbFd, unixShmNode *pShmNode){
       rc = SQLITE_READONLY_CANTINIT;
     }else{
       rc = unixShmSystemLock(pDbFd, F_WRLCK, UNIX_SHM_DMS, 1);
-      /* The first connection to attach must truncate the -shm file.  We
-      ** truncate to 3 bytes (an arbitrary small number, less than the
-      ** -shm header size) rather than 0 as a system debugging aid, to
-      ** help detect if a -shm file truncation is legitimate or is the work
-      ** or a rogue process. */
-      if( rc==SQLITE_OK && robust_ftruncate(pShmNode->hShm, 3) ){
+      /* The first connection to attach must truncate the -shm file.  We 
+      ** truncate to 3 bytes (an arbitrary small number, less than the 
+      ** -shm header size) rather than 0 as a system debugging aid, to 
+      ** help detect if a -shm file truncation is legitimate or is the work 
+      ** or a rogue process. */ 
+      if( rc==SQLITE_OK && robust_ftruncate(pShmNode->hShm, 3) ){ 
         rc = unixLogError(SQLITE_IOERR_SHMOPEN,"ftruncate",pShmNode->zFilename);
       }
     }
@@ -38841,7 +38841,7 @@ static int unixOpenSharedMemory(unixFile *pDbFd){
   /* Check to see if a unixShmNode object already exists. Reuse an existing
   ** one if present. Create a new one if necessary.
   */
-  assert( unixFileMutexNotheld(pDbFd) );
+  assert( unixFileMutexNotheld(pDbFd) ); 
   unixEnterMutex();
   pInode = pDbFd->pInode;
   pShmNode = pInode->pShmNode;
@@ -38880,12 +38880,12 @@ static int unixOpenSharedMemory(unixFile *pDbFd){
     sqlite3_snprintf(nShmFilename, zShm, "%s-shm", zBasePath);
     sqlite3FileSuffix3(pDbFd->zPath, zShm);
 #endif
-    pShmNode->hShm = -1;
+    pShmNode->hShm = -1; 
     pDbFd->pInode->pShmNode = pShmNode;
     pShmNode->pInode = pDbFd->pInode;
     if( sqlite3GlobalConfig.bCoreMutex ){
-      pShmNode->pShmMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST);
-      if( pShmNode->pShmMutex==0 ){
+      pShmNode->pShmMutex = sqlite3_mutex_alloc(SQLITE_MUTEX_FAST); 
+      if( pShmNode->pShmMutex==0 ){ 
         rc = SQLITE_NOMEM_BKPT;
         goto shm_open_err;
       }
@@ -38896,10 +38896,10 @@ static int unixOpenSharedMemory(unixFile *pDbFd){
         pShmNode->hShm = robust_open(zShm, O_RDWR|O_CREAT|O_NOFOLLOW,
                                      (sStat.st_mode&0777));
       }
-      if( pShmNode->hShm<0 ){
+      if( pShmNode->hShm<0 ){ 
         pShmNode->hShm = robust_open(zShm, O_RDONLY|O_NOFOLLOW,
                                      (sStat.st_mode&0777));
-        if( pShmNode->hShm<0 ){
+        if( pShmNode->hShm<0 ){ 
           rc = unixLogError(SQLITE_CANTOPEN_BKPT, "open", zShm);
           goto shm_open_err;
         }
@@ -38910,7 +38910,7 @@ static int unixOpenSharedMemory(unixFile *pDbFd){
       ** is owned by the same user that owns the original database.  Otherwise,
       ** the original owner will not be able to connect.
       */
-      robustFchown(pShmNode->hShm, sStat.st_uid, sStat.st_gid);
+      robustFchown(pShmNode->hShm, sStat.st_uid, sStat.st_gid); 
 
       rc = unixLockSharedMemory(pDbFd, pShmNode);
       if( rc!=SQLITE_OK && rc!=SQLITE_READONLY_CANTINIT ) goto shm_open_err;
@@ -38930,13 +38930,13 @@ static int unixOpenSharedMemory(unixFile *pDbFd){
   ** the cover of the unixEnterMutex() mutex and the pointer from the
   ** new (struct unixShm) object to the pShmNode has been set. All that is
   ** left to do is to link the new object into the linked list starting
-  ** at pShmNode->pFirst. This must be done while holding the
-  ** pShmNode->pShmMutex.
+  ** at pShmNode->pFirst. This must be done while holding the 
+  ** pShmNode->pShmMutex. 
   */
-  sqlite3_mutex_enter(pShmNode->pShmMutex);
+  sqlite3_mutex_enter(pShmNode->pShmMutex); 
   p->pNext = pShmNode->pFirst;
   pShmNode->pFirst = p;
-  sqlite3_mutex_leave(pShmNode->pShmMutex);
+  sqlite3_mutex_leave(pShmNode->pShmMutex); 
   return rc;
 
   /* Jump here on any error */
@@ -38988,7 +38988,7 @@ static int unixShmMap(
 
   p = pDbFd->pShm;
   pShmNode = p->pShmNode;
-  sqlite3_mutex_enter(pShmNode->pShmMutex);
+  sqlite3_mutex_enter(pShmNode->pShmMutex); 
   if( pShmNode->isUnlocked ){
     rc = unixLockSharedMemory(pDbFd, pShmNode);
     if( rc!=SQLITE_OK ) goto shmpage_out;
@@ -38996,8 +38996,8 @@ static int unixShmMap(
   }
   assert( szRegion==pShmNode->szRegion || pShmNode->nRegion==0 );
   assert( pShmNode->pInode==pDbFd->pInode );
-  assert( pShmNode->hShm>=0 || pDbFd->pInode->bProcessLock==1 );
-  assert( pShmNode->hShm<0 || pDbFd->pInode->bProcessLock==0 );
+  assert( pShmNode->hShm>=0 || pDbFd->pInode->bProcessLock==1 ); 
+  assert( pShmNode->hShm<0 || pDbFd->pInode->bProcessLock==0 ); 
 
   /* Minimum number of regions required to be mapped. */
   nReqRegion = ((iRegion+nShmPerMap) / nShmPerMap) * nShmPerMap;
@@ -39009,12 +39009,12 @@ static int unixShmMap(
 
     pShmNode->szRegion = szRegion;
 
-    if( pShmNode->hShm>=0 ){
+    if( pShmNode->hShm>=0 ){ 
       /* The requested region is not mapped into this processes address space.
       ** Check to see if it has been allocated (i.e. if the wal-index file is
       ** large enough to contain the requested region).
       */
-      if( osFstat(pShmNode->hShm, &sStat) ){
+      if( osFstat(pShmNode->hShm, &sStat) ){ 
         rc = SQLITE_IOERR_SHMSIZE;
         goto shmpage_out;
       }
@@ -39042,7 +39042,7 @@ static int unixShmMap(
           assert( (nByte % pgsz)==0 );
           for(iPg=(sStat.st_size/pgsz); iPg<(nByte/pgsz); iPg++){
             int x = 0;
-            if( seekAndWriteFd(pShmNode->hShm, iPg*pgsz + pgsz-1,"",1,&x)!=1 ){
+            if( seekAndWriteFd(pShmNode->hShm, iPg*pgsz + pgsz-1,"",1,&x)!=1 ){ 
               const char *zFile = pShmNode->zFilename;
               rc = unixLogError(SQLITE_IOERR_SHMSIZE, "write", zFile);
               goto shmpage_out;
@@ -39065,22 +39065,22 @@ static int unixShmMap(
       int nMap = szRegion*nShmPerMap;
       int i;
       void *pMem;
-      if( pShmNode->hShm>=0 ){
+      if( pShmNode->hShm>=0 ){ 
         pMem = osMmap(0, nMap,
             pShmNode->isReadonly ? PROT_READ : PROT_READ|PROT_WRITE,
-            MAP_SHARED, pShmNode->hShm, szRegion*(i64)pShmNode->nRegion
+            MAP_SHARED, pShmNode->hShm, szRegion*(i64)pShmNode->nRegion 
         );
         if( pMem==MAP_FAILED ){
           rc = unixLogError(SQLITE_IOERR_SHMMAP, "mmap", pShmNode->zFilename);
           goto shmpage_out;
         }
       }else{
-        pMem = sqlite3_malloc64(nMap);
+        pMem = sqlite3_malloc64(nMap); 
         if( pMem==0 ){
           rc = SQLITE_NOMEM_BKPT;
           goto shmpage_out;
         }
-        memset(pMem, 0, nMap);
+        memset(pMem, 0, nMap); 
       }
 
       for(i=0; i<nShmPerMap; i++){
@@ -39097,7 +39097,7 @@ shmpage_out:
     *pp = 0;
   }
   if( pShmNode->isReadonly && rc==SQLITE_OK ) rc = SQLITE_READONLY;
-  sqlite3_mutex_leave(pShmNode->pShmMutex);
+  sqlite3_mutex_leave(pShmNode->pShmMutex); 
   return rc;
 }
 
@@ -39163,8 +39163,8 @@ static int unixShmLock(
        || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED)
        || flags==(SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE) );
   assert( n==1 || (flags & SQLITE_SHM_EXCLUSIVE)!=0 );
-  assert( pShmNode->hShm>=0 || pDbFd->pInode->bProcessLock==1 );
-  assert( pShmNode->hShm<0 || pDbFd->pInode->bProcessLock==0 );
+  assert( pShmNode->hShm>=0 || pDbFd->pInode->bProcessLock==1 ); 
+  assert( pShmNode->hShm<0 || pDbFd->pInode->bProcessLock==0 ); 
 
   /* Check that, if this to be a blocking lock, no locks that occur later
   ** in the following list than the lock being obtained are already held:
@@ -39190,7 +39190,7 @@ static int unixShmLock(
 
   mask = (1<<(ofst+n)) - (1<<ofst);
   assert( n>1 || mask==(1<<ofst) );
-  sqlite3_mutex_enter(pShmNode->pShmMutex);
+  sqlite3_mutex_enter(pShmNode->pShmMutex); 
   assert( assertLockingArrayOk(pShmNode) );
   if( flags & SQLITE_SHM_UNLOCK ){
     if( (p->exclMask|p->sharedMask) & mask ){
@@ -39261,7 +39261,7 @@ static int unixShmLock(
     }
   }
   assert( assertLockingArrayOk(pShmNode) );
-  sqlite3_mutex_leave(pShmNode->pShmMutex);
+  sqlite3_mutex_leave(pShmNode->pShmMutex); 
   OSTRACE(("SHM-LOCK shmid-%d, pid-%d got %03x,%03x\n",
            p->id, osGetpid(0), p->sharedMask, p->exclMask));
   return rc;
@@ -39280,7 +39280,7 @@ static void unixShmBarrier(
   sqlite3MemoryBarrier();         /* compiler-defined memory barrier */
   assert( fd->pMethods->xLock==nolockLock
        || unixFileMutexNotheld((unixFile*)fd)
-  );
+  ); 
   unixEnterMutex();               /* Also mutex, for redundancy */
   unixLeaveMutex();
 }
@@ -39311,23 +39311,23 @@ static int unixShmUnmap(
 
   /* Remove connection p from the set of connections associated
   ** with pShmNode */
-  sqlite3_mutex_enter(pShmNode->pShmMutex);
+  sqlite3_mutex_enter(pShmNode->pShmMutex); 
   for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
   *pp = p->pNext;
 
   /* Free the connection p */
   sqlite3_free(p);
   pDbFd->pShm = 0;
-  sqlite3_mutex_leave(pShmNode->pShmMutex);
+  sqlite3_mutex_leave(pShmNode->pShmMutex); 
 
   /* If pShmNode->nRef has reached 0, then close the underlying
   ** shared-memory file, too */
-  assert( unixFileMutexNotheld(pDbFd) );
+  assert( unixFileMutexNotheld(pDbFd) ); 
   unixEnterMutex();
   assert( pShmNode->nRef>0 );
   pShmNode->nRef--;
   if( pShmNode->nRef==0 ){
-    if( deleteFlag && pShmNode->hShm>=0 ){
+    if( deleteFlag && pShmNode->hShm>=0 ){ 
       osUnlink(pShmNode->zFilename);
     }
     unixShmPurge(pDbFd);
@@ -39649,7 +39649,7 @@ IOMETHODS(
 IOMETHODS(
   nolockIoFinder,           /* Finder function name */
   nolockIoMethods,          /* sqlite3_io_methods object name */
-  3,                        /* shared memory and mmap are enabled */
+  3,                        /* shared memory and mmap are enabled */ 
   nolockClose,              /* xClose method */
   nolockLock,               /* xLock method */
   nolockUnlock,             /* xUnlock method */
@@ -40155,7 +40155,7 @@ static UnixUnusedFd *findReusableFd(const char *zPath, int flags){
   **
   ** Even if a subsequent open() call does succeed, the consequences of
   ** not searching for a reusable file descriptor are not dire.  */
-  if( inodeList!=0 && 0==osStat(zPath, &sStat) ){
+  if( inodeList!=0 && 0==osStat(zPath, &sStat) ){ 
     unixInodeInfo *pInode;
 
     pInode = inodeList;
@@ -40165,15 +40165,15 @@ static UnixUnusedFd *findReusableFd(const char *zPath, int flags){
     }
     if( pInode ){
       UnixUnusedFd **pp;
-      assert( sqlite3_mutex_notheld(pInode->pLockMutex) );
-      sqlite3_mutex_enter(pInode->pLockMutex);
+      assert( sqlite3_mutex_notheld(pInode->pLockMutex) ); 
+      sqlite3_mutex_enter(pInode->pLockMutex); 
       flags &= (SQLITE_OPEN_READONLY|SQLITE_OPEN_READWRITE);
       for(pp=&pInode->pUnused; *pp && (*pp)->flags!=flags; pp=&((*pp)->pNext));
       pUnused = *pp;
       if( pUnused ){
         *pp = pUnused->pNext;
       }
-      sqlite3_mutex_leave(pInode->pLockMutex);
+      sqlite3_mutex_leave(pInode->pLockMutex); 
     }
   }
   unixLeaveMutex();
@@ -42326,7 +42326,7 @@ SQLITE_API int sqlite3_os_init(void){
   for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){
     sqlite3_vfs_register(&aVfs[i], i==0);
   }
-  unixBigLock = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1);
+  unixBigLock = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1); 
 
 #ifndef SQLITE_OMIT_WAL
   /* Validate lock assumptions */
@@ -42360,7 +42360,7 @@ SQLITE_API int sqlite3_os_init(void){
 ** This routine is a no-op for unix.
 */
 SQLITE_API int sqlite3_os_end(void){
-  unixBigLock = 0;
+  unixBigLock = 0; 
   return SQLITE_OK;
 }
 
@@ -42654,7 +42654,7 @@ struct winFile {
   int nFetchOut;                /* Number of outstanding xFetch references */
   HANDLE hMap;                  /* Handle for accessing memory mapping */
   void *pMapRegion;             /* Area memory mapped */
-  sqlite3_int64 mmapSize;       /* Size of mapped region */
+  sqlite3_int64 mmapSize;       /* Size of mapped region */ 
   sqlite3_int64 mmapSizeMax;    /* Configured FCNTL_MMAP_SIZE value */
 #endif
 };
@@ -44280,13 +44280,13 @@ SQLITE_API char *sqlite3_win32_utf8_to_mbcs_v2(const char *zText, int useAnsi){
 }
 
 /*
-** This function is the same as sqlite3_win32_set_directory (below); however,
-** it accepts a UTF-8 string.
+** This function is the same as sqlite3_win32_set_directory (below); however, 
+** it accepts a UTF-8 string. 
 */
-SQLITE_API int sqlite3_win32_set_directory8(
-  unsigned long type, /* Identifier for directory being set or reset */
-  const char *zValue  /* New value for directory being set or reset */
-){
+SQLITE_API int sqlite3_win32_set_directory8( 
+  unsigned long type, /* Identifier for directory being set or reset */ 
+  const char *zValue  /* New value for directory being set or reset */ 
+){ 
   char **ppDirectory = 0;
 #ifndef SQLITE_OMIT_AUTOINIT
   int rc = sqlite3_initialize();
@@ -44302,54 +44302,54 @@ SQLITE_API int sqlite3_win32_set_directory8(
   );
   assert( !ppDirectory || sqlite3MemdebugHasType(*ppDirectory, MEMTYPE_HEAP) );
   if( ppDirectory ){
-    char *zCopy = 0;
+    char *zCopy = 0; 
     if( zValue && zValue[0] ){
-      zCopy = sqlite3_mprintf("%s", zValue);
-      if ( zCopy==0 ){
+      zCopy = sqlite3_mprintf("%s", zValue); 
+      if ( zCopy==0 ){ 
         return SQLITE_NOMEM_BKPT;
       }
     }
     sqlite3_free(*ppDirectory);
-    *ppDirectory = zCopy;
+    *ppDirectory = zCopy; 
     return SQLITE_OK;
   }
   return SQLITE_ERROR;
 }
 
 /*
-** This function is the same as sqlite3_win32_set_directory (below); however,
-** it accepts a UTF-16 string.
-*/
-SQLITE_API int sqlite3_win32_set_directory16(
-  unsigned long type, /* Identifier for directory being set or reset */
-  const void *zValue  /* New value for directory being set or reset */
-){
-  int rc;
-  char *zUtf8 = 0;
-  if( zValue ){
-    zUtf8 = sqlite3_win32_unicode_to_utf8(zValue);
-    if( zUtf8==0 ) return SQLITE_NOMEM_BKPT;
-  }
-  rc = sqlite3_win32_set_directory8(type, zUtf8);
-  if( zUtf8 ) sqlite3_free(zUtf8);
-  return rc;
-}
-
-/*
-** This function sets the data directory or the temporary directory based on
-** the provided arguments.  The type argument must be 1 in order to set the
-** data directory or 2 in order to set the temporary directory.  The zValue
-** argument is the name of the directory to use.  The return value will be
-** SQLITE_OK if successful.
-*/
-SQLITE_API int sqlite3_win32_set_directory(
-  unsigned long type, /* Identifier for directory being set or reset */
-  void *zValue        /* New value for directory being set or reset */
-){
-  return sqlite3_win32_set_directory16(type, zValue);
-}
-
-/*
+** This function is the same as sqlite3_win32_set_directory (below); however, 
+** it accepts a UTF-16 string. 
+*/ 
+SQLITE_API int sqlite3_win32_set_directory16( 
+  unsigned long type, /* Identifier for directory being set or reset */ 
+  const void *zValue  /* New value for directory being set or reset */ 
+){ 
+  int rc; 
+  char *zUtf8 = 0; 
+  if( zValue ){ 
+    zUtf8 = sqlite3_win32_unicode_to_utf8(zValue); 
+    if( zUtf8==0 ) return SQLITE_NOMEM_BKPT; 
+  } 
+  rc = sqlite3_win32_set_directory8(type, zUtf8); 
+  if( zUtf8 ) sqlite3_free(zUtf8); 
+  return rc; 
+} 
+ 
+/* 
+** This function sets the data directory or the temporary directory based on 
+** the provided arguments.  The type argument must be 1 in order to set the 
+** data directory or 2 in order to set the temporary directory.  The zValue 
+** argument is the name of the directory to use.  The return value will be 
+** SQLITE_OK if successful. 
+*/ 
+SQLITE_API int sqlite3_win32_set_directory( 
+  unsigned long type, /* Identifier for directory being set or reset */ 
+  void *zValue        /* New value for directory being set or reset */ 
+){ 
+  return sqlite3_win32_set_directory16(type, zValue); 
+} 
+ 
+/* 
 ** The return value of winGetLastErrorMsg
 ** is zero if the error message fits in the buffer, or non-zero
 ** otherwise (if the message was truncated).
@@ -45273,29 +45273,29 @@ static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
   winFile *pFile = (winFile*)id;  /* File handle object */
   int rc = SQLITE_OK;             /* Return code for this function */
   DWORD lastErrno;
-#if SQLITE_MAX_MMAP_SIZE>0
-  sqlite3_int64 oldMmapSize;
-  if( pFile->nFetchOut>0 ){
-    /* File truncation is a no-op if there are outstanding memory mapped
-    ** pages.  This is because truncating the file means temporarily unmapping
-    ** the file, and that might delete memory out from under existing cursors.
-    **
-    ** This can result in incremental vacuum not truncating the file,
-    ** if there is an active read cursor when the incremental vacuum occurs.
-    ** No real harm comes of this - the database file is not corrupted,
-    ** though some folks might complain that the file is bigger than it
-    ** needs to be.
-    **
-    ** The only feasible work-around is to defer the truncation until after
-    ** all references to memory-mapped content are closed.  That is doable,
-    ** but involves adding a few branches in the common write code path which
-    ** could slow down normal operations slightly.  Hence, we have decided for
-    ** now to simply make trancations a no-op if there are pending reads.  We
-    ** can maybe revisit this decision in the future.
-    */
-    return SQLITE_OK;
-  }
-#endif
+#if SQLITE_MAX_MMAP_SIZE>0 
+  sqlite3_int64 oldMmapSize; 
+  if( pFile->nFetchOut>0 ){ 
+    /* File truncation is a no-op if there are outstanding memory mapped 
+    ** pages.  This is because truncating the file means temporarily unmapping 
+    ** the file, and that might delete memory out from under existing cursors. 
+    ** 
+    ** This can result in incremental vacuum not truncating the file, 
+    ** if there is an active read cursor when the incremental vacuum occurs. 
+    ** No real harm comes of this - the database file is not corrupted, 
+    ** though some folks might complain that the file is bigger than it 
+    ** needs to be. 
+    ** 
+    ** The only feasible work-around is to defer the truncation until after 
+    ** all references to memory-mapped content are closed.  That is doable, 
+    ** but involves adding a few branches in the common write code path which 
+    ** could slow down normal operations slightly.  Hence, we have decided for 
+    ** now to simply make trancations a no-op if there are pending reads.  We 
+    ** can maybe revisit this decision in the future. 
+    */ 
+    return SQLITE_OK; 
+  } 
+#endif 
 
   assert( pFile );
   SimulateIOError(return SQLITE_IOERR_TRUNCATE);
@@ -45311,15 +45311,15 @@ static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
     nByte = ((nByte + pFile->szChunk - 1)/pFile->szChunk) * pFile->szChunk;
   }
 
-#if SQLITE_MAX_MMAP_SIZE>0
-  if( pFile->pMapRegion ){
-    oldMmapSize = pFile->mmapSize;
-  }else{
-    oldMmapSize = 0;
-  }
-  winUnmapfile(pFile);
-#endif
-
+#if SQLITE_MAX_MMAP_SIZE>0 
+  if( pFile->pMapRegion ){ 
+    oldMmapSize = pFile->mmapSize; 
+  }else{ 
+    oldMmapSize = 0; 
+  } 
+  winUnmapfile(pFile); 
+#endif 
+ 
   /* SetEndOfFile() returns non-zero when successful, or zero when it fails. */
   if( winSeekFile(pFile, nByte) ){
     rc = winLogError(SQLITE_IOERR_TRUNCATE, pFile->lastErrno,
@@ -45332,12 +45332,12 @@ static int winTruncate(sqlite3_file *id, sqlite3_int64 nByte){
   }
 
 #if SQLITE_MAX_MMAP_SIZE>0
-  if( rc==SQLITE_OK && oldMmapSize>0 ){
-    if( oldMmapSize>nByte ){
-      winMapfile(pFile, -1);
-    }else{
-      winMapfile(pFile, oldMmapSize);
-    }
+  if( rc==SQLITE_OK && oldMmapSize>0 ){ 
+    if( oldMmapSize>nByte ){ 
+      winMapfile(pFile, -1); 
+    }else{ 
+      winMapfile(pFile, oldMmapSize); 
+    } 
   }
 #endif
 
@@ -46050,16 +46050,16 @@ static SYSTEM_INFO winSysInfo;
 **     assert( winShmMutexHeld() );
 **   winShmLeaveMutex()
 */
-static sqlite3_mutex *winBigLock = 0;
+static sqlite3_mutex *winBigLock = 0; 
 static void winShmEnterMutex(void){
-  sqlite3_mutex_enter(winBigLock);
+  sqlite3_mutex_enter(winBigLock); 
 }
 static void winShmLeaveMutex(void){
-  sqlite3_mutex_leave(winBigLock);
+  sqlite3_mutex_leave(winBigLock); 
 }
 #ifndef NDEBUG
 static int winShmMutexHeld(void) {
-  return sqlite3_mutex_held(winBigLock);
+  return sqlite3_mutex_held(winBigLock); 
 }
 #endif
 
@@ -46725,9 +46725,9 @@ shmpage_out:
 static int winUnmapfile(winFile *pFile){
   assert( pFile!=0 );
   OSTRACE(("UNMAP-FILE pid=%lu, pFile=%p, hMap=%p, pMapRegion=%p, "
-           "mmapSize=%lld, mmapSizeMax=%lld\n",
+           "mmapSize=%lld, mmapSizeMax=%lld\n", 
            osGetCurrentProcessId(), pFile, pFile->hMap, pFile->pMapRegion,
-           pFile->mmapSize, pFile->mmapSizeMax));
+           pFile->mmapSize, pFile->mmapSizeMax)); 
   if( pFile->pMapRegion ){
     if( !osUnmapViewOfFile(pFile->pMapRegion) ){
       pFile->lastErrno = osGetLastError();
@@ -48499,10 +48499,10 @@ SQLITE_API int sqlite3_os_init(void){
   sqlite3_vfs_register(&winLongPathNolockVfs, 0);
 #endif
 
-#ifndef SQLITE_OMIT_WAL
-  winBigLock = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1);
-#endif
-
+#ifndef SQLITE_OMIT_WAL 
+  winBigLock = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1); 
+#endif 
+ 
   return SQLITE_OK;
 }
 
@@ -48513,51 +48513,51 @@ SQLITE_API int sqlite3_os_end(void){
     sleepObj = NULL;
   }
 #endif
-
-#ifndef SQLITE_OMIT_WAL
-  winBigLock = 0;
-#endif
-
+ 
+#ifndef SQLITE_OMIT_WAL 
+  winBigLock = 0; 
+#endif 
+ 
   return SQLITE_OK;
 }
 
 #endif /* SQLITE_OS_WIN */
 
 /************** End of os_win.c **********************************************/
-/************** Begin file memdb.c *******************************************/
-/*
-** 2016-09-07
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-******************************************************************************
-**
-** This file implements an in-memory VFS. A database is held as a contiguous
-** block of memory.
-**
-** This file also implements interface sqlite3_serialize() and
-** sqlite3_deserialize().
-*/
-/* #include "sqliteInt.h" */
+/************** Begin file memdb.c *******************************************/ 
+/* 
+** 2016-09-07 
+** 
+** The author disclaims copyright to this source code.  In place of 
+** a legal notice, here is a blessing: 
+** 
+**    May you do good and not evil. 
+**    May you find forgiveness for yourself and forgive others. 
+**    May you share freely, never taking more than you give. 
+** 
+****************************************************************************** 
+** 
+** This file implements an in-memory VFS. A database is held as a contiguous 
+** block of memory. 
+** 
+** This file also implements interface sqlite3_serialize() and 
+** sqlite3_deserialize(). 
+*/ 
+/* #include "sqliteInt.h" */ 
 #ifndef SQLITE_OMIT_DESERIALIZE
-
-/*
-** Forward declaration of objects used by this utility
-*/
-typedef struct sqlite3_vfs MemVfs;
-typedef struct MemFile MemFile;
+ 
+/* 
+** Forward declaration of objects used by this utility 
+*/ 
+typedef struct sqlite3_vfs MemVfs; 
+typedef struct MemFile MemFile; 
 typedef struct MemStore MemStore;
-
-/* Access to a lower-level VFS that (might) implement dynamic loading,
-** access to randomness, etc.
-*/
-#define ORIGVFS(p) ((sqlite3_vfs*)((p)->pAppData))
-
+ 
+/* Access to a lower-level VFS that (might) implement dynamic loading, 
+** access to randomness, etc. 
+*/ 
+#define ORIGVFS(p) ((sqlite3_vfs*)((p)->pAppData)) 
+ 
 /* Storage for a memdb file.
 **
 ** An memdb object can be shared or separate.  Shared memdb objects can be
@@ -48595,13 +48595,13 @@ typedef struct MemStore MemStore;
 **
 */
 struct MemStore {
-  sqlite3_int64 sz;               /* Size of the file */
-  sqlite3_int64 szAlloc;          /* Space allocated to aData */
-  sqlite3_int64 szMax;            /* Maximum allowed size of the file */
-  unsigned char *aData;           /* content of the file */
+  sqlite3_int64 sz;               /* Size of the file */ 
+  sqlite3_int64 szAlloc;          /* Space allocated to aData */ 
+  sqlite3_int64 szMax;            /* Maximum allowed size of the file */ 
+  unsigned char *aData;           /* content of the file */ 
   sqlite3_mutex *pMutex;          /* Used by shared stores only */
-  int nMmap;                      /* Number of memory mapped pages */
-  unsigned mFlags;                /* Flags */
+  int nMmap;                      /* Number of memory mapped pages */ 
+  unsigned mFlags;                /* Flags */ 
   int nRdLock;                    /* Number of readers */
   int nWrLock;                    /* Number of writers.  (Always 0 or 1) */
   int nRef;                       /* Number of users of this MemStore */
@@ -48612,10 +48612,10 @@ struct MemStore {
 struct MemFile {
   sqlite3_file base;              /* IO methods */
   MemStore *pStore;               /* The storage */
-  int eLock;                      /* Most recent lock against this file */
-};
-
-/*
+  int eLock;                      /* Most recent lock against this file */ 
+}; 
+ 
+/* 
 ** File-scope variables for holding the memdb files that are accessible
 ** to multiple database connections in separate threads.
 **
@@ -48627,86 +48627,86 @@ static struct MemFS {
 } memdb_g;
 
 /*
-** Methods for MemFile
-*/
-static int memdbClose(sqlite3_file*);
-static int memdbRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
-static int memdbWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst);
-static int memdbTruncate(sqlite3_file*, sqlite3_int64 size);
-static int memdbSync(sqlite3_file*, int flags);
-static int memdbFileSize(sqlite3_file*, sqlite3_int64 *pSize);
-static int memdbLock(sqlite3_file*, int);
-/* static int memdbCheckReservedLock(sqlite3_file*, int *pResOut);// not used */
-static int memdbFileControl(sqlite3_file*, int op, void *pArg);
-/* static int memdbSectorSize(sqlite3_file*); // not used */
-static int memdbDeviceCharacteristics(sqlite3_file*);
-static int memdbFetch(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp);
-static int memdbUnfetch(sqlite3_file*, sqlite3_int64 iOfst, void *p);
-
-/*
-** Methods for MemVfs
-*/
-static int memdbOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *);
-/* static int memdbDelete(sqlite3_vfs*, const char *zName, int syncDir); */
-static int memdbAccess(sqlite3_vfs*, const char *zName, int flags, int *);
-static int memdbFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut);
-static void *memdbDlOpen(sqlite3_vfs*, const char *zFilename);
-static void memdbDlError(sqlite3_vfs*, int nByte, char *zErrMsg);
-static void (*memdbDlSym(sqlite3_vfs *pVfs, void *p, const char*zSym))(void);
-static void memdbDlClose(sqlite3_vfs*, void*);
-static int memdbRandomness(sqlite3_vfs*, int nByte, char *zOut);
-static int memdbSleep(sqlite3_vfs*, int microseconds);
-/* static int memdbCurrentTime(sqlite3_vfs*, double*); */
-static int memdbGetLastError(sqlite3_vfs*, int, char *);
-static int memdbCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*);
-
-static sqlite3_vfs memdb_vfs = {
-  2,                           /* iVersion */
-  0,                           /* szOsFile (set when registered) */
-  1024,                        /* mxPathname */
-  0,                           /* pNext */
-  "memdb",                     /* zName */
+** Methods for MemFile 
+*/ 
+static int memdbClose(sqlite3_file*); 
+static int memdbRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); 
+static int memdbWrite(sqlite3_file*,const void*,int iAmt, sqlite3_int64 iOfst); 
+static int memdbTruncate(sqlite3_file*, sqlite3_int64 size); 
+static int memdbSync(sqlite3_file*, int flags); 
+static int memdbFileSize(sqlite3_file*, sqlite3_int64 *pSize); 
+static int memdbLock(sqlite3_file*, int); 
+/* static int memdbCheckReservedLock(sqlite3_file*, int *pResOut);// not used */ 
+static int memdbFileControl(sqlite3_file*, int op, void *pArg); 
+/* static int memdbSectorSize(sqlite3_file*); // not used */ 
+static int memdbDeviceCharacteristics(sqlite3_file*); 
+static int memdbFetch(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp); 
+static int memdbUnfetch(sqlite3_file*, sqlite3_int64 iOfst, void *p); 
+ 
+/* 
+** Methods for MemVfs 
+*/ 
+static int memdbOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *); 
+/* static int memdbDelete(sqlite3_vfs*, const char *zName, int syncDir); */ 
+static int memdbAccess(sqlite3_vfs*, const char *zName, int flags, int *); 
+static int memdbFullPathname(sqlite3_vfs*, const char *zName, int, char *zOut); 
+static void *memdbDlOpen(sqlite3_vfs*, const char *zFilename); 
+static void memdbDlError(sqlite3_vfs*, int nByte, char *zErrMsg); 
+static void (*memdbDlSym(sqlite3_vfs *pVfs, void *p, const char*zSym))(void); 
+static void memdbDlClose(sqlite3_vfs*, void*); 
+static int memdbRandomness(sqlite3_vfs*, int nByte, char *zOut); 
+static int memdbSleep(sqlite3_vfs*, int microseconds); 
+/* static int memdbCurrentTime(sqlite3_vfs*, double*); */ 
+static int memdbGetLastError(sqlite3_vfs*, int, char *); 
+static int memdbCurrentTimeInt64(sqlite3_vfs*, sqlite3_int64*); 
+ 
+static sqlite3_vfs memdb_vfs = { 
+  2,                           /* iVersion */ 
+  0,                           /* szOsFile (set when registered) */ 
+  1024,                        /* mxPathname */ 
+  0,                           /* pNext */ 
+  "memdb",                     /* zName */ 
   0,                           /* pAppData (set when registered) */
-  memdbOpen,                   /* xOpen */
-  0, /* memdbDelete, */        /* xDelete */
-  memdbAccess,                 /* xAccess */
-  memdbFullPathname,           /* xFullPathname */
-  memdbDlOpen,                 /* xDlOpen */
-  memdbDlError,                /* xDlError */
-  memdbDlSym,                  /* xDlSym */
-  memdbDlClose,                /* xDlClose */
-  memdbRandomness,             /* xRandomness */
-  memdbSleep,                  /* xSleep */
-  0, /* memdbCurrentTime, */   /* xCurrentTime */
-  memdbGetLastError,           /* xGetLastError */
+  memdbOpen,                   /* xOpen */ 
+  0, /* memdbDelete, */        /* xDelete */ 
+  memdbAccess,                 /* xAccess */ 
+  memdbFullPathname,           /* xFullPathname */ 
+  memdbDlOpen,                 /* xDlOpen */ 
+  memdbDlError,                /* xDlError */ 
+  memdbDlSym,                  /* xDlSym */ 
+  memdbDlClose,                /* xDlClose */ 
+  memdbRandomness,             /* xRandomness */ 
+  memdbSleep,                  /* xSleep */ 
+  0, /* memdbCurrentTime, */   /* xCurrentTime */ 
+  memdbGetLastError,           /* xGetLastError */ 
   memdbCurrentTimeInt64,       /* xCurrentTimeInt64 */
   0,                           /* xSetSystemCall */
   0,                           /* xGetSystemCall */
   0,                           /* xNextSystemCall */
-};
-
-static const sqlite3_io_methods memdb_io_methods = {
-  3,                              /* iVersion */
-  memdbClose,                      /* xClose */
-  memdbRead,                       /* xRead */
-  memdbWrite,                      /* xWrite */
-  memdbTruncate,                   /* xTruncate */
-  memdbSync,                       /* xSync */
-  memdbFileSize,                   /* xFileSize */
-  memdbLock,                       /* xLock */
+}; 
+ 
+static const sqlite3_io_methods memdb_io_methods = { 
+  3,                              /* iVersion */ 
+  memdbClose,                      /* xClose */ 
+  memdbRead,                       /* xRead */ 
+  memdbWrite,                      /* xWrite */ 
+  memdbTruncate,                   /* xTruncate */ 
+  memdbSync,                       /* xSync */ 
+  memdbFileSize,                   /* xFileSize */ 
+  memdbLock,                       /* xLock */ 
   memdbLock,                       /* xUnlock - same as xLock in this case */
-  0, /* memdbCheckReservedLock, */ /* xCheckReservedLock */
-  memdbFileControl,                /* xFileControl */
-  0, /* memdbSectorSize,*/         /* xSectorSize */
-  memdbDeviceCharacteristics,      /* xDeviceCharacteristics */
-  0,                               /* xShmMap */
-  0,                               /* xShmLock */
-  0,                               /* xShmBarrier */
-  0,                               /* xShmUnmap */
-  memdbFetch,                      /* xFetch */
-  memdbUnfetch                     /* xUnfetch */
-};
-
+  0, /* memdbCheckReservedLock, */ /* xCheckReservedLock */ 
+  memdbFileControl,                /* xFileControl */ 
+  0, /* memdbSectorSize,*/         /* xSectorSize */ 
+  memdbDeviceCharacteristics,      /* xDeviceCharacteristics */ 
+  0,                               /* xShmMap */ 
+  0,                               /* xShmLock */ 
+  0,                               /* xShmBarrier */ 
+  0,                               /* xShmUnmap */ 
+  memdbFetch,                      /* xFetch */ 
+  memdbUnfetch                     /* xUnfetch */ 
+}; 
+ 
 /*
 ** Enter/leave the mutex on a MemStore
 */
@@ -48725,15 +48725,15 @@ static void memdbLeave(MemStore *p){
   sqlite3_mutex_leave(p->pMutex);
 }
 #endif
+ 
+ 
 
-
-
-/*
-** Close an memdb-file.
+/* 
+** Close an memdb-file. 
 ** Free the underlying MemStore object when its refcount drops to zero
 ** or less.
-*/
-static int memdbClose(sqlite3_file *pFile){
+*/ 
+static int memdbClose(sqlite3_file *pFile){ 
   MemStore *p = ((MemFile*)pFile)->pStore;
   if( p->zFName ){
     int i;
@@ -48769,60 +48769,60 @@ static int memdbClose(sqlite3_file *pFile){
   }else{
     memdbLeave(p);
   }
-  return SQLITE_OK;
-}
-
-/*
-** Read data from an memdb-file.
-*/
-static int memdbRead(
+  return SQLITE_OK; 
+} 
+ 
+/* 
+** Read data from an memdb-file. 
+*/ 
+static int memdbRead( 
   sqlite3_file *pFile,
   void *zBuf,
   int iAmt,
-  sqlite_int64 iOfst
-){
+  sqlite_int64 iOfst 
+){ 
   MemStore *p = ((MemFile*)pFile)->pStore;
   memdbEnter(p);
-  if( iOfst+iAmt>p->sz ){
-    memset(zBuf, 0, iAmt);
-    if( iOfst<p->sz ) memcpy(zBuf, p->aData+iOfst, p->sz - iOfst);
+  if( iOfst+iAmt>p->sz ){ 
+    memset(zBuf, 0, iAmt); 
+    if( iOfst<p->sz ) memcpy(zBuf, p->aData+iOfst, p->sz - iOfst); 
     memdbLeave(p);
-    return SQLITE_IOERR_SHORT_READ;
-  }
-  memcpy(zBuf, p->aData+iOfst, iAmt);
+    return SQLITE_IOERR_SHORT_READ; 
+  } 
+  memcpy(zBuf, p->aData+iOfst, iAmt); 
   memdbLeave(p);
-  return SQLITE_OK;
-}
-
-/*
-** Try to enlarge the memory allocation to hold at least sz bytes
-*/
+  return SQLITE_OK; 
+} 
+ 
+/* 
+** Try to enlarge the memory allocation to hold at least sz bytes 
+*/ 
 static int memdbEnlarge(MemStore *p, sqlite3_int64 newSz){
-  unsigned char *pNew;
+  unsigned char *pNew; 
   if( (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)==0 || NEVER(p->nMmap>0) ){
-    return SQLITE_FULL;
-  }
-  if( newSz>p->szMax ){
-    return SQLITE_FULL;
-  }
-  newSz *= 2;
-  if( newSz>p->szMax ) newSz = p->szMax;
+    return SQLITE_FULL; 
+  } 
+  if( newSz>p->szMax ){ 
+    return SQLITE_FULL; 
+  } 
+  newSz *= 2; 
+  if( newSz>p->szMax ) newSz = p->szMax; 
   pNew = sqlite3Realloc(p->aData, newSz);
   if( pNew==0 ) return SQLITE_IOERR_NOMEM;
-  p->aData = pNew;
-  p->szAlloc = newSz;
-  return SQLITE_OK;
-}
-
-/*
-** Write data to an memdb-file.
-*/
-static int memdbWrite(
-  sqlite3_file *pFile,
-  const void *z,
-  int iAmt,
-  sqlite_int64 iOfst
-){
+  p->aData = pNew; 
+  p->szAlloc = newSz; 
+  return SQLITE_OK; 
+} 
+ 
+/* 
+** Write data to an memdb-file. 
+*/ 
+static int memdbWrite( 
+  sqlite3_file *pFile, 
+  const void *z, 
+  int iAmt, 
+  sqlite_int64 iOfst 
+){ 
   MemStore *p = ((MemFile*)pFile)->pStore;
   memdbEnter(p);
   if( NEVER(p->mFlags & SQLITE_DESERIALIZE_READONLY) ){
@@ -48831,30 +48831,30 @@ static int memdbWrite(
     memdbLeave(p);
     return SQLITE_IOERR_WRITE;
   }
-  if( iOfst+iAmt>p->sz ){
-    int rc;
-    if( iOfst+iAmt>p->szAlloc
-     && (rc = memdbEnlarge(p, iOfst+iAmt))!=SQLITE_OK
-    ){
+  if( iOfst+iAmt>p->sz ){ 
+    int rc; 
+    if( iOfst+iAmt>p->szAlloc 
+     && (rc = memdbEnlarge(p, iOfst+iAmt))!=SQLITE_OK 
+    ){ 
       memdbLeave(p);
-      return rc;
-    }
-    if( iOfst>p->sz ) memset(p->aData+p->sz, 0, iOfst-p->sz);
-    p->sz = iOfst+iAmt;
-  }
-  memcpy(p->aData+iOfst, z, iAmt);
+      return rc; 
+    } 
+    if( iOfst>p->sz ) memset(p->aData+p->sz, 0, iOfst-p->sz); 
+    p->sz = iOfst+iAmt; 
+  } 
+  memcpy(p->aData+iOfst, z, iAmt); 
   memdbLeave(p);
-  return SQLITE_OK;
-}
-
-/*
-** Truncate an memdb-file.
-**
-** In rollback mode (which is always the case for memdb, as it does not
-** support WAL mode) the truncate() method is only used to reduce
-** the size of a file, never to increase the size.
-*/
-static int memdbTruncate(sqlite3_file *pFile, sqlite_int64 size){
+  return SQLITE_OK; 
+} 
+ 
+/* 
+** Truncate an memdb-file. 
+** 
+** In rollback mode (which is always the case for memdb, as it does not 
+** support WAL mode) the truncate() method is only used to reduce 
+** the size of a file, never to increase the size. 
+*/ 
+static int memdbTruncate(sqlite3_file *pFile, sqlite_int64 size){ 
   MemStore *p = ((MemFile*)pFile)->pStore;
   int rc = SQLITE_OK;
   memdbEnter(p);
@@ -48866,32 +48866,32 @@ static int memdbTruncate(sqlite3_file *pFile, sqlite_int64 size){
   }
   memdbLeave(p);
   return rc;
-}
-
-/*
-** Sync an memdb-file.
-*/
-static int memdbSync(sqlite3_file *pFile, int flags){
+} 
+ 
+/* 
+** Sync an memdb-file. 
+*/ 
+static int memdbSync(sqlite3_file *pFile, int flags){ 
   UNUSED_PARAMETER(pFile);
   UNUSED_PARAMETER(flags);
-  return SQLITE_OK;
-}
-
-/*
-** Return the current file-size of an memdb-file.
-*/
-static int memdbFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
+  return SQLITE_OK; 
+} 
+ 
+/* 
+** Return the current file-size of an memdb-file. 
+*/ 
+static int memdbFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){ 
   MemStore *p = ((MemFile*)pFile)->pStore;
   memdbEnter(p);
-  *pSize = p->sz;
+  *pSize = p->sz; 
   memdbLeave(p);
-  return SQLITE_OK;
-}
-
-/*
-** Lock an memdb-file.
-*/
-static int memdbLock(sqlite3_file *pFile, int eLock){
+  return SQLITE_OK; 
+} 
+ 
+/* 
+** Lock an memdb-file. 
+*/ 
+static int memdbLock(sqlite3_file *pFile, int eLock){ 
   MemFile *pThis = (MemFile*)pFile;
   MemStore *p = pThis->pStore;
   int rc = SQLITE_OK;
@@ -48924,112 +48924,112 @@ static int memdbLock(sqlite3_file *pFile, int eLock){
     }
     assert( p->nRdLock>0 );
     p->nRdLock--;
-  }
+  } 
   if( rc==SQLITE_OK ) pThis->eLock = eLock;
   memdbLeave(p);
   return rc;
-}
-
+} 
+ 
 #if 0
-/*
+/* 
 ** This interface is only used for crash recovery, which does not
 ** occur on an in-memory database.
-*/
-static int memdbCheckReservedLock(sqlite3_file *pFile, int *pResOut){
-  *pResOut = 0;
-  return SQLITE_OK;
-}
-#endif
-
-
-/*
-** File control method. For custom operations on an memdb-file.
-*/
-static int memdbFileControl(sqlite3_file *pFile, int op, void *pArg){
+*/ 
+static int memdbCheckReservedLock(sqlite3_file *pFile, int *pResOut){ 
+  *pResOut = 0; 
+  return SQLITE_OK; 
+} 
+#endif 
+ 
+
+/* 
+** File control method. For custom operations on an memdb-file. 
+*/ 
+static int memdbFileControl(sqlite3_file *pFile, int op, void *pArg){ 
   MemStore *p = ((MemFile*)pFile)->pStore;
-  int rc = SQLITE_NOTFOUND;
+  int rc = SQLITE_NOTFOUND; 
   memdbEnter(p);
-  if( op==SQLITE_FCNTL_VFSNAME ){
-    *(char**)pArg = sqlite3_mprintf("memdb(%p,%lld)", p->aData, p->sz);
-    rc = SQLITE_OK;
-  }
-  if( op==SQLITE_FCNTL_SIZE_LIMIT ){
-    sqlite3_int64 iLimit = *(sqlite3_int64*)pArg;
-    if( iLimit<p->sz ){
-      if( iLimit<0 ){
-        iLimit = p->szMax;
-      }else{
-        iLimit = p->sz;
-      }
-    }
-    p->szMax = iLimit;
-    *(sqlite3_int64*)pArg = iLimit;
-    rc = SQLITE_OK;
-  }
+  if( op==SQLITE_FCNTL_VFSNAME ){ 
+    *(char**)pArg = sqlite3_mprintf("memdb(%p,%lld)", p->aData, p->sz); 
+    rc = SQLITE_OK; 
+  } 
+  if( op==SQLITE_FCNTL_SIZE_LIMIT ){ 
+    sqlite3_int64 iLimit = *(sqlite3_int64*)pArg; 
+    if( iLimit<p->sz ){ 
+      if( iLimit<0 ){ 
+        iLimit = p->szMax; 
+      }else{ 
+        iLimit = p->sz; 
+      } 
+    } 
+    p->szMax = iLimit; 
+    *(sqlite3_int64*)pArg = iLimit; 
+    rc = SQLITE_OK; 
+  } 
   memdbLeave(p);
-  return rc;
-}
-
-#if 0  /* Not used because of SQLITE_IOCAP_POWERSAFE_OVERWRITE */
-/*
-** Return the sector-size in bytes for an memdb-file.
-*/
-static int memdbSectorSize(sqlite3_file *pFile){
-  return 1024;
-}
-#endif
-
-/*
-** Return the device characteristic flags supported by an memdb-file.
-*/
-static int memdbDeviceCharacteristics(sqlite3_file *pFile){
+  return rc; 
+} 
+ 
+#if 0  /* Not used because of SQLITE_IOCAP_POWERSAFE_OVERWRITE */ 
+/* 
+** Return the sector-size in bytes for an memdb-file. 
+*/ 
+static int memdbSectorSize(sqlite3_file *pFile){ 
+  return 1024; 
+} 
+#endif 
+ 
+/* 
+** Return the device characteristic flags supported by an memdb-file. 
+*/ 
+static int memdbDeviceCharacteristics(sqlite3_file *pFile){ 
   UNUSED_PARAMETER(pFile);
   return SQLITE_IOCAP_ATOMIC |
-         SQLITE_IOCAP_POWERSAFE_OVERWRITE |
-         SQLITE_IOCAP_SAFE_APPEND |
-         SQLITE_IOCAP_SEQUENTIAL;
-}
-
-/* Fetch a page of a memory-mapped file */
-static int memdbFetch(
-  sqlite3_file *pFile,
-  sqlite3_int64 iOfst,
-  int iAmt,
-  void **pp
-){
+         SQLITE_IOCAP_POWERSAFE_OVERWRITE | 
+         SQLITE_IOCAP_SAFE_APPEND | 
+         SQLITE_IOCAP_SEQUENTIAL; 
+} 
+ 
+/* Fetch a page of a memory-mapped file */ 
+static int memdbFetch( 
+  sqlite3_file *pFile, 
+  sqlite3_int64 iOfst, 
+  int iAmt, 
+  void **pp 
+){ 
   MemStore *p = ((MemFile*)pFile)->pStore;
   memdbEnter(p);
   if( iOfst+iAmt>p->sz || (p->mFlags & SQLITE_DESERIALIZE_RESIZEABLE)!=0 ){
-    *pp = 0;
-  }else{
-    p->nMmap++;
-    *pp = (void*)(p->aData + iOfst);
-  }
+    *pp = 0; 
+  }else{ 
+    p->nMmap++; 
+    *pp = (void*)(p->aData + iOfst); 
+  } 
   memdbLeave(p);
-  return SQLITE_OK;
-}
-
-/* Release a memory-mapped page */
-static int memdbUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){
+  return SQLITE_OK; 
+} 
+ 
+/* Release a memory-mapped page */ 
+static int memdbUnfetch(sqlite3_file *pFile, sqlite3_int64 iOfst, void *pPage){ 
   MemStore *p = ((MemFile*)pFile)->pStore;
   UNUSED_PARAMETER(iOfst);
   UNUSED_PARAMETER(pPage);
   memdbEnter(p);
-  p->nMmap--;
+  p->nMmap--; 
   memdbLeave(p);
-  return SQLITE_OK;
-}
-
-/*
-** Open an mem file handle.
-*/
-static int memdbOpen(
-  sqlite3_vfs *pVfs,
-  const char *zName,
+  return SQLITE_OK; 
+} 
+ 
+/* 
+** Open an mem file handle. 
+*/ 
+static int memdbOpen( 
+  sqlite3_vfs *pVfs, 
+  const char *zName, 
   sqlite3_file *pFd,
-  int flags,
-  int *pOutFlags
-){
+  int flags, 
+  int *pOutFlags 
+){ 
   MemFile *pFile = (MemFile*)pFd;
   MemStore *p = 0;
   int szName;
@@ -49092,276 +49092,276 @@ static int memdbOpen(
     memset(p, 0, sizeof(*p));
     p->mFlags = SQLITE_DESERIALIZE_RESIZEABLE | SQLITE_DESERIALIZE_FREEONCLOSE;
     p->szMax = sqlite3GlobalConfig.mxMemdbSize;
-  }
+  } 
   pFile->pStore = p;
   if( pOutFlags!=0 ){
     *pOutFlags = flags | SQLITE_OPEN_MEMORY;
   }
   pFd->pMethods = &memdb_io_methods;
   memdbLeave(p);
-  return SQLITE_OK;
-}
-
+  return SQLITE_OK; 
+} 
+ 
 #if 0 /* Only used to delete rollback journals, super-journals, and WAL
-      ** files, none of which exist in memdb.  So this routine is never used */
-/*
-** Delete the file located at zPath. If the dirSync argument is true,
-** ensure the file-system modifications are synced to disk before
-** returning.
-*/
-static int memdbDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){
-  return SQLITE_IOERR_DELETE;
-}
-#endif
-
-/*
-** Test for access permissions. Return true if the requested permission
-** is available, or false otherwise.
-**
-** With memdb, no files ever exist on disk.  So always return false.
-*/
-static int memdbAccess(
+      ** files, none of which exist in memdb.  So this routine is never used */ 
+/* 
+** Delete the file located at zPath. If the dirSync argument is true, 
+** ensure the file-system modifications are synced to disk before 
+** returning. 
+*/ 
+static int memdbDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ 
+  return SQLITE_IOERR_DELETE; 
+} 
+#endif 
+ 
+/* 
+** Test for access permissions. Return true if the requested permission 
+** is available, or false otherwise. 
+** 
+** With memdb, no files ever exist on disk.  So always return false. 
+*/ 
+static int memdbAccess( 
   sqlite3_vfs *pVfs,
   const char *zPath,
   int flags,
-  int *pResOut
-){
+  int *pResOut 
+){ 
   UNUSED_PARAMETER(pVfs);
   UNUSED_PARAMETER(zPath);
   UNUSED_PARAMETER(flags);
-  *pResOut = 0;
-  return SQLITE_OK;
-}
-
-/*
-** Populate buffer zOut with the full canonical pathname corresponding
-** to the pathname in zPath. zOut is guaranteed to point to a buffer
-** of at least (INST_MAX_PATHNAME+1) bytes.
-*/
-static int memdbFullPathname(
+  *pResOut = 0; 
+  return SQLITE_OK; 
+} 
+ 
+/* 
+** Populate buffer zOut with the full canonical pathname corresponding 
+** to the pathname in zPath. zOut is guaranteed to point to a buffer 
+** of at least (INST_MAX_PATHNAME+1) bytes. 
+*/ 
+static int memdbFullPathname( 
   sqlite3_vfs *pVfs,
   const char *zPath,
   int nOut,
-  char *zOut
-){
+  char *zOut 
+){ 
   UNUSED_PARAMETER(pVfs);
-  sqlite3_snprintf(nOut, zOut, "%s", zPath);
-  return SQLITE_OK;
-}
-
-/*
-** Open the dynamic library located at zPath and return a handle.
-*/
-static void *memdbDlOpen(sqlite3_vfs *pVfs, const char *zPath){
-  return ORIGVFS(pVfs)->xDlOpen(ORIGVFS(pVfs), zPath);
-}
-
-/*
-** Populate the buffer zErrMsg (size nByte bytes) with a human readable
+  sqlite3_snprintf(nOut, zOut, "%s", zPath); 
+  return SQLITE_OK; 
+} 
+ 
+/* 
+** Open the dynamic library located at zPath and return a handle. 
+*/ 
+static void *memdbDlOpen(sqlite3_vfs *pVfs, const char *zPath){ 
+  return ORIGVFS(pVfs)->xDlOpen(ORIGVFS(pVfs), zPath); 
+} 
+ 
+/* 
+** Populate the buffer zErrMsg (size nByte bytes) with a human readable 
 ** utf-8 string describing the most recent error encountered associated
-** with dynamic libraries.
-*/
-static void memdbDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){
-  ORIGVFS(pVfs)->xDlError(ORIGVFS(pVfs), nByte, zErrMsg);
-}
-
-/*
-** Return a pointer to the symbol zSymbol in the dynamic library pHandle.
-*/
-static void (*memdbDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){
-  return ORIGVFS(pVfs)->xDlSym(ORIGVFS(pVfs), p, zSym);
-}
-
-/*
-** Close the dynamic library handle pHandle.
-*/
-static void memdbDlClose(sqlite3_vfs *pVfs, void *pHandle){
-  ORIGVFS(pVfs)->xDlClose(ORIGVFS(pVfs), pHandle);
-}
-
-/*
+** with dynamic libraries. 
+*/ 
+static void memdbDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){ 
+  ORIGVFS(pVfs)->xDlError(ORIGVFS(pVfs), nByte, zErrMsg); 
+} 
+ 
+/* 
+** Return a pointer to the symbol zSymbol in the dynamic library pHandle. 
+*/ 
+static void (*memdbDlSym(sqlite3_vfs *pVfs, void *p, const char *zSym))(void){ 
+  return ORIGVFS(pVfs)->xDlSym(ORIGVFS(pVfs), p, zSym); 
+} 
+ 
+/* 
+** Close the dynamic library handle pHandle. 
+*/ 
+static void memdbDlClose(sqlite3_vfs *pVfs, void *pHandle){ 
+  ORIGVFS(pVfs)->xDlClose(ORIGVFS(pVfs), pHandle); 
+} 
+ 
+/* 
 ** Populate the buffer pointed to by zBufOut with nByte bytes of
-** random data.
-*/
-static int memdbRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){
-  return ORIGVFS(pVfs)->xRandomness(ORIGVFS(pVfs), nByte, zBufOut);
-}
-
-/*
+** random data. 
+*/ 
+static int memdbRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ 
+  return ORIGVFS(pVfs)->xRandomness(ORIGVFS(pVfs), nByte, zBufOut); 
+} 
+ 
+/* 
 ** Sleep for nMicro microseconds. Return the number of microseconds
-** actually slept.
-*/
-static int memdbSleep(sqlite3_vfs *pVfs, int nMicro){
-  return ORIGVFS(pVfs)->xSleep(ORIGVFS(pVfs), nMicro);
-}
-
-#if 0  /* Never used.  Modern cores only call xCurrentTimeInt64() */
-/*
-** Return the current time as a Julian Day number in *pTimeOut.
-*/
-static int memdbCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){
-  return ORIGVFS(pVfs)->xCurrentTime(ORIGVFS(pVfs), pTimeOut);
-}
-#endif
-
-static int memdbGetLastError(sqlite3_vfs *pVfs, int a, char *b){
-  return ORIGVFS(pVfs)->xGetLastError(ORIGVFS(pVfs), a, b);
-}
-static int memdbCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p){
-  return ORIGVFS(pVfs)->xCurrentTimeInt64(ORIGVFS(pVfs), p);
-}
-
-/*
-** Translate a database connection pointer and schema name into a
-** MemFile pointer.
-*/
-static MemFile *memdbFromDbSchema(sqlite3 *db, const char *zSchema){
-  MemFile *p = 0;
+** actually slept. 
+*/ 
+static int memdbSleep(sqlite3_vfs *pVfs, int nMicro){ 
+  return ORIGVFS(pVfs)->xSleep(ORIGVFS(pVfs), nMicro); 
+} 
+ 
+#if 0  /* Never used.  Modern cores only call xCurrentTimeInt64() */ 
+/* 
+** Return the current time as a Julian Day number in *pTimeOut. 
+*/ 
+static int memdbCurrentTime(sqlite3_vfs *pVfs, double *pTimeOut){ 
+  return ORIGVFS(pVfs)->xCurrentTime(ORIGVFS(pVfs), pTimeOut); 
+} 
+#endif 
+ 
+static int memdbGetLastError(sqlite3_vfs *pVfs, int a, char *b){ 
+  return ORIGVFS(pVfs)->xGetLastError(ORIGVFS(pVfs), a, b); 
+} 
+static int memdbCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p){ 
+  return ORIGVFS(pVfs)->xCurrentTimeInt64(ORIGVFS(pVfs), p); 
+} 
+ 
+/* 
+** Translate a database connection pointer and schema name into a 
+** MemFile pointer. 
+*/ 
+static MemFile *memdbFromDbSchema(sqlite3 *db, const char *zSchema){ 
+  MemFile *p = 0; 
   MemStore *pStore;
-  int rc = sqlite3_file_control(db, zSchema, SQLITE_FCNTL_FILE_POINTER, &p);
-  if( rc ) return 0;
-  if( p->base.pMethods!=&memdb_io_methods ) return 0;
+  int rc = sqlite3_file_control(db, zSchema, SQLITE_FCNTL_FILE_POINTER, &p); 
+  if( rc ) return 0; 
+  if( p->base.pMethods!=&memdb_io_methods ) return 0; 
   pStore = p->pStore;
   memdbEnter(pStore);
   if( pStore->zFName!=0 ) p = 0;
   memdbLeave(pStore);
-  return p;
-}
-
-/*
-** Return the serialization of a database
-*/
-SQLITE_API unsigned char *sqlite3_serialize(
-  sqlite3 *db,              /* The database connection */
-  const char *zSchema,      /* Which database within the connection */
-  sqlite3_int64 *piSize,    /* Write size here, if not NULL */
-  unsigned int mFlags       /* Maybe SQLITE_SERIALIZE_NOCOPY */
-){
-  MemFile *p;
-  int iDb;
-  Btree *pBt;
-  sqlite3_int64 sz;
-  int szPage = 0;
-  sqlite3_stmt *pStmt = 0;
-  unsigned char *pOut;
-  char *zSql;
-  int rc;
-
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( !sqlite3SafetyCheckOk(db) ){
-    (void)SQLITE_MISUSE_BKPT;
-    return 0;
-  }
-#endif
-
-  if( zSchema==0 ) zSchema = db->aDb[0].zDbSName;
-  p = memdbFromDbSchema(db, zSchema);
-  iDb = sqlite3FindDbName(db, zSchema);
-  if( piSize ) *piSize = -1;
-  if( iDb<0 ) return 0;
-  if( p ){
+  return p; 
+} 
+ 
+/* 
+** Return the serialization of a database 
+*/ 
+SQLITE_API unsigned char *sqlite3_serialize( 
+  sqlite3 *db,              /* The database connection */ 
+  const char *zSchema,      /* Which database within the connection */ 
+  sqlite3_int64 *piSize,    /* Write size here, if not NULL */ 
+  unsigned int mFlags       /* Maybe SQLITE_SERIALIZE_NOCOPY */ 
+){ 
+  MemFile *p; 
+  int iDb; 
+  Btree *pBt; 
+  sqlite3_int64 sz; 
+  int szPage = 0; 
+  sqlite3_stmt *pStmt = 0; 
+  unsigned char *pOut; 
+  char *zSql; 
+  int rc; 
+ 
+#ifdef SQLITE_ENABLE_API_ARMOR 
+  if( !sqlite3SafetyCheckOk(db) ){ 
+    (void)SQLITE_MISUSE_BKPT; 
+    return 0; 
+  } 
+#endif 
+ 
+  if( zSchema==0 ) zSchema = db->aDb[0].zDbSName; 
+  p = memdbFromDbSchema(db, zSchema); 
+  iDb = sqlite3FindDbName(db, zSchema); 
+  if( piSize ) *piSize = -1; 
+  if( iDb<0 ) return 0; 
+  if( p ){ 
     MemStore *pStore = p->pStore;
     assert( pStore->pMutex==0 );
     if( piSize ) *piSize = pStore->sz;
-    if( mFlags & SQLITE_SERIALIZE_NOCOPY ){
+    if( mFlags & SQLITE_SERIALIZE_NOCOPY ){ 
       pOut = pStore->aData;
-    }else{
+    }else{ 
       pOut = sqlite3_malloc64( pStore->sz );
       if( pOut ) memcpy(pOut, pStore->aData, pStore->sz);
-    }
-    return pOut;
-  }
-  pBt = db->aDb[iDb].pBt;
-  if( pBt==0 ) return 0;
-  szPage = sqlite3BtreeGetPageSize(pBt);
-  zSql = sqlite3_mprintf("PRAGMA \"%w\".page_count", zSchema);
-  rc = zSql ? sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0) : SQLITE_NOMEM;
-  sqlite3_free(zSql);
-  if( rc ) return 0;
-  rc = sqlite3_step(pStmt);
-  if( rc!=SQLITE_ROW ){
-    pOut = 0;
-  }else{
-    sz = sqlite3_column_int64(pStmt, 0)*szPage;
-    if( piSize ) *piSize = sz;
-    if( mFlags & SQLITE_SERIALIZE_NOCOPY ){
-      pOut = 0;
-    }else{
-      pOut = sqlite3_malloc64( sz );
-      if( pOut ){
-        int nPage = sqlite3_column_int(pStmt, 0);
-        Pager *pPager = sqlite3BtreePager(pBt);
-        int pgno;
-        for(pgno=1; pgno<=nPage; pgno++){
-          DbPage *pPage = 0;
-          unsigned char *pTo = pOut + szPage*(sqlite3_int64)(pgno-1);
-          rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pPage, 0);
-          if( rc==SQLITE_OK ){
-            memcpy(pTo, sqlite3PagerGetData(pPage), szPage);
-          }else{
-            memset(pTo, 0, szPage);
-          }
+    } 
+    return pOut; 
+  } 
+  pBt = db->aDb[iDb].pBt; 
+  if( pBt==0 ) return 0; 
+  szPage = sqlite3BtreeGetPageSize(pBt); 
+  zSql = sqlite3_mprintf("PRAGMA \"%w\".page_count", zSchema); 
+  rc = zSql ? sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0) : SQLITE_NOMEM; 
+  sqlite3_free(zSql); 
+  if( rc ) return 0; 
+  rc = sqlite3_step(pStmt); 
+  if( rc!=SQLITE_ROW ){ 
+    pOut = 0; 
+  }else{ 
+    sz = sqlite3_column_int64(pStmt, 0)*szPage; 
+    if( piSize ) *piSize = sz; 
+    if( mFlags & SQLITE_SERIALIZE_NOCOPY ){ 
+      pOut = 0; 
+    }else{ 
+      pOut = sqlite3_malloc64( sz ); 
+      if( pOut ){ 
+        int nPage = sqlite3_column_int(pStmt, 0); 
+        Pager *pPager = sqlite3BtreePager(pBt); 
+        int pgno; 
+        for(pgno=1; pgno<=nPage; pgno++){ 
+          DbPage *pPage = 0; 
+          unsigned char *pTo = pOut + szPage*(sqlite3_int64)(pgno-1); 
+          rc = sqlite3PagerGet(pPager, pgno, (DbPage**)&pPage, 0); 
+          if( rc==SQLITE_OK ){ 
+            memcpy(pTo, sqlite3PagerGetData(pPage), szPage); 
+          }else{ 
+            memset(pTo, 0, szPage); 
+          } 
           sqlite3PagerUnref(pPage);
-        }
-      }
-    }
-  }
-  sqlite3_finalize(pStmt);
-  return pOut;
-}
-
-/* Convert zSchema to a MemDB and initialize its content.
-*/
-SQLITE_API int sqlite3_deserialize(
-  sqlite3 *db,            /* The database connection */
-  const char *zSchema,    /* Which DB to reopen with the deserialization */
-  unsigned char *pData,   /* The serialized database content */
-  sqlite3_int64 szDb,     /* Number bytes in the deserialization */
-  sqlite3_int64 szBuf,    /* Total size of buffer pData[] */
-  unsigned mFlags         /* Zero or more SQLITE_DESERIALIZE_* flags */
-){
-  MemFile *p;
-  char *zSql;
-  sqlite3_stmt *pStmt = 0;
-  int rc;
-  int iDb;
-
-#ifdef SQLITE_ENABLE_API_ARMOR
-  if( !sqlite3SafetyCheckOk(db) ){
-    return SQLITE_MISUSE_BKPT;
-  }
-  if( szDb<0 ) return SQLITE_MISUSE_BKPT;
-  if( szBuf<0 ) return SQLITE_MISUSE_BKPT;
-#endif
-
-  sqlite3_mutex_enter(db->mutex);
-  if( zSchema==0 ) zSchema = db->aDb[0].zDbSName;
-  iDb = sqlite3FindDbName(db, zSchema);
+        } 
+      } 
+    } 
+  } 
+  sqlite3_finalize(pStmt); 
+  return pOut; 
+} 
+ 
+/* Convert zSchema to a MemDB and initialize its content. 
+*/ 
+SQLITE_API int sqlite3_deserialize( 
+  sqlite3 *db,            /* The database connection */ 
+  const char *zSchema,    /* Which DB to reopen with the deserialization */ 
+  unsigned char *pData,   /* The serialized database content */ 
+  sqlite3_int64 szDb,     /* Number bytes in the deserialization */ 
+  sqlite3_int64 szBuf,    /* Total size of buffer pData[] */ 
+  unsigned mFlags         /* Zero or more SQLITE_DESERIALIZE_* flags */ 
+){ 
+  MemFile *p; 
+  char *zSql; 
+  sqlite3_stmt *pStmt = 0; 
+  int rc; 
+  int iDb; 
+ 
+#ifdef SQLITE_ENABLE_API_ARMOR 
+  if( !sqlite3SafetyCheckOk(db) ){ 
+    return SQLITE_MISUSE_BKPT; 
+  } 
+  if( szDb<0 ) return SQLITE_MISUSE_BKPT; 
+  if( szBuf<0 ) return SQLITE_MISUSE_BKPT; 
+#endif 
+ 
+  sqlite3_mutex_enter(db->mutex); 
+  if( zSchema==0 ) zSchema = db->aDb[0].zDbSName; 
+  iDb = sqlite3FindDbName(db, zSchema); 
   testcase( iDb==1 );
   if( iDb<2 && iDb!=0 ){
-    rc = SQLITE_ERROR;
-    goto end_deserialize;
+    rc = SQLITE_ERROR; 
+    goto end_deserialize; 
   }
-  zSql = sqlite3_mprintf("ATTACH x AS %Q", zSchema);
+  zSql = sqlite3_mprintf("ATTACH x AS %Q", zSchema); 
   if( zSql==0 ){
     rc = SQLITE_NOMEM;
   }else{
     rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
     sqlite3_free(zSql);
   }
-  if( rc ) goto end_deserialize;
-  db->init.iDb = (u8)iDb;
-  db->init.reopenMemdb = 1;
-  rc = sqlite3_step(pStmt);
-  db->init.reopenMemdb = 0;
-  if( rc!=SQLITE_DONE ){
-    rc = SQLITE_ERROR;
-    goto end_deserialize;
-  }
-  p = memdbFromDbSchema(db, zSchema);
-  if( p==0 ){
-    rc = SQLITE_ERROR;
-  }else{
+  if( rc ) goto end_deserialize; 
+  db->init.iDb = (u8)iDb; 
+  db->init.reopenMemdb = 1; 
+  rc = sqlite3_step(pStmt); 
+  db->init.reopenMemdb = 0; 
+  if( rc!=SQLITE_DONE ){ 
+    rc = SQLITE_ERROR; 
+    goto end_deserialize; 
+  } 
+  p = memdbFromDbSchema(db, zSchema); 
+  if( p==0 ){ 
+    rc = SQLITE_ERROR; 
+  }else{ 
     MemStore *pStore = p->pStore;
     pStore->aData = pData;
     pData = 0;
@@ -49370,41 +49370,41 @@ SQLITE_API int sqlite3_deserialize(
     pStore->szMax = szBuf;
     if( pStore->szMax<sqlite3GlobalConfig.mxMemdbSize ){
       pStore->szMax = sqlite3GlobalConfig.mxMemdbSize;
-    }
+    } 
     pStore->mFlags = mFlags;
-    rc = SQLITE_OK;
-  }
-
-end_deserialize:
-  sqlite3_finalize(pStmt);
+    rc = SQLITE_OK; 
+  } 
+ 
+end_deserialize: 
+  sqlite3_finalize(pStmt); 
   if( pData && (mFlags & SQLITE_DESERIALIZE_FREEONCLOSE)!=0 ){
     sqlite3_free(pData);
   }
-  sqlite3_mutex_leave(db->mutex);
-  return rc;
-}
-
+  sqlite3_mutex_leave(db->mutex); 
+  return rc; 
+} 
+ 
 /*
-** This routine is called when the extension is loaded.
-** Register the new VFS.
-*/
-SQLITE_PRIVATE int sqlite3MemdbInit(void){
-  sqlite3_vfs *pLower = sqlite3_vfs_find(0);
+** This routine is called when the extension is loaded. 
+** Register the new VFS. 
+*/ 
+SQLITE_PRIVATE int sqlite3MemdbInit(void){ 
+  sqlite3_vfs *pLower = sqlite3_vfs_find(0); 
   unsigned int sz;
   if( NEVER(pLower==0) ) return SQLITE_ERROR;
   sz = pLower->szOsFile;
-  memdb_vfs.pAppData = pLower;
+  memdb_vfs.pAppData = pLower; 
   /* The following conditional can only be true when compiled for
   ** Windows x86 and SQLITE_MAX_MMAP_SIZE=0.  We always leave
   ** it in, to be safe, but it is marked as NO_TEST since there
   ** is no way to reach it under most builds. */
   if( sz<sizeof(MemFile) ) sz = sizeof(MemFile); /*NO_TEST*/
-  memdb_vfs.szOsFile = sz;
-  return sqlite3_vfs_register(&memdb_vfs, 0);
-}
+  memdb_vfs.szOsFile = sz; 
+  return sqlite3_vfs_register(&memdb_vfs, 0); 
+} 
 #endif /* SQLITE_OMIT_DESERIALIZE */
-
-/************** End of memdb.c ***********************************************/
+ 
+/************** End of memdb.c ***********************************************/ 
 /************** Begin file bitvec.c ******************************************/
 /*
 ** 2008 February 16
@@ -49854,7 +49854,7 @@ bitvec_end:
 **   The PCache.pSynced variable is used to optimize searching for a dirty
 **   page to eject from the cache mid-transaction. It is better to eject
 **   a page that does not require a journal sync than one that does.
-**   Therefore, pSynced is maintained so that it *almost* always points
+**   Therefore, pSynced is maintained so that it *almost* always points 
 **   to either the oldest page in the pDirty/pDirtyTail list that has a
 **   clear PGHDR_NEED_SYNC flag or to a page that is older than this one
 **   (so that the right page to eject can be found by following pDirtyPrev
@@ -50066,10 +50066,10 @@ static int numberOfCachePages(PCache *p){
     return p->szCache;
   }else{
     i64 n;
-    /* IMPLEMANTATION-OF: R-59858-46238 If the argument N is negative, then the
-    ** number of cache pages is adjusted to be a number of pages that would
-    ** use approximately abs(N*1024) bytes of memory based on the current
-    ** page size. */
+    /* IMPLEMANTATION-OF: R-59858-46238 If the argument N is negative, then the 
+    ** number of cache pages is adjusted to be a number of pages that would 
+    ** use approximately abs(N*1024) bytes of memory based on the current 
+    ** page size. */ 
     n = ((-1024*(i64)p->szCache)/(p->szPage+p->szExtra));
     if( n>1000000000 ) n = 1000000000;
     return (int)n;
@@ -50258,7 +50258,7 @@ SQLITE_PRIVATE int sqlite3PcacheFetchStress(
       sqlite3_log(SQLITE_FULL,
                   "spill page %d making room for %d - cache used: %d/%d",
                   pPg->pgno, pgno,
-                  sqlite3GlobalConfig.pcache2.xPagecount(pCache->pCache),
+                  sqlite3GlobalConfig.pcache2.xPagecount(pCache->pCache), 
                 numberOfCachePages(pCache));
 #endif
       pcacheTrace(("%p.SPILL %d\n",pCache,pPg->pgno));
@@ -50683,15 +50683,15 @@ SQLITE_PRIVATE int sqlite3PCachePercentDirty(PCache *pCache){
   return nCache ? (int)(((i64)nDirty * 100) / nCache) : 0;
 }
 
-#ifdef SQLITE_DIRECT_OVERFLOW_READ
+#ifdef SQLITE_DIRECT_OVERFLOW_READ 
 /*
-** Return true if there are one or more dirty pages in the cache. Else false.
-*/
-SQLITE_PRIVATE int sqlite3PCacheIsDirty(PCache *pCache){
-  return (pCache->pDirty!=0);
-}
-#endif
-
+** Return true if there are one or more dirty pages in the cache. Else false. 
+*/ 
+SQLITE_PRIVATE int sqlite3PCacheIsDirty(PCache *pCache){ 
+  return (pCache->pDirty!=0); 
+} 
+#endif 
+ 
 #if defined(SQLITE_CHECK_PAGES) || defined(SQLITE_DEBUG)
 /*
 ** For all dirty pages currently in the cache, invoke the specified
@@ -50802,32 +50802,32 @@ typedef struct PGroup PGroup;
 ** structure. Unless SQLITE_PCACHE_SEPARATE_HEADER is defined, a buffer of
 ** PgHdr1.pCache->szPage bytes is allocated directly before this structure
 ** in memory.
-**
-** Note: Variables isBulkLocal and isAnchor were once type "u8". That works,
+** 
+** Note: Variables isBulkLocal and isAnchor were once type "u8". That works, 
 ** but causes a 2-byte gap in the structure for most architectures (since
-** pointers must be either 4 or 8-byte aligned). As this structure is located
-** in memory directly after the associated page data, if the database is
+** pointers must be either 4 or 8-byte aligned). As this structure is located 
+** in memory directly after the associated page data, if the database is 
 ** corrupt, code at the b-tree layer may overread the page buffer and
-** read part of this structure before the corruption is detected. This
-** can cause a valgrind error if the unitialized gap is accessed. Using u16
-** ensures there is no such gap, and therefore no bytes of unitialized memory
-** in the structure.
+** read part of this structure before the corruption is detected. This 
+** can cause a valgrind error if the unitialized gap is accessed. Using u16 
+** ensures there is no such gap, and therefore no bytes of unitialized memory 
+** in the structure. 
 */
 struct PgHdr1 {
   sqlite3_pcache_page page;      /* Base class. Must be first. pBuf & pExtra */
   unsigned int iKey;             /* Key value (page number) */
-  u16 isBulkLocal;               /* This page from bulk local storage */
-  u16 isAnchor;                  /* This is the PGroup.lru element */
+  u16 isBulkLocal;               /* This page from bulk local storage */ 
+  u16 isAnchor;                  /* This is the PGroup.lru element */ 
   PgHdr1 *pNext;                 /* Next in hash table chain */
   PCache1 *pCache;               /* Cache that currently owns this page */
   PgHdr1 *pLruNext;              /* Next in LRU list of unpinned pages */
   PgHdr1 *pLruPrev;              /* Previous in LRU list of unpinned pages */
-                                 /* NB: pLruPrev is only valid if pLruNext!=0 */
+                                 /* NB: pLruPrev is only valid if pLruNext!=0 */ 
 };
 
 /*
-** A page is pinned if it is not on the LRU list.  To be "pinned" means
-** that the page is in active use and must not be deallocated.
+** A page is pinned if it is not on the LRU list.  To be "pinned" means 
+** that the page is in active use and must not be deallocated. 
 */
 #define PAGE_IS_PINNED(p)    ((p)->pLruNext==0)
 #define PAGE_IS_UNPINNED(p)  ((p)->pLruNext!=0)
@@ -50888,7 +50888,7 @@ struct PCache1 {
   unsigned int nMax;                  /* Configured "cache_size" value */
   unsigned int n90pct;                /* nMax*9/10 */
   unsigned int iMaxKey;               /* Largest key seen since xTruncate() */
-  unsigned int nPurgeableDummy;       /* pnPurgeable points here when not used*/
+  unsigned int nPurgeableDummy;       /* pnPurgeable points here when not used*/ 
 
   /* Hash table of all pages. The following variables may only be accessed
   ** when the accessor is holding the PGroup mutex.
@@ -51023,7 +51023,7 @@ static int pcache1InitBulk(PCache1 *pCache){
       pX->isBulkLocal = 1;
       pX->isAnchor = 0;
       pX->pNext = pCache->pFree;
-      pX->pLruPrev = 0;           /* Initializing this saves a valgrind error */
+      pX->pLruPrev = 0;           /* Initializing this saves a valgrind error */ 
       pCache->pFree = pX;
       zBulk += pCache->szAlloc;
     }while( --nBulk );
@@ -51203,7 +51203,7 @@ static void pcache1FreePage(PgHdr1 *p){
 ** exists, this function falls back to sqlite3Malloc().
 */
 SQLITE_PRIVATE void *sqlite3PageMalloc(int sz){
-  assert( sz<=65536+8 ); /* These allocations are never very large */
+  assert( sz<=65536+8 ); /* These allocations are never very large */ 
   return pcache1Alloc(sz);
 }
 
@@ -51298,8 +51298,8 @@ static PgHdr1 *pcache1PinPage(PgHdr1 *pPage){
   pPage->pLruPrev->pLruNext = pPage->pLruNext;
   pPage->pLruNext->pLruPrev = pPage->pLruPrev;
   pPage->pLruNext = 0;
-  /* pPage->pLruPrev = 0;
-  ** No need to clear pLruPrev as it is never accessed if pLruNext is 0 */
+  /* pPage->pLruPrev = 0; 
+  ** No need to clear pLruPrev as it is never accessed if pLruNext is 0 */ 
   assert( pPage->isAnchor==0 );
   assert( pPage->pCache->pGroup->lru.isAnchor==1 );
   pPage->pCache->nRecyclable--;
@@ -51492,7 +51492,7 @@ static sqlite3_pcache *pcache1Create(int szPage, int szExtra, int bPurgeable){
     }else{
       pGroup = &pcache1.grp;
     }
-    pcache1EnterMutex(pGroup);
+    pcache1EnterMutex(pGroup); 
     if( pGroup->lru.isAnchor==0 ){
       pGroup->lru.isAnchor = 1;
       pGroup->lru.pLruPrev = pGroup->lru.pLruNext = &pGroup->lru;
@@ -51509,7 +51509,7 @@ static sqlite3_pcache *pcache1Create(int szPage, int szExtra, int bPurgeable){
       pGroup->mxPinned = pGroup->nMaxPage + 10 - pGroup->nMinPage;
       pCache->pnPurgeable = &pGroup->nPurgeable;
     }else{
-      pCache->pnPurgeable = &pCache->nPurgeableDummy;
+      pCache->pnPurgeable = &pCache->nPurgeableDummy; 
     }
     pcache1LeaveMutex(pGroup);
     if( pCache->nHash==0 ){
@@ -51643,8 +51643,8 @@ static SQLITE_NOINLINE PgHdr1 *pcache1FetchStage2(
     pPage->pNext = pCache->apHash[h];
     pPage->pCache = pCache;
     pPage->pLruNext = 0;
-    /* pPage->pLruPrev = 0;
-    ** No need to clear pLruPrev since it is not accessed when pLruNext==0 */
+    /* pPage->pLruPrev = 0; 
+    ** No need to clear pLruPrev since it is not accessed when pLruNext==0 */ 
     *(void **)pPage->page.pExtra = 0;
     pCache->apHash[h] = pPage;
     if( iKey>pCache->iMaxKey ){
@@ -51804,7 +51804,7 @@ static void pcache1Unpin(
   /* It is an error to call this function if the page is already
   ** part of the PGroup LRU list.
   */
-  assert( pPage->pLruNext==0 );
+  assert( pPage->pLruNext==0 ); 
   assert( PAGE_IS_PINNED(pPage) );
 
   if( reuseUnlikely || pGroup->nPurgeable>pGroup->nMaxPage ){
@@ -52121,23 +52121,23 @@ struct RowSet {
 #define ROWSET_NEXT    0x02   /* True if sqlite3RowSetNext() has been called */
 
 /*
-** Allocate a RowSet object.  Return NULL if a memory allocation
-** error occurs.
-*/
-SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3 *db){
-  RowSet *p = sqlite3DbMallocRawNN(db, sizeof(*p));
-  if( p ){
-    int N = sqlite3DbMallocSize(db, p);
-    p->pChunk = 0;
-    p->db = db;
-    p->pEntry = 0;
-    p->pLast = 0;
-    p->pForest = 0;
-    p->pFresh = (struct RowSetEntry*)(ROUND8(sizeof(*p)) + (char*)p);
-    p->nFresh = (u16)((N - ROUND8(sizeof(*p)))/sizeof(struct RowSetEntry));
-    p->rsFlags = ROWSET_SORTED;
-    p->iBatch = 0;
-  }
+** Allocate a RowSet object.  Return NULL if a memory allocation 
+** error occurs. 
+*/
+SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3 *db){ 
+  RowSet *p = sqlite3DbMallocRawNN(db, sizeof(*p)); 
+  if( p ){ 
+    int N = sqlite3DbMallocSize(db, p); 
+    p->pChunk = 0; 
+    p->db = db; 
+    p->pEntry = 0; 
+    p->pLast = 0; 
+    p->pForest = 0; 
+    p->pFresh = (struct RowSetEntry*)(ROUND8(sizeof(*p)) + (char*)p); 
+    p->nFresh = (u16)((N - ROUND8(sizeof(*p)))/sizeof(struct RowSetEntry)); 
+    p->rsFlags = ROWSET_SORTED; 
+    p->iBatch = 0; 
+  } 
   return p;
 }
 
@@ -52146,8 +52146,8 @@ SQLITE_PRIVATE RowSet *sqlite3RowSetInit(sqlite3 *db){
 ** the RowSet has allocated over its lifetime.  This routine is
 ** the destructor for the RowSet.
 */
-SQLITE_PRIVATE void sqlite3RowSetClear(void *pArg){
-  RowSet *p = (RowSet*)pArg;
+SQLITE_PRIVATE void sqlite3RowSetClear(void *pArg){ 
+  RowSet *p = (RowSet*)pArg; 
   struct RowSetChunk *pChunk, *pNextChunk;
   for(pChunk=p->pChunk; pChunk; pChunk = pNextChunk){
     pNextChunk = pChunk->pNextChunk;
@@ -52162,16 +52162,16 @@ SQLITE_PRIVATE void sqlite3RowSetClear(void *pArg){
 }
 
 /*
-** Deallocate all chunks from a RowSet.  This frees all memory that
-** the RowSet has allocated over its lifetime.  This routine is
-** the destructor for the RowSet.
-*/
-SQLITE_PRIVATE void sqlite3RowSetDelete(void *pArg){
-  sqlite3RowSetClear(pArg);
-  sqlite3DbFree(((RowSet*)pArg)->db, pArg);
-}
-
-/*
+** Deallocate all chunks from a RowSet.  This frees all memory that 
+** the RowSet has allocated over its lifetime.  This routine is 
+** the destructor for the RowSet. 
+*/ 
+SQLITE_PRIVATE void sqlite3RowSetDelete(void *pArg){ 
+  sqlite3RowSetClear(pArg); 
+  sqlite3DbFree(((RowSet*)pArg)->db, pArg); 
+} 
+ 
+/* 
 ** Allocate a new RowSetEntry object that is associated with the
 ** given RowSet.  Return a pointer to the new and completely uninitialized
 ** object.
@@ -52658,8 +52658,8 @@ SQLITE_PRIVATE int sqlite3WalHeapMemory(Wal *pWal);
 SQLITE_PRIVATE int sqlite3WalSnapshotGet(Wal *pWal, sqlite3_snapshot **ppSnapshot);
 SQLITE_PRIVATE void sqlite3WalSnapshotOpen(Wal *pWal, sqlite3_snapshot *pSnapshot);
 SQLITE_PRIVATE int sqlite3WalSnapshotRecover(Wal *pWal);
-SQLITE_PRIVATE int sqlite3WalSnapshotCheck(Wal *pWal, sqlite3_snapshot *pSnapshot);
-SQLITE_PRIVATE void sqlite3WalSnapshotUnlock(Wal *pWal);
+SQLITE_PRIVATE int sqlite3WalSnapshotCheck(Wal *pWal, sqlite3_snapshot *pSnapshot); 
+SQLITE_PRIVATE void sqlite3WalSnapshotUnlock(Wal *pWal); 
 #endif
 
 #ifdef SQLITE_ENABLE_ZIPVFS
@@ -53348,7 +53348,7 @@ struct Pager {
   char *zJournal;             /* Name of the journal file */
   int (*xBusyHandler)(void*); /* Function to call when busy */
   void *pBusyHandlerArg;      /* Context argument for xBusyHandler */
-  int aStat[4];               /* Total cache hits, misses, writes, spills */
+  int aStat[4];               /* Total cache hits, misses, writes, spills */ 
 #ifdef SQLITE_TEST
   int nRead;                  /* Database pages read */
 #endif
@@ -53370,7 +53370,7 @@ struct Pager {
 #define PAGER_STAT_HIT   0
 #define PAGER_STAT_MISS  1
 #define PAGER_STAT_WRITE 2
-#define PAGER_STAT_SPILL 3
+#define PAGER_STAT_SPILL 3 
 
 /*
 ** The following global variables hold counters used for
@@ -53463,30 +53463,30 @@ static const unsigned char aJournalMagic[] = {
 */
 #define isOpen(pFd) ((pFd)->pMethods!=0)
 
-#ifdef SQLITE_DIRECT_OVERFLOW_READ
-/*
-** Return true if page pgno can be read directly from the database file
-** by the b-tree layer. This is the case if:
-**
-**   * the database file is open,
-**   * there are no dirty pages in the cache, and
-**   * the desired page is not currently in the wal file.
-*/
-SQLITE_PRIVATE int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno){
-  if( pPager->fd->pMethods==0 ) return 0;
-  if( sqlite3PCacheIsDirty(pPager->pPCache) ) return 0;
-#ifndef SQLITE_OMIT_WAL
-  if( pPager->pWal ){
-    u32 iRead = 0;
-    int rc;
-    rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iRead);
-    return (rc==SQLITE_OK && iRead==0);
-  }
-#endif
-  return 1;
-}
-#endif
-
+#ifdef SQLITE_DIRECT_OVERFLOW_READ 
+/*
+** Return true if page pgno can be read directly from the database file 
+** by the b-tree layer. This is the case if: 
+** 
+**   * the database file is open, 
+**   * there are no dirty pages in the cache, and 
+**   * the desired page is not currently in the wal file. 
+*/
+SQLITE_PRIVATE int sqlite3PagerDirectReadOk(Pager *pPager, Pgno pgno){ 
+  if( pPager->fd->pMethods==0 ) return 0; 
+  if( sqlite3PCacheIsDirty(pPager->pPCache) ) return 0; 
+#ifndef SQLITE_OMIT_WAL 
+  if( pPager->pWal ){ 
+    u32 iRead = 0; 
+    int rc; 
+    rc = sqlite3WalFindFrame(pPager->pWal, pgno, &iRead); 
+    return (rc==SQLITE_OK && iRead==0); 
+  } 
+#endif 
+  return 1; 
+}
+#endif
+ 
 #ifndef SQLITE_OMIT_WAL
 # define pagerUseWal(x) ((x)->pWal!=0)
 #else
@@ -53646,12 +53646,12 @@ static int assert_pager_state(Pager *p){
 ** to "print *pPager" in gdb:
 **
 ** (gdb) printf "%s", print_pager_state(pPager)
-**
-** This routine has external linkage in order to suppress compiler warnings
-** about an unused function.  It is enclosed within SQLITE_DEBUG and so does
-** not appear in normal builds.
+** 
+** This routine has external linkage in order to suppress compiler warnings 
+** about an unused function.  It is enclosed within SQLITE_DEBUG and so does 
+** not appear in normal builds. 
 */
-char *print_pager_state(Pager *p){
+char *print_pager_state(Pager *p){ 
   static char zRet[1024];
 
   sqlite3_snprintf(1024, zRet,
@@ -53867,7 +53867,7 @@ static int jrnlBufferSize(Pager *pPager){
 #endif
 
 #ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
-  if( pPager->dbSize>0 && (dc&SQLITE_IOCAP_BATCH_ATOMIC) ){
+  if( pPager->dbSize>0 && (dc&SQLITE_IOCAP_BATCH_ATOMIC) ){ 
     return -1;
   }
 #endif
@@ -54782,7 +54782,7 @@ static int pager_end_transaction(Pager *pPager, int hasSuper, int bCommit){
     rc = pager_truncate(pPager, pPager->dbSize);
   }
 
-  if( rc==SQLITE_OK && bCommit ){
+  if( rc==SQLITE_OK && bCommit ){ 
     rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_COMMIT_PHASETWO, 0);
     if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
   }
@@ -55554,7 +55554,7 @@ end_playback:
   ** assertion that the transaction counter was modified.
   */
 #ifdef SQLITE_DEBUG
-  sqlite3OsFileControlHint(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0);
+  sqlite3OsFileControlHint(pPager->fd,SQLITE_FCNTL_DB_UNCHANGED,0); 
 #endif
 
   /* If this playback is happening automatically as a result of an IO or
@@ -56312,18 +56312,18 @@ static int pagerOpentemp(
 ** retried. If it returns zero, then the SQLITE_BUSY error is
 ** returned to the caller of the pager API function.
 */
-SQLITE_PRIVATE void sqlite3PagerSetBusyHandler(
+SQLITE_PRIVATE void sqlite3PagerSetBusyHandler( 
   Pager *pPager,                       /* Pager object */
   int (*xBusyHandler)(void *),         /* Pointer to busy-handler function */
   void *pBusyHandlerArg                /* Argument to pass to xBusyHandler */
 ){
-  void **ap;
+  void **ap; 
   pPager->xBusyHandler = xBusyHandler;
   pPager->pBusyHandlerArg = pBusyHandlerArg;
-  ap = (void **)&pPager->xBusyHandler;
-  assert( ((int(*)(void *))(ap[0]))==xBusyHandler );
-  assert( ap[1]==pBusyHandlerArg );
-  sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_BUSYHANDLER, (void *)ap);
+  ap = (void **)&pPager->xBusyHandler; 
+  assert( ((int(*)(void *))(ap[0]))==xBusyHandler ); 
+  assert( ap[1]==pBusyHandlerArg ); 
+  sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_BUSYHANDLER, (void *)ap); 
 }
 
 /*
@@ -56382,14 +56382,14 @@ SQLITE_PRIVATE int sqlite3PagerSetPagesize(Pager *pPager, u32 *pPageSize, int nR
       rc = sqlite3OsFileSize(pPager->fd, &nByte);
     }
     if( rc==SQLITE_OK ){
-      /* 8 bytes of zeroed overrun space is sufficient so that the b-tree
-      * cell header parser will never run off the end of the allocation */
-      pNew = (char *)sqlite3PageMalloc(pageSize+8);
-      if( !pNew ){
-        rc = SQLITE_NOMEM_BKPT;
-      }else{
-        memset(pNew+pageSize, 0, 8);
-      }
+      /* 8 bytes of zeroed overrun space is sufficient so that the b-tree 
+      * cell header parser will never run off the end of the allocation */ 
+      pNew = (char *)sqlite3PageMalloc(pageSize+8); 
+      if( !pNew ){ 
+        rc = SQLITE_NOMEM_BKPT; 
+      }else{ 
+        memset(pNew+pageSize, 0, 8); 
+      } 
     }
 
     if( rc==SQLITE_OK ){
@@ -56440,10 +56440,10 @@ SQLITE_PRIVATE Pgno sqlite3PagerMaxPageCount(Pager *pPager, Pgno mxPage){
     pPager->mxPgno = mxPage;
   }
   assert( pPager->eState!=PAGER_OPEN );      /* Called only by OP_MaxPgcnt */
-  /* assert( pPager->mxPgno>=pPager->dbSize ); */
-  /* OP_MaxPgcnt ensures that the parameter passed to this function is not
-  ** less than the total number of valid pages in the database. But this
-  ** may be less than Pager.dbSize, and so the assert() above is not valid */
+  /* assert( pPager->mxPgno>=pPager->dbSize ); */ 
+  /* OP_MaxPgcnt ensures that the parameter passed to this function is not 
+  ** less than the total number of valid pages in the database. But this 
+  ** may be less than Pager.dbSize, and so the assert() above is not valid */ 
   return pPager->mxPgno;
 }
 
@@ -56718,31 +56718,31 @@ static void pagerFreeMapHdrs(Pager *pPager){
   }
 }
 
-/* Verify that the database file has not be deleted or renamed out from
-** under the pager.  Return SQLITE_OK if the database is still where it ought
-** to be on disk.  Return non-zero (SQLITE_READONLY_DBMOVED or some other error
-** code from sqlite3OsAccess()) if the database has gone missing.
-*/
-static int databaseIsUnmoved(Pager *pPager){
-  int bHasMoved = 0;
-  int rc;
-
-  if( pPager->tempFile ) return SQLITE_OK;
-  if( pPager->dbSize==0 ) return SQLITE_OK;
-  assert( pPager->zFilename && pPager->zFilename[0] );
-  rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_HAS_MOVED, &bHasMoved);
-  if( rc==SQLITE_NOTFOUND ){
-    /* If the HAS_MOVED file-control is unimplemented, assume that the file
-    ** has not been moved.  That is the historical behavior of SQLite: prior to
-    ** version 3.8.3, it never checked */
-    rc = SQLITE_OK;
-  }else if( rc==SQLITE_OK && bHasMoved ){
-    rc = SQLITE_READONLY_DBMOVED;
-  }
-  return rc;
-}
-
-
+/* Verify that the database file has not be deleted or renamed out from 
+** under the pager.  Return SQLITE_OK if the database is still where it ought 
+** to be on disk.  Return non-zero (SQLITE_READONLY_DBMOVED or some other error 
+** code from sqlite3OsAccess()) if the database has gone missing. 
+*/ 
+static int databaseIsUnmoved(Pager *pPager){ 
+  int bHasMoved = 0; 
+  int rc; 
+
+  if( pPager->tempFile ) return SQLITE_OK; 
+  if( pPager->dbSize==0 ) return SQLITE_OK; 
+  assert( pPager->zFilename && pPager->zFilename[0] ); 
+  rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_HAS_MOVED, &bHasMoved); 
+  if( rc==SQLITE_NOTFOUND ){ 
+    /* If the HAS_MOVED file-control is unimplemented, assume that the file 
+    ** has not been moved.  That is the historical behavior of SQLite: prior to 
+    ** version 3.8.3, it never checked */ 
+    rc = SQLITE_OK; 
+  }else if( rc==SQLITE_OK && bHasMoved ){ 
+    rc = SQLITE_READONLY_DBMOVED; 
+  } 
+  return rc; 
+} 
+ 
+ 
 /*
 ** Shutdown the page cache.  Free all memory and close all files.
 **
@@ -56758,7 +56758,7 @@ static int databaseIsUnmoved(Pager *pPager){
 ** to the caller.
 */
 SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager, sqlite3 *db){
-  u8 *pTmp = (u8*)pPager->pTmpSpace;
+  u8 *pTmp = (u8*)pPager->pTmpSpace; 
   assert( db || pagerUseWal(pPager)==0 );
   assert( assert_pager_state(pPager) );
   disable_simulated_io_errors();
@@ -56767,17 +56767,17 @@ SQLITE_PRIVATE int sqlite3PagerClose(Pager *pPager, sqlite3 *db){
   /* pPager->errCode = 0; */
   pPager->exclusiveMode = 0;
 #ifndef SQLITE_OMIT_WAL
-  {
-    u8 *a = 0;
-    assert( db || pPager->pWal==0 );
+  { 
+    u8 *a = 0; 
+    assert( db || pPager->pWal==0 ); 
     if( db && 0==(db->flags & SQLITE_NoCkptOnClose)
-     && SQLITE_OK==databaseIsUnmoved(pPager)
-    ){
-      a = pTmp;
-    }
-    sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags, pPager->pageSize,a);
-    pPager->pWal = 0;
-  }
+     && SQLITE_OK==databaseIsUnmoved(pPager) 
+    ){ 
+      a = pTmp; 
+    } 
+    sqlite3WalClose(pPager->pWal, db, pPager->walSyncFlags, pPager->pageSize,a); 
+    pPager->pWal = 0; 
+  } 
 #endif
   pager_reset(pPager);
   if( MEMDB ){
@@ -57222,7 +57222,7 @@ static int pagerStress(void *p, PgHdr *pPg){
     return SQLITE_OK;
   }
 
-  pPager->aStat[PAGER_STAT_SPILL]++;
+  pPager->aStat[PAGER_STAT_SPILL]++; 
   pPg->pDirty = 0;
   if( pagerUseWal(pPager) ){
     /* Write a single frame for this page to the log. */
@@ -57329,10 +57329,10 @@ SQLITE_PRIVATE int sqlite3PagerOpen(
   int tempFile = 0;        /* True for temp files (incl. in-memory files) */
   int memDb = 0;           /* True if this is an in-memory file */
 #ifndef SQLITE_OMIT_DESERIALIZE
-  int memJM = 0;           /* Memory journal mode */
-#else
-# define memJM 0
-#endif
+  int memJM = 0;           /* Memory journal mode */ 
+#else 
+# define memJM 0 
+#endif 
   int readOnly = 0;        /* True if this is a read-only file */
   int journalFileSize;     /* Bytes to allocate for each journal fd */
   char *zPathname = 0;     /* Full path to database file */
@@ -57535,8 +57535,8 @@ SQLITE_PRIVATE int sqlite3PagerOpen(
     assert( !memDb );
 #ifndef SQLITE_OMIT_DESERIALIZE
     pPager->memVfs = memJM = (fout&SQLITE_OPEN_MEMORY)!=0;
-#endif
-    readOnly = (fout&SQLITE_OPEN_READONLY)!=0;
+#endif 
+    readOnly = (fout&SQLITE_OPEN_READONLY)!=0; 
 
     /* If the file was successfully opened for read/write access,
     ** choose a default page size in case we have to create the
@@ -57667,7 +57667,7 @@ act_like_temp_file:
   setSectorSize(pPager);
   if( !useJournal ){
     pPager->journalMode = PAGER_JOURNALMODE_OFF;
-  }else if( memDb || memJM ){
+  }else if( memDb || memJM ){ 
     pPager->journalMode = PAGER_JOURNALMODE_MEMORY;
   }
   /* pPager->xBusyHandler = 0; */
@@ -58975,8 +58975,8 @@ static int pager_incr_changecounter(Pager *pPager, int isDirectMode){
 SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zSuper){
   int rc = SQLITE_OK;
   void *pArg = (void*)zSuper;
-  rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg);
-  if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
+  rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg); 
+  if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK; 
   if( rc==SQLITE_OK && !pPager->noSync ){
     assert( !MEMDB );
     rc = sqlite3OsSync(pPager->fd, pPager->syncFlags);
@@ -59071,10 +59071,10 @@ SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne(
     ** backup in progress needs to be restarted.  */
     sqlite3BackupRestart(pPager->pBackup);
   }else{
-    PgHdr *pList;
+    PgHdr *pList; 
     if( pagerUseWal(pPager) ){
       PgHdr *pPageOne = 0;
-      pList = sqlite3PcacheDirtyList(pPager->pPCache);
+      pList = sqlite3PcacheDirtyList(pPager->pPCache); 
       if( pList==0 ){
         /* Must have at least one page for the WAL commit flag.
         ** Ticket [2d1a5c67dfc2363e44f29d9bbd57f] 2011-05-18 */
@@ -59095,14 +59095,14 @@ SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne(
       ** should be used.  No rollback journal is created if batch-atomic-write
       ** is enabled.
       */
-#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
+#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE 
       sqlite3_file *fd = pPager->fd;
       int bBatch = zSuper==0    /* An SQLITE_IOCAP_BATCH_ATOMIC commit */
         && (sqlite3OsDeviceCharacteristics(fd) & SQLITE_IOCAP_BATCH_ATOMIC)
         && !pPager->noSync
         && sqlite3JournalIsInMemory(pPager->jfd);
 #else
-#     define bBatch 0
+#     define bBatch 0 
 #endif
 
 #ifdef SQLITE_ENABLE_ATOMIC_WRITE
@@ -59154,16 +59154,16 @@ SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne(
           }
         }
       }
-#else  /* SQLITE_ENABLE_ATOMIC_WRITE */
+#else  /* SQLITE_ENABLE_ATOMIC_WRITE */ 
 #ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
       if( zSuper ){
         rc = sqlite3JournalCreate(pPager->jfd);
         if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
-        assert( bBatch==0 );
+        assert( bBatch==0 ); 
       }
 #endif
       rc = pager_incr_changecounter(pPager, 0);
-#endif /* !SQLITE_ENABLE_ATOMIC_WRITE */
+#endif /* !SQLITE_ENABLE_ATOMIC_WRITE */ 
       if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
 
       /* Write the super-journal name into the journal file. If a
@@ -59187,36 +59187,36 @@ SQLITE_PRIVATE int sqlite3PagerCommitPhaseOne(
       rc = syncJournal(pPager, 0);
       if( rc!=SQLITE_OK ) goto commit_phase_one_exit;
 
-      pList = sqlite3PcacheDirtyList(pPager->pPCache);
-#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE
+      pList = sqlite3PcacheDirtyList(pPager->pPCache); 
+#ifdef SQLITE_ENABLE_BATCH_ATOMIC_WRITE 
       if( bBatch ){
         rc = sqlite3OsFileControl(fd, SQLITE_FCNTL_BEGIN_ATOMIC_WRITE, 0);
         if( rc==SQLITE_OK ){
-          rc = pager_write_pagelist(pPager, pList);
-          if( rc==SQLITE_OK ){
-            rc = sqlite3OsFileControl(fd, SQLITE_FCNTL_COMMIT_ATOMIC_WRITE, 0);
-          }
-          if( rc!=SQLITE_OK ){
-            sqlite3OsFileControlHint(fd, SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE, 0);
-          }
-        }
-
-        if( (rc&0xFF)==SQLITE_IOERR && rc!=SQLITE_IOERR_NOMEM ){
-          rc = sqlite3JournalCreate(pPager->jfd);
-          if( rc!=SQLITE_OK ){
-            sqlite3OsClose(pPager->jfd);
-            goto commit_phase_one_exit;
-          }
-          bBatch = 0;
+          rc = pager_write_pagelist(pPager, pList); 
+          if( rc==SQLITE_OK ){ 
+            rc = sqlite3OsFileControl(fd, SQLITE_FCNTL_COMMIT_ATOMIC_WRITE, 0); 
+          } 
+          if( rc!=SQLITE_OK ){ 
+            sqlite3OsFileControlHint(fd, SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE, 0); 
+          } 
+        } 
+ 
+        if( (rc&0xFF)==SQLITE_IOERR && rc!=SQLITE_IOERR_NOMEM ){ 
+          rc = sqlite3JournalCreate(pPager->jfd); 
+          if( rc!=SQLITE_OK ){ 
+            sqlite3OsClose(pPager->jfd); 
+            goto commit_phase_one_exit; 
+          } 
+          bBatch = 0; 
         }else{
-          sqlite3OsClose(pPager->jfd);
+          sqlite3OsClose(pPager->jfd); 
         }
       }
-#endif /* SQLITE_ENABLE_BATCH_ATOMIC_WRITE */
+#endif /* SQLITE_ENABLE_BATCH_ATOMIC_WRITE */ 
 
-      if( bBatch==0 ){
-        rc = pager_write_pagelist(pPager, pList);
-      }
+      if( bBatch==0 ){ 
+        rc = pager_write_pagelist(pPager, pList); 
+      } 
       if( rc!=SQLITE_OK ){
         assert( rc!=SQLITE_IOERR_BLOCKED );
         goto commit_phase_one_exit;
@@ -59437,12 +59437,12 @@ SQLITE_PRIVATE int *sqlite3PagerStats(Pager *pPager){
 #endif
 
 /*
-** Parameter eStat must be one of SQLITE_DBSTATUS_CACHE_HIT, _MISS, _WRITE,
-** or _WRITE+1.  The SQLITE_DBSTATUS_CACHE_WRITE+1 case is a translation
-** of SQLITE_DBSTATUS_CACHE_SPILL.  The _SPILL case is not contiguous because
-** it was added later.
-**
-** Before returning, *pnVal is incremented by the
+** Parameter eStat must be one of SQLITE_DBSTATUS_CACHE_HIT, _MISS, _WRITE, 
+** or _WRITE+1.  The SQLITE_DBSTATUS_CACHE_WRITE+1 case is a translation 
+** of SQLITE_DBSTATUS_CACHE_SPILL.  The _SPILL case is not contiguous because 
+** it was added later. 
+** 
+** Before returning, *pnVal is incremented by the 
 ** current cache hit or miss count, according to the value of eStat. If the
 ** reset parameter is non-zero, the cache hit or miss count is zeroed before
 ** returning.
@@ -59452,18 +59452,18 @@ SQLITE_PRIVATE void sqlite3PagerCacheStat(Pager *pPager, int eStat, int reset, i
   assert( eStat==SQLITE_DBSTATUS_CACHE_HIT
        || eStat==SQLITE_DBSTATUS_CACHE_MISS
        || eStat==SQLITE_DBSTATUS_CACHE_WRITE
-       || eStat==SQLITE_DBSTATUS_CACHE_WRITE+1
+       || eStat==SQLITE_DBSTATUS_CACHE_WRITE+1 
   );
 
   assert( SQLITE_DBSTATUS_CACHE_HIT+1==SQLITE_DBSTATUS_CACHE_MISS );
   assert( SQLITE_DBSTATUS_CACHE_HIT+2==SQLITE_DBSTATUS_CACHE_WRITE );
-  assert( PAGER_STAT_HIT==0 && PAGER_STAT_MISS==1
-           && PAGER_STAT_WRITE==2 && PAGER_STAT_SPILL==3 );
+  assert( PAGER_STAT_HIT==0 && PAGER_STAT_MISS==1 
+           && PAGER_STAT_WRITE==2 && PAGER_STAT_SPILL==3 ); 
 
-  eStat -= SQLITE_DBSTATUS_CACHE_HIT;
-  *pnVal += pPager->aStat[eStat];
+  eStat -= SQLITE_DBSTATUS_CACHE_HIT; 
+  *pnVal += pPager->aStat[eStat]; 
   if( reset ){
-    pPager->aStat[eStat] = 0;
+    pPager->aStat[eStat] = 0; 
   }
 }
 
@@ -59789,12 +59789,12 @@ SQLITE_PRIVATE int sqlite3PagerMovepage(Pager *pPager, DbPage *pPg, Pgno pgno, i
   */
   pPg->flags &= ~PGHDR_NEED_SYNC;
   pPgOld = sqlite3PagerLookup(pPager, pgno);
-  assert( !pPgOld || pPgOld->nRef==1 || CORRUPT_DB );
+  assert( !pPgOld || pPgOld->nRef==1 || CORRUPT_DB ); 
   if( pPgOld ){
     if( NEVER(pPgOld->nRef>1) ){
-      sqlite3PagerUnrefNotNull(pPgOld);
-      return SQLITE_CORRUPT_BKPT;
-    }
+      sqlite3PagerUnrefNotNull(pPgOld); 
+      return SQLITE_CORRUPT_BKPT; 
+    } 
     pPg->flags |= (pPgOld->flags&PGHDR_NEED_SYNC);
     if( pPager->tempFile ){
       /* Do not discard pages from an in-memory database since we might
@@ -60321,38 +60321,38 @@ SQLITE_PRIVATE int sqlite3PagerSnapshotRecover(Pager *pPager){
   }
   return rc;
 }
-
-/*
-** The caller currently has a read transaction open on the database.
-** If this is not a WAL database, SQLITE_ERROR is returned. Otherwise,
-** this function takes a SHARED lock on the CHECKPOINTER slot and then
+ 
+/* 
+** The caller currently has a read transaction open on the database. 
+** If this is not a WAL database, SQLITE_ERROR is returned. Otherwise, 
+** this function takes a SHARED lock on the CHECKPOINTER slot and then 
 ** checks if the snapshot passed as the second argument is still
-** available. If so, SQLITE_OK is returned.
-**
-** If the snapshot is not available, SQLITE_ERROR is returned. Or, if
-** the CHECKPOINTER lock cannot be obtained, SQLITE_BUSY. If any error
-** occurs (any value other than SQLITE_OK is returned), the CHECKPOINTER
-** lock is released before returning.
-*/
-SQLITE_PRIVATE int sqlite3PagerSnapshotCheck(Pager *pPager, sqlite3_snapshot *pSnapshot){
-  int rc;
-  if( pPager->pWal ){
-    rc = sqlite3WalSnapshotCheck(pPager->pWal, pSnapshot);
-  }else{
-    rc = SQLITE_ERROR;
-  }
-  return rc;
-}
-
-/*
-** Release a lock obtained by an earlier successful call to
-** sqlite3PagerSnapshotCheck().
-*/
-SQLITE_PRIVATE void sqlite3PagerSnapshotUnlock(Pager *pPager){
-  assert( pPager->pWal );
-  sqlite3WalSnapshotUnlock(pPager->pWal);
-}
-
+** available. If so, SQLITE_OK is returned. 
+** 
+** If the snapshot is not available, SQLITE_ERROR is returned. Or, if 
+** the CHECKPOINTER lock cannot be obtained, SQLITE_BUSY. If any error 
+** occurs (any value other than SQLITE_OK is returned), the CHECKPOINTER 
+** lock is released before returning. 
+*/ 
+SQLITE_PRIVATE int sqlite3PagerSnapshotCheck(Pager *pPager, sqlite3_snapshot *pSnapshot){ 
+  int rc; 
+  if( pPager->pWal ){ 
+    rc = sqlite3WalSnapshotCheck(pPager->pWal, pSnapshot); 
+  }else{ 
+    rc = SQLITE_ERROR; 
+  } 
+  return rc; 
+} 
+ 
+/* 
+** Release a lock obtained by an earlier successful call to 
+** sqlite3PagerSnapshotCheck(). 
+*/ 
+SQLITE_PRIVATE void sqlite3PagerSnapshotUnlock(Pager *pPager){ 
+  assert( pPager->pWal ); 
+  sqlite3WalSnapshotUnlock(pPager->pWal); 
+} 
+ 
 #endif /* SQLITE_ENABLE_SNAPSHOT */
 #endif /* !SQLITE_OMIT_WAL */
 
@@ -61004,16 +61004,16 @@ struct WalIterator {
 **
 ** Scenario (3) can only occur when pWal->writeLock is false and iPage==0
 */
-static SQLITE_NOINLINE int walIndexPageRealloc(
-  Wal *pWal,               /* The WAL context */
-  int iPage,               /* The page we seek */
-  volatile u32 **ppPage    /* Write the page pointer here */
-){
+static SQLITE_NOINLINE int walIndexPageRealloc( 
+  Wal *pWal,               /* The WAL context */ 
+  int iPage,               /* The page we seek */ 
+  volatile u32 **ppPage    /* Write the page pointer here */ 
+){ 
   int rc = SQLITE_OK;
 
   /* Enlarge the pWal->apWiData[] array if required */
   if( pWal->nWiData<=iPage ){
-    sqlite3_int64 nByte = sizeof(u32*)*(iPage+1);
+    sqlite3_int64 nByte = sizeof(u32*)*(iPage+1); 
     volatile u32 **apNew;
     apNew = (volatile u32 **)sqlite3Realloc((void *)pWal->apWiData, nByte);
     if( !apNew ){
@@ -61027,24 +61027,24 @@ static SQLITE_NOINLINE int walIndexPageRealloc(
   }
 
   /* Request a pointer to the required page from the VFS */
-  assert( pWal->apWiData[iPage]==0 );
-  if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ){
-    pWal->apWiData[iPage] = (u32 volatile *)sqlite3MallocZero(WALINDEX_PGSZ);
-    if( !pWal->apWiData[iPage] ) rc = SQLITE_NOMEM_BKPT;
-  }else{
+  assert( pWal->apWiData[iPage]==0 ); 
+  if( pWal->exclusiveMode==WAL_HEAPMEMORY_MODE ){ 
+    pWal->apWiData[iPage] = (u32 volatile *)sqlite3MallocZero(WALINDEX_PGSZ); 
+    if( !pWal->apWiData[iPage] ) rc = SQLITE_NOMEM_BKPT; 
+  }else{ 
     rc = sqlite3OsShmMap(pWal->pDbFd, iPage, WALINDEX_PGSZ,
-        pWal->writeLock, (void volatile **)&pWal->apWiData[iPage]
-    );
+        pWal->writeLock, (void volatile **)&pWal->apWiData[iPage] 
+    ); 
     assert( pWal->apWiData[iPage]!=0
          || rc!=SQLITE_OK
          || (pWal->writeLock==0 && iPage==0) );
-    testcase( pWal->apWiData[iPage]==0 && rc==SQLITE_OK );
+    testcase( pWal->apWiData[iPage]==0 && rc==SQLITE_OK ); 
     if( rc==SQLITE_OK ){
       if( iPage>0 && sqlite3FaultSim(600) ) rc = SQLITE_NOMEM;
     }else if( (rc&0xff)==SQLITE_READONLY ){
-      pWal->readOnly |= WAL_SHM_RDONLY;
-      if( rc==SQLITE_READONLY ){
-        rc = SQLITE_OK;
+      pWal->readOnly |= WAL_SHM_RDONLY; 
+      if( rc==SQLITE_READONLY ){ 
+        rc = SQLITE_OK; 
       }
     }
   }
@@ -61053,16 +61053,16 @@ static SQLITE_NOINLINE int walIndexPageRealloc(
   assert( iPage==0 || *ppPage || rc!=SQLITE_OK );
   return rc;
 }
-static int walIndexPage(
-  Wal *pWal,               /* The WAL context */
-  int iPage,               /* The page we seek */
-  volatile u32 **ppPage    /* Write the page pointer here */
-){
-  if( pWal->nWiData<=iPage || (*ppPage = pWal->apWiData[iPage])==0 ){
-    return walIndexPageRealloc(pWal, iPage, ppPage);
-  }
-  return SQLITE_OK;
-}
+static int walIndexPage( 
+  Wal *pWal,               /* The WAL context */ 
+  int iPage,               /* The page we seek */ 
+  volatile u32 **ppPage    /* Write the page pointer here */ 
+){ 
+  if( pWal->nWiData<=iPage || (*ppPage = pWal->apWiData[iPage])==0 ){ 
+    return walIndexPageRealloc(pWal, iPage, ppPage); 
+  } 
+  return SQLITE_OK; 
+} 
 
 /*
 ** Return a pointer to the WalCkptInfo structure in the wal-index.
@@ -61121,7 +61121,7 @@ static void walChecksumBytes(
 
   assert( nByte>=8 );
   assert( (nByte&0x00000007)==0 );
-  assert( nByte<=65536 );
+  assert( nByte<=65536 ); 
 
   if( nativeCksum ){
     do {
@@ -61353,28 +61353,28 @@ static int walNextHash(int iPriorHash){
   return (iPriorHash+1)&(HASHTABLE_NSLOT-1);
 }
 
-/*
-** An instance of the WalHashLoc object is used to describe the location
-** of a page hash table in the wal-index.  This becomes the return value
-** from walHashGet().
-*/
-typedef struct WalHashLoc WalHashLoc;
-struct WalHashLoc {
-  volatile ht_slot *aHash;  /* Start of the wal-index hash table */
-  volatile u32 *aPgno;      /* aPgno[1] is the page of first frame indexed */
-  u32 iZero;                /* One less than the frame number of first indexed*/
-};
-
+/* 
+** An instance of the WalHashLoc object is used to describe the location 
+** of a page hash table in the wal-index.  This becomes the return value 
+** from walHashGet(). 
+*/ 
+typedef struct WalHashLoc WalHashLoc; 
+struct WalHashLoc { 
+  volatile ht_slot *aHash;  /* Start of the wal-index hash table */ 
+  volatile u32 *aPgno;      /* aPgno[1] is the page of first frame indexed */ 
+  u32 iZero;                /* One less than the frame number of first indexed*/ 
+}; 
+ 
 /*
 ** Return pointers to the hash table and page number array stored on
 ** page iHash of the wal-index. The wal-index is broken into 32KB pages
 ** numbered starting from 0.
 **
-** Set output variable pLoc->aHash to point to the start of the hash table
+** Set output variable pLoc->aHash to point to the start of the hash table 
 ** in the wal-index file. Set pLoc->iZero to one less than the frame
 ** number of the first frame indexed by this hash table. If a
 ** slot in the hash table is set to N, it refers to frame number
-** (pLoc->iZero+N) in the log.
+** (pLoc->iZero+N) in the log. 
 **
 ** Finally, set pLoc->aPgno so that pLoc->aPgno[0] is the page number of the
 ** first frame indexed by the hash table, frame (pLoc->iZero).
@@ -61382,20 +61382,20 @@ struct WalHashLoc {
 static int walHashGet(
   Wal *pWal,                      /* WAL handle */
   int iHash,                      /* Find the iHash'th table */
-  WalHashLoc *pLoc                /* OUT: Hash table location */
+  WalHashLoc *pLoc                /* OUT: Hash table location */ 
 ){
   int rc;                         /* Return code */
 
-  rc = walIndexPage(pWal, iHash, &pLoc->aPgno);
+  rc = walIndexPage(pWal, iHash, &pLoc->aPgno); 
   assert( rc==SQLITE_OK || iHash>0 );
 
   if( pLoc->aPgno ){
-    pLoc->aHash = (volatile ht_slot *)&pLoc->aPgno[HASHTABLE_NPAGE];
+    pLoc->aHash = (volatile ht_slot *)&pLoc->aPgno[HASHTABLE_NPAGE]; 
     if( iHash==0 ){
-      pLoc->aPgno = &pLoc->aPgno[WALINDEX_HDR_SIZE/sizeof(u32)];
-      pLoc->iZero = 0;
+      pLoc->aPgno = &pLoc->aPgno[WALINDEX_HDR_SIZE/sizeof(u32)]; 
+      pLoc->iZero = 0; 
     }else{
-      pLoc->iZero = HASHTABLE_NPAGE_ONE + (iHash-1)*HASHTABLE_NPAGE;
+      pLoc->iZero = HASHTABLE_NPAGE_ONE + (iHash-1)*HASHTABLE_NPAGE; 
     }
   }else if( NEVER(rc==SQLITE_OK) ){
     rc = SQLITE_ERROR;
@@ -61445,7 +61445,7 @@ static u32 walFramePgno(Wal *pWal, u32 iFrame){
 ** actually needed.
 */
 static void walCleanupHash(Wal *pWal){
-  WalHashLoc sLoc;                /* Hash table location */
+  WalHashLoc sLoc;                /* Hash table location */ 
   int iLimit = 0;                 /* Zero values greater than this */
   int nByte;                      /* Number of bytes to zero in aPgno[] */
   int i;                          /* Used to iterate through aHash[] */
@@ -61459,7 +61459,7 @@ static void walCleanupHash(Wal *pWal){
 
   /* Obtain pointers to the hash-table and page-number array containing
   ** the entry that corresponds to frame pWal->hdr.mxFrame. It is guaranteed
-  ** that the page said hash-table and array reside on is already mapped.(1)
+  ** that the page said hash-table and array reside on is already mapped.(1) 
   */
   assert( pWal->nWiData>walFramePage(pWal->hdr.mxFrame) );
   assert( pWal->apWiData[walFramePage(pWal->hdr.mxFrame)] );
@@ -61469,11 +61469,11 @@ static void walCleanupHash(Wal *pWal){
   /* Zero all hash-table entries that correspond to frame numbers greater
   ** than pWal->hdr.mxFrame.
   */
-  iLimit = pWal->hdr.mxFrame - sLoc.iZero;
+  iLimit = pWal->hdr.mxFrame - sLoc.iZero; 
   assert( iLimit>0 );
   for(i=0; i<HASHTABLE_NSLOT; i++){
-    if( sLoc.aHash[i]>iLimit ){
-      sLoc.aHash[i] = 0;
+    if( sLoc.aHash[i]>iLimit ){ 
+      sLoc.aHash[i] = 0; 
     }
   }
 
@@ -61492,7 +61492,7 @@ static void walCleanupHash(Wal *pWal){
     int j;           /* Loop counter */
     int iKey;        /* Hash key */
     for(j=0; j<iLimit; j++){
-      for(iKey=walHash(sLoc.aPgno[j]);sLoc.aHash[iKey];iKey=walNextHash(iKey)){
+      for(iKey=walHash(sLoc.aPgno[j]);sLoc.aHash[iKey];iKey=walNextHash(iKey)){ 
         if( sLoc.aHash[iKey]==j+1 ) break;
       }
       assert( sLoc.aHash[iKey]==j+1 );
@@ -61508,9 +61508,9 @@ static void walCleanupHash(Wal *pWal){
 */
 static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
   int rc;                         /* Return code */
-  WalHashLoc sLoc;                /* Wal-index hash table location */
+  WalHashLoc sLoc;                /* Wal-index hash table location */ 
 
-  rc = walHashGet(pWal, walFramePage(iFrame), &sLoc);
+  rc = walHashGet(pWal, walFramePage(iFrame), &sLoc); 
 
   /* Assuming the wal-index file was successfully mapped, populate the
   ** page number array and hash table entry.
@@ -61520,7 +61520,7 @@ static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
     int idx;                      /* Value to write to hash-table slot */
     int nCollide;                 /* Number of hash collisions */
 
-    idx = iFrame - sLoc.iZero;
+    idx = iFrame - sLoc.iZero; 
     assert( idx <= HASHTABLE_NSLOT/2 + 1 );
 
     /* If this is the first entry to be added to this hash-table, zero the
@@ -61545,7 +61545,7 @@ static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
 
     /* Write the aPgno[] array entry and the hash-table slot. */
     nCollide = idx;
-    for(iKey=walHash(iPage); sLoc.aHash[iKey]; iKey=walNextHash(iKey)){
+    for(iKey=walHash(iPage); sLoc.aHash[iKey]; iKey=walNextHash(iKey)){ 
       if( (nCollide--)==0 ) return SQLITE_CORRUPT_BKPT;
     }
     sLoc.aPgno[idx-1] = iPage;
@@ -61558,7 +61558,7 @@ static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
     {
       int i;           /* Loop counter */
       int nEntry = 0;  /* Number of entries in the hash table */
-      for(i=0; i<HASHTABLE_NSLOT; i++){ if( sLoc.aHash[i] ) nEntry++; }
+      for(i=0; i<HASHTABLE_NSLOT; i++){ if( sLoc.aHash[i] ) nEntry++; } 
       assert( nEntry==idx );
     }
 
@@ -61570,9 +61570,9 @@ static int walIndexAppend(Wal *pWal, u32 iFrame, u32 iPage){
     if( (idx&0x3ff)==0 ){
       int i;           /* Loop counter */
       for(i=0; i<idx; i++){
-        for(iKey=walHash(sLoc.aPgno[i]);
-            sLoc.aHash[iKey];
-            iKey=walNextHash(iKey)){
+        for(iKey=walHash(sLoc.aPgno[i]); 
+            sLoc.aHash[iKey]; 
+            iKey=walNextHash(iKey)){ 
           if( sLoc.aHash[iKey]==i+1 ) break;
         }
         assert( sLoc.aHash[iKey]==i+1 );
@@ -62142,9 +62142,9 @@ static void walIteratorFree(WalIterator *p){
 
 /*
 ** Construct a WalInterator object that can be used to loop over all
-** pages in the WAL following frame nBackfill in ascending order. Frames
-** nBackfill or earlier may be included - excluding them is an optimization
-** only. The caller must hold the checkpoint lock.
+** pages in the WAL following frame nBackfill in ascending order. Frames 
+** nBackfill or earlier may be included - excluding them is an optimization 
+** only. The caller must hold the checkpoint lock. 
 **
 ** On success, make *pp point to the newly allocated WalInterator object
 ** return SQLITE_OK. Otherwise, return an error code. If this routine
@@ -62153,11 +62153,11 @@ static void walIteratorFree(WalIterator *p){
 ** The calling routine should invoke walIteratorFree() to destroy the
 ** WalIterator object when it has finished with it.
 */
-static int walIteratorInit(Wal *pWal, u32 nBackfill, WalIterator **pp){
+static int walIteratorInit(Wal *pWal, u32 nBackfill, WalIterator **pp){ 
   WalIterator *p;                 /* Return value */
   int nSegment;                   /* Number of segments to merge */
   u32 iLast;                      /* Last frame in log */
-  sqlite3_int64 nByte;            /* Number of bytes to allocate */
+  sqlite3_int64 nByte;            /* Number of bytes to allocate */ 
   int i;                          /* Iterator variable */
   ht_slot *aTmp;                  /* Temp space used by merge-sort */
   int rc = SQLITE_OK;             /* Return Code */
@@ -62190,38 +62190,38 @@ static int walIteratorInit(Wal *pWal, u32 nBackfill, WalIterator **pp){
     rc = SQLITE_NOMEM_BKPT;
   }
 
-  for(i=walFramePage(nBackfill+1); rc==SQLITE_OK && i<nSegment; i++){
-    WalHashLoc sLoc;
+  for(i=walFramePage(nBackfill+1); rc==SQLITE_OK && i<nSegment; i++){ 
+    WalHashLoc sLoc; 
 
-    rc = walHashGet(pWal, i, &sLoc);
+    rc = walHashGet(pWal, i, &sLoc); 
     if( rc==SQLITE_OK ){
       int j;                      /* Counter variable */
       int nEntry;                 /* Number of entries in this segment */
       ht_slot *aIndex;            /* Sorted index for this segment */
 
       if( (i+1)==nSegment ){
-        nEntry = (int)(iLast - sLoc.iZero);
+        nEntry = (int)(iLast - sLoc.iZero); 
       }else{
-        nEntry = (int)((u32*)sLoc.aHash - (u32*)sLoc.aPgno);
+        nEntry = (int)((u32*)sLoc.aHash - (u32*)sLoc.aPgno); 
       }
-      aIndex = &((ht_slot *)&p->aSegment[p->nSegment])[sLoc.iZero];
-      sLoc.iZero++;
+      aIndex = &((ht_slot *)&p->aSegment[p->nSegment])[sLoc.iZero]; 
+      sLoc.iZero++; 
 
       for(j=0; j<nEntry; j++){
         aIndex[j] = (ht_slot)j;
       }
-      walMergesort((u32 *)sLoc.aPgno, aTmp, aIndex, &nEntry);
-      p->aSegment[i].iZero = sLoc.iZero;
+      walMergesort((u32 *)sLoc.aPgno, aTmp, aIndex, &nEntry); 
+      p->aSegment[i].iZero = sLoc.iZero; 
       p->aSegment[i].nEntry = nEntry;
       p->aSegment[i].aIndex = aIndex;
-      p->aSegment[i].aPgno = (u32 *)sLoc.aPgno;
+      p->aSegment[i].aPgno = (u32 *)sLoc.aPgno; 
     }
   }
   sqlite3_free(aTmp);
 
   if( rc!=SQLITE_OK ){
     walIteratorFree(p);
-    p = 0;
+    p = 0; 
   }
   *pp = p;
   return rc;
@@ -62462,13 +62462,13 @@ static int walCheckpoint(
       }
     }
 
-    /* Allocate the iterator */
-    if( pInfo->nBackfill<mxSafeFrame ){
-      rc = walIteratorInit(pWal, pInfo->nBackfill, &pIter);
-      assert( rc==SQLITE_OK || pIter==0 );
-    }
-
-    if( pIter
+    /* Allocate the iterator */ 
+    if( pInfo->nBackfill<mxSafeFrame ){ 
+      rc = walIteratorInit(pWal, pInfo->nBackfill, &pIter); 
+      assert( rc==SQLITE_OK || pIter==0 ); 
+    } 
+ 
+    if( pIter 
      && (rc = walBusyLock(pWal,xBusy,pBusyArg,WAL_READ_LOCK(0),1))==SQLITE_OK
     ){
       u32 nBackfill = pInfo->nBackfill;
@@ -62483,7 +62483,7 @@ static int walCheckpoint(
       */
       if( rc==SQLITE_OK ){
         i64 nReq = ((i64)mxPage * szPage);
-        i64 nSize;                    /* Current size of database file */
+        i64 nSize;                    /* Current size of database file */ 
         sqlite3OsFileControl(pWal->pDbFd, SQLITE_FCNTL_CKPT_START, 0);
         rc = sqlite3OsFileSize(pWal->pDbFd, &nSize);
         if( rc==SQLITE_OK && nSize<nReq ){
@@ -63211,7 +63211,7 @@ static int walTryBeginRead(Wal *pWal, int *pChanged, int useWal, int cnt){
   }
 #endif
   for(i=1; i<WAL_NREADER; i++){
-    u32 thisMark = AtomicLoad(pInfo->aReadMark+i);
+    u32 thisMark = AtomicLoad(pInfo->aReadMark+i); 
     if( mxReadMark<=thisMark && thisMark<=mxFrame ){
       assert( thisMark!=READMARK_NOT_USED );
       mxReadMark = thisMark;
@@ -63277,9 +63277,9 @@ static int walTryBeginRead(Wal *pWal, int *pChanged, int useWal, int cnt){
   ** we can guarantee that the checkpointer that set nBackfill could not
   ** see any pages past pWal->hdr.mxFrame, this problem does not come up.
   */
-  pWal->minFrame = AtomicLoad(&pInfo->nBackfill)+1;
+  pWal->minFrame = AtomicLoad(&pInfo->nBackfill)+1; 
   walShmBarrier(pWal);
-  if( AtomicLoad(pInfo->aReadMark+mxI)!=mxReadMark
+  if( AtomicLoad(pInfo->aReadMark+mxI)!=mxReadMark 
    || memcmp((void *)walIndexHdr(pWal), &pWal->hdr, sizeof(WalIndexHdr))
   ){
     walUnlockShared(pWal, WAL_READ_LOCK(mxI));
@@ -63330,12 +63330,12 @@ SQLITE_PRIVATE int sqlite3WalSnapshotRecover(Wal *pWal){
       }else{
         u32 i = pInfo->nBackfillAttempted;
         for(i=pInfo->nBackfillAttempted; i>AtomicLoad(&pInfo->nBackfill); i--){
-          WalHashLoc sLoc;          /* Hash table location */
+          WalHashLoc sLoc;          /* Hash table location */ 
           u32 pgno;                 /* Page number in db file */
           i64 iDbOff;               /* Offset of db file entry */
           i64 iWalOff;              /* Offset of wal file entry */
 
-          rc = walHashGet(pWal, walFramePage(i), &sLoc);
+          rc = walHashGet(pWal, walFramePage(i), &sLoc); 
           if( rc!=SQLITE_OK ) break;
           assert( i - sLoc.iZero - 1 >=0 );
           pgno = sLoc.aPgno[i-sLoc.iZero-1];
@@ -63379,7 +63379,7 @@ SQLITE_PRIVATE int sqlite3WalSnapshotRecover(Wal *pWal){
 **
 ** If the database contents have changes since the previous read
 ** transaction, then *pChanged is set to 1 before returning.  The
-** Pager layer will use this to know that its cache is stale and
+** Pager layer will use this to know that its cache is stale and 
 ** needs to be flushed.
 */
 SQLITE_PRIVATE int sqlite3WalBeginReadTransaction(Wal *pWal, int *pChanged){
@@ -63556,21 +63556,21 @@ SQLITE_PRIVATE int sqlite3WalFindFrame(
   **     table after the current read-transaction had started.
   */
   iMinHash = walFramePage(pWal->minFrame);
-  for(iHash=walFramePage(iLast); iHash>=iMinHash; iHash--){
-    WalHashLoc sLoc;              /* Hash table location */
+  for(iHash=walFramePage(iLast); iHash>=iMinHash; iHash--){ 
+    WalHashLoc sLoc;              /* Hash table location */ 
     int iKey;                     /* Hash slot index */
     int nCollide;                 /* Number of hash collisions remaining */
     int rc;                       /* Error code */
     u32 iH;
 
-    rc = walHashGet(pWal, iHash, &sLoc);
+    rc = walHashGet(pWal, iHash, &sLoc); 
     if( rc!=SQLITE_OK ){
       return rc;
     }
     nCollide = HASHTABLE_NSLOT;
     iKey = walHash(pgno);
     while( (iH = AtomicLoad(&sLoc.aHash[iKey]))!=0 ){
-      u32 iFrame = iH + sLoc.iZero;
+      u32 iFrame = iH + sLoc.iZero; 
       if( iFrame<=iLast && iFrame>=pWal->minFrame && sLoc.aPgno[iH-1]==pgno ){
         assert( iFrame>iRead || CORRUPT_DB );
         iRead = iFrame;
@@ -63580,7 +63580,7 @@ SQLITE_PRIVATE int sqlite3WalFindFrame(
       }
       iKey = walNextHash(iKey);
     }
-    if( iRead ) break;
+    if( iRead ) break; 
   }
 
 #ifdef SQLITE_ENABLE_EXPENSIVE_ASSERT
@@ -64469,43 +64469,43 @@ SQLITE_API int sqlite3_snapshot_cmp(sqlite3_snapshot *p1, sqlite3_snapshot *p2){
   if( pHdr1->mxFrame>pHdr2->mxFrame ) return +1;
   return 0;
 }
-
-/*
-** The caller currently has a read transaction open on the database.
-** This function takes a SHARED lock on the CHECKPOINTER slot and then
+ 
+/* 
+** The caller currently has a read transaction open on the database. 
+** This function takes a SHARED lock on the CHECKPOINTER slot and then 
 ** checks if the snapshot passed as the second argument is still
-** available. If so, SQLITE_OK is returned.
-**
-** If the snapshot is not available, SQLITE_ERROR is returned. Or, if
-** the CHECKPOINTER lock cannot be obtained, SQLITE_BUSY. If any error
-** occurs (any value other than SQLITE_OK is returned), the CHECKPOINTER
-** lock is released before returning.
-*/
-SQLITE_PRIVATE int sqlite3WalSnapshotCheck(Wal *pWal, sqlite3_snapshot *pSnapshot){
-  int rc;
-  rc = walLockShared(pWal, WAL_CKPT_LOCK);
-  if( rc==SQLITE_OK ){
-    WalIndexHdr *pNew = (WalIndexHdr*)pSnapshot;
-    if( memcmp(pNew->aSalt, pWal->hdr.aSalt, sizeof(pWal->hdr.aSalt))
-     || pNew->mxFrame<walCkptInfo(pWal)->nBackfillAttempted
-    ){
-      rc = SQLITE_ERROR_SNAPSHOT;
-      walUnlockShared(pWal, WAL_CKPT_LOCK);
-    }
-  }
-  return rc;
-}
-
-/*
-** Release a lock obtained by an earlier successful call to
-** sqlite3WalSnapshotCheck().
-*/
-SQLITE_PRIVATE void sqlite3WalSnapshotUnlock(Wal *pWal){
-  assert( pWal );
-  walUnlockShared(pWal, WAL_CKPT_LOCK);
-}
-
-
+** available. If so, SQLITE_OK is returned. 
+** 
+** If the snapshot is not available, SQLITE_ERROR is returned. Or, if 
+** the CHECKPOINTER lock cannot be obtained, SQLITE_BUSY. If any error 
+** occurs (any value other than SQLITE_OK is returned), the CHECKPOINTER 
+** lock is released before returning. 
+*/ 
+SQLITE_PRIVATE int sqlite3WalSnapshotCheck(Wal *pWal, sqlite3_snapshot *pSnapshot){ 
+  int rc; 
+  rc = walLockShared(pWal, WAL_CKPT_LOCK); 
+  if( rc==SQLITE_OK ){ 
+    WalIndexHdr *pNew = (WalIndexHdr*)pSnapshot; 
+    if( memcmp(pNew->aSalt, pWal->hdr.aSalt, sizeof(pWal->hdr.aSalt)) 
+     || pNew->mxFrame<walCkptInfo(pWal)->nBackfillAttempted 
+    ){ 
+      rc = SQLITE_ERROR_SNAPSHOT; 
+      walUnlockShared(pWal, WAL_CKPT_LOCK); 
+    } 
+  } 
+  return rc; 
+} 
+ 
+/* 
+** Release a lock obtained by an earlier successful call to 
+** sqlite3WalSnapshotCheck(). 
+*/ 
+SQLITE_PRIVATE void sqlite3WalSnapshotUnlock(Wal *pWal){ 
+  assert( pWal ); 
+  walUnlockShared(pWal, WAL_CKPT_LOCK); 
+} 
+ 
+ 
 #endif /* SQLITE_ENABLE_SNAPSHOT */
 
 #ifdef SQLITE_ENABLE_ZIPVFS
@@ -64836,7 +64836,7 @@ struct MemPage {
   u16 maxLocal;        /* Copy of BtShared.maxLocal or BtShared.maxLeaf */
   u16 minLocal;        /* Copy of BtShared.minLocal or BtShared.minLeaf */
   u16 cellOffset;      /* Index in aData of first cell pointer */
-  int nFree;           /* Number of free bytes on the page. -1 for unknown */
+  int nFree;           /* Number of free bytes on the page. -1 for unknown */ 
   u16 nCell;           /* Number of cells on this page, local and ovfl */
   u16 maskPage;        /* Mask for page offset */
   u16 aiOvfl[4];       /* Insert the i-th overflow cell before the aiOvfl-th
@@ -65060,31 +65060,31 @@ struct CellInfo {
 ** found at self->pBt->mutex.
 **
 ** skipNext meaning:
-** The meaning of skipNext depends on the value of eState:
-**
-**   eState            Meaning of skipNext
-**   VALID             skipNext is meaningless and is ignored
-**   INVALID           skipNext is meaningless and is ignored
-**   SKIPNEXT          sqlite3BtreeNext() is a no-op if skipNext>0 and
-**                     sqlite3BtreePrevious() is no-op if skipNext<0.
-**   REQUIRESEEK       restoreCursorPosition() restores the cursor to
-**                     eState=SKIPNEXT if skipNext!=0
-**   FAULT             skipNext holds the cursor fault error code.
+** The meaning of skipNext depends on the value of eState: 
+** 
+**   eState            Meaning of skipNext 
+**   VALID             skipNext is meaningless and is ignored 
+**   INVALID           skipNext is meaningless and is ignored 
+**   SKIPNEXT          sqlite3BtreeNext() is a no-op if skipNext>0 and 
+**                     sqlite3BtreePrevious() is no-op if skipNext<0. 
+**   REQUIRESEEK       restoreCursorPosition() restores the cursor to 
+**                     eState=SKIPNEXT if skipNext!=0 
+**   FAULT             skipNext holds the cursor fault error code. 
 */
 struct BtCursor {
   u8 eState;                /* One of the CURSOR_XXX constants (see below) */
   u8 curFlags;              /* zero or more BTCF_* flags defined below */
   u8 curPagerFlags;         /* Flags to send to sqlite3PagerGet() */
   u8 hints;                 /* As configured by CursorSetHints() */
-  int skipNext;    /* Prev() is noop if negative. Next() is noop if positive.
-                   ** Error code if eState==CURSOR_FAULT */
+  int skipNext;    /* Prev() is noop if negative. Next() is noop if positive. 
+                   ** Error code if eState==CURSOR_FAULT */ 
   Btree *pBtree;            /* The Btree to which this cursor belongs */
-  Pgno *aOverflow;          /* Cache of overflow page locations */
-  void *pKey;               /* Saved key that was cursor last known position */
-  /* All fields above are zeroed when the cursor is allocated.  See
-  ** sqlite3BtreeCursorZero().  Fields that follow must be manually
-  ** initialized. */
-#define BTCURSOR_FIRST_UNINIT pBt   /* Name of first uninitialized field */
+  Pgno *aOverflow;          /* Cache of overflow page locations */ 
+  void *pKey;               /* Saved key that was cursor last known position */ 
+  /* All fields above are zeroed when the cursor is allocated.  See 
+  ** sqlite3BtreeCursorZero().  Fields that follow must be manually 
+  ** initialized. */ 
+#define BTCURSOR_FIRST_UNINIT pBt   /* Name of first uninitialized field */ 
   BtShared *pBt;            /* The BtShared this cursor points to */
   BtCursor *pNext;          /* Forms a linked list of all cursors */
   CellInfo info;            /* A parse of the cell we are pointing at */
@@ -65140,8 +65140,8 @@ struct BtCursor {
 **   Do nothing else with this cursor.  Any attempt to use the cursor
 **   should return the error code stored in BtCursor.skipNext
 */
-#define CURSOR_VALID             0
-#define CURSOR_INVALID           1
+#define CURSOR_VALID             0 
+#define CURSOR_INVALID           1 
 #define CURSOR_SKIPNEXT          2
 #define CURSOR_REQUIRESEEK       3
 #define CURSOR_FAULT             4
@@ -65460,10 +65460,10 @@ static void SQLITE_NOINLINE btreeEnterAll(sqlite3 *db){
       skipOk = 0;
     }
   }
-  db->noSharedCache = skipOk;
+  db->noSharedCache = skipOk; 
 }
 SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){
-  if( db->noSharedCache==0 ) btreeEnterAll(db);
+  if( db->noSharedCache==0 ) btreeEnterAll(db); 
 }
 static void SQLITE_NOINLINE btreeLeaveAll(sqlite3 *db){
   int i;
@@ -65475,7 +65475,7 @@ static void SQLITE_NOINLINE btreeLeaveAll(sqlite3 *db){
   }
 }
 SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3 *db){
-  if( db->noSharedCache==0 ) btreeLeaveAll(db);
+  if( db->noSharedCache==0 ) btreeLeaveAll(db); 
 }
 
 #ifndef NDEBUG
@@ -66249,19 +66249,19 @@ static int saveCursorKey(BtCursor *pCur){
     /* Only the rowid is required for a table btree */
     pCur->nKey = sqlite3BtreeIntegerKey(pCur);
   }else{
-    /* For an index btree, save the complete key content. It is possible
-    ** that the current key is corrupt. In that case, it is possible that
-    ** the sqlite3VdbeRecordUnpack() function may overread the buffer by
+    /* For an index btree, save the complete key content. It is possible 
+    ** that the current key is corrupt. In that case, it is possible that 
+    ** the sqlite3VdbeRecordUnpack() function may overread the buffer by 
     ** up to the size of 1 varint plus 1 8-byte value when the cursor
     ** position is restored. Hence the 17 bytes of padding allocated
-    ** below. */
+    ** below. */ 
     void *pKey;
     pCur->nKey = sqlite3BtreePayloadSize(pCur);
-    pKey = sqlite3Malloc( pCur->nKey + 9 + 8 );
+    pKey = sqlite3Malloc( pCur->nKey + 9 + 8 ); 
     if( pKey ){
       rc = sqlite3BtreePayload(pCur, 0, (int)pCur->nKey, pKey);
       if( rc==SQLITE_OK ){
-        memset(((u8*)pKey)+pCur->nKey, 0, 9+8);
+        memset(((u8*)pKey)+pCur->nKey, 0, 9+8); 
         pCur->pKey = pKey;
       }else{
         sqlite3_free(pKey);
@@ -66396,12 +66396,12 @@ static int btreeMoveto(
   UnpackedRecord *pIdxKey;   /* Unpacked index key */
 
   if( pKey ){
-    KeyInfo *pKeyInfo = pCur->pKeyInfo;
+    KeyInfo *pKeyInfo = pCur->pKeyInfo; 
     assert( nKey==(i64)(int)nKey );
-    pIdxKey = sqlite3VdbeAllocUnpackedRecord(pKeyInfo);
+    pIdxKey = sqlite3VdbeAllocUnpackedRecord(pKeyInfo); 
     if( pIdxKey==0 ) return SQLITE_NOMEM_BKPT;
-    sqlite3VdbeRecordUnpack(pKeyInfo, (int)nKey, pKey, pIdxKey);
-    if( pIdxKey->nField==0 || pIdxKey->nField>pKeyInfo->nAllField ){
+    sqlite3VdbeRecordUnpack(pKeyInfo, (int)nKey, pKey, pIdxKey); 
+    if( pIdxKey->nField==0 || pIdxKey->nField>pKeyInfo->nAllField ){ 
       rc = SQLITE_CORRUPT_BKPT;
     }else{
       rc = sqlite3BtreeIndexMoveto(pCur, pIdxKey, pRes);
@@ -66423,23 +66423,23 @@ static int btreeMoveto(
 */
 static int btreeRestoreCursorPosition(BtCursor *pCur){
   int rc;
-  int skipNext = 0;
+  int skipNext = 0; 
   assert( cursorOwnsBtShared(pCur) );
   assert( pCur->eState>=CURSOR_REQUIRESEEK );
   if( pCur->eState==CURSOR_FAULT ){
     return pCur->skipNext;
   }
   pCur->eState = CURSOR_INVALID;
-  if( sqlite3FaultSim(410) ){
-    rc = SQLITE_IOERR;
-  }else{
-    rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext);
-  }
+  if( sqlite3FaultSim(410) ){ 
+    rc = SQLITE_IOERR; 
+  }else{ 
+    rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext); 
+  } 
   if( rc==SQLITE_OK ){
     sqlite3_free(pCur->pKey);
     pCur->pKey = 0;
     assert( pCur->eState==CURSOR_VALID || pCur->eState==CURSOR_INVALID );
-    if( skipNext ) pCur->skipNext = skipNext;
+    if( skipNext ) pCur->skipNext = skipNext; 
     if( pCur->skipNext && pCur->eState==CURSOR_VALID ){
       pCur->eState = CURSOR_SKIPNEXT;
     }
@@ -66465,11 +66465,11 @@ static int btreeRestoreCursorPosition(BtCursor *pCur){
 ** back to where it ought to be if this routine returns true.
 */
 SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor *pCur){
-  assert( EIGHT_BYTE_ALIGNMENT(pCur)
-       || pCur==sqlite3BtreeFakeValidCursor() );
-  assert( offsetof(BtCursor, eState)==0 );
-  assert( sizeof(pCur->eState)==1 );
-  return CURSOR_VALID != *(u8*)pCur;
+  assert( EIGHT_BYTE_ALIGNMENT(pCur) 
+       || pCur==sqlite3BtreeFakeValidCursor() ); 
+  assert( offsetof(BtCursor, eState)==0 ); 
+  assert( sizeof(pCur->eState)==1 ); 
+  return CURSOR_VALID != *(u8*)pCur; 
 }
 
 /*
@@ -66592,13 +66592,13 @@ static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){
     *pRC = rc;
     return;
   }
-  if( ((char*)sqlite3PagerGetExtra(pDbPage))[0]!=0 ){
-    /* The first byte of the extra data is the MemPage.isInit byte.
-    ** If that byte is set, it means this page is also being used
-    ** as a btree page. */
-    *pRC = SQLITE_CORRUPT_BKPT;
-    goto ptrmap_exit;
-  }
+  if( ((char*)sqlite3PagerGetExtra(pDbPage))[0]!=0 ){ 
+    /* The first byte of the extra data is the MemPage.isInit byte. 
+    ** If that byte is set, it means this page is also being used 
+    ** as a btree page. */ 
+    *pRC = SQLITE_CORRUPT_BKPT; 
+    goto ptrmap_exit; 
+  } 
   offset = PTRMAP_PTROFFSET(iPtrmap, key);
   if( offset<0 ){
     *pRC = SQLITE_CORRUPT_BKPT;
@@ -66661,7 +66661,7 @@ static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){
 #else /* if defined SQLITE_OMIT_AUTOVACUUM */
   #define ptrmapPut(w,x,y,z,rc)
   #define ptrmapGet(w,x,y,z) SQLITE_OK
-  #define ptrmapPutOvflPtr(x, y, z, rc)
+  #define ptrmapPutOvflPtr(x, y, z, rc) 
 #endif
 
 /*
@@ -66972,24 +66972,24 @@ static u16 cellSize(MemPage *pPage, int iCell){
 
 #ifndef SQLITE_OMIT_AUTOVACUUM
 /*
-** The cell pCell is currently part of page pSrc but will ultimately be part
-** of pPage.  (pSrc and pPager are often the same.)  If pCell contains a
-** pointer to an overflow page, insert an entry into the pointer-map for
-** the overflow page that will be valid after pCell has been moved to pPage.
+** The cell pCell is currently part of page pSrc but will ultimately be part 
+** of pPage.  (pSrc and pPager are often the same.)  If pCell contains a 
+** pointer to an overflow page, insert an entry into the pointer-map for 
+** the overflow page that will be valid after pCell has been moved to pPage. 
 */
-static void ptrmapPutOvflPtr(MemPage *pPage, MemPage *pSrc, u8 *pCell,int *pRC){
+static void ptrmapPutOvflPtr(MemPage *pPage, MemPage *pSrc, u8 *pCell,int *pRC){ 
   CellInfo info;
   if( *pRC ) return;
   assert( pCell!=0 );
   pPage->xParseCell(pPage, pCell, &info);
   if( info.nLocal<info.nPayload ){
-    Pgno ovfl;
-    if( SQLITE_WITHIN(pSrc->aDataEnd, pCell, pCell+info.nLocal) ){
-      testcase( pSrc!=pPage );
-      *pRC = SQLITE_CORRUPT_BKPT;
-      return;
-    }
-    ovfl = get4byte(&pCell[info.nSize-4]);
+    Pgno ovfl; 
+    if( SQLITE_WITHIN(pSrc->aDataEnd, pCell, pCell+info.nLocal) ){ 
+      testcase( pSrc!=pPage ); 
+      *pRC = SQLITE_CORRUPT_BKPT; 
+      return; 
+    } 
+    ovfl = get4byte(&pCell[info.nSize-4]); 
     ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno, pRC);
   }
 }
@@ -67034,7 +67034,7 @@ static int defragmentPage(MemPage *pPage, int nMaxFrag){
   hdr = pPage->hdrOffset;
   cellOffset = pPage->cellOffset;
   nCell = pPage->nCell;
-  assert( nCell==get2byte(&data[hdr+3]) || CORRUPT_DB );
+  assert( nCell==get2byte(&data[hdr+3]) || CORRUPT_DB ); 
   iCellFirst = cellOffset + 2*nCell;
   usableSize = pPage->pBt->usableSize;
 
@@ -67045,10 +67045,10 @@ static int defragmentPage(MemPage *pPage, int nMaxFrag){
   ** reconstruct the entire page.  */
   if( (int)data[hdr+7]<=nMaxFrag ){
     int iFree = get2byte(&data[hdr+1]);
-    if( iFree>usableSize-4 ) return SQLITE_CORRUPT_PAGE(pPage);
+    if( iFree>usableSize-4 ) return SQLITE_CORRUPT_PAGE(pPage); 
     if( iFree ){
       int iFree2 = get2byte(&data[iFree]);
-      if( iFree2>usableSize-4 ) return SQLITE_CORRUPT_PAGE(pPage);
+      if( iFree2>usableSize-4 ) return SQLITE_CORRUPT_PAGE(pPage); 
       if( 0==iFree2 || (data[iFree2]==0 && data[iFree2+1]==0) ){
         u8 *pEnd = &data[cellOffset + nCell*2];
         u8 *pAddr;
@@ -67059,15 +67059,15 @@ static int defragmentPage(MemPage *pPage, int nMaxFrag){
           return SQLITE_CORRUPT_PAGE(pPage);
         }
         if( iFree2 ){
-          if( iFree+sz>iFree2 ) return SQLITE_CORRUPT_PAGE(pPage);
+          if( iFree+sz>iFree2 ) return SQLITE_CORRUPT_PAGE(pPage); 
           sz2 = get2byte(&data[iFree2+2]);
-          if( iFree2+sz2 > usableSize ) return SQLITE_CORRUPT_PAGE(pPage);
+          if( iFree2+sz2 > usableSize ) return SQLITE_CORRUPT_PAGE(pPage); 
           memmove(&data[iFree+sz+sz2], &data[iFree+sz], iFree2-(iFree+sz));
           sz += sz2;
         }else if( NEVER(iFree+sz>usableSize) ){
-          return SQLITE_CORRUPT_PAGE(pPage);
+          return SQLITE_CORRUPT_PAGE(pPage); 
         }
-
+ 
         cbrk = top+sz;
         assert( cbrk+(iFree-top) <= usableSize );
         memmove(&data[cbrk], &data[top], iFree-top);
@@ -67117,7 +67117,7 @@ static int defragmentPage(MemPage *pPage, int nMaxFrag){
   data[hdr+7] = 0;
 
  defragment_out:
-  assert( pPage->nFree>=0 );
+  assert( pPage->nFree>=0 ); 
   if( data[hdr+7]+cbrk-iCellFirst!=pPage->nFree ){
     return SQLITE_CORRUPT_PAGE(pPage);
   }
@@ -67145,16 +67145,16 @@ static int defragmentPage(MemPage *pPage, int nMaxFrag){
 ** causes the fragmentation count to exceed 60.
 */
 static u8 *pageFindSlot(MemPage *pPg, int nByte, int *pRc){
-  const int hdr = pPg->hdrOffset;            /* Offset to page header */
-  u8 * const aData = pPg->aData;             /* Page data */
-  int iAddr = hdr + 1;                       /* Address of ptr to pc */
-  int pc = get2byte(&aData[iAddr]);          /* Address of a free slot */
-  int x;                                     /* Excess size of the slot */
-  int maxPC = pPg->pBt->usableSize - nByte;  /* Max address for a usable slot */
-  int size;                                  /* Size of the free slot */
+  const int hdr = pPg->hdrOffset;            /* Offset to page header */ 
+  u8 * const aData = pPg->aData;             /* Page data */ 
+  int iAddr = hdr + 1;                       /* Address of ptr to pc */ 
+  int pc = get2byte(&aData[iAddr]);          /* Address of a free slot */ 
+  int x;                                     /* Excess size of the slot */ 
+  int maxPC = pPg->pBt->usableSize - nByte;  /* Max address for a usable slot */ 
+  int size;                                  /* Size of the free slot */ 
 
   assert( pc>0 );
-  while( pc<=maxPC ){
+  while( pc<=maxPC ){ 
     /* EVIDENCE-OF: R-22710-53328 The third and fourth bytes of each
     ** freeblock form a big-endian integer which is the size of the freeblock
     ** in bytes, including the 4-byte header. */
@@ -67162,7 +67162,7 @@ static u8 *pageFindSlot(MemPage *pPg, int nByte, int *pRc){
     if( (x = size - nByte)>=0 ){
       testcase( x==4 );
       testcase( x==3 );
-      if( x<4 ){
+      if( x<4 ){ 
         /* EVIDENCE-OF: R-11498-58022 In a well-formed b-tree page, the total
         ** number of bytes in fragments may not exceed 60. */
         if( aData[hdr+7]>57 ) return 0;
@@ -67171,29 +67171,29 @@ static u8 *pageFindSlot(MemPage *pPg, int nByte, int *pRc){
         ** fragmented bytes within the page. */
         memcpy(&aData[iAddr], &aData[pc], 2);
         aData[hdr+7] += (u8)x;
-      }else if( x+pc > maxPC ){
-        /* This slot extends off the end of the usable part of the page */
-        *pRc = SQLITE_CORRUPT_PAGE(pPg);
-        return 0;
+      }else if( x+pc > maxPC ){ 
+        /* This slot extends off the end of the usable part of the page */ 
+        *pRc = SQLITE_CORRUPT_PAGE(pPg); 
+        return 0; 
       }else{
         /* The slot remains on the free-list. Reduce its size to account
-        ** for the portion used by the new allocation. */
+        ** for the portion used by the new allocation. */ 
         put2byte(&aData[pc+2], x);
       }
       return &aData[pc + x];
     }
     iAddr = pc;
     pc = get2byte(&aData[pc]);
-    if( pc<=iAddr+size ){
-      if( pc ){
-        /* The next slot in the chain is not past the end of the current slot */
-        *pRc = SQLITE_CORRUPT_PAGE(pPg);
-      }
-      return 0;
-    }
-  }
-  if( pc>maxPC+nByte-4 ){
-    /* The free slot chain extends off the end of the page */
+    if( pc<=iAddr+size ){ 
+      if( pc ){ 
+        /* The next slot in the chain is not past the end of the current slot */ 
+        *pRc = SQLITE_CORRUPT_PAGE(pPg); 
+      } 
+      return 0; 
+    } 
+  }
+  if( pc>maxPC+nByte-4 ){ 
+    /* The free slot chain extends off the end of the page */ 
     *pRc = SQLITE_CORRUPT_PAGE(pPg);
   }
   return 0;
@@ -67236,7 +67236,7 @@ static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){
   ** However, that integer is too large to be stored in a 2-byte unsigned
   ** integer, so a value of 0 is used in its place. */
   top = get2byte(&data[hdr+5]);
-  assert( top<=(int)pPage->pBt->usableSize ); /* by btreeComputeFreeSpace() */
+  assert( top<=(int)pPage->pBt->usableSize ); /* by btreeComputeFreeSpace() */ 
   if( gap>top ){
     if( top==0 && pPage->pBt->usableSize==65536 ){
       top = 65536;
@@ -67245,9 +67245,9 @@ static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){
     }
   }
 
-  /* If there is enough space between gap and top for one more cell pointer,
-  ** and if the freelist is not empty, then search the
-  ** freelist looking for a slot big enough to satisfy the request.
+  /* If there is enough space between gap and top for one more cell pointer, 
+  ** and if the freelist is not empty, then search the 
+  ** freelist looking for a slot big enough to satisfy the request. 
   */
   testcase( gap+2==top );
   testcase( gap+1==top );
@@ -67274,7 +67274,7 @@ static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){
   testcase( gap+2+nByte==top );
   if( gap+2+nByte>top ){
     assert( pPage->nCell>0 || CORRUPT_DB );
-    assert( pPage->nFree>=0 );
+    assert( pPage->nFree>=0 ); 
     rc = defragmentPage(pPage, MIN(4, pPage->nFree - (2+nByte)));
     if( rc ) return rc;
     top = get2byteNotZero(&data[hdr+5]);
@@ -67283,7 +67283,7 @@ static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){
 
 
   /* Allocate memory from the gap in between the cell pointer array
-  ** and the cell content area.  The btreeComputeFreeSpace() call has already
+  ** and the cell content area.  The btreeComputeFreeSpace() call has already 
   ** validated the freelist.  Given that the freelist is valid, there
   ** is no way that the allocation can extend off the end of the page.
   ** The assert() below verifies the previous sentence.
@@ -67302,7 +67302,7 @@ static int allocateSpace(MemPage *pPage, int nByte, int *pIdx){
 **
 ** Adjacent freeblocks are coalesced.
 **
-** Even though the freeblock list was checked by btreeComputeFreeSpace(),
+** Even though the freeblock list was checked by btreeComputeFreeSpace(), 
 ** that routine will not detect overlap between cells or freeblocks.  Nor
 ** does it detect cells or freeblocks that encrouch into the reserved bytes
 ** at the end of the page.  So do additional corruption checks inside this
@@ -67465,10 +67465,10 @@ static int decodeFlags(MemPage *pPage, int flagByte){
 }
 
 /*
-** Compute the amount of freespace on the page.  In other words, fill
-** in the pPage->nFree field.
+** Compute the amount of freespace on the page.  In other words, fill 
+** in the pPage->nFree field. 
 */
-static int btreeComputeFreeSpace(MemPage *pPage){
+static int btreeComputeFreeSpace(MemPage *pPage){ 
   int pc;            /* Address of a freeblock within pPage->aData[] */
   u8 hdr;            /* Offset to beginning of page header */
   u8 *data;          /* Equal to pPage->aData */
@@ -67484,17 +67484,17 @@ static int btreeComputeFreeSpace(MemPage *pPage){
   assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
   assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) );
   assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
-  assert( pPage->isInit==1 );
-  assert( pPage->nFree<0 );
+  assert( pPage->isInit==1 ); 
+  assert( pPage->nFree<0 ); 
 
-  usableSize = pPage->pBt->usableSize;
+  usableSize = pPage->pBt->usableSize; 
   hdr = pPage->hdrOffset;
   data = pPage->aData;
   /* EVIDENCE-OF: R-58015-48175 The two-byte integer at offset 5 designates
   ** the start of the cell content area. A zero value for this integer is
   ** interpreted as 65536. */
   top = get2byteNotZero(&data[hdr+5]);
-  iCellFirst = hdr + 8 + pPage->childPtrSize + 2*pPage->nCell;
+  iCellFirst = hdr + 8 + pPage->childPtrSize + 2*pPage->nCell; 
   iCellLast = usableSize - 4;
 
   /* Compute the total free space on the page
@@ -67539,104 +67539,104 @@ static int btreeComputeFreeSpace(MemPage *pPage){
   ** serves to verify that the offset to the start of the cell-content
   ** area, according to the page header, lies within the page.
   */
-  if( nFree>usableSize || nFree<iCellFirst ){
+  if( nFree>usableSize || nFree<iCellFirst ){ 
     return SQLITE_CORRUPT_PAGE(pPage);
   }
   pPage->nFree = (u16)(nFree - iCellFirst);
-  return SQLITE_OK;
-}
-
-/*
-** Do additional sanity check after btreeInitPage() if
+  return SQLITE_OK; 
+} 
+ 
+/* 
+** Do additional sanity check after btreeInitPage() if 
 ** PRAGMA cell_size_check=ON
-*/
-static SQLITE_NOINLINE int btreeCellSizeCheck(MemPage *pPage){
-  int iCellFirst;    /* First allowable cell or freeblock offset */
-  int iCellLast;     /* Last possible cell or freeblock offset */
-  int i;             /* Index into the cell pointer array */
-  int sz;            /* Size of a cell */
-  int pc;            /* Address of a freeblock within pPage->aData[] */
-  u8 *data;          /* Equal to pPage->aData */
-  int usableSize;    /* Maximum usable space on the page */
-  int cellOffset;    /* Start of cell content area */
-
-  iCellFirst = pPage->cellOffset + 2*pPage->nCell;
-  usableSize = pPage->pBt->usableSize;
-  iCellLast = usableSize - 4;
-  data = pPage->aData;
-  cellOffset = pPage->cellOffset;
-  if( !pPage->leaf ) iCellLast--;
-  for(i=0; i<pPage->nCell; i++){
-    pc = get2byteAligned(&data[cellOffset+i*2]);
-    testcase( pc==iCellFirst );
-    testcase( pc==iCellLast );
-    if( pc<iCellFirst || pc>iCellLast ){
-      return SQLITE_CORRUPT_PAGE(pPage);
-    }
-    sz = pPage->xCellSize(pPage, &data[pc]);
-    testcase( pc+sz==usableSize );
-    if( pc+sz>usableSize ){
-      return SQLITE_CORRUPT_PAGE(pPage);
-    }
-  }
-  return SQLITE_OK;
-}
-
-/*
-** Initialize the auxiliary information for a disk block.
-**
-** Return SQLITE_OK on success.  If we see that the page does
+*/ 
+static SQLITE_NOINLINE int btreeCellSizeCheck(MemPage *pPage){ 
+  int iCellFirst;    /* First allowable cell or freeblock offset */ 
+  int iCellLast;     /* Last possible cell or freeblock offset */ 
+  int i;             /* Index into the cell pointer array */ 
+  int sz;            /* Size of a cell */ 
+  int pc;            /* Address of a freeblock within pPage->aData[] */ 
+  u8 *data;          /* Equal to pPage->aData */ 
+  int usableSize;    /* Maximum usable space on the page */ 
+  int cellOffset;    /* Start of cell content area */ 
+ 
+  iCellFirst = pPage->cellOffset + 2*pPage->nCell; 
+  usableSize = pPage->pBt->usableSize; 
+  iCellLast = usableSize - 4; 
+  data = pPage->aData; 
+  cellOffset = pPage->cellOffset; 
+  if( !pPage->leaf ) iCellLast--; 
+  for(i=0; i<pPage->nCell; i++){ 
+    pc = get2byteAligned(&data[cellOffset+i*2]); 
+    testcase( pc==iCellFirst ); 
+    testcase( pc==iCellLast ); 
+    if( pc<iCellFirst || pc>iCellLast ){ 
+      return SQLITE_CORRUPT_PAGE(pPage); 
+    } 
+    sz = pPage->xCellSize(pPage, &data[pc]); 
+    testcase( pc+sz==usableSize ); 
+    if( pc+sz>usableSize ){ 
+      return SQLITE_CORRUPT_PAGE(pPage); 
+    } 
+  } 
+  return SQLITE_OK; 
+} 
+ 
+/* 
+** Initialize the auxiliary information for a disk block. 
+** 
+** Return SQLITE_OK on success.  If we see that the page does 
 ** not contain a well-formed database page, then return
-** SQLITE_CORRUPT.  Note that a return of SQLITE_OK does not
-** guarantee that the page is well-formed.  It only shows that
-** we failed to detect any corruption.
-*/
-static int btreeInitPage(MemPage *pPage){
-  u8 *data;          /* Equal to pPage->aData */
-  BtShared *pBt;        /* The main btree structure */
-
-  assert( pPage->pBt!=0 );
-  assert( pPage->pBt->db!=0 );
-  assert( sqlite3_mutex_held(pPage->pBt->mutex) );
-  assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
-  assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) );
-  assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
-  assert( pPage->isInit==0 );
-
-  pBt = pPage->pBt;
-  data = pPage->aData + pPage->hdrOffset;
-  /* EVIDENCE-OF: R-28594-02890 The one-byte flag at offset 0 indicating
-  ** the b-tree page type. */
-  if( decodeFlags(pPage, data[0]) ){
-    return SQLITE_CORRUPT_PAGE(pPage);
-  }
-  assert( pBt->pageSize>=512 && pBt->pageSize<=65536 );
-  pPage->maskPage = (u16)(pBt->pageSize - 1);
-  pPage->nOverflow = 0;
-  pPage->cellOffset = pPage->hdrOffset + 8 + pPage->childPtrSize;
-  pPage->aCellIdx = data + pPage->childPtrSize + 8;
-  pPage->aDataEnd = pPage->aData + pBt->usableSize;
-  pPage->aDataOfst = pPage->aData + pPage->childPtrSize;
-  /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the
-  ** number of cells on the page. */
-  pPage->nCell = get2byte(&data[3]);
-  if( pPage->nCell>MX_CELL(pBt) ){
-    /* To many cells for a single page.  The page must be corrupt */
-    return SQLITE_CORRUPT_PAGE(pPage);
-  }
-  testcase( pPage->nCell==MX_CELL(pBt) );
-  /* EVIDENCE-OF: R-24089-57979 If a page contains no cells (which is only
-  ** possible for a root page of a table that contains no rows) then the
-  ** offset to the cell content area will equal the page size minus the
-  ** bytes of reserved space. */
-  assert( pPage->nCell>0
-       || get2byteNotZero(&data[5])==(int)pBt->usableSize
-       || CORRUPT_DB );
-  pPage->nFree = -1;  /* Indicate that this value is yet uncomputed */
+** SQLITE_CORRUPT.  Note that a return of SQLITE_OK does not 
+** guarantee that the page is well-formed.  It only shows that 
+** we failed to detect any corruption. 
+*/ 
+static int btreeInitPage(MemPage *pPage){ 
+  u8 *data;          /* Equal to pPage->aData */ 
+  BtShared *pBt;        /* The main btree structure */ 
+ 
+  assert( pPage->pBt!=0 ); 
+  assert( pPage->pBt->db!=0 ); 
+  assert( sqlite3_mutex_held(pPage->pBt->mutex) ); 
+  assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) ); 
+  assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) ); 
+  assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) ); 
+  assert( pPage->isInit==0 ); 
+ 
+  pBt = pPage->pBt; 
+  data = pPage->aData + pPage->hdrOffset; 
+  /* EVIDENCE-OF: R-28594-02890 The one-byte flag at offset 0 indicating 
+  ** the b-tree page type. */ 
+  if( decodeFlags(pPage, data[0]) ){ 
+    return SQLITE_CORRUPT_PAGE(pPage); 
+  } 
+  assert( pBt->pageSize>=512 && pBt->pageSize<=65536 ); 
+  pPage->maskPage = (u16)(pBt->pageSize - 1); 
+  pPage->nOverflow = 0; 
+  pPage->cellOffset = pPage->hdrOffset + 8 + pPage->childPtrSize; 
+  pPage->aCellIdx = data + pPage->childPtrSize + 8; 
+  pPage->aDataEnd = pPage->aData + pBt->usableSize; 
+  pPage->aDataOfst = pPage->aData + pPage->childPtrSize; 
+  /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the 
+  ** number of cells on the page. */ 
+  pPage->nCell = get2byte(&data[3]); 
+  if( pPage->nCell>MX_CELL(pBt) ){ 
+    /* To many cells for a single page.  The page must be corrupt */ 
+    return SQLITE_CORRUPT_PAGE(pPage); 
+  } 
+  testcase( pPage->nCell==MX_CELL(pBt) ); 
+  /* EVIDENCE-OF: R-24089-57979 If a page contains no cells (which is only 
+  ** possible for a root page of a table that contains no rows) then the 
+  ** offset to the cell content area will equal the page size minus the 
+  ** bytes of reserved space. */ 
+  assert( pPage->nCell>0 
+       || get2byteNotZero(&data[5])==(int)pBt->usableSize 
+       || CORRUPT_DB ); 
+  pPage->nFree = -1;  /* Indicate that this value is yet uncomputed */ 
   pPage->isInit = 1;
-  if( pBt->db->flags & SQLITE_CellSizeCk ){
-    return btreeCellSizeCheck(pPage);
-  }
+  if( pBt->db->flags & SQLITE_CellSizeCk ){ 
+    return btreeCellSizeCheck(pPage); 
+  } 
   return SQLITE_OK;
 }
 
@@ -67778,18 +67778,18 @@ static int getAndInitPage(
 
   if( pgno>btreePagecount(pBt) ){
     rc = SQLITE_CORRUPT_BKPT;
-    goto getAndInitPage_error1;
+    goto getAndInitPage_error1; 
   }
   rc = sqlite3PagerGet(pBt->pPager, pgno, (DbPage**)&pDbPage, bReadOnly);
   if( rc ){
-    goto getAndInitPage_error1;
+    goto getAndInitPage_error1; 
   }
   *ppPage = (MemPage*)sqlite3PagerGetExtra(pDbPage);
   if( (*ppPage)->isInit==0 ){
     btreePageFromDbPage(pDbPage, pgno, pBt);
     rc = btreeInitPage(*ppPage);
     if( rc!=SQLITE_OK ){
-      goto getAndInitPage_error2;
+      goto getAndInitPage_error2; 
     }
   }
   assert( (*ppPage)->pgno==pgno );
@@ -67799,13 +67799,13 @@ static int getAndInitPage(
   ** compatible with the root page. */
   if( pCur && ((*ppPage)->nCell<1 || (*ppPage)->intKey!=pCur->curIntKey) ){
     rc = SQLITE_CORRUPT_PGNO(pgno);
-    goto getAndInitPage_error2;
+    goto getAndInitPage_error2; 
   }
   return SQLITE_OK;
 
-getAndInitPage_error2:
-  releasePage(*ppPage);
-getAndInitPage_error1:
+getAndInitPage_error2: 
+  releasePage(*ppPage); 
+getAndInitPage_error1: 
   if( pCur ){
     pCur->iPage--;
     pCur->pPage = pCur->apPage[pCur->iPage];
@@ -68090,7 +68090,7 @@ SQLITE_PRIVATE int sqlite3BtreeOpen(
     }
     pBt->openFlags = (u8)flags;
     pBt->db = db;
-    sqlite3PagerSetBusyHandler(pBt->pPager, btreeInvokeBusyHandler, pBt);
+    sqlite3PagerSetBusyHandler(pBt->pPager, btreeInvokeBusyHandler, pBt); 
     p->pBt = pBt;
 
     pBt->pCursor = 0;
@@ -68653,10 +68653,10 @@ static void setDefaultSyncFlag(BtShared *pBt, u8 safety_level){
 # define setDefaultSyncFlag(pBt,safety_level)
 #endif
 
-/* Forward declaration */
-static int newDatabase(BtShared*);
-
-
+/* Forward declaration */ 
+static int newDatabase(BtShared*); 
+ 
+ 
 /*
 ** Get a reference to pPage1 of the database file.  This will
 ** also acquire a readlock on that file.
@@ -68669,8 +68669,8 @@ static int newDatabase(BtShared*);
 static int lockBtree(BtShared *pBt){
   int rc;              /* Result code from subfunctions */
   MemPage *pPage1;     /* Page 1 of the database file */
-  u32 nPage;           /* Number of pages in the database */
-  u32 nPageFile = 0;   /* Number of pages in the database file */
+  u32 nPage;           /* Number of pages in the database */ 
+  u32 nPageFile = 0;   /* Number of pages in the database file */ 
 
   assert( sqlite3_mutex_held(pBt->mutex) );
   assert( pBt->pPage1==0 );
@@ -68683,13 +68683,13 @@ static int lockBtree(BtShared *pBt){
   ** a valid database file.
   */
   nPage = get4byte(28+(u8*)pPage1->aData);
-  sqlite3PagerPagecount(pBt->pPager, (int*)&nPageFile);
+  sqlite3PagerPagecount(pBt->pPager, (int*)&nPageFile); 
   if( nPage==0 || memcmp(24+(u8*)pPage1->aData, 92+(u8*)pPage1->aData,4)!=0 ){
     nPage = nPageFile;
   }
-  if( (pBt->db->flags & SQLITE_ResetDatabase)!=0 ){
-    nPage = 0;
-  }
+  if( (pBt->db->flags & SQLITE_ResetDatabase)!=0 ){ 
+    nPage = 0; 
+  } 
   if( nPage>0 ){
     u32 pageSize;
     u32 usableSize;
@@ -68764,7 +68764,7 @@ static int lockBtree(BtShared *pBt){
     ){
       goto page1_init_failed;
     }
-    pBt->btsFlags |= BTS_PAGESIZE_FIXED;
+    pBt->btsFlags |= BTS_PAGESIZE_FIXED; 
     assert( (pageSize & 7)==0 );
     /* EVIDENCE-OF: R-59310-51205 The "reserved space" size in the 1-byte
     ** integer at offset 20 is the number of bytes of space at the end of
@@ -68789,7 +68789,7 @@ static int lockBtree(BtShared *pBt){
                                    pageSize-usableSize);
       return rc;
     }
-    if( sqlite3WritableSchema(pBt->db)==0 && nPage>nPageFile ){
+    if( sqlite3WritableSchema(pBt->db)==0 && nPage>nPageFile ){ 
       rc = SQLITE_CORRUPT_BKPT;
       goto page1_init_failed;
     }
@@ -68977,7 +68977,7 @@ SQLITE_PRIVATE int sqlite3BtreeNewDb(Btree *p){
 ** when A already has a read lock, we encourage A to give up and let B
 ** proceed.
 */
-SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree *p, int wrflag, int *pSchemaVersion){
+SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree *p, int wrflag, int *pSchemaVersion){ 
   BtShared *pBt = p->pBt;
   Pager *pPager = pBt->pPager;
   int rc = SQLITE_OK;
@@ -68996,10 +68996,10 @@ SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree *p, int wrflag, int *pSchemaVers
 
   if( (p->db->flags & SQLITE_ResetDatabase)
    && sqlite3PagerIsreadonly(pPager)==0
-  ){
-    pBt->btsFlags &= ~BTS_READ_ONLY;
-  }
-
+  ){ 
+    pBt->btsFlags &= ~BTS_READ_ONLY; 
+  } 
+ 
   /* Write transactions are not possible on a read-only database */
   if( (pBt->btsFlags & BTS_READ_ONLY)!=0 && wrflag ){
     rc = SQLITE_READONLY;
@@ -69071,11 +69071,11 @@ SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree *p, int wrflag, int *pSchemaVers
         rc = sqlite3PagerBegin(pPager, wrflag>1, sqlite3TempInMemory(p->db));
         if( rc==SQLITE_OK ){
           rc = newDatabase(pBt);
-        }else if( rc==SQLITE_BUSY_SNAPSHOT && pBt->inTransaction==TRANS_NONE ){
-          /* if there was no transaction opened when this function was
-          ** called and SQLITE_BUSY_SNAPSHOT is returned, change the error
-          ** code to SQLITE_BUSY. */
-          rc = SQLITE_BUSY;
+        }else if( rc==SQLITE_BUSY_SNAPSHOT && pBt->inTransaction==TRANS_NONE ){ 
+          /* if there was no transaction opened when this function was 
+          ** called and SQLITE_BUSY_SNAPSHOT is returned, change the error 
+          ** code to SQLITE_BUSY. */ 
+          rc = SQLITE_BUSY; 
         }
       }
     }
@@ -69132,17 +69132,17 @@ SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree *p, int wrflag, int *pSchemaVers
   }
 
 trans_begun:
-  if( rc==SQLITE_OK ){
-    if( pSchemaVersion ){
-      *pSchemaVersion = get4byte(&pBt->pPage1->aData[40]);
-    }
-    if( wrflag ){
-      /* This call makes sure that the pager has the correct number of
-      ** open savepoints. If the second parameter is greater than 0 and
-      ** the sub-journal is not already open, then it will be opened here.
-      */
+  if( rc==SQLITE_OK ){ 
+    if( pSchemaVersion ){ 
+      *pSchemaVersion = get4byte(&pBt->pPage1->aData[40]); 
+    } 
+    if( wrflag ){ 
+      /* This call makes sure that the pager has the correct number of 
+      ** open savepoints. If the second parameter is greater than 0 and 
+      ** the sub-journal is not already open, then it will be opened here. 
+      */ 
       rc = sqlite3PagerOpenSavepoint(pPager, p->db->nSavepoint);
-    }
+    } 
   }
 
   btreeIntegrity(p);
@@ -69172,7 +69172,7 @@ static int setChildPtrmaps(MemPage *pPage){
   for(i=0; i<nCell; i++){
     u8 *pCell = findCell(pPage, i);
 
-    ptrmapPutOvflPtr(pPage, pPage, pCell, &rc);
+    ptrmapPutOvflPtr(pPage, pPage, pCell, &rc); 
 
     if( !pPage->leaf ){
       Pgno childPgno = get4byte(pCell);
@@ -69280,7 +69280,7 @@ static int relocatePage(
       eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE );
   assert( sqlite3_mutex_held(pBt->mutex) );
   assert( pDbPage->pBt==pBt );
-  if( iDbPage<3 ) return SQLITE_CORRUPT_BKPT;
+  if( iDbPage<3 ) return SQLITE_CORRUPT_BKPT; 
 
   /* Move page iDbPage from its current location to page number iFreePage */
   TRACE(("AUTOVACUUM: Moving %d to free page %d (ptr page %d type %d)\n",
@@ -69814,18 +69814,18 @@ SQLITE_PRIVATE int sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode, int wr
 }
 
 /*
-** Set the pBt->nPage field correctly, according to the current
-** state of the database.  Assume pBt->pPage1 is valid.
-*/
-static void btreeSetNPage(BtShared *pBt, MemPage *pPage1){
-  int nPage = get4byte(&pPage1->aData[28]);
-  testcase( nPage==0 );
-  if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage);
+** Set the pBt->nPage field correctly, according to the current 
+** state of the database.  Assume pBt->pPage1 is valid. 
+*/ 
+static void btreeSetNPage(BtShared *pBt, MemPage *pPage1){ 
+  int nPage = get4byte(&pPage1->aData[28]); 
+  testcase( nPage==0 ); 
+  if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage); 
   testcase( pBt->nPage!=(u32)nPage );
-  pBt->nPage = nPage;
-}
-
-/*
+  pBt->nPage = nPage; 
+} 
+ 
+/* 
 ** Rollback the transaction in progress.
 **
 ** If tripCode is not SQLITE_OK then cursors will be invalidated (tripped).
@@ -69870,7 +69870,7 @@ SQLITE_PRIVATE int sqlite3BtreeRollback(Btree *p, int tripCode, int writeOnly){
     ** call btreeGetPage() on page 1 again to make
     ** sure pPage1->aData is set correctly. */
     if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){
-      btreeSetNPage(pBt, pPage1);
+      btreeSetNPage(pBt, pPage1); 
       releasePageOne(pPage1);
     }
     assert( countValidCursors(pBt, 1)==0 );
@@ -69950,11 +69950,11 @@ SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *p, int op, int iSavepoint){
         pBt->nPage = 0;
       }
       rc = newDatabase(pBt);
-      btreeSetNPage(pBt, pBt->pPage1);
+      btreeSetNPage(pBt, pBt->pPage1); 
 
       /* pBt->nPage might be zero if the database was corrupt when
-      ** the transaction was started. Otherwise, it must be at least 1.  */
-      assert( CORRUPT_DB || pBt->nPage>0 );
+      ** the transaction was started. Otherwise, it must be at least 1.  */ 
+      assert( CORRUPT_DB || pBt->nPage>0 ); 
     }
     sqlite3BtreeLeave(p);
   }
@@ -70116,7 +70116,7 @@ SQLITE_PRIVATE int sqlite3BtreeCursorSize(void){
 ** of run-time by skipping the initialization of those elements.
 */
 SQLITE_PRIVATE void sqlite3BtreeCursorZero(BtCursor *p){
-  memset(p, 0, offsetof(BtCursor, BTCURSOR_FIRST_UNINIT));
+  memset(p, 0, offsetof(BtCursor, BTCURSOR_FIRST_UNINIT)); 
 }
 
 /*
@@ -70153,7 +70153,7 @@ SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
     }else{
       sqlite3BtreeLeave(pBtree);
     }
-    pCur->pBtree = 0;
+    pCur->pBtree = 0; 
   }
   return SQLITE_OK;
 }
@@ -70167,19 +70167,19 @@ SQLITE_PRIVATE int sqlite3BtreeCloseCursor(BtCursor *pCur){
 ** Using this cache reduces the number of calls to btreeParseCell().
 */
 #ifndef NDEBUG
-  static int cellInfoEqual(CellInfo *a, CellInfo *b){
-    if( a->nKey!=b->nKey ) return 0;
-    if( a->pPayload!=b->pPayload ) return 0;
-    if( a->nPayload!=b->nPayload ) return 0;
-    if( a->nLocal!=b->nLocal ) return 0;
-    if( a->nSize!=b->nSize ) return 0;
-    return 1;
-  }
+  static int cellInfoEqual(CellInfo *a, CellInfo *b){ 
+    if( a->nKey!=b->nKey ) return 0; 
+    if( a->pPayload!=b->pPayload ) return 0; 
+    if( a->nPayload!=b->nPayload ) return 0; 
+    if( a->nLocal!=b->nLocal ) return 0; 
+    if( a->nSize!=b->nSize ) return 0; 
+    return 1; 
+  } 
   static void assertCellInfo(BtCursor *pCur){
     CellInfo info;
     memset(&info, 0, sizeof(info));
     btreeParseCell(pCur->pPage, pCur->ix, &info);
-    assert( CORRUPT_DB || cellInfoEqual(&info, &pCur->info) );
+    assert( CORRUPT_DB || cellInfoEqual(&info, &pCur->info) ); 
   }
 #else
   #define assertCellInfo(x)
@@ -70265,25 +70265,25 @@ SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor *pCur){
 }
 
 /*
-** Return an upper bound on the size of any record for the table
-** that the cursor is pointing into.
-**
-** This is an optimization.  Everything will still work if this
-** routine always returns 2147483647 (which is the largest record
-** that SQLite can handle) or more.  But returning a smaller value might
-** prevent large memory allocations when trying to interpret a
-** corrupt datrabase.
-**
-** The current implementation merely returns the size of the underlying
-** database file.
-*/
-SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeMaxRecordSize(BtCursor *pCur){
-  assert( cursorHoldsMutex(pCur) );
-  assert( pCur->eState==CURSOR_VALID );
-  return pCur->pBt->pageSize * (sqlite3_int64)pCur->pBt->nPage;
-}
-
-/*
+** Return an upper bound on the size of any record for the table 
+** that the cursor is pointing into. 
+** 
+** This is an optimization.  Everything will still work if this 
+** routine always returns 2147483647 (which is the largest record 
+** that SQLite can handle) or more.  But returning a smaller value might 
+** prevent large memory allocations when trying to interpret a 
+** corrupt datrabase. 
+** 
+** The current implementation merely returns the size of the underlying 
+** database file. 
+*/ 
+SQLITE_PRIVATE sqlite3_int64 sqlite3BtreeMaxRecordSize(BtCursor *pCur){ 
+  assert( cursorHoldsMutex(pCur) ); 
+  assert( pCur->eState==CURSOR_VALID ); 
+  return pCur->pBt->pageSize * (sqlite3_int64)pCur->pBt->nPage; 
+} 
+ 
+/* 
 ** Given the page number of an overflow page in the database (parameter
 ** ovfl), this function finds the page number of the next page in the
 ** linked list of overflow pages. If possible, it uses the auto-vacuum
@@ -70488,9 +70488,9 @@ static int accessPayload(
     */
     if( (pCur->curFlags & BTCF_ValidOvfl)==0 ){
       int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
-      if( pCur->aOverflow==0
-       || nOvfl*(int)sizeof(Pgno) > sqlite3MallocSize(pCur->aOverflow)
-      ){
+      if( pCur->aOverflow==0 
+       || nOvfl*(int)sizeof(Pgno) > sqlite3MallocSize(pCur->aOverflow) 
+      ){ 
         Pgno *aNew = (Pgno*)sqlite3Realloc(
             pCur->aOverflow, nOvfl*2*sizeof(Pgno)
         );
@@ -70552,7 +70552,7 @@ static int accessPayload(
         **
         **   1) this is a read operation, and
         **   2) data is required from the start of this overflow page, and
-        **   3) there are no dirty pages in the page-cache
+        **   3) there are no dirty pages in the page-cache 
         **   4) the database is file-backed, and
         **   5) the page is not in the WAL file
         **   6) at least 4 bytes have already been read into the output buffer
@@ -70563,10 +70563,10 @@ static int accessPayload(
         */
         if( eOp==0                                             /* (1) */
          && offset==0                                          /* (2) */
-         && sqlite3PagerDirectReadOk(pBt->pPager, nextPage)    /* (3,4,5) */
+         && sqlite3PagerDirectReadOk(pBt->pPager, nextPage)    /* (3,4,5) */ 
          && &pBuf[-4]>=pBufStart                               /* (6) */
         ){
-          sqlite3_file *fd = sqlite3PagerFile(pBt->pPager);
+          sqlite3_file *fd = sqlite3PagerFile(pBt->pPager); 
           u8 aSave[4];
           u8 *aWrite = &pBuf[-4];
           assert( aWrite>=pBufStart );                         /* due to (6) */
@@ -71000,7 +71000,7 @@ SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
     /* ^-- dbsqlfuzz b92b72e4de80b5140c30ab71372ca719b8feb618 */
     assert( pCur->pPage->leaf );
 #endif
-    *pRes = 0;
+    *pRes = 0; 
     return SQLITE_OK;
   }
 
@@ -71075,7 +71075,7 @@ SQLITE_PRIVATE int sqlite3BtreeTableMoveto(
       ** try to get there using sqlite3BtreeNext() rather than a full
       ** binary search.  This is an optimization only.  The correct answer
       ** is still obtained without this case, only a little more slowely */
-      if( pCur->info.nKey+1==intKey ){
+      if( pCur->info.nKey+1==intKey ){ 
         *pRes = 0;
         rc = sqlite3BtreeNext(pCur, 0);
         if( rc==SQLITE_OK ){
@@ -71456,24 +71456,24 @@ static SQLITE_NOINLINE int btreeNext(BtCursor *pCur){
     if( CURSOR_INVALID==pCur->eState ){
       return SQLITE_DONE;
     }
-    if( pCur->eState==CURSOR_SKIPNEXT ){
+    if( pCur->eState==CURSOR_SKIPNEXT ){ 
       pCur->eState = CURSOR_VALID;
-      if( pCur->skipNext>0 ) return SQLITE_OK;
+      if( pCur->skipNext>0 ) return SQLITE_OK; 
     }
   }
 
   pPage = pCur->pPage;
   idx = ++pCur->ix;
   if( !pPage->isInit || sqlite3FaultSim(412) ){
-    /* The only known way for this to happen is for there to be a
-    ** recursive SQL function that does a DELETE operation as part of a
-    ** SELECT which deletes content out from under an active cursor
-    ** in a corrupt database file where the table being DELETE-ed from
-    ** has pages in common with the table being queried.  See TH3
-    ** module cov1/btree78.test testcase 220 (2018-06-08) for an
-    ** example. */
-    return SQLITE_CORRUPT_BKPT;
-  }
+    /* The only known way for this to happen is for there to be a 
+    ** recursive SQL function that does a DELETE operation as part of a 
+    ** SELECT which deletes content out from under an active cursor 
+    ** in a corrupt database file where the table being DELETE-ed from 
+    ** has pages in common with the table being queried.  See TH3 
+    ** module cov1/btree78.test testcase 220 (2018-06-08) for an 
+    ** example. */ 
+    return SQLITE_CORRUPT_BKPT; 
+  } 
 
   if( idx>=pPage->nCell ){
     if( !pPage->leaf ){
@@ -71556,9 +71556,9 @@ static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur){
     if( CURSOR_INVALID==pCur->eState ){
       return SQLITE_DONE;
     }
-    if( CURSOR_SKIPNEXT==pCur->eState ){
+    if( CURSOR_SKIPNEXT==pCur->eState ){ 
       pCur->eState = CURSOR_VALID;
-      if( pCur->skipNext<0 ) return SQLITE_OK;
+      if( pCur->skipNext<0 ) return SQLITE_OK; 
     }
   }
 
@@ -71928,7 +71928,7 @@ static int allocateBtreePage(
     TRACE(("ALLOCATE: %d from end of file\n", *pPgno));
   }
 
-  assert( CORRUPT_DB || *pPgno!=PENDING_BYTE_PAGE(pBt) );
+  assert( CORRUPT_DB || *pPgno!=PENDING_BYTE_PAGE(pBt) ); 
 
 end_allocate_page:
   releasePage(pTrunk);
@@ -71956,15 +71956,15 @@ static int freePage2(BtShared *pBt, MemPage *pMemPage, Pgno iPage){
   MemPage *pPage1 = pBt->pPage1;      /* Local reference to page 1 */
   MemPage *pPage;                     /* Page being freed. May be NULL. */
   int rc;                             /* Return Code */
-  u32 nFree;                          /* Initial number of pages on free-list */
+  u32 nFree;                          /* Initial number of pages on free-list */ 
 
   assert( sqlite3_mutex_held(pBt->mutex) );
   assert( CORRUPT_DB || iPage>1 );
   assert( !pMemPage || pMemPage->pgno==iPage );
 
   if( NEVER(iPage<2) || iPage>pBt->nPage ){
-    return SQLITE_CORRUPT_BKPT;
-  }
+    return SQLITE_CORRUPT_BKPT; 
+  } 
   if( pMemPage ){
     pPage = pMemPage;
     sqlite3PagerRef(pPage->pDbPage);
@@ -72106,9 +72106,9 @@ static SQLITE_NOINLINE int clearCellOverflow(
 
   assert( sqlite3_mutex_held(pPage->pBt->mutex) );
   assert( pInfo->nLocal!=pInfo->nPayload );
-  testcase( pCell + pInfo->nSize == pPage->aDataEnd );
-  testcase( pCell + (pInfo->nSize-1) == pPage->aDataEnd );
-  if( pCell + pInfo->nSize > pPage->aDataEnd ){
+  testcase( pCell + pInfo->nSize == pPage->aDataEnd ); 
+  testcase( pCell + (pInfo->nSize-1) == pPage->aDataEnd ); 
+  if( pCell + pInfo->nSize > pPage->aDataEnd ){ 
     /* Cell extends past end of page */
     return SQLITE_CORRUPT_PAGE(pPage);
   }
@@ -72391,7 +72391,7 @@ static void dropCell(MemPage *pPage, int idx, int sz, int *pRC){
   assert( CORRUPT_DB || sz==cellSize(pPage, idx) );
   assert( sqlite3PagerIswriteable(pPage->pDbPage) );
   assert( sqlite3_mutex_held(pPage->pBt->mutex) );
-  assert( pPage->nFree>=0 );
+  assert( pPage->nFree>=0 ); 
   data = pPage->aData;
   ptr = &pPage->aCellIdx[2*idx];
   assert( pPage->pBt->usableSize > (int)(ptr-data) );
@@ -72458,7 +72458,7 @@ static void insertCell(
   assert( ArraySize(pPage->apOvfl)==ArraySize(pPage->aiOvfl) );
   assert( sqlite3_mutex_held(pPage->pBt->mutex) );
   assert( sz==pPage->xCellSize(pPage, pCell) || CORRUPT_DB );
-  assert( pPage->nFree>=0 );
+  assert( pPage->nFree>=0 ); 
   if( pPage->nOverflow || sz+2>pPage->nFree ){
     if( pTemp ){
       memcpy(pTemp, pCell, sz);
@@ -72500,15 +72500,15 @@ static void insertCell(
     assert( idx+sz <= (int)pPage->pBt->usableSize );
     pPage->nFree -= (u16)(2 + sz);
     if( iChild ){
-      /* In a corrupt database where an entry in the cell index section of
-      ** a btree page has a value of 3 or less, the pCell value might point
-      ** as many as 4 bytes in front of the start of the aData buffer for
-      ** the source page.  Make sure this does not cause problems by not
-      ** reading the first 4 bytes */
-      memcpy(&data[idx+4], pCell+4, sz-4);
+      /* In a corrupt database where an entry in the cell index section of 
+      ** a btree page has a value of 3 or less, the pCell value might point 
+      ** as many as 4 bytes in front of the start of the aData buffer for 
+      ** the source page.  Make sure this does not cause problems by not 
+      ** reading the first 4 bytes */ 
+      memcpy(&data[idx+4], pCell+4, sz-4); 
       put4byte(&data[idx], iChild);
-    }else{
-      memcpy(&data[idx], pCell, sz);
+    }else{ 
+      memcpy(&data[idx], pCell, sz); 
     }
     pIns = pPage->aCellIdx + i*2;
     memmove(pIns+2, pIns, 2*(pPage->nCell - i));
@@ -72516,100 +72516,100 @@ static void insertCell(
     pPage->nCell++;
     /* increment the cell count */
     if( (++data[pPage->hdrOffset+4])==0 ) data[pPage->hdrOffset+3]++;
-    assert( get2byte(&data[pPage->hdrOffset+3])==pPage->nCell || CORRUPT_DB );
+    assert( get2byte(&data[pPage->hdrOffset+3])==pPage->nCell || CORRUPT_DB ); 
 #ifndef SQLITE_OMIT_AUTOVACUUM
     if( pPage->pBt->autoVacuum ){
       /* The cell may contain a pointer to an overflow page. If so, write
       ** the entry for the overflow page into the pointer map.
       */
-      ptrmapPutOvflPtr(pPage, pPage, pCell, pRC);
+      ptrmapPutOvflPtr(pPage, pPage, pCell, pRC); 
     }
 #endif
   }
 }
 
 /*
-** The following parameters determine how many adjacent pages get involved
-** in a balancing operation.  NN is the number of neighbors on either side
-** of the page that participate in the balancing operation.  NB is the
-** total number of pages that participate, including the target page and
-** NN neighbors on either side.
-**
-** The minimum value of NN is 1 (of course).  Increasing NN above 1
-** (to 2 or 3) gives a modest improvement in SELECT and DELETE performance
-** in exchange for a larger degradation in INSERT and UPDATE performance.
-** The value of NN appears to give the best results overall.
-**
-** (Later:) The description above makes it seem as if these values are
-** tunable - as if you could change them and recompile and it would all work.
-** But that is unlikely.  NB has been 3 since the inception of SQLite and
-** we have never tested any other value.
-*/
-#define NN 1             /* Number of neighbors on either side of pPage */
-#define NB 3             /* (NN*2+1): Total pages involved in the balance */
-
-/*
+** The following parameters determine how many adjacent pages get involved 
+** in a balancing operation.  NN is the number of neighbors on either side 
+** of the page that participate in the balancing operation.  NB is the 
+** total number of pages that participate, including the target page and 
+** NN neighbors on either side. 
+** 
+** The minimum value of NN is 1 (of course).  Increasing NN above 1 
+** (to 2 or 3) gives a modest improvement in SELECT and DELETE performance 
+** in exchange for a larger degradation in INSERT and UPDATE performance. 
+** The value of NN appears to give the best results overall. 
+** 
+** (Later:) The description above makes it seem as if these values are 
+** tunable - as if you could change them and recompile and it would all work. 
+** But that is unlikely.  NB has been 3 since the inception of SQLite and 
+** we have never tested any other value. 
+*/ 
+#define NN 1             /* Number of neighbors on either side of pPage */ 
+#define NB 3             /* (NN*2+1): Total pages involved in the balance */ 
+ 
+/* 
 ** A CellArray object contains a cache of pointers and sizes for a
 ** consecutive sequence of cells that might be held on multiple pages.
-**
-** The cells in this array are the divider cell or cells from the pParent
-** page plus up to three child pages.  There are a total of nCell cells.
-**
-** pRef is a pointer to one of the pages that contributes cells.  This is
-** used to access information such as MemPage.intKey and MemPage.pBt->pageSize
-** which should be common to all pages that contribute cells to this array.
-**
-** apCell[] and szCell[] hold, respectively, pointers to the start of each
-** cell and the size of each cell.  Some of the apCell[] pointers might refer
-** to overflow cells.  In other words, some apCel[] pointers might not point
-** to content area of the pages.
-**
-** A szCell[] of zero means the size of that cell has not yet been computed.
-**
-** The cells come from as many as four different pages:
-**
-**             -----------
-**             | Parent  |
-**             -----------
-**            /     |     \
-**           /      |      \
-**  ---------   ---------   ---------
-**  |Child-1|   |Child-2|   |Child-3|
-**  ---------   ---------   ---------
-**
-** The order of cells is in the array is for an index btree is:
-**
-**       1.  All cells from Child-1 in order
-**       2.  The first divider cell from Parent
-**       3.  All cells from Child-2 in order
-**       4.  The second divider cell from Parent
-**       5.  All cells from Child-3 in order
-**
-** For a table-btree (with rowids) the items 2 and 4 are empty because
-** content exists only in leaves and there are no divider cells.
-**
-** For an index btree, the apEnd[] array holds pointer to the end of page
-** for Child-1, the Parent, Child-2, the Parent (again), and Child-3,
-** respectively. The ixNx[] array holds the number of cells contained in
-** each of these 5 stages, and all stages to the left.  Hence:
-**
-**    ixNx[0] = Number of cells in Child-1.
-**    ixNx[1] = Number of cells in Child-1 plus 1 for first divider.
-**    ixNx[2] = Number of cells in Child-1 and Child-2 + 1 for 1st divider.
-**    ixNx[3] = Number of cells in Child-1 and Child-2 + both divider cells
-**    ixNx[4] = Total number of cells.
-**
-** For a table-btree, the concept is similar, except only apEnd[0]..apEnd[2]
-** are used and they point to the leaf pages only, and the ixNx value are:
-**
-**    ixNx[0] = Number of cells in Child-1.
-**    ixNx[1] = Number of cells in Child-1 and Child-2.
-**    ixNx[2] = Total number of cells.
-**
-** Sometimes when deleting, a child page can have zero cells.  In those
-** cases, ixNx[] entries with higher indexes, and the corresponding apEnd[]
-** entries, shift down.  The end result is that each ixNx[] entry should
-** be larger than the previous
+** 
+** The cells in this array are the divider cell or cells from the pParent 
+** page plus up to three child pages.  There are a total of nCell cells. 
+** 
+** pRef is a pointer to one of the pages that contributes cells.  This is 
+** used to access information such as MemPage.intKey and MemPage.pBt->pageSize 
+** which should be common to all pages that contribute cells to this array. 
+** 
+** apCell[] and szCell[] hold, respectively, pointers to the start of each 
+** cell and the size of each cell.  Some of the apCell[] pointers might refer 
+** to overflow cells.  In other words, some apCel[] pointers might not point 
+** to content area of the pages. 
+** 
+** A szCell[] of zero means the size of that cell has not yet been computed. 
+** 
+** The cells come from as many as four different pages: 
+** 
+**             ----------- 
+**             | Parent  | 
+**             ----------- 
+**            /     |     \ 
+**           /      |      \ 
+**  ---------   ---------   --------- 
+**  |Child-1|   |Child-2|   |Child-3| 
+**  ---------   ---------   --------- 
+** 
+** The order of cells is in the array is for an index btree is: 
+** 
+**       1.  All cells from Child-1 in order 
+**       2.  The first divider cell from Parent 
+**       3.  All cells from Child-2 in order 
+**       4.  The second divider cell from Parent 
+**       5.  All cells from Child-3 in order 
+** 
+** For a table-btree (with rowids) the items 2 and 4 are empty because 
+** content exists only in leaves and there are no divider cells. 
+** 
+** For an index btree, the apEnd[] array holds pointer to the end of page 
+** for Child-1, the Parent, Child-2, the Parent (again), and Child-3, 
+** respectively. The ixNx[] array holds the number of cells contained in 
+** each of these 5 stages, and all stages to the left.  Hence: 
+** 
+**    ixNx[0] = Number of cells in Child-1. 
+**    ixNx[1] = Number of cells in Child-1 plus 1 for first divider. 
+**    ixNx[2] = Number of cells in Child-1 and Child-2 + 1 for 1st divider. 
+**    ixNx[3] = Number of cells in Child-1 and Child-2 + both divider cells 
+**    ixNx[4] = Total number of cells. 
+** 
+** For a table-btree, the concept is similar, except only apEnd[0]..apEnd[2] 
+** are used and they point to the leaf pages only, and the ixNx value are: 
+** 
+**    ixNx[0] = Number of cells in Child-1. 
+**    ixNx[1] = Number of cells in Child-1 and Child-2. 
+**    ixNx[2] = Total number of cells. 
+** 
+** Sometimes when deleting, a child page can have zero cells.  In those 
+** cases, ixNx[] entries with higher indexes, and the corresponding apEnd[] 
+** entries, shift down.  The end result is that each ixNx[] entry should 
+** be larger than the previous 
 */
 typedef struct CellArray CellArray;
 struct CellArray {
@@ -72617,8 +72617,8 @@ struct CellArray {
   MemPage *pRef;          /* Reference page */
   u8 **apCell;            /* All cells begin balanced */
   u16 *szCell;            /* Local size of all cells in apCell[] */
-  u8 *apEnd[NB*2];        /* MemPage.aDataEnd values */
-  int ixNx[NB*2];         /* Index of at which we move to the next apEnd[] */
+  u8 *apEnd[NB*2];        /* MemPage.aDataEnd values */ 
+  int ixNx[NB*2];         /* Index of at which we move to the next apEnd[] */ 
 };
 
 /*
@@ -72669,58 +72669,58 @@ static u16 cachedCellSize(CellArray *p, int N){
 ** responsibility of the caller to set it correctly.
 */
 static int rebuildPage(
-  CellArray *pCArray,             /* Content to be added to page pPg */
-  int iFirst,                     /* First cell in pCArray to use */
+  CellArray *pCArray,             /* Content to be added to page pPg */ 
+  int iFirst,                     /* First cell in pCArray to use */ 
   int nCell,                      /* Final number of cells on page */
-  MemPage *pPg                    /* The page to be reconstructed */
+  MemPage *pPg                    /* The page to be reconstructed */ 
 ){
   const int hdr = pPg->hdrOffset;          /* Offset of header on pPg */
   u8 * const aData = pPg->aData;           /* Pointer to data for pPg */
   const int usableSize = pPg->pBt->usableSize;
   u8 * const pEnd = &aData[usableSize];
-  int i = iFirst;                 /* Which cell to copy from pCArray*/
-  u32 j;                          /* Start of cell content area */
-  int iEnd = i+nCell;             /* Loop terminator */
+  int i = iFirst;                 /* Which cell to copy from pCArray*/ 
+  u32 j;                          /* Start of cell content area */ 
+  int iEnd = i+nCell;             /* Loop terminator */ 
   u8 *pCellptr = pPg->aCellIdx;
   u8 *pTmp = sqlite3PagerTempSpace(pPg->pBt->pPager);
   u8 *pData;
-  int k;                          /* Current slot in pCArray->apEnd[] */
-  u8 *pSrcEnd;                    /* Current pCArray->apEnd[k] value */
+  int k;                          /* Current slot in pCArray->apEnd[] */ 
+  u8 *pSrcEnd;                    /* Current pCArray->apEnd[k] value */ 
 
-  assert( i<iEnd );
-  j = get2byte(&aData[hdr+5]);
+  assert( i<iEnd ); 
+  j = get2byte(&aData[hdr+5]); 
   if( j>(u32)usableSize ){ j = 0; }
-  memcpy(&pTmp[j], &aData[j], usableSize - j);
-
-  for(k=0; pCArray->ixNx[k]<=i && ALWAYS(k<NB*2); k++){}
-  pSrcEnd = pCArray->apEnd[k];
+  memcpy(&pTmp[j], &aData[j], usableSize - j); 
 
+  for(k=0; pCArray->ixNx[k]<=i && ALWAYS(k<NB*2); k++){} 
+  pSrcEnd = pCArray->apEnd[k]; 
+ 
   pData = pEnd;
-  while( 1/*exit by break*/ ){
-    u8 *pCell = pCArray->apCell[i];
-    u16 sz = pCArray->szCell[i];
-    assert( sz>0 );
+  while( 1/*exit by break*/ ){ 
+    u8 *pCell = pCArray->apCell[i]; 
+    u16 sz = pCArray->szCell[i]; 
+    assert( sz>0 ); 
     if( SQLITE_WITHIN(pCell,aData+j,pEnd) ){
-      if( ((uptr)(pCell+sz))>(uptr)pEnd ) return SQLITE_CORRUPT_BKPT;
+      if( ((uptr)(pCell+sz))>(uptr)pEnd ) return SQLITE_CORRUPT_BKPT; 
       pCell = &pTmp[pCell - aData];
-    }else if( (uptr)(pCell+sz)>(uptr)pSrcEnd
-           && (uptr)(pCell)<(uptr)pSrcEnd
-    ){
-      return SQLITE_CORRUPT_BKPT;
+    }else if( (uptr)(pCell+sz)>(uptr)pSrcEnd 
+           && (uptr)(pCell)<(uptr)pSrcEnd 
+    ){ 
+      return SQLITE_CORRUPT_BKPT; 
     }
-
-    pData -= sz;
+ 
+    pData -= sz; 
     put2byte(pCellptr, (pData - aData));
     pCellptr += 2;
     if( pData < pCellptr ) return SQLITE_CORRUPT_BKPT;
     memmove(pData, pCell, sz);
-    assert( sz==pPg->xCellSize(pPg, pCell) || CORRUPT_DB );
-    i++;
-    if( i>=iEnd ) break;
-    if( pCArray->ixNx[k]<=i ){
-      k++;
-      pSrcEnd = pCArray->apEnd[k];
-    }
+    assert( sz==pPg->xCellSize(pPg, pCell) || CORRUPT_DB ); 
+    i++; 
+    if( i>=iEnd ) break; 
+    if( pCArray->ixNx[k]<=i ){ 
+      k++; 
+      pSrcEnd = pCArray->apEnd[k]; 
+    } 
   }
 
   /* The pPg->nFree field is now set incorrectly. The caller will fix it. */
@@ -72735,11 +72735,11 @@ static int rebuildPage(
 }
 
 /*
-** The pCArray objects contains pointers to b-tree cells and the cell sizes.
-** This function attempts to add the cells stored in the array to page pPg.
-** If it cannot (because the page needs to be defragmented before the cells
-** will fit), non-zero is returned. Otherwise, if the cells are added
-** successfully, zero is returned.
+** The pCArray objects contains pointers to b-tree cells and the cell sizes. 
+** This function attempts to add the cells stored in the array to page pPg. 
+** If it cannot (because the page needs to be defragmented before the cells 
+** will fit), non-zero is returned. Otherwise, if the cells are added 
+** successfully, zero is returned. 
 **
 ** Argument pCellptr points to the first entry in the cell-pointer array
 ** (part of page pPg) to populate. After cell apCell[0] is written to the
@@ -72761,23 +72761,23 @@ static int rebuildPage(
 static int pageInsertArray(
   MemPage *pPg,                   /* Page to add cells to */
   u8 *pBegin,                     /* End of cell-pointer array */
-  u8 **ppData,                    /* IN/OUT: Page content-area pointer */
+  u8 **ppData,                    /* IN/OUT: Page content-area pointer */ 
   u8 *pCellptr,                   /* Pointer to cell-pointer area */
   int iFirst,                     /* Index of first cell to add */
   int nCell,                      /* Number of cells to add to pPg */
   CellArray *pCArray              /* Array of cells */
 ){
-  int i = iFirst;                 /* Loop counter - cell index to insert */
-  u8 *aData = pPg->aData;         /* Complete page */
-  u8 *pData = *ppData;            /* Content area.  A subset of aData[] */
-  int iEnd = iFirst + nCell;      /* End of loop. One past last cell to ins */
-  int k;                          /* Current slot in pCArray->apEnd[] */
-  u8 *pEnd;                       /* Maximum extent of cell data */
+  int i = iFirst;                 /* Loop counter - cell index to insert */ 
+  u8 *aData = pPg->aData;         /* Complete page */ 
+  u8 *pData = *ppData;            /* Content area.  A subset of aData[] */ 
+  int iEnd = iFirst + nCell;      /* End of loop. One past last cell to ins */ 
+  int k;                          /* Current slot in pCArray->apEnd[] */ 
+  u8 *pEnd;                       /* Maximum extent of cell data */ 
   assert( CORRUPT_DB || pPg->hdrOffset==0 );    /* Never called on page 1 */
-  if( iEnd<=iFirst ) return 0;
-  for(k=0; pCArray->ixNx[k]<=i && ALWAYS(k<NB*2); k++){}
-  pEnd = pCArray->apEnd[k];
-  while( 1 /*Exit by break*/ ){
+  if( iEnd<=iFirst ) return 0; 
+  for(k=0; pCArray->ixNx[k]<=i && ALWAYS(k<NB*2); k++){} 
+  pEnd = pCArray->apEnd[k]; 
+  while( 1 /*Exit by break*/ ){ 
     int sz, rc;
     u8 *pSlot;
     assert( pCArray->szCell[i]!=0 );
@@ -72793,34 +72793,34 @@ static int pageInsertArray(
     assert( (pSlot+sz)<=pCArray->apCell[i]
          || pSlot>=(pCArray->apCell[i]+sz)
          || CORRUPT_DB );
-    if( (uptr)(pCArray->apCell[i]+sz)>(uptr)pEnd
-     && (uptr)(pCArray->apCell[i])<(uptr)pEnd
-    ){
-      assert( CORRUPT_DB );
-      (void)SQLITE_CORRUPT_BKPT;
-      return 1;
-    }
+    if( (uptr)(pCArray->apCell[i]+sz)>(uptr)pEnd 
+     && (uptr)(pCArray->apCell[i])<(uptr)pEnd 
+    ){ 
+      assert( CORRUPT_DB ); 
+      (void)SQLITE_CORRUPT_BKPT; 
+      return 1; 
+    } 
     memmove(pSlot, pCArray->apCell[i], sz);
     put2byte(pCellptr, (pSlot - aData));
     pCellptr += 2;
-    i++;
-    if( i>=iEnd ) break;
-    if( pCArray->ixNx[k]<=i ){
-      k++;
-      pEnd = pCArray->apEnd[k];
-    }
+    i++; 
+    if( i>=iEnd ) break; 
+    if( pCArray->ixNx[k]<=i ){ 
+      k++; 
+      pEnd = pCArray->apEnd[k]; 
+    } 
   }
   *ppData = pData;
   return 0;
 }
 
 /*
-** The pCArray object contains pointers to b-tree cells and their sizes.
-**
-** This function adds the space associated with each cell in the array
-** that is currently stored within the body of pPg to the pPg free-list.
-** The cell-pointers and other fields of the page are not updated.
+** The pCArray object contains pointers to b-tree cells and their sizes. 
 **
+** This function adds the space associated with each cell in the array 
+** that is currently stored within the body of pPg to the pPg free-list. 
+** The cell-pointers and other fields of the page are not updated. 
+** 
 ** This function returns the total number of cells added to the free-list.
 */
 static int pageFreeArray(
@@ -72871,9 +72871,9 @@ static int pageFreeArray(
 }
 
 /*
-** pCArray contains pointers to and sizes of all cells in the page being
-** balanced.  The current page, pPg, has pPg->nCell cells starting with
-** pCArray->apCell[iOld].  After balancing, this page should hold nNew cells
+** pCArray contains pointers to and sizes of all cells in the page being 
+** balanced.  The current page, pPg, has pPg->nCell cells starting with 
+** pCArray->apCell[iOld].  After balancing, this page should hold nNew cells 
 ** starting at apCell[iNew].
 **
 ** This routine makes the necessary adjustments to pPg so that it contains
@@ -72905,7 +72905,7 @@ static int editPage(
 #endif
 
   /* Remove cells from the start and end of the page */
-  assert( nCell>=0 );
+  assert( nCell>=0 ); 
   if( iOld<iNew ){
     int nShift = pageFreeArray(pPg, iOld, iNew-iOld, pCArray);
     if( NEVER(nShift>nCell) ) return SQLITE_CORRUPT_BKPT;
@@ -72913,9 +72913,9 @@ static int editPage(
     nCell -= nShift;
   }
   if( iNewEnd < iOldEnd ){
-    int nTail = pageFreeArray(pPg, iNewEnd, iOldEnd - iNewEnd, pCArray);
-    assert( nCell>=nTail );
-    nCell -= nTail;
+    int nTail = pageFreeArray(pPg, iNewEnd, iOldEnd - iNewEnd, pCArray); 
+    assert( nCell>=nTail ); 
+    nCell -= nTail; 
   }
 
   pData = &aData[get2byteNotZero(&aData[hdr+5])];
@@ -72926,7 +72926,7 @@ static int editPage(
   if( iNew<iOld ){
     int nAdd = MIN(nNew,iOld-iNew);
     assert( (iOld-iNew)<nNew || nCell==0 || CORRUPT_DB );
-    assert( nAdd>=0 );
+    assert( nAdd>=0 ); 
     pCellptr = pPg->aCellIdx;
     memmove(&pCellptr[nAdd*2], pCellptr, nCell*2);
     if( pageInsertArray(
@@ -72941,9 +72941,9 @@ static int editPage(
     int iCell = (iOld + pPg->aiOvfl[i]) - iNew;
     if( iCell>=0 && iCell<nNew ){
       pCellptr = &pPg->aCellIdx[iCell * 2];
-      if( nCell>iCell ){
-        memmove(&pCellptr[2], pCellptr, (nCell - iCell) * 2);
-      }
+      if( nCell>iCell ){ 
+        memmove(&pCellptr[2], pCellptr, (nCell - iCell) * 2); 
+      } 
       nCell++;
       cachedCellSize(pCArray, iCell+iNew);
       if( pageInsertArray(
@@ -72954,7 +72954,7 @@ static int editPage(
   }
 
   /* Append cells to the end of the page */
-  assert( nCell>=0 );
+  assert( nCell>=0 ); 
   pCellptr = &pPg->aCellIdx[nCell*2];
   if( pageInsertArray(
         pPg, pBegin, &pData, pCellptr,
@@ -72983,7 +72983,7 @@ static int editPage(
  editpage_fail:
   /* Unable to edit this page. Rebuild it from scratch instead. */
   populateCellCache(pCArray, iNew, nNew);
-  return rebuildPage(pCArray, iNew, nNew, pPg);
+  return rebuildPage(pCArray, iNew, nNew, pPg); 
 }
 
 
@@ -73021,9 +73021,9 @@ static int balance_quick(MemPage *pParent, MemPage *pPage, u8 *pSpace){
   assert( sqlite3PagerIswriteable(pParent->pDbPage) );
   assert( pPage->nOverflow==1 );
 
-  if( pPage->nCell==0 ) return SQLITE_CORRUPT_BKPT;  /* dbfuzz001.test */
-  assert( pPage->nFree>=0 );
-  assert( pParent->nFree>=0 );
+  if( pPage->nCell==0 ) return SQLITE_CORRUPT_BKPT;  /* dbfuzz001.test */ 
+  assert( pPage->nFree>=0 ); 
+  assert( pParent->nFree>=0 ); 
 
   /* Allocate a new page. This page will become the right-sibling of
   ** pPage. Make the parent page writable, so that the new divider cell
@@ -73037,22 +73037,22 @@ static int balance_quick(MemPage *pParent, MemPage *pPage, u8 *pSpace){
     u8 *pCell = pPage->apOvfl[0];
     u16 szCell = pPage->xCellSize(pPage, pCell);
     u8 *pStop;
-    CellArray b;
+    CellArray b; 
 
     assert( sqlite3PagerIswriteable(pNew->pDbPage) );
-    assert( CORRUPT_DB || pPage->aData[0]==(PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF) );
+    assert( CORRUPT_DB || pPage->aData[0]==(PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF) ); 
     zeroPage(pNew, PTF_INTKEY|PTF_LEAFDATA|PTF_LEAF);
-    b.nCell = 1;
-    b.pRef = pPage;
-    b.apCell = &pCell;
-    b.szCell = &szCell;
-    b.apEnd[0] = pPage->aDataEnd;
-    b.ixNx[0] = 2;
-    rc = rebuildPage(&b, 0, 1, pNew);
-    if( NEVER(rc) ){
-      releasePage(pNew);
-      return rc;
-    }
+    b.nCell = 1; 
+    b.pRef = pPage; 
+    b.apCell = &pCell; 
+    b.szCell = &szCell; 
+    b.apEnd[0] = pPage->aDataEnd; 
+    b.ixNx[0] = 2; 
+    rc = rebuildPage(&b, 0, 1, pNew); 
+    if( NEVER(rc) ){ 
+      releasePage(pNew); 
+      return rc; 
+    } 
     pNew->nFree = pBt->usableSize - pNew->cellOffset - 2 - szCell;
 
     /* If this is an auto-vacuum database, update the pointer map
@@ -73067,7 +73067,7 @@ static int balance_quick(MemPage *pParent, MemPage *pPage, u8 *pSpace){
     if( ISAUTOVACUUM ){
       ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno, &rc);
       if( szCell>pNew->minLocal ){
-        ptrmapPutOvflPtr(pNew, pNew, pCell, &rc);
+        ptrmapPutOvflPtr(pNew, pNew, pCell, &rc); 
       }
     }
 
@@ -73193,7 +73193,7 @@ static void copyNodeContent(MemPage *pFrom, MemPage *pTo, int *pRC){
     */
     pTo->isInit = 0;
     rc = btreeInitPage(pTo);
-    if( rc==SQLITE_OK ) rc = btreeComputeFreeSpace(pTo);
+    if( rc==SQLITE_OK ) rc = btreeComputeFreeSpace(pTo); 
     if( rc!=SQLITE_OK ){
       *pRC = rc;
       return;
@@ -73301,7 +73301,7 @@ static int balance_nonroot(
   if( !aOvflSpace ){
     return SQLITE_NOMEM_BKPT;
   }
-  assert( pParent->nFree>=0 );
+  assert( pParent->nFree>=0 ); 
 
   /* Find the sibling pages to balance. Also locate the cells in pParent
   ** that divide the siblings. An attempt is made to find NN siblings on
@@ -73343,13 +73343,13 @@ static int balance_nonroot(
       memset(apOld, 0, (i+1)*sizeof(MemPage*));
       goto balance_cleanup;
     }
-    if( apOld[i]->nFree<0 ){
-      rc = btreeComputeFreeSpace(apOld[i]);
-      if( rc ){
-        memset(apOld, 0, (i)*sizeof(MemPage*));
-        goto balance_cleanup;
-      }
-    }
+    if( apOld[i]->nFree<0 ){ 
+      rc = btreeComputeFreeSpace(apOld[i]); 
+      if( rc ){ 
+        memset(apOld, 0, (i)*sizeof(MemPage*)); 
+        goto balance_cleanup; 
+      } 
+    } 
     nMaxCells += apOld[i]->nCell + ArraySize(pParent->apOvfl);
     if( (i--)==0 ) break;
 
@@ -73402,7 +73402,7 @@ static int balance_nonroot(
      + nMaxCells*sizeof(u16)                       /* b.szCell */
      + pBt->pageSize;                              /* aSpace1 */
 
-  assert( szScratch<=7*(int)pBt->pageSize );
+  assert( szScratch<=7*(int)pBt->pageSize ); 
   b.apCell = sqlite3StackAllocRaw(0, szScratch );
   if( b.apCell==0 ){
     rc = SQLITE_NOMEM_BKPT;
@@ -73438,7 +73438,7 @@ static int balance_nonroot(
     u16 maskPage = pOld->maskPage;
     u8 *piCell = aData + pOld->cellOffset;
     u8 *piEnd;
-    VVA_ONLY( int nCellAtStart = b.nCell; )
+    VVA_ONLY( int nCellAtStart = b.nCell; ) 
 
     /* Verify that all sibling pages are of the same "type" (table-leaf,
     ** table-interior, index-leaf, or index-interior).
@@ -73449,7 +73449,7 @@ static int balance_nonroot(
     }
 
     /* Load b.apCell[] with pointers to all cells in pOld.  If pOld
-    ** contains overflow cells, include them in the b.apCell[] array
+    ** contains overflow cells, include them in the b.apCell[] array 
     ** in the correct spot.
     **
     ** Note that when there are multiple overflow cells, it is always the
@@ -73468,9 +73468,9 @@ static int balance_nonroot(
     memset(&b.szCell[b.nCell], 0, sizeof(b.szCell[0])*(limit+pOld->nOverflow));
     if( pOld->nOverflow>0 ){
       if( NEVER(limit<pOld->aiOvfl[0]) ){
-        rc = SQLITE_CORRUPT_BKPT;
-        goto balance_cleanup;
-      }
+        rc = SQLITE_CORRUPT_BKPT; 
+        goto balance_cleanup; 
+      } 
       limit = pOld->aiOvfl[0];
       for(j=0; j<limit; j++){
         b.apCell[b.nCell] = aData + (maskPage & get2byteAligned(piCell));
@@ -73490,7 +73490,7 @@ static int balance_nonroot(
       piCell += 2;
       b.nCell++;
     }
-    assert( (b.nCell-nCellAtStart)==(pOld->nCell+pOld->nOverflow) );
+    assert( (b.nCell-nCellAtStart)==(pOld->nCell+pOld->nOverflow) ); 
 
     cntOld[i] = b.nCell;
     if( i<nOld-1 && !leafData){
@@ -73544,19 +73544,19 @@ static int balance_nonroot(
   **
   */
   usableSpace = pBt->usableSize - 12 + leafCorrection;
-  for(i=k=0; i<nOld; i++, k++){
+  for(i=k=0; i<nOld; i++, k++){ 
     MemPage *p = apOld[i];
-    b.apEnd[k] = p->aDataEnd;
-    b.ixNx[k] = cntOld[i];
-    if( k && b.ixNx[k]==b.ixNx[k-1] ){
-      k--;  /* Omit b.ixNx[] entry for child pages with no cells */
-    }
-    if( !leafData ){
-      k++;
-      b.apEnd[k] = pParent->aDataEnd;
-      b.ixNx[k] = cntOld[i]+1;
-    }
-    assert( p->nFree>=0 );
+    b.apEnd[k] = p->aDataEnd; 
+    b.ixNx[k] = cntOld[i]; 
+    if( k && b.ixNx[k]==b.ixNx[k-1] ){ 
+      k--;  /* Omit b.ixNx[] entry for child pages with no cells */ 
+    } 
+    if( !leafData ){ 
+      k++; 
+      b.apEnd[k] = pParent->aDataEnd; 
+      b.ixNx[k] = cntOld[i]+1; 
+    } 
+    assert( p->nFree>=0 ); 
     szNew[i] = usableSpace - p->nFree;
     for(j=0; j<p->nOverflow; j++){
       szNew[i] += 2 + p->xCellSize(p, p->apOvfl[j]);
@@ -73787,19 +73787,19 @@ static int balance_nonroot(
   ** populated, not here.
   */
   if( ISAUTOVACUUM ){
-    MemPage *pOld;
-    MemPage *pNew = pOld = apNew[0];
+    MemPage *pOld; 
+    MemPage *pNew = pOld = apNew[0]; 
     int cntOldNext = pNew->nCell + pNew->nOverflow;
     int iNew = 0;
     int iOld = 0;
 
     for(i=0; i<b.nCell; i++){
       u8 *pCell = b.apCell[i];
-      while( i==cntOldNext ){
-        iOld++;
-        assert( iOld<nNew || iOld<nOld );
-        assert( iOld>=0 && iOld<NB );
-        pOld = iOld<nNew ? apNew[iOld] : apOld[iOld];
+      while( i==cntOldNext ){ 
+        iOld++; 
+        assert( iOld<nNew || iOld<nOld ); 
+        assert( iOld>=0 && iOld<NB ); 
+        pOld = iOld<nNew ? apNew[iOld] : apOld[iOld]; 
         cntOldNext += pOld->nCell + pOld->nOverflow + !leafData;
       }
       if( i==cntNew[iNew] ){
@@ -73815,13 +73815,13 @@ static int balance_nonroot(
       ** overflow cell), we can skip updating the pointer map entries.  */
       if( iOld>=nNew
        || pNew->pgno!=aPgno[iOld]
-       || !SQLITE_WITHIN(pCell,pOld->aData,pOld->aDataEnd)
+       || !SQLITE_WITHIN(pCell,pOld->aData,pOld->aDataEnd) 
       ){
         if( !leafCorrection ){
           ptrmapPut(pBt, get4byte(pCell), PTRMAP_BTREE, pNew->pgno, &rc);
         }
         if( cachedCellSize(&b,i)>pNew->minLocal ){
-          ptrmapPutOvflPtr(pNew, pOld, pCell, &rc);
+          ptrmapPutOvflPtr(pNew, pOld, pCell, &rc); 
         }
         if( rc ) goto balance_cleanup;
       }
@@ -73973,8 +73973,8 @@ static int balance_nonroot(
     rc = defragmentPage(apNew[0], -1);
     testcase( rc!=SQLITE_OK );
     assert( apNew[0]->nFree ==
-        (get2byteNotZero(&apNew[0]->aData[5]) - apNew[0]->cellOffset
-          - apNew[0]->nCell*2)
+        (get2byteNotZero(&apNew[0]->aData[5]) - apNew[0]->cellOffset 
+          - apNew[0]->nCell*2) 
       || rc!=SQLITE_OK
     );
     copyNodeContent(apNew[0], pParent, &rc);
@@ -74073,7 +74073,7 @@ static int balance_deeper(MemPage *pRoot, MemPage **ppChild){
   }
   assert( sqlite3PagerIswriteable(pChild->pDbPage) );
   assert( sqlite3PagerIswriteable(pRoot->pDbPage) );
-  assert( pChild->nCell==pRoot->nCell || CORRUPT_DB );
+  assert( pChild->nCell==pRoot->nCell || CORRUPT_DB ); 
 
   TRACE(("BALANCE: copy root %d into %d\n", pRoot->pgno, pChild->pgno));
 
@@ -74139,7 +74139,7 @@ static int balance(BtCursor *pCur){
     int iPage;
     MemPage *pPage = pCur->pPage;
 
-    if( NEVER(pPage->nFree<0) && btreeComputeFreeSpace(pPage) ) break;
+    if( NEVER(pPage->nFree<0) && btreeComputeFreeSpace(pPage) ) break; 
     if( pPage->nOverflow==0 && pPage->nFree<=nMin ){
       break;
     }else if( (iPage = pCur->iPage)==0 ){
@@ -74168,9 +74168,9 @@ static int balance(BtCursor *pCur){
       int const iIdx = pCur->aiIdx[iPage-1];
 
       rc = sqlite3PagerWrite(pParent->pDbPage);
-      if( rc==SQLITE_OK && pParent->nFree<0 ){
-        rc = btreeComputeFreeSpace(pParent);
-      }
+      if( rc==SQLITE_OK && pParent->nFree<0 ){ 
+        rc = btreeComputeFreeSpace(pParent); 
+      } 
       if( rc==SQLITE_OK ){
 #ifndef SQLITE_OMIT_QUICKBALANCE
         if( pPage->intKeyLeaf
@@ -74249,102 +74249,102 @@ static int balance(BtCursor *pCur){
   return rc;
 }
 
-/* Overwrite content from pX into pDest.  Only do the write if the
-** content is different from what is already there.
-*/
-static int btreeOverwriteContent(
-  MemPage *pPage,           /* MemPage on which writing will occur */
-  u8 *pDest,                /* Pointer to the place to start writing */
-  const BtreePayload *pX,   /* Source of data to write */
-  int iOffset,              /* Offset of first byte to write */
-  int iAmt                  /* Number of bytes to be written */
-){
-  int nData = pX->nData - iOffset;
-  if( nData<=0 ){
-    /* Overwritting with zeros */
-    int i;
-    for(i=0; i<iAmt && pDest[i]==0; i++){}
-    if( i<iAmt ){
-      int rc = sqlite3PagerWrite(pPage->pDbPage);
-      if( rc ) return rc;
-      memset(pDest + i, 0, iAmt - i);
-    }
-  }else{
-    if( nData<iAmt ){
-      /* Mixed read data and zeros at the end.  Make a recursive call
-      ** to write the zeros then fall through to write the real data */
-      int rc = btreeOverwriteContent(pPage, pDest+nData, pX, iOffset+nData,
-                                 iAmt-nData);
-      if( rc ) return rc;
-      iAmt = nData;
-    }
-    if( memcmp(pDest, ((u8*)pX->pData) + iOffset, iAmt)!=0 ){
-      int rc = sqlite3PagerWrite(pPage->pDbPage);
-      if( rc ) return rc;
-      /* In a corrupt database, it is possible for the source and destination
-      ** buffers to overlap.  This is harmless since the database is already
-      ** corrupt but it does cause valgrind and ASAN warnings.  So use
-      ** memmove(). */
-      memmove(pDest, ((u8*)pX->pData) + iOffset, iAmt);
-    }
-  }
-  return SQLITE_OK;
-}
-
-/*
-** Overwrite the cell that cursor pCur is pointing to with fresh content
-** contained in pX.
-*/
-static int btreeOverwriteCell(BtCursor *pCur, const BtreePayload *pX){
-  int iOffset;                        /* Next byte of pX->pData to write */
-  int nTotal = pX->nData + pX->nZero; /* Total bytes of to write */
-  int rc;                             /* Return code */
-  MemPage *pPage = pCur->pPage;       /* Page being written */
-  BtShared *pBt;                      /* Btree */
-  Pgno ovflPgno;                      /* Next overflow page to write */
-  u32 ovflPageSize;                   /* Size to write on overflow page */
-
+/* Overwrite content from pX into pDest.  Only do the write if the 
+** content is different from what is already there. 
+*/ 
+static int btreeOverwriteContent( 
+  MemPage *pPage,           /* MemPage on which writing will occur */ 
+  u8 *pDest,                /* Pointer to the place to start writing */ 
+  const BtreePayload *pX,   /* Source of data to write */ 
+  int iOffset,              /* Offset of first byte to write */ 
+  int iAmt                  /* Number of bytes to be written */ 
+){ 
+  int nData = pX->nData - iOffset; 
+  if( nData<=0 ){ 
+    /* Overwritting with zeros */ 
+    int i; 
+    for(i=0; i<iAmt && pDest[i]==0; i++){} 
+    if( i<iAmt ){ 
+      int rc = sqlite3PagerWrite(pPage->pDbPage); 
+      if( rc ) return rc; 
+      memset(pDest + i, 0, iAmt - i); 
+    } 
+  }else{ 
+    if( nData<iAmt ){ 
+      /* Mixed read data and zeros at the end.  Make a recursive call 
+      ** to write the zeros then fall through to write the real data */ 
+      int rc = btreeOverwriteContent(pPage, pDest+nData, pX, iOffset+nData, 
+                                 iAmt-nData); 
+      if( rc ) return rc; 
+      iAmt = nData; 
+    } 
+    if( memcmp(pDest, ((u8*)pX->pData) + iOffset, iAmt)!=0 ){ 
+      int rc = sqlite3PagerWrite(pPage->pDbPage); 
+      if( rc ) return rc; 
+      /* In a corrupt database, it is possible for the source and destination 
+      ** buffers to overlap.  This is harmless since the database is already 
+      ** corrupt but it does cause valgrind and ASAN warnings.  So use 
+      ** memmove(). */ 
+      memmove(pDest, ((u8*)pX->pData) + iOffset, iAmt); 
+    } 
+  } 
+  return SQLITE_OK; 
+} 
+
+/*
+** Overwrite the cell that cursor pCur is pointing to with fresh content 
+** contained in pX. 
+*/ 
+static int btreeOverwriteCell(BtCursor *pCur, const BtreePayload *pX){ 
+  int iOffset;                        /* Next byte of pX->pData to write */ 
+  int nTotal = pX->nData + pX->nZero; /* Total bytes of to write */ 
+  int rc;                             /* Return code */ 
+  MemPage *pPage = pCur->pPage;       /* Page being written */ 
+  BtShared *pBt;                      /* Btree */ 
+  Pgno ovflPgno;                      /* Next overflow page to write */ 
+  u32 ovflPageSize;                   /* Size to write on overflow page */ 
+ 
   if( pCur->info.pPayload + pCur->info.nLocal > pPage->aDataEnd
    || pCur->info.pPayload < pPage->aData + pPage->cellOffset
   ){
-    return SQLITE_CORRUPT_BKPT;
-  }
-  /* Overwrite the local portion first */
-  rc = btreeOverwriteContent(pPage, pCur->info.pPayload, pX,
-                             0, pCur->info.nLocal);
-  if( rc ) return rc;
-  if( pCur->info.nLocal==nTotal ) return SQLITE_OK;
-
-  /* Now overwrite the overflow pages */
-  iOffset = pCur->info.nLocal;
-  assert( nTotal>=0 );
-  assert( iOffset>=0 );
-  ovflPgno = get4byte(pCur->info.pPayload + iOffset);
-  pBt = pPage->pBt;
-  ovflPageSize = pBt->usableSize - 4;
-  do{
-    rc = btreeGetPage(pBt, ovflPgno, &pPage, 0);
-    if( rc ) return rc;
+    return SQLITE_CORRUPT_BKPT; 
+  } 
+  /* Overwrite the local portion first */ 
+  rc = btreeOverwriteContent(pPage, pCur->info.pPayload, pX, 
+                             0, pCur->info.nLocal); 
+  if( rc ) return rc; 
+  if( pCur->info.nLocal==nTotal ) return SQLITE_OK; 
+ 
+  /* Now overwrite the overflow pages */ 
+  iOffset = pCur->info.nLocal; 
+  assert( nTotal>=0 ); 
+  assert( iOffset>=0 ); 
+  ovflPgno = get4byte(pCur->info.pPayload + iOffset); 
+  pBt = pPage->pBt; 
+  ovflPageSize = pBt->usableSize - 4; 
+  do{ 
+    rc = btreeGetPage(pBt, ovflPgno, &pPage, 0); 
+    if( rc ) return rc; 
     if( sqlite3PagerPageRefcount(pPage->pDbPage)!=1 || pPage->isInit ){
-      rc = SQLITE_CORRUPT_BKPT;
-    }else{
-      if( iOffset+ovflPageSize<(u32)nTotal ){
-        ovflPgno = get4byte(pPage->aData);
-      }else{
-        ovflPageSize = nTotal - iOffset;
-      }
-      rc = btreeOverwriteContent(pPage, pPage->aData+4, pX,
-                                 iOffset, ovflPageSize);
-    }
-    sqlite3PagerUnref(pPage->pDbPage);
-    if( rc ) return rc;
-    iOffset += ovflPageSize;
-  }while( iOffset<nTotal );
+      rc = SQLITE_CORRUPT_BKPT; 
+    }else{ 
+      if( iOffset+ovflPageSize<(u32)nTotal ){ 
+        ovflPgno = get4byte(pPage->aData); 
+      }else{ 
+        ovflPageSize = nTotal - iOffset; 
+      } 
+      rc = btreeOverwriteContent(pPage, pPage->aData+4, pX, 
+                                 iOffset, ovflPageSize); 
+    } 
+    sqlite3PagerUnref(pPage->pDbPage); 
+    if( rc ) return rc; 
+    iOffset += ovflPageSize; 
+  }while( iOffset<nTotal ); 
   return SQLITE_OK;
-}
-
-
-/*
+} 
+ 
+ 
+/* 
 ** Insert a new record into the BTree.  The content of the new record
 ** is described by the pX object.  The pCur cursor is used only to
 ** define what table the record should be inserted into, and is left
@@ -74444,83 +74444,83 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
     }
 
     /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing
-    ** to a row with the same key as the new entry being inserted.
-    */
-#ifdef SQLITE_DEBUG
-    if( flags & BTREE_SAVEPOSITION ){
-      assert( pCur->curFlags & BTCF_ValidNKey );
-      assert( pX->nKey==pCur->info.nKey );
-      assert( loc==0 );
-    }
-#endif
-
-    /* On the other hand, BTREE_SAVEPOSITION==0 does not imply
-    ** that the cursor is not pointing to a row to be overwritten.
-    ** So do a complete check.
-    */
+    ** to a row with the same key as the new entry being inserted. 
+    */ 
+#ifdef SQLITE_DEBUG 
+    if( flags & BTREE_SAVEPOSITION ){ 
+      assert( pCur->curFlags & BTCF_ValidNKey ); 
+      assert( pX->nKey==pCur->info.nKey ); 
+      assert( loc==0 ); 
+    } 
+#endif 
+
+    /* On the other hand, BTREE_SAVEPOSITION==0 does not imply 
+    ** that the cursor is not pointing to a row to be overwritten. 
+    ** So do a complete check. 
+    */ 
     if( (pCur->curFlags&BTCF_ValidNKey)!=0 && pX->nKey==pCur->info.nKey ){
-      /* The cursor is pointing to the entry that is to be
-      ** overwritten */
-      assert( pX->nData>=0 && pX->nZero>=0 );
-      if( pCur->info.nSize!=0
-       && pCur->info.nPayload==(u32)pX->nData+pX->nZero
-      ){
-        /* New entry is the same size as the old.  Do an overwrite */
-        return btreeOverwriteCell(pCur, pX);
-      }
-      assert( loc==0 );
+      /* The cursor is pointing to the entry that is to be 
+      ** overwritten */ 
+      assert( pX->nData>=0 && pX->nZero>=0 ); 
+      if( pCur->info.nSize!=0 
+       && pCur->info.nPayload==(u32)pX->nData+pX->nZero 
+      ){ 
+        /* New entry is the same size as the old.  Do an overwrite */ 
+        return btreeOverwriteCell(pCur, pX); 
+      } 
+      assert( loc==0 ); 
     }else if( loc==0 ){
-      /* The cursor is *not* pointing to the cell to be overwritten, nor
-      ** to an adjacent cell.  Move the cursor so that it is pointing either
-      ** to the cell to be overwritten or an adjacent cell.
-      */
+      /* The cursor is *not* pointing to the cell to be overwritten, nor 
+      ** to an adjacent cell.  Move the cursor so that it is pointing either 
+      ** to the cell to be overwritten or an adjacent cell. 
+      */ 
       rc = sqlite3BtreeTableMoveto(pCur, pX->nKey,
                (flags & BTREE_APPEND)!=0, &loc);
       if( rc ) return rc;
     }
-  }else{
-    /* This is an index or a WITHOUT ROWID table */
-
+  }else{ 
+    /* This is an index or a WITHOUT ROWID table */ 
+ 
     /* If BTREE_SAVEPOSITION is set, the cursor must already be pointing
-    ** to a row with the same key as the new entry being inserted.
-    */
-    assert( (flags & BTREE_SAVEPOSITION)==0 || loc==0 );
-
-    /* If the cursor is not already pointing either to the cell to be
-    ** overwritten, or if a new cell is being inserted, if the cursor is
-    ** not pointing to an immediately adjacent cell, then move the cursor
-    ** so that it does.
-    */
-    if( loc==0 && (flags & BTREE_SAVEPOSITION)==0 ){
-      if( pX->nMem ){
-        UnpackedRecord r;
-        r.pKeyInfo = pCur->pKeyInfo;
-        r.aMem = pX->aMem;
-        r.nField = pX->nMem;
-        r.default_rc = 0;
-        r.eqSeen = 0;
+    ** to a row with the same key as the new entry being inserted. 
+    */ 
+    assert( (flags & BTREE_SAVEPOSITION)==0 || loc==0 ); 
+ 
+    /* If the cursor is not already pointing either to the cell to be 
+    ** overwritten, or if a new cell is being inserted, if the cursor is 
+    ** not pointing to an immediately adjacent cell, then move the cursor 
+    ** so that it does. 
+    */ 
+    if( loc==0 && (flags & BTREE_SAVEPOSITION)==0 ){ 
+      if( pX->nMem ){ 
+        UnpackedRecord r; 
+        r.pKeyInfo = pCur->pKeyInfo; 
+        r.aMem = pX->aMem; 
+        r.nField = pX->nMem; 
+        r.default_rc = 0; 
+        r.eqSeen = 0; 
         rc = sqlite3BtreeIndexMoveto(pCur, &r, &loc);
-      }else{
+      }else{ 
         rc = btreeMoveto(pCur, pX->pKey, pX->nKey,
                     (flags & BTREE_APPEND)!=0, &loc);
-      }
-      if( rc ) return rc;
-    }
-
-    /* If the cursor is currently pointing to an entry to be overwritten
-    ** and the new content is the same as as the old, then use the
-    ** overwrite optimization.
-    */
-    if( loc==0 ){
-      getCellInfo(pCur);
-      if( pCur->info.nKey==pX->nKey ){
-        BtreePayload x2;
-        x2.pData = pX->pKey;
-        x2.nData = pX->nKey;
-        x2.nZero = 0;
-        return btreeOverwriteCell(pCur, &x2);
-      }
-    }
+      } 
+      if( rc ) return rc; 
+    }
+ 
+    /* If the cursor is currently pointing to an entry to be overwritten 
+    ** and the new content is the same as as the old, then use the 
+    ** overwrite optimization. 
+    */ 
+    if( loc==0 ){ 
+      getCellInfo(pCur); 
+      if( pCur->info.nKey==pX->nKey ){ 
+        BtreePayload x2; 
+        x2.pData = pX->pKey; 
+        x2.nData = pX->nKey; 
+        x2.nZero = 0; 
+        return btreeOverwriteCell(pCur, &x2); 
+      } 
+    } 
   }
   assert( pCur->eState==CURSOR_VALID
        || (pCur->eState==CURSOR_INVALID && loc)
@@ -74529,14 +74529,14 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
   pPage = pCur->pPage;
   assert( pPage->intKey || pX->nKey>=0 || (flags & BTREE_PREFORMAT) );
   assert( pPage->leaf || !pPage->intKey );
-  if( pPage->nFree<0 ){
+  if( pPage->nFree<0 ){ 
     if( NEVER(pCur->eState>CURSOR_INVALID) ){
       rc = SQLITE_CORRUPT_BKPT;
     }else{
       rc = btreeComputeFreeSpace(pPage);
     }
-    if( rc ) return rc;
-  }
+    if( rc ) return rc; 
+  } 
 
   TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n",
           pCur->pgnoRoot, pX->nKey, pX->nData, pPage->pgno,
@@ -74811,12 +74811,12 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
   assert( pCur->curFlags & BTCF_WriteFlag );
   assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
   assert( !hasReadConflicts(p, pCur->pgnoRoot) );
-  assert( (flags & ~(BTREE_SAVEPOSITION | BTREE_AUXDELETE))==0 );
-  if( pCur->eState==CURSOR_REQUIRESEEK ){
-    rc = btreeRestoreCursorPosition(pCur);
+  assert( (flags & ~(BTREE_SAVEPOSITION | BTREE_AUXDELETE))==0 ); 
+  if( pCur->eState==CURSOR_REQUIRESEEK ){ 
+    rc = btreeRestoreCursorPosition(pCur); 
     assert( rc!=SQLITE_OK || CORRUPT_DB || pCur->eState==CURSOR_VALID );
     if( rc || pCur->eState!=CURSOR_VALID ) return rc;
-  }
+  } 
   assert( CORRUPT_DB || pCur->eState==CURSOR_VALID );
 
   iCellDepth = pCur->iPage;
@@ -74842,7 +74842,7 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
   if( bPreserve ){
     if( !pPage->leaf
      || (pPage->nFree+cellSizePtr(pPage,pCell)+2)>(int)(pBt->usableSize*2/3)
-     || pPage->nCell==1  /* See dbfuzz001.test for a test case */
+     || pPage->nCell==1  /* See dbfuzz001.test for a test case */ 
     ){
       /* A b-tree rebalance will be required after deleting this entry.
       ** Save the cursor key.  */
@@ -74899,10 +74899,10 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
     Pgno n;
     unsigned char *pTmp;
 
-    if( pLeaf->nFree<0 ){
-      rc = btreeComputeFreeSpace(pLeaf);
-      if( rc ) return rc;
-    }
+    if( pLeaf->nFree<0 ){ 
+      rc = btreeComputeFreeSpace(pLeaf); 
+      if( rc ) return rc; 
+    } 
     if( iCellDepth<pCur->iPage-1 ){
       n = pCur->apPage[iCellDepth+1]->pgno;
     }else{
@@ -75265,9 +75265,9 @@ static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){
   assert( sqlite3BtreeHoldsMutex(p) );
   assert( p->inTrans==TRANS_WRITE );
   assert( iTable>=2 );
-  if( iTable>btreePagecount(pBt) ){
-    return SQLITE_CORRUPT_BKPT;
-  }
+  if( iTable>btreePagecount(pBt) ){ 
+    return SQLITE_CORRUPT_BKPT; 
+  } 
 
   rc = sqlite3BtreeClearTable(p, iTable, 0);
   if( rc ) return rc;
@@ -75521,14 +75521,14 @@ static void checkAppendMsg(
   pCheck->nErr++;
   va_start(ap, zFormat);
   if( pCheck->errMsg.nChar ){
-    sqlite3_str_append(&pCheck->errMsg, "\n", 1);
+    sqlite3_str_append(&pCheck->errMsg, "\n", 1); 
   }
   if( pCheck->zPfx ){
-    sqlite3_str_appendf(&pCheck->errMsg, pCheck->zPfx, pCheck->v1, pCheck->v2);
+    sqlite3_str_appendf(&pCheck->errMsg, pCheck->zPfx, pCheck->v1, pCheck->v2); 
   }
-  sqlite3_str_vappendf(&pCheck->errMsg, zFormat, ap);
+  sqlite3_str_vappendf(&pCheck->errMsg, zFormat, ap); 
   va_end(ap);
-  if( pCheck->errMsg.accError==SQLITE_NOMEM ){
+  if( pCheck->errMsg.accError==SQLITE_NOMEM ){ 
     pCheck->bOomFault = 1;
   }
 }
@@ -75563,7 +75563,7 @@ static void setPageReferenced(IntegrityCk *pCheck, Pgno iPg){
 ** Also check that the page number is in bounds.
 */
 static int checkRef(IntegrityCk *pCheck, Pgno iPage){
-  if( iPage>pCheck->nPage || iPage==0 ){
+  if( iPage>pCheck->nPage || iPage==0 ){ 
     checkAppendMsg(pCheck, "invalid page number %d", iPage);
     return 1;
   }
@@ -75615,34 +75615,34 @@ static void checkList(
   IntegrityCk *pCheck,  /* Integrity checking context */
   int isFreeList,       /* True for a freelist.  False for overflow page list */
   Pgno iPage,           /* Page number for first page in the list */
-  u32 N                 /* Expected number of pages in the list */
+  u32 N                 /* Expected number of pages in the list */ 
 ){
   int i;
-  u32 expected = N;
-  int nErrAtStart = pCheck->nErr;
-  while( iPage!=0 && pCheck->mxErr ){
+  u32 expected = N; 
+  int nErrAtStart = pCheck->nErr; 
+  while( iPage!=0 && pCheck->mxErr ){ 
     DbPage *pOvflPage;
     unsigned char *pOvflData;
     if( checkRef(pCheck, iPage) ) break;
-    N--;
+    N--; 
     if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage, 0) ){
       checkAppendMsg(pCheck, "failed to get page %d", iPage);
       break;
     }
     pOvflData = (unsigned char *)sqlite3PagerGetData(pOvflPage);
     if( isFreeList ){
-      u32 n = (u32)get4byte(&pOvflData[4]);
+      u32 n = (u32)get4byte(&pOvflData[4]); 
 #ifndef SQLITE_OMIT_AUTOVACUUM
       if( pCheck->pBt->autoVacuum ){
         checkPtrmap(pCheck, iPage, PTRMAP_FREEPAGE, 0);
       }
 #endif
-      if( n>pCheck->pBt->usableSize/4-2 ){
+      if( n>pCheck->pBt->usableSize/4-2 ){ 
         checkAppendMsg(pCheck,
            "freelist leaf count too big on page %d", iPage);
         N--;
       }else{
-        for(i=0; i<(int)n; i++){
+        for(i=0; i<(int)n; i++){ 
           Pgno iFreePage = get4byte(&pOvflData[8+i*4]);
 #ifndef SQLITE_OMIT_AUTOVACUUM
           if( pCheck->pBt->autoVacuum ){
@@ -75669,12 +75669,12 @@ static void checkList(
     iPage = get4byte(pOvflData);
     sqlite3PagerUnref(pOvflPage);
   }
-  if( N && nErrAtStart==pCheck->nErr ){
-    checkAppendMsg(pCheck,
-      "%s is %d but should be %d",
-      isFreeList ? "size" : "overflow list length",
-      expected-N, expected);
-  }
+  if( N && nErrAtStart==pCheck->nErr ){ 
+    checkAppendMsg(pCheck, 
+      "%s is %d but should be %d", 
+      isFreeList ? "size" : "overflow list length", 
+      expected-N, expected); 
+  } 
 }
 #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
 
@@ -75800,11 +75800,11 @@ static int checkTreePage(
                    "btreeInitPage() returns error code %d", rc);
     goto end_of_check;
   }
-  if( (rc = btreeComputeFreeSpace(pPage))!=0 ){
-    assert( rc==SQLITE_CORRUPT );
-    checkAppendMsg(pCheck, "free space corruption", rc);
-    goto end_of_check;
-  }
+  if( (rc = btreeComputeFreeSpace(pPage))!=0 ){ 
+    assert( rc==SQLITE_CORRUPT ); 
+    checkAppendMsg(pCheck, "free space corruption", rc); 
+    goto end_of_check; 
+  } 
   data = pPage->aData;
   hdr = pPage->hdrOffset;
 
@@ -75877,7 +75877,7 @@ static int checkTreePage(
 
     /* Check the content overflow list */
     if( info.nPayload>info.nLocal ){
-      u32 nPage;       /* Number of pages on the overflow chain */
+      u32 nPage;       /* Number of pages on the overflow chain */ 
       Pgno pgnoOvfl;   /* First page of the overflow chain */
       assert( pc + info.nSize - 4 <= usableSize );
       nPage = (info.nPayload - info.nLocal + usableSize - 5)/(usableSize - 4);
@@ -75937,9 +75937,9 @@ static int checkTreePage(
     i = get2byte(&data[hdr+1]);
     while( i>0 ){
       int size, j;
-      assert( (u32)i<=usableSize-4 ); /* Enforced by btreeComputeFreeSpace() */
+      assert( (u32)i<=usableSize-4 ); /* Enforced by btreeComputeFreeSpace() */ 
       size = get2byte(&data[i+2]);
-      assert( (u32)(i+size)<=usableSize ); /* due to btreeComputeFreeSpace() */
+      assert( (u32)(i+size)<=usableSize ); /* due to btreeComputeFreeSpace() */ 
       btreeHeapInsert(heap, (((u32)i)<<16)|(i+size-1));
       /* EVIDENCE-OF: R-58208-19414 The first 2 bytes of a freeblock are a
       ** big-endian integer which is the offset in the b-tree page of the next
@@ -75948,8 +75948,8 @@ static int checkTreePage(
       j = get2byte(&data[i]);
       /* EVIDENCE-OF: R-06866-39125 Freeblocks are always connected in order of
       ** increasing offset. */
-      assert( j==0 || j>i+size );     /* Enforced by btreeComputeFreeSpace() */
-      assert( (u32)j<=usableSize-4 ); /* Enforced by btreeComputeFreeSpace() */
+      assert( j==0 || j>i+size );     /* Enforced by btreeComputeFreeSpace() */ 
+      assert( (u32)j<=usableSize-4 ); /* Enforced by btreeComputeFreeSpace() */ 
       i = j;
     }
     /* Analyze the min-heap looking for overlap between cells and/or
@@ -76034,7 +76034,7 @@ SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(
   Pgno i;
   IntegrityCk sCheck;
   BtShared *pBt = p->pBt;
-  u64 savedDbFlags = pBt->db->flags;
+  u64 savedDbFlags = pBt->db->flags; 
   char zErr[100];
   int bPartial = 0;            /* True if not checking all btrees */
   int bCkFreelist = 1;         /* True to scan the freelist */
@@ -76095,7 +76095,7 @@ SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(
 
   /* Check all the tables.
   */
-#ifndef SQLITE_OMIT_AUTOVACUUM
+#ifndef SQLITE_OMIT_AUTOVACUUM 
   if( !bPartial ){
     if( pBt->autoVacuum ){
       Pgno mx = 0;
@@ -76109,14 +76109,14 @@ SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(
         );
       }
     }else if( get4byte(&pBt->pPage1->aData[64])!=0 ){
-      checkAppendMsg(&sCheck,
+      checkAppendMsg(&sCheck, 
         "incremental_vacuum enabled with a max rootpage of zero"
-      );
-    }
-  }
-#endif
+      ); 
+    } 
+  } 
+#endif 
   testcase( pBt->db->flags & SQLITE_CellSizeCk );
-  pBt->db->flags &= ~(u64)SQLITE_CellSizeCk;
+  pBt->db->flags &= ~(u64)SQLITE_CellSizeCk; 
   for(i=0; (int)i<nRoot && sCheck.mxErr; i++){
     i64 notUsed;
     if( aRoot[i]==0 ) continue;
@@ -76159,11 +76159,11 @@ integrity_ck_cleanup:
   sqlite3PageFree(sCheck.heap);
   sqlite3_free(sCheck.aPgRef);
   if( sCheck.bOomFault ){
-    sqlite3_str_reset(&sCheck.errMsg);
+    sqlite3_str_reset(&sCheck.errMsg); 
     sCheck.nErr++;
   }
   *pnErr = sCheck.nErr;
-  if( sCheck.nErr==0 ) sqlite3_str_reset(&sCheck.errMsg);
+  if( sCheck.nErr==0 ) sqlite3_str_reset(&sCheck.errMsg); 
   /* Make sure this analysis did not leave any unref() pages. */
   assert( nRef==sqlite3PagerRefcount(pBt->pPager) );
   sqlite3BtreeLeave(p);
@@ -76393,11 +76393,11 @@ SQLITE_PRIVATE int sqlite3BtreeSetVersion(Btree *pBtree, int iVersion){
   pBt->btsFlags &= ~BTS_NO_WAL;
   if( iVersion==1 ) pBt->btsFlags |= BTS_NO_WAL;
 
-  rc = sqlite3BtreeBeginTrans(pBtree, 0, 0);
+  rc = sqlite3BtreeBeginTrans(pBtree, 0, 0); 
   if( rc==SQLITE_OK ){
     u8 *aData = pBt->pPage1->aData;
     if( aData[18]!=(u8)iVersion || aData[19]!=(u8)iVersion ){
-      rc = sqlite3BtreeBeginTrans(pBtree, 2, 0);
+      rc = sqlite3BtreeBeginTrans(pBtree, 2, 0); 
       if( rc==SQLITE_OK ){
         rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
         if( rc==SQLITE_OK ){
@@ -76810,7 +76810,7 @@ SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage){
     ** before this function exits.
     */
     if( rc==SQLITE_OK && SQLITE_TXN_NONE==sqlite3BtreeTxnState(p->pSrc) ){
-      rc = sqlite3BtreeBeginTrans(p->pSrc, 0, 0);
+      rc = sqlite3BtreeBeginTrans(p->pSrc, 0, 0); 
       bCloseTrans = 1;
     }
 
@@ -76826,7 +76826,7 @@ SQLITE_API int sqlite3_backup_step(sqlite3_backup *p, int nPage){
 
     /* Lock the destination database, if it is not locked already. */
     if( SQLITE_OK==rc && p->bDestLocked==0
-     && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2,
+     && SQLITE_OK==(rc = sqlite3BtreeBeginTrans(p->pDest, 2, 
                                                 (int*)&p->iDestSchema))
     ){
       p->bDestLocked = 1;
@@ -77247,11 +77247,11 @@ copy_finished:
 /* #include "sqliteInt.h" */
 /* #include "vdbeInt.h" */
 
-/* True if X is a power of two.  0 is considered a power of two here.
-** In other words, return true if X has at most one bit set.
-*/
-#define ISPOWEROF2(X)  (((X)&((X)-1))==0)
-
+/* True if X is a power of two.  0 is considered a power of two here. 
+** In other words, return true if X has at most one bit set. 
+*/ 
+#define ISPOWEROF2(X)  (((X)&((X)-1))==0) 
+ 
 #ifdef SQLITE_DEBUG
 /*
 ** Check invariants on a Mem object.
@@ -77271,12 +77271,12 @@ SQLITE_PRIVATE int sqlite3VdbeCheckMemInvariants(Mem *p){
   ** That saves a few cycles in inner loops. */
   assert( (p->flags & MEM_Dyn)==0 || p->szMalloc==0 );
 
-  /* Cannot have more than one of MEM_Int, MEM_Real, or MEM_IntReal */
-  assert( ISPOWEROF2(p->flags & (MEM_Int|MEM_Real|MEM_IntReal)) );
+  /* Cannot have more than one of MEM_Int, MEM_Real, or MEM_IntReal */ 
+  assert( ISPOWEROF2(p->flags & (MEM_Int|MEM_Real|MEM_IntReal)) ); 
 
   if( p->flags & MEM_Null ){
     /* Cannot be both MEM_Null and some other type */
-    assert( (p->flags & (MEM_Int|MEM_Real|MEM_Str|MEM_Blob|MEM_Agg))==0 );
+    assert( (p->flags & (MEM_Int|MEM_Real|MEM_Str|MEM_Blob|MEM_Agg))==0 ); 
 
     /* If MEM_Null is set, then either the value is a pure NULL (the usual
     ** case) or it is a pointer set using sqlite3_bind_pointer() or
@@ -77291,7 +77291,7 @@ SQLITE_PRIVATE int sqlite3VdbeCheckMemInvariants(Mem *p){
               ((p->flags&MEM_Static)!=0 ? 1 : 0) <= 1 );
 
       /* No other bits set */
-      assert( (p->flags & ~(MEM_Null|MEM_Term|MEM_Subtype|MEM_FromBind
+      assert( (p->flags & ~(MEM_Null|MEM_Term|MEM_Subtype|MEM_FromBind 
                            |MEM_Dyn|MEM_Ephem|MEM_Static))==0 );
     }else{
       /* A pure NULL might have other flags, such as MEM_Static, MEM_Dyn,
@@ -77328,15 +77328,15 @@ SQLITE_PRIVATE int sqlite3VdbeCheckMemInvariants(Mem *p){
 }
 #endif
 
-/*
-** Render a Mem object which is one of MEM_Int, MEM_Real, or MEM_IntReal
-** into a buffer.
-*/
-static void vdbeMemRenderNum(int sz, char *zBuf, Mem *p){
-  StrAccum acc;
-  assert( p->flags & (MEM_Int|MEM_Real|MEM_IntReal) );
+/* 
+** Render a Mem object which is one of MEM_Int, MEM_Real, or MEM_IntReal 
+** into a buffer. 
+*/ 
+static void vdbeMemRenderNum(int sz, char *zBuf, Mem *p){ 
+  StrAccum acc; 
+  assert( p->flags & (MEM_Int|MEM_Real|MEM_IntReal) ); 
   assert( sz>22 );
-  if( p->flags & MEM_Int ){
+  if( p->flags & MEM_Int ){ 
 #if GCC_VERSION>=7000000
     /* Work-around for GCC bug
     ** https://gcc.gnu.org/bugzilla/show_bug.cgi?id=96270 */
@@ -77347,72 +77347,72 @@ static void vdbeMemRenderNum(int sz, char *zBuf, Mem *p){
 #else
     sqlite3Int64ToText(p->u.i, zBuf);
 #endif
-  }else{
+  }else{ 
     sqlite3StrAccumInit(&acc, 0, zBuf, sz, 0);
     sqlite3_str_appendf(&acc, "%!.15g",
          (p->flags & MEM_IntReal)!=0 ? (double)p->u.i : p->u.r);
     assert( acc.zText==zBuf && acc.mxAlloc<=0 );
     zBuf[acc.nChar] = 0; /* Fast version of sqlite3StrAccumFinish(&acc) */
-  }
-}
-
-#ifdef SQLITE_DEBUG
-/*
-** Validity checks on pMem.  pMem holds a string.
-**
-** (1) Check that string value of pMem agrees with its integer or real value.
-** (2) Check that the string is correctly zero terminated
-**
-** A single int or real value always converts to the same strings.  But
-** many different strings can be converted into the same int or real.
-** If a table contains a numeric value and an index is based on the
-** corresponding string value, then it is important that the string be
-** derived from the numeric value, not the other way around, to ensure
-** that the index and table are consistent.  See ticket
-** https://www.sqlite.org/src/info/343634942dd54ab (2018-01-31) for
-** an example.
-**
-** This routine looks at pMem to verify that if it has both a numeric
-** representation and a string representation then the string rep has
-** been derived from the numeric and not the other way around.  It returns
-** true if everything is ok and false if there is a problem.
-**
-** This routine is for use inside of assert() statements only.
-*/
-SQLITE_PRIVATE int sqlite3VdbeMemValidStrRep(Mem *p){
-  char zBuf[100];
-  char *z;
-  int i, j, incr;
-  if( (p->flags & MEM_Str)==0 ) return 1;
-  if( p->flags & MEM_Term ){
-    /* Insure that the string is properly zero-terminated.  Pay particular
-    ** attention to the case where p->n is odd */
-    if( p->szMalloc>0 && p->z==p->zMalloc ){
-      assert( p->enc==SQLITE_UTF8 || p->szMalloc >= ((p->n+1)&~1)+2 );
-      assert( p->enc!=SQLITE_UTF8 || p->szMalloc >= p->n+1 );
-    }
-    assert( p->z[p->n]==0 );
-    assert( p->enc==SQLITE_UTF8 || p->z[(p->n+1)&~1]==0 );
-    assert( p->enc==SQLITE_UTF8 || p->z[((p->n+1)&~1)+1]==0 );
-  }
-  if( (p->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 ) return 1;
-  vdbeMemRenderNum(sizeof(zBuf), zBuf, p);
-  z = p->z;
-  i = j = 0;
-  incr = 1;
-  if( p->enc!=SQLITE_UTF8 ){
-    incr = 2;
-    if( p->enc==SQLITE_UTF16BE ) z++;
-  }
-  while( zBuf[j] ){
-    if( zBuf[j++]!=z[i] ) return 0;
-    i += incr;
-  }
-  return 1;
-}
-#endif /* SQLITE_DEBUG */
-
-/*
+  } 
+} 
+
+#ifdef SQLITE_DEBUG 
+/*
+** Validity checks on pMem.  pMem holds a string. 
+** 
+** (1) Check that string value of pMem agrees with its integer or real value. 
+** (2) Check that the string is correctly zero terminated 
+** 
+** A single int or real value always converts to the same strings.  But 
+** many different strings can be converted into the same int or real. 
+** If a table contains a numeric value and an index is based on the 
+** corresponding string value, then it is important that the string be 
+** derived from the numeric value, not the other way around, to ensure 
+** that the index and table are consistent.  See ticket 
+** https://www.sqlite.org/src/info/343634942dd54ab (2018-01-31) for 
+** an example. 
+** 
+** This routine looks at pMem to verify that if it has both a numeric 
+** representation and a string representation then the string rep has 
+** been derived from the numeric and not the other way around.  It returns 
+** true if everything is ok and false if there is a problem. 
+** 
+** This routine is for use inside of assert() statements only. 
+*/ 
+SQLITE_PRIVATE int sqlite3VdbeMemValidStrRep(Mem *p){ 
+  char zBuf[100]; 
+  char *z; 
+  int i, j, incr; 
+  if( (p->flags & MEM_Str)==0 ) return 1; 
+  if( p->flags & MEM_Term ){ 
+    /* Insure that the string is properly zero-terminated.  Pay particular 
+    ** attention to the case where p->n is odd */ 
+    if( p->szMalloc>0 && p->z==p->zMalloc ){ 
+      assert( p->enc==SQLITE_UTF8 || p->szMalloc >= ((p->n+1)&~1)+2 ); 
+      assert( p->enc!=SQLITE_UTF8 || p->szMalloc >= p->n+1 ); 
+    } 
+    assert( p->z[p->n]==0 ); 
+    assert( p->enc==SQLITE_UTF8 || p->z[(p->n+1)&~1]==0 ); 
+    assert( p->enc==SQLITE_UTF8 || p->z[((p->n+1)&~1)+1]==0 ); 
+  } 
+  if( (p->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 ) return 1; 
+  vdbeMemRenderNum(sizeof(zBuf), zBuf, p); 
+  z = p->z; 
+  i = j = 0; 
+  incr = 1; 
+  if( p->enc!=SQLITE_UTF8 ){ 
+    incr = 2; 
+    if( p->enc==SQLITE_UTF16BE ) z++; 
+  } 
+  while( zBuf[j] ){ 
+    if( zBuf[j++]!=z[i] ) return 0; 
+    i += incr; 
+  } 
+  return 1; 
+} 
+#endif /* SQLITE_DEBUG */ 
+ 
+/* 
 ** If pMem is an object with a valid string representation, this routine
 ** ensures the internal encoding for the string representation is
 ** 'desiredEnc', one of SQLITE_UTF8, SQLITE_UTF16LE or SQLITE_UTF16BE.
@@ -77430,7 +77430,7 @@ SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
   int rc;
 #endif
   assert( pMem!=0 );
-  assert( !sqlite3VdbeMemIsRowSet(pMem) );
+  assert( !sqlite3VdbeMemIsRowSet(pMem) ); 
   assert( desiredEnc==SQLITE_UTF8 || desiredEnc==SQLITE_UTF16LE
            || desiredEnc==SQLITE_UTF16BE );
   if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){
@@ -77453,7 +77453,7 @@ SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
 }
 
 /*
-** Make sure pMem->z points to a writable allocation of at least n bytes.
+** Make sure pMem->z points to a writable allocation of at least n bytes. 
 **
 ** If the bPreserve argument is true, then copy of the content of
 ** pMem->z into the new allocation.  pMem must be either a string or
@@ -77462,7 +77462,7 @@ SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
 */
 SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPreserve){
   assert( sqlite3VdbeCheckMemInvariants(pMem) );
-  assert( !sqlite3VdbeMemIsRowSet(pMem) );
+  assert( !sqlite3VdbeMemIsRowSet(pMem) ); 
   testcase( pMem->db==0 );
 
   /* If the bPreserve flag is set to true, then the memory cell must already
@@ -77517,40 +77517,40 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPre
 **
 ** Any prior string or blob content in the pMem object may be discarded.
 ** The pMem->xDel destructor is called, if it exists.  Though MEM_Str
-** and MEM_Blob values may be discarded, MEM_Int, MEM_Real, MEM_IntReal,
-** and MEM_Null values are preserved.
+** and MEM_Blob values may be discarded, MEM_Int, MEM_Real, MEM_IntReal, 
+** and MEM_Null values are preserved. 
 **
 ** Return SQLITE_OK on success or an error code (probably SQLITE_NOMEM)
 ** if unable to complete the resizing.
 */
 SQLITE_PRIVATE int sqlite3VdbeMemClearAndResize(Mem *pMem, int szNew){
-  assert( CORRUPT_DB || szNew>0 );
+  assert( CORRUPT_DB || szNew>0 ); 
   assert( (pMem->flags & MEM_Dyn)==0 || pMem->szMalloc==0 );
   if( pMem->szMalloc<szNew ){
     return sqlite3VdbeMemGrow(pMem, szNew, 0);
   }
   assert( (pMem->flags & MEM_Dyn)==0 );
   pMem->z = pMem->zMalloc;
-  pMem->flags &= (MEM_Null|MEM_Int|MEM_Real|MEM_IntReal);
+  pMem->flags &= (MEM_Null|MEM_Int|MEM_Real|MEM_IntReal); 
   return SQLITE_OK;
 }
 
 /*
 ** It is already known that pMem contains an unterminated string.
 ** Add the zero terminator.
-**
-** Three bytes of zero are added.  In this way, there is guaranteed
-** to be a double-zero byte at an even byte boundary in order to
-** terminate a UTF16 string, even if the initial size of the buffer
-** is an odd number of bytes.
+** 
+** Three bytes of zero are added.  In this way, there is guaranteed 
+** to be a double-zero byte at an even byte boundary in order to 
+** terminate a UTF16 string, even if the initial size of the buffer 
+** is an odd number of bytes. 
 */
 static SQLITE_NOINLINE int vdbeMemAddTerminator(Mem *pMem){
-  if( sqlite3VdbeMemGrow(pMem, pMem->n+3, 1) ){
+  if( sqlite3VdbeMemGrow(pMem, pMem->n+3, 1) ){ 
     return SQLITE_NOMEM_BKPT;
   }
   pMem->z[pMem->n] = 0;
   pMem->z[pMem->n+1] = 0;
-  pMem->z[pMem->n+2] = 0;
+  pMem->z[pMem->n+2] = 0; 
   pMem->flags |= MEM_Term;
   return SQLITE_OK;
 }
@@ -77564,7 +77564,7 @@ static SQLITE_NOINLINE int vdbeMemAddTerminator(Mem *pMem){
 SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *pMem){
   assert( pMem!=0 );
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
-  assert( !sqlite3VdbeMemIsRowSet(pMem) );
+  assert( !sqlite3VdbeMemIsRowSet(pMem) ); 
   if( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ){
     if( ExpandBlob(pMem) ) return SQLITE_NOMEM;
     if( pMem->szMalloc==0 || pMem->z!=pMem->zMalloc ){
@@ -77589,15 +77589,15 @@ SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){
   int nByte;
   assert( pMem!=0 );
   assert( pMem->flags & MEM_Zero );
-  assert( (pMem->flags&MEM_Blob)!=0 || MemNullNochng(pMem) );
-  testcase( sqlite3_value_nochange(pMem) );
-  assert( !sqlite3VdbeMemIsRowSet(pMem) );
+  assert( (pMem->flags&MEM_Blob)!=0 || MemNullNochng(pMem) ); 
+  testcase( sqlite3_value_nochange(pMem) ); 
+  assert( !sqlite3VdbeMemIsRowSet(pMem) ); 
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
 
   /* Set nByte to the number of bytes required to store the expanded blob. */
   nByte = pMem->n + pMem->u.nZero;
   if( nByte<=0 ){
-    if( (pMem->flags & MEM_Blob)==0 ) return SQLITE_OK;
+    if( (pMem->flags & MEM_Blob)==0 ) return SQLITE_OK; 
     nByte = 1;
   }
   if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
@@ -77629,12 +77629,12 @@ SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem *pMem){
 }
 
 /*
-** Add MEM_Str to the set of representations for the given Mem.  This
-** routine is only called if pMem is a number of some kind, not a NULL
-** or a BLOB.
+** Add MEM_Str to the set of representations for the given Mem.  This 
+** routine is only called if pMem is a number of some kind, not a NULL 
+** or a BLOB. 
 **
-** Existing representations MEM_Int, MEM_Real, or MEM_IntReal are invalidated
-** if bForce is true but are retained if bForce is false.
+** Existing representations MEM_Int, MEM_Real, or MEM_IntReal are invalidated 
+** if bForce is true but are retained if bForce is false. 
 **
 ** A MEM_Null value will never be passed to this function. This function is
 ** used for converting values to text for returning to the user (i.e. via
@@ -77647,10 +77647,10 @@ SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, u8 enc, u8 bForce){
 
   assert( pMem!=0 );
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
-  assert( !(pMem->flags&MEM_Zero) );
-  assert( !(pMem->flags&(MEM_Str|MEM_Blob)) );
-  assert( pMem->flags&(MEM_Int|MEM_Real|MEM_IntReal) );
-  assert( !sqlite3VdbeMemIsRowSet(pMem) );
+  assert( !(pMem->flags&MEM_Zero) ); 
+  assert( !(pMem->flags&(MEM_Str|MEM_Blob)) ); 
+  assert( pMem->flags&(MEM_Int|MEM_Real|MEM_IntReal) ); 
+  assert( !sqlite3VdbeMemIsRowSet(pMem) ); 
   assert( EIGHT_BYTE_ALIGNMENT(pMem) );
 
 
@@ -77659,12 +77659,12 @@ SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, u8 enc, u8 bForce){
     return SQLITE_NOMEM_BKPT;
   }
 
-  vdbeMemRenderNum(nByte, pMem->z, pMem);
-  assert( pMem->z!=0 );
-  pMem->n = sqlite3Strlen30NN(pMem->z);
+  vdbeMemRenderNum(nByte, pMem->z, pMem); 
+  assert( pMem->z!=0 ); 
+  pMem->n = sqlite3Strlen30NN(pMem->z); 
   pMem->enc = SQLITE_UTF8;
   pMem->flags |= MEM_Str|MEM_Term;
-  if( bForce ) pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal);
+  if( bForce ) pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal); 
   sqlite3VdbeChangeEncoding(pMem, enc);
   return SQLITE_OK;
 }
@@ -77700,31 +77700,31 @@ SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
 }
 
 /*
-** Memory cell pAccum contains the context of an aggregate function.
-** This routine calls the xValue method for that function and stores
-** the results in memory cell pMem.
-**
+** Memory cell pAccum contains the context of an aggregate function. 
+** This routine calls the xValue method for that function and stores 
+** the results in memory cell pMem. 
+** 
 ** SQLITE_ERROR is returned if xValue() reports an error. SQLITE_OK
-** otherwise.
-*/
-#ifndef SQLITE_OMIT_WINDOWFUNC
-SQLITE_PRIVATE int sqlite3VdbeMemAggValue(Mem *pAccum, Mem *pOut, FuncDef *pFunc){
-  sqlite3_context ctx;
-  assert( pFunc!=0 );
-  assert( pFunc->xValue!=0 );
-  assert( (pAccum->flags & MEM_Null)!=0 || pFunc==pAccum->u.pDef );
-  assert( pAccum->db==0 || sqlite3_mutex_held(pAccum->db->mutex) );
-  memset(&ctx, 0, sizeof(ctx));
-  sqlite3VdbeMemSetNull(pOut);
-  ctx.pOut = pOut;
-  ctx.pMem = pAccum;
-  ctx.pFunc = pFunc;
-  pFunc->xValue(&ctx);
-  return ctx.isError;
-}
-#endif /* SQLITE_OMIT_WINDOWFUNC */
-
-/*
+** otherwise. 
+*/ 
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+SQLITE_PRIVATE int sqlite3VdbeMemAggValue(Mem *pAccum, Mem *pOut, FuncDef *pFunc){ 
+  sqlite3_context ctx; 
+  assert( pFunc!=0 ); 
+  assert( pFunc->xValue!=0 ); 
+  assert( (pAccum->flags & MEM_Null)!=0 || pFunc==pAccum->u.pDef ); 
+  assert( pAccum->db==0 || sqlite3_mutex_held(pAccum->db->mutex) ); 
+  memset(&ctx, 0, sizeof(ctx)); 
+  sqlite3VdbeMemSetNull(pOut); 
+  ctx.pOut = pOut; 
+  ctx.pMem = pAccum; 
+  ctx.pFunc = pFunc; 
+  pFunc->xValue(&ctx); 
+  return ctx.isError; 
+} 
+#endif /* SQLITE_OMIT_WINDOWFUNC */ 
+ 
+/* 
 ** If the memory cell contains a value that must be freed by
 ** invoking the external callback in Mem.xDel, then this routine
 ** will free that value.  It also sets Mem.flags to MEM_Null.
@@ -77836,8 +77836,8 @@ SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem *pMem){
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
   assert( EIGHT_BYTE_ALIGNMENT(pMem) );
   flags = pMem->flags;
-  if( flags & (MEM_Int|MEM_IntReal) ){
-    testcase( flags & MEM_IntReal );
+  if( flags & (MEM_Int|MEM_IntReal) ){ 
+    testcase( flags & MEM_IntReal ); 
     return pMem->u.i;
   }else if( flags & MEM_Real ){
     return doubleToInt64(pMem->u.r);
@@ -77866,8 +77866,8 @@ SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem *pMem){
   assert( EIGHT_BYTE_ALIGNMENT(pMem) );
   if( pMem->flags & MEM_Real ){
     return pMem->u.r;
-  }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){
-    testcase( pMem->flags & MEM_IntReal );
+  }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){ 
+    testcase( pMem->flags & MEM_IntReal ); 
     return (double)pMem->u.i;
   }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
     return memRealValue(pMem);
@@ -77878,17 +77878,17 @@ SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem *pMem){
 }
 
 /*
-** Return 1 if pMem represents true, and return 0 if pMem represents false.
+** Return 1 if pMem represents true, and return 0 if pMem represents false. 
 ** Return the value ifNull if pMem is NULL.
-*/
-SQLITE_PRIVATE int sqlite3VdbeBooleanValue(Mem *pMem, int ifNull){
-  testcase( pMem->flags & MEM_IntReal );
-  if( pMem->flags & (MEM_Int|MEM_IntReal) ) return pMem->u.i!=0;
-  if( pMem->flags & MEM_Null ) return ifNull;
-  return sqlite3VdbeRealValue(pMem)!=0.0;
-}
-
-/*
+*/ 
+SQLITE_PRIVATE int sqlite3VdbeBooleanValue(Mem *pMem, int ifNull){ 
+  testcase( pMem->flags & MEM_IntReal ); 
+  if( pMem->flags & (MEM_Int|MEM_IntReal) ) return pMem->u.i!=0; 
+  if( pMem->flags & MEM_Null ) return ifNull; 
+  return sqlite3VdbeRealValue(pMem)!=0.0; 
+} 
+ 
+/* 
 ** The MEM structure is already a MEM_Real.  Try to also make it a
 ** MEM_Int if we can.
 */
@@ -77896,7 +77896,7 @@ SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){
   i64 ix;
   assert( pMem!=0 );
   assert( pMem->flags & MEM_Real );
-  assert( !sqlite3VdbeMemIsRowSet(pMem) );
+  assert( !sqlite3VdbeMemIsRowSet(pMem) ); 
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
   assert( EIGHT_BYTE_ALIGNMENT(pMem) );
 
@@ -77924,7 +77924,7 @@ SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){
 SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem *pMem){
   assert( pMem!=0 );
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
-  assert( !sqlite3VdbeMemIsRowSet(pMem) );
+  assert( !sqlite3VdbeMemIsRowSet(pMem) ); 
   assert( EIGHT_BYTE_ALIGNMENT(pMem) );
 
   pMem->u.i = sqlite3VdbeIntValue(pMem);
@@ -77946,24 +77946,24 @@ SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem *pMem){
   return SQLITE_OK;
 }
 
-/* Compare a floating point value to an integer.  Return true if the two
-** values are the same within the precision of the floating point value.
-**
-** This function assumes that i was obtained by assignment from r1.
-**
-** For some versions of GCC on 32-bit machines, if you do the more obvious
-** comparison of "r1==(double)i" you sometimes get an answer of false even
-** though the r1 and (double)i values are bit-for-bit the same.
-*/
-SQLITE_PRIVATE int sqlite3RealSameAsInt(double r1, sqlite3_int64 i){
-  double r2 = (double)i;
-  return r1==0.0
-      || (memcmp(&r1, &r2, sizeof(r1))==0
-          && i >= -2251799813685248LL && i < 2251799813685248LL);
-}
-
-/*
-** Convert pMem so that it has type MEM_Real or MEM_Int.
+/* Compare a floating point value to an integer.  Return true if the two 
+** values are the same within the precision of the floating point value. 
+** 
+** This function assumes that i was obtained by assignment from r1. 
+** 
+** For some versions of GCC on 32-bit machines, if you do the more obvious 
+** comparison of "r1==(double)i" you sometimes get an answer of false even 
+** though the r1 and (double)i values are bit-for-bit the same. 
+*/ 
+SQLITE_PRIVATE int sqlite3RealSameAsInt(double r1, sqlite3_int64 i){ 
+  double r2 = (double)i; 
+  return r1==0.0 
+      || (memcmp(&r1, &r2, sizeof(r1))==0 
+          && i >= -2251799813685248LL && i < 2251799813685248LL); 
+} 
+ 
+/*
+** Convert pMem so that it has type MEM_Real or MEM_Int. 
 ** Invalidate any prior representations.
 **
 ** Every effort is made to force the conversion, even if the input
@@ -77972,26 +77972,26 @@ SQLITE_PRIVATE int sqlite3RealSameAsInt(double r1, sqlite3_int64 i){
 */
 SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem *pMem){
   assert( pMem!=0 );
-  testcase( pMem->flags & MEM_Int );
-  testcase( pMem->flags & MEM_Real );
-  testcase( pMem->flags & MEM_IntReal );
-  testcase( pMem->flags & MEM_Null );
-  if( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))==0 ){
+  testcase( pMem->flags & MEM_Int ); 
+  testcase( pMem->flags & MEM_Real ); 
+  testcase( pMem->flags & MEM_IntReal ); 
+  testcase( pMem->flags & MEM_Null ); 
+  if( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))==0 ){ 
     int rc;
-    sqlite3_int64 ix;
+    sqlite3_int64 ix; 
     assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
     assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
-    rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
-    if( ((rc==0 || rc==1) && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1)
-     || sqlite3RealSameAsInt(pMem->u.r, (ix = (i64)pMem->u.r))
-    ){
-      pMem->u.i = ix;
+    rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc); 
+    if( ((rc==0 || rc==1) && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1) 
+     || sqlite3RealSameAsInt(pMem->u.r, (ix = (i64)pMem->u.r)) 
+    ){ 
+      pMem->u.i = ix; 
       MemSetTypeFlag(pMem, MEM_Int);
     }else{
-      MemSetTypeFlag(pMem, MEM_Real);
+      MemSetTypeFlag(pMem, MEM_Real); 
     }
   }
-  assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))!=0 );
+  assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))!=0 ); 
   pMem->flags &= ~(MEM_Str|MEM_Blob|MEM_Zero);
   return SQLITE_OK;
 }
@@ -78034,7 +78034,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemCast(Mem *pMem, u8 aff, u8 encoding){
       pMem->flags |= (pMem->flags&MEM_Blob)>>3;
       sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding);
       assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
-      pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal|MEM_Blob|MEM_Zero);
+      pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal|MEM_Blob|MEM_Zero); 
       return sqlite3VdbeChangeEncoding(pMem, encoding);
     }
   }
@@ -78132,7 +78132,7 @@ SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
 }
 
 /* A no-op destructor */
-SQLITE_PRIVATE void sqlite3NoopDestructor(void *p){ UNUSED_PARAMETER(p); }
+SQLITE_PRIVATE void sqlite3NoopDestructor(void *p){ UNUSED_PARAMETER(p); } 
 
 /*
 ** Set the value stored in *pMem should already be a NULL.
@@ -78166,36 +78166,36 @@ SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
 }
 #endif
 
-#ifdef SQLITE_DEBUG
-/*
-** Return true if the Mem holds a RowSet object.  This routine is intended
-** for use inside of assert() statements.
-*/
-SQLITE_PRIVATE int sqlite3VdbeMemIsRowSet(const Mem *pMem){
-  return (pMem->flags&(MEM_Blob|MEM_Dyn))==(MEM_Blob|MEM_Dyn)
-         && pMem->xDel==sqlite3RowSetDelete;
-}
-#endif
-
+#ifdef SQLITE_DEBUG 
 /*
+** Return true if the Mem holds a RowSet object.  This routine is intended 
+** for use inside of assert() statements. 
+*/ 
+SQLITE_PRIVATE int sqlite3VdbeMemIsRowSet(const Mem *pMem){ 
+  return (pMem->flags&(MEM_Blob|MEM_Dyn))==(MEM_Blob|MEM_Dyn) 
+         && pMem->xDel==sqlite3RowSetDelete; 
+} 
+#endif 
+ 
+/* 
 ** Delete any previous value and set the value of pMem to be an
 ** empty boolean index.
-**
-** Return SQLITE_OK on success and SQLITE_NOMEM if a memory allocation
-** error occurs.
+** 
+** Return SQLITE_OK on success and SQLITE_NOMEM if a memory allocation 
+** error occurs. 
 */
-SQLITE_PRIVATE int sqlite3VdbeMemSetRowSet(Mem *pMem){
+SQLITE_PRIVATE int sqlite3VdbeMemSetRowSet(Mem *pMem){ 
   sqlite3 *db = pMem->db;
-  RowSet *p;
+  RowSet *p; 
   assert( db!=0 );
-  assert( !sqlite3VdbeMemIsRowSet(pMem) );
+  assert( !sqlite3VdbeMemIsRowSet(pMem) ); 
   sqlite3VdbeMemRelease(pMem);
-  p = sqlite3RowSetInit(db);
-  if( p==0 ) return SQLITE_NOMEM;
-  pMem->z = (char*)p;
-  pMem->flags = MEM_Blob|MEM_Dyn;
-  pMem->xDel = sqlite3RowSetDelete;
-  return SQLITE_OK;
+  p = sqlite3RowSetInit(db); 
+  if( p==0 ) return SQLITE_NOMEM; 
+  pMem->z = (char*)p; 
+  pMem->flags = MEM_Blob|MEM_Dyn; 
+  pMem->xDel = sqlite3RowSetDelete; 
+  return SQLITE_OK; 
 }
 
 /*
@@ -78234,17 +78234,17 @@ SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){
           (int)(pX - pVdbe->aMem), (int)(pMem - pVdbe->aMem));
       }
       /* If pX is marked as a shallow copy of pMem, then try to verify that
-      ** no significant changes have been made to pX since the OP_SCopy.
-      ** A significant change would indicated a missed call to this
-      ** function for pX.  Minor changes, such as adding or removing a
-      ** dual type, are allowed, as long as the underlying value is the
-      ** same. */
+      ** no significant changes have been made to pX since the OP_SCopy. 
+      ** A significant change would indicated a missed call to this 
+      ** function for pX.  Minor changes, such as adding or removing a 
+      ** dual type, are allowed, as long as the underlying value is the 
+      ** same. */ 
       mFlags = pMem->flags & pX->flags & pX->mScopyFlags;
-      assert( (mFlags&(MEM_Int|MEM_IntReal))==0 || pMem->u.i==pX->u.i );
+      assert( (mFlags&(MEM_Int|MEM_IntReal))==0 || pMem->u.i==pX->u.i ); 
 
-      /* pMem is the register that is changing.  But also mark pX as
-      ** undefined so that we can quickly detect the shallow-copy error */
-      pX->flags = MEM_Undefined;
+      /* pMem is the register that is changing.  But also mark pX as 
+      ** undefined so that we can quickly detect the shallow-copy error */ 
+      pX->flags = MEM_Undefined; 
       pX->pScopyFrom = 0;
     }
   }
@@ -78264,7 +78264,7 @@ static SQLITE_NOINLINE void vdbeClrCopy(Mem *pTo, const Mem *pFrom, int eType){
   sqlite3VdbeMemShallowCopy(pTo, pFrom, eType);
 }
 SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
-  assert( !sqlite3VdbeMemIsRowSet(pFrom) );
+  assert( !sqlite3VdbeMemIsRowSet(pFrom) ); 
   assert( pTo->db==pFrom->db );
   if( VdbeMemDynamic(pTo) ){ vdbeClrCopy(pTo,pFrom,srcType); return; }
   memcpy(pTo, pFrom, MEMCELLSIZE);
@@ -78282,7 +78282,7 @@ SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int sr
 SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
   int rc = SQLITE_OK;
 
-  assert( !sqlite3VdbeMemIsRowSet(pFrom) );
+  assert( !sqlite3VdbeMemIsRowSet(pFrom) ); 
   if( VdbeMemDynamic(pTo) ) vdbeMemClearExternAndSetNull(pTo);
   memcpy(pTo, pFrom, MEMCELLSIZE);
   pTo->flags &= ~MEM_Dyn;
@@ -78341,7 +78341,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemSetStr(
 
   assert( pMem!=0 );
   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
-  assert( !sqlite3VdbeMemIsRowSet(pMem) );
+  assert( !sqlite3VdbeMemIsRowSet(pMem) ); 
 
   /* If z is a NULL pointer, set pMem to contain an SQL NULL. */
   if( !z ){
@@ -78375,25 +78375,25 @@ SQLITE_PRIVATE int sqlite3VdbeMemSetStr(
       nAlloc += (enc==SQLITE_UTF8?1:2);
     }
     if( nByte>iLimit ){
-      return sqlite3ErrorToParser(pMem->db, SQLITE_TOOBIG);
+      return sqlite3ErrorToParser(pMem->db, SQLITE_TOOBIG); 
     }
     testcase( nAlloc==0 );
     testcase( nAlloc==31 );
     testcase( nAlloc==32 );
-    if( sqlite3VdbeMemClearAndResize(pMem, (int)MAX(nAlloc,32)) ){
+    if( sqlite3VdbeMemClearAndResize(pMem, (int)MAX(nAlloc,32)) ){ 
       return SQLITE_NOMEM_BKPT;
     }
     memcpy(pMem->z, z, nAlloc);
   }else{
     sqlite3VdbeMemRelease(pMem);
     pMem->z = (char *)z;
-    if( xDel==SQLITE_DYNAMIC ){
-      pMem->zMalloc = pMem->z;
-      pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
-    }else{
-      pMem->xDel = xDel;
-      flags |= ((xDel==SQLITE_STATIC)?MEM_Static:MEM_Dyn);
-    }
+    if( xDel==SQLITE_DYNAMIC ){ 
+      pMem->zMalloc = pMem->z; 
+      pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc); 
+    }else{ 
+      pMem->xDel = xDel; 
+      flags |= ((xDel==SQLITE_STATIC)?MEM_Static:MEM_Dyn); 
+    } 
   }
 
   pMem->n = (int)(nByte & 0x7fffffff);
@@ -78445,9 +78445,9 @@ SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(
 ){
   int rc;
   pMem->flags = MEM_Null;
-  if( sqlite3BtreeMaxRecordSize(pCur)<offset+amt ){
-    return SQLITE_CORRUPT_BKPT;
-  }
+  if( sqlite3BtreeMaxRecordSize(pCur)<offset+amt ){ 
+    return SQLITE_CORRUPT_BKPT; 
+  } 
   if( SQLITE_OK==(rc = sqlite3VdbeMemClearAndResize(pMem, amt+1)) ){
     rc = sqlite3BtreePayload(pCur, offset, amt, pMem->z);
     if( rc==SQLITE_OK ){
@@ -78473,7 +78473,7 @@ SQLITE_PRIVATE int sqlite3VdbeMemFromBtreeZeroOffset(
 
   /* Note: the calls to BtreeKeyFetch() and DataFetch() below assert()
   ** that both the BtShared and database handle mutexes are held. */
-  assert( !sqlite3VdbeMemIsRowSet(pMem) );
+  assert( !sqlite3VdbeMemIsRowSet(pMem) ); 
   pMem->z = (char *)sqlite3BtreePayloadFetch(pCur, &available);
   assert( pMem->z!=0 );
 
@@ -78496,7 +78496,7 @@ static SQLITE_NOINLINE const void *valueToText(sqlite3_value* pVal, u8 enc){
   assert( pVal!=0 );
   assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
   assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
-  assert( !sqlite3VdbeMemIsRowSet(pVal) );
+  assert( !sqlite3VdbeMemIsRowSet(pVal) ); 
   assert( (pVal->flags & (MEM_Null))==0 );
   if( pVal->flags & (MEM_Blob|MEM_Str) ){
     if( ExpandBlob(pVal) ) return 0;
@@ -78518,7 +78518,7 @@ static SQLITE_NOINLINE const void *valueToText(sqlite3_value* pVal, u8 enc){
   assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
               || pVal->db->mallocFailed );
   if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
-    assert( sqlite3VdbeMemValidStrRep(pVal) );
+    assert( sqlite3VdbeMemValidStrRep(pVal) ); 
     return pVal->z;
   }else{
     return 0;
@@ -78539,9 +78539,9 @@ SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
   if( !pVal ) return 0;
   assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
   assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
-  assert( !sqlite3VdbeMemIsRowSet(pVal) );
+  assert( !sqlite3VdbeMemIsRowSet(pVal) ); 
   if( (pVal->flags&(MEM_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){
-    assert( sqlite3VdbeMemValidStrRep(pVal) );
+    assert( sqlite3VdbeMemValidStrRep(pVal) ); 
     return pVal->z;
   }
   if( pVal->flags&MEM_Null ){
@@ -78810,12 +78810,12 @@ static int valueFromExpr(
     }else{
       sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8);
     }
-    assert( (pVal->flags & MEM_IntReal)==0 );
-    if( pVal->flags & (MEM_Int|MEM_IntReal|MEM_Real) ){
-      testcase( pVal->flags & MEM_Int );
-      testcase( pVal->flags & MEM_Real );
-      pVal->flags &= ~MEM_Str;
-    }
+    assert( (pVal->flags & MEM_IntReal)==0 ); 
+    if( pVal->flags & (MEM_Int|MEM_IntReal|MEM_Real) ){ 
+      testcase( pVal->flags & MEM_Int ); 
+      testcase( pVal->flags & MEM_Real ); 
+      pVal->flags &= ~MEM_Str; 
+    } 
     if( enc!=SQLITE_UTF8 ){
       rc = sqlite3VdbeChangeEncoding(pVal, enc);
     }
@@ -78842,7 +78842,7 @@ static int valueFromExpr(
   }else if( op==TK_NULL ){
     pVal = valueNew(db, pCtx);
     if( pVal==0 ) goto no_mem;
-    sqlite3VdbeMemSetNull(pVal);
+    sqlite3VdbeMemSetNull(pVal); 
   }
 #ifndef SQLITE_OMIT_BLOB_LITERAL
   else if( op==TK_BLOB ){
@@ -78864,14 +78864,14 @@ static int valueFromExpr(
     rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
   }
 #endif
-  else if( op==TK_TRUEFALSE ){
+  else if( op==TK_TRUEFALSE ){ 
     assert( !ExprHasProperty(pExpr, EP_IntValue) );
-    pVal = valueNew(db, pCtx);
-    if( pVal ){
-      pVal->flags = MEM_Int;
-      pVal->u.i = pExpr->u.zToken[4]==0;
-    }
-  }
+    pVal = valueNew(db, pCtx); 
+    if( pVal ){ 
+      pVal->flags = MEM_Int; 
+      pVal->u.i = pExpr->u.zToken[4]==0; 
+    } 
+  } 
 
   *ppVal = pVal;
   return rc;
@@ -79074,11 +79074,11 @@ SQLITE_PRIVATE int sqlite3Stat4Column(
   int iCol,                       /* Column to extract */
   sqlite3_value **ppVal           /* OUT: Extracted value */
 ){
-  u32 t = 0;                      /* a column type code */
+  u32 t = 0;                      /* a column type code */ 
   int nHdr;                       /* Size of the header in the record */
   int iHdr;                       /* Next unread header byte */
   int iField;                     /* Next unread data byte */
-  int szField = 0;                /* Size of the current data field */
+  int szField = 0;                /* Size of the current data field */ 
   int i;                          /* Column index */
   u8 *a = (u8*)pRec;              /* Typecast byte array */
   Mem *pMem = *ppVal;             /* Write result into this Mem object */
@@ -79218,7 +79218,7 @@ SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(Parse *pParse){
   pParse->pVdbe = p;
   assert( pParse->aLabel==0 );
   assert( pParse->nLabel==0 );
-  assert( p->nOpAlloc==0 );
+  assert( p->nOpAlloc==0 ); 
   assert( pParse->szOpAlloc==0 );
   sqlite3VdbeAddOp2(p, OP_Init, 0, 1);
   return p;
@@ -79255,44 +79255,44 @@ SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, u8 prepFlag
   p->zSql = sqlite3DbStrNDup(p->db, z, n);
 }
 
-#ifdef SQLITE_ENABLE_NORMALIZE
-/*
-** Add a new element to the Vdbe->pDblStr list.
-*/
-SQLITE_PRIVATE void sqlite3VdbeAddDblquoteStr(sqlite3 *db, Vdbe *p, const char *z){
-  if( p ){
-    int n = sqlite3Strlen30(z);
-    DblquoteStr *pStr = sqlite3DbMallocRawNN(db,
-                            sizeof(*pStr)+n+1-sizeof(pStr->z));
-    if( pStr ){
-      pStr->pNextStr = p->pDblStr;
-      p->pDblStr = pStr;
-      memcpy(pStr->z, z, n+1);
-    }
-  }
-}
-#endif
-
-#ifdef SQLITE_ENABLE_NORMALIZE
-/*
-** zId of length nId is a double-quoted identifier.  Check to see if
-** that identifier is really used as a string literal.
-*/
-SQLITE_PRIVATE int sqlite3VdbeUsesDoubleQuotedString(
-  Vdbe *pVdbe,            /* The prepared statement */
-  const char *zId         /* The double-quoted identifier, already dequoted */
-){
-  DblquoteStr *pStr;
-  assert( zId!=0 );
-  if( pVdbe->pDblStr==0 ) return 0;
-  for(pStr=pVdbe->pDblStr; pStr; pStr=pStr->pNextStr){
-    if( strcmp(zId, pStr->z)==0 ) return 1;
-  }
-  return 0;
-}
-#endif
-
-/*
+#ifdef SQLITE_ENABLE_NORMALIZE 
+/*
+** Add a new element to the Vdbe->pDblStr list. 
+*/ 
+SQLITE_PRIVATE void sqlite3VdbeAddDblquoteStr(sqlite3 *db, Vdbe *p, const char *z){ 
+  if( p ){ 
+    int n = sqlite3Strlen30(z); 
+    DblquoteStr *pStr = sqlite3DbMallocRawNN(db, 
+                            sizeof(*pStr)+n+1-sizeof(pStr->z)); 
+    if( pStr ){ 
+      pStr->pNextStr = p->pDblStr; 
+      p->pDblStr = pStr; 
+      memcpy(pStr->z, z, n+1); 
+    } 
+  } 
+} 
+#endif 
+ 
+#ifdef SQLITE_ENABLE_NORMALIZE 
+/* 
+** zId of length nId is a double-quoted identifier.  Check to see if 
+** that identifier is really used as a string literal. 
+*/ 
+SQLITE_PRIVATE int sqlite3VdbeUsesDoubleQuotedString( 
+  Vdbe *pVdbe,            /* The prepared statement */ 
+  const char *zId         /* The double-quoted identifier, already dequoted */ 
+){ 
+  DblquoteStr *pStr; 
+  assert( zId!=0 ); 
+  if( pVdbe->pDblStr==0 ) return 0; 
+  for(pStr=pVdbe->pDblStr; pStr; pStr=pStr->pNextStr){ 
+    if( strcmp(zId, pStr->z)==0 ) return 1; 
+  } 
+  return 0; 
+} 
+#endif 
+ 
+/* 
 ** Swap all content between two VDBE structures.
 */
 SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe *pA, Vdbe *pB){
@@ -79312,10 +79312,10 @@ SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe *pA, Vdbe *pB){
   pA->zSql = pB->zSql;
   pB->zSql = zTmp;
 #ifdef SQLITE_ENABLE_NORMALIZE
-  zTmp = pA->zNormSql;
-  pA->zNormSql = pB->zNormSql;
-  pB->zNormSql = zTmp;
-#endif
+  zTmp = pA->zNormSql; 
+  pA->zNormSql = pB->zNormSql; 
+  pB->zNormSql = zTmp; 
+#endif 
   pB->expmask = pA->expmask;
   pB->prepFlags = pA->prepFlags;
   memcpy(pB->aCounter, pA->aCounter, sizeof(pB->aCounter));
@@ -79344,11 +79344,11 @@ static int growOpArray(Vdbe *v, int nOp){
   ** operation (without SQLITE_TEST_REALLOC_STRESS) is to double the current
   ** size of the op array or add 1KB of space, whichever is smaller. */
 #ifdef SQLITE_TEST_REALLOC_STRESS
-  sqlite3_int64 nNew = (v->nOpAlloc>=512 ? 2*(sqlite3_int64)v->nOpAlloc
-                        : (sqlite3_int64)v->nOpAlloc+nOp);
+  sqlite3_int64 nNew = (v->nOpAlloc>=512 ? 2*(sqlite3_int64)v->nOpAlloc 
+                        : (sqlite3_int64)v->nOpAlloc+nOp); 
 #else
-  sqlite3_int64 nNew = (v->nOpAlloc ? 2*(sqlite3_int64)v->nOpAlloc
-                        : (sqlite3_int64)(1024/sizeof(Op)));
+  sqlite3_int64 nNew = (v->nOpAlloc ? 2*(sqlite3_int64)v->nOpAlloc 
+                        : (sqlite3_int64)(1024/sizeof(Op))); 
   UNUSED_PARAMETER(nOp);
 #endif
 
@@ -79359,11 +79359,11 @@ static int growOpArray(Vdbe *v, int nOp){
   }
 
   assert( nOp<=(1024/sizeof(Op)) );
-  assert( nNew>=(v->nOpAlloc+nOp) );
+  assert( nNew>=(v->nOpAlloc+nOp) ); 
   pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
   if( pNew ){
     p->szOpAlloc = sqlite3DbMallocSize(p->db, pNew);
-    v->nOpAlloc = p->szOpAlloc/sizeof(Op);
+    v->nOpAlloc = p->szOpAlloc/sizeof(Op); 
     v->aOp = pNew;
   }
   return (pNew ? SQLITE_OK : SQLITE_NOMEM_BKPT);
@@ -79404,9 +79404,9 @@ static void test_addop_breakpoint(int pc, Op *pOp){
 ** operand.
 */
 static SQLITE_NOINLINE int growOp3(Vdbe *p, int op, int p1, int p2, int p3){
-  assert( p->nOpAlloc<=p->nOp );
+  assert( p->nOpAlloc<=p->nOp ); 
   if( growOpArray(p, 1) ) return 1;
-  assert( p->nOpAlloc>p->nOp );
+  assert( p->nOpAlloc>p->nOp ); 
   return sqlite3VdbeAddOp3(p, op, p1, p2, p3);
 }
 SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
@@ -79416,7 +79416,7 @@ SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
   i = p->nOp;
   assert( p->iVdbeMagic==VDBE_MAGIC_INIT );
   assert( op>=0 && op<0xff );
-  if( p->nOpAlloc<=i ){
+  if( p->nOpAlloc<=i ){ 
     return growOp3(p, op, p1, p2, p3);
   }
   assert( p->aOp!=0 );
@@ -79580,70 +79580,70 @@ SQLITE_PRIVATE int sqlite3VdbeAddOp4Dup8(
   return sqlite3VdbeAddOp4(p, op, p1, p2, p3, p4copy, p4type);
 }
 
-#ifndef SQLITE_OMIT_EXPLAIN
-/*
-** Return the address of the current EXPLAIN QUERY PLAN baseline.
-** 0 means "none".
-*/
-SQLITE_PRIVATE int sqlite3VdbeExplainParent(Parse *pParse){
-  VdbeOp *pOp;
-  if( pParse->addrExplain==0 ) return 0;
-  pOp = sqlite3VdbeGetOp(pParse->pVdbe, pParse->addrExplain);
-  return pOp->p2;
-}
-
-/*
-** Set a debugger breakpoint on the following routine in order to
-** monitor the EXPLAIN QUERY PLAN code generation.
-*/
-#if defined(SQLITE_DEBUG)
-SQLITE_PRIVATE void sqlite3ExplainBreakpoint(const char *z1, const char *z2){
-  (void)z1;
-  (void)z2;
-}
-#endif
-
-/*
+#ifndef SQLITE_OMIT_EXPLAIN 
+/*
+** Return the address of the current EXPLAIN QUERY PLAN baseline. 
+** 0 means "none". 
+*/ 
+SQLITE_PRIVATE int sqlite3VdbeExplainParent(Parse *pParse){ 
+  VdbeOp *pOp; 
+  if( pParse->addrExplain==0 ) return 0; 
+  pOp = sqlite3VdbeGetOp(pParse->pVdbe, pParse->addrExplain); 
+  return pOp->p2; 
+} 
+ 
+/* 
+** Set a debugger breakpoint on the following routine in order to 
+** monitor the EXPLAIN QUERY PLAN code generation. 
+*/ 
+#if defined(SQLITE_DEBUG) 
+SQLITE_PRIVATE void sqlite3ExplainBreakpoint(const char *z1, const char *z2){ 
+  (void)z1; 
+  (void)z2; 
+} 
+#endif 
+ 
+/* 
 ** Add a new OP_Explain opcode.
-**
-** If the bPush flag is true, then make this opcode the parent for
-** subsequent Explains until sqlite3VdbeExplainPop() is called.
-*/
-SQLITE_PRIVATE void sqlite3VdbeExplain(Parse *pParse, u8 bPush, const char *zFmt, ...){
-#ifndef SQLITE_DEBUG
-  /* Always include the OP_Explain opcodes if SQLITE_DEBUG is defined.
-  ** But omit them (for performance) during production builds */
-  if( pParse->explain==2 )
-#endif
-  {
-    char *zMsg;
-    Vdbe *v;
-    va_list ap;
-    int iThis;
-    va_start(ap, zFmt);
-    zMsg = sqlite3VMPrintf(pParse->db, zFmt, ap);
-    va_end(ap);
-    v = pParse->pVdbe;
-    iThis = v->nOp;
-    sqlite3VdbeAddOp4(v, OP_Explain, iThis, pParse->addrExplain, 0,
-                      zMsg, P4_DYNAMIC);
-    sqlite3ExplainBreakpoint(bPush?"PUSH":"", sqlite3VdbeGetOp(v,-1)->p4.z);
-    if( bPush){
-      pParse->addrExplain = iThis;
-    }
-  }
-}
-
-/*
-** Pop the EXPLAIN QUERY PLAN stack one level.
-*/
-SQLITE_PRIVATE void sqlite3VdbeExplainPop(Parse *pParse){
-  sqlite3ExplainBreakpoint("POP", 0);
-  pParse->addrExplain = sqlite3VdbeExplainParent(pParse);
-}
-#endif /* SQLITE_OMIT_EXPLAIN */
-
-/*
+** 
+** If the bPush flag is true, then make this opcode the parent for 
+** subsequent Explains until sqlite3VdbeExplainPop() is called. 
+*/ 
+SQLITE_PRIVATE void sqlite3VdbeExplain(Parse *pParse, u8 bPush, const char *zFmt, ...){ 
+#ifndef SQLITE_DEBUG 
+  /* Always include the OP_Explain opcodes if SQLITE_DEBUG is defined. 
+  ** But omit them (for performance) during production builds */ 
+  if( pParse->explain==2 ) 
+#endif 
+  { 
+    char *zMsg; 
+    Vdbe *v; 
+    va_list ap; 
+    int iThis; 
+    va_start(ap, zFmt); 
+    zMsg = sqlite3VMPrintf(pParse->db, zFmt, ap); 
+    va_end(ap); 
+    v = pParse->pVdbe; 
+    iThis = v->nOp; 
+    sqlite3VdbeAddOp4(v, OP_Explain, iThis, pParse->addrExplain, 0, 
+                      zMsg, P4_DYNAMIC); 
+    sqlite3ExplainBreakpoint(bPush?"PUSH":"", sqlite3VdbeGetOp(v,-1)->p4.z); 
+    if( bPush){ 
+      pParse->addrExplain = iThis; 
+    } 
+  } 
+} 
+ 
+/* 
+** Pop the EXPLAIN QUERY PLAN stack one level. 
+*/ 
+SQLITE_PRIVATE void sqlite3VdbeExplainPop(Parse *pParse){ 
+  sqlite3ExplainBreakpoint("POP", 0); 
+  pParse->addrExplain = sqlite3VdbeExplainParent(pParse); 
+} 
+#endif /* SQLITE_OMIT_EXPLAIN */ 
+ 
+/* 
 ** Add an OP_ParseSchema opcode.  This routine is broken out from
 ** sqlite3VdbeAddOp4() since it needs to also needs to mark all btrees
 ** as having been used.
@@ -79705,22 +79705,22 @@ SQLITE_PRIVATE void sqlite3VdbeEndCoroutine(Vdbe *v, int regYield){
 ** The VDBE knows that a P2 value is a label because labels are
 ** always negative and P2 values are suppose to be non-negative.
 ** Hence, a negative P2 value is a label that has yet to be resolved.
-** (Later:) This is only true for opcodes that have the OPFLG_JUMP
-** property.
-**
-** Variable usage notes:
+** (Later:) This is only true for opcodes that have the OPFLG_JUMP 
+** property. 
 **
-**     Parse.aLabel[x]     Stores the address that the x-th label resolves
-**                         into.  For testing (SQLITE_DEBUG), unresolved
-**                         labels stores -1, but that is not required.
-**     Parse.nLabelAlloc   Number of slots allocated to Parse.aLabel[]
-**     Parse.nLabel        The *negative* of the number of labels that have
-**                         been issued.  The negative is stored because
-**                         that gives a performance improvement over storing
-**                         the equivalent positive value.
+** Variable usage notes: 
+** 
+**     Parse.aLabel[x]     Stores the address that the x-th label resolves 
+**                         into.  For testing (SQLITE_DEBUG), unresolved 
+**                         labels stores -1, but that is not required. 
+**     Parse.nLabelAlloc   Number of slots allocated to Parse.aLabel[] 
+**     Parse.nLabel        The *negative* of the number of labels that have 
+**                         been issued.  The negative is stored because 
+**                         that gives a performance improvement over storing 
+**                         the equivalent positive value. 
 */
-SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Parse *pParse){
-  return --pParse->nLabel;
+SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Parse *pParse){ 
+  return --pParse->nLabel; 
 }
 
 /*
@@ -79728,36 +79728,36 @@ SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Parse *pParse){
 ** be inserted.  The parameter "x" must have been obtained from
 ** a prior call to sqlite3VdbeMakeLabel().
 */
-static SQLITE_NOINLINE void resizeResolveLabel(Parse *p, Vdbe *v, int j){
-  int nNewSize = 10 - p->nLabel;
-  p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel,
-                     nNewSize*sizeof(p->aLabel[0]));
-  if( p->aLabel==0 ){
-    p->nLabelAlloc = 0;
-  }else{
-#ifdef SQLITE_DEBUG
-    int i;
-    for(i=p->nLabelAlloc; i<nNewSize; i++) p->aLabel[i] = -1;
-#endif
-    p->nLabelAlloc = nNewSize;
-    p->aLabel[j] = v->nOp;
-  }
-}
+static SQLITE_NOINLINE void resizeResolveLabel(Parse *p, Vdbe *v, int j){ 
+  int nNewSize = 10 - p->nLabel; 
+  p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel, 
+                     nNewSize*sizeof(p->aLabel[0])); 
+  if( p->aLabel==0 ){ 
+    p->nLabelAlloc = 0; 
+  }else{ 
+#ifdef SQLITE_DEBUG 
+    int i; 
+    for(i=p->nLabelAlloc; i<nNewSize; i++) p->aLabel[i] = -1; 
+#endif 
+    p->nLabelAlloc = nNewSize; 
+    p->aLabel[j] = v->nOp; 
+  } 
+} 
 SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe *v, int x){
   Parse *p = v->pParse;
   int j = ADDR(x);
   assert( v->iVdbeMagic==VDBE_MAGIC_INIT );
-  assert( j<-p->nLabel );
+  assert( j<-p->nLabel ); 
   assert( j>=0 );
-#ifdef SQLITE_DEBUG
-  if( p->db->flags & SQLITE_VdbeAddopTrace ){
-    printf("RESOLVE LABEL %d to %d\n", x, v->nOp);
-  }
-#endif
-  if( p->nLabelAlloc + p->nLabel < 0 ){
-    resizeResolveLabel(p,v,j);
-  }else{
-    assert( p->aLabel[j]==(-1) ); /* Labels may only be resolved once */
+#ifdef SQLITE_DEBUG 
+  if( p->db->flags & SQLITE_VdbeAddopTrace ){ 
+    printf("RESOLVE LABEL %d to %d\n", x, v->nOp); 
+  } 
+#endif 
+  if( p->nLabelAlloc + p->nLabel < 0 ){ 
+    resizeResolveLabel(p,v,j); 
+  }else{ 
+    assert( p->aLabel[j]==(-1) ); /* Labels may only be resolved once */ 
     p->aLabel[j] = v->nOp;
   }
 }
@@ -79873,7 +79873,7 @@ SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *v, int mayAbort){
   int hasAbort = 0;
   int hasFkCounter = 0;
   int hasCreateTable = 0;
-  int hasCreateIndex = 0;
+  int hasCreateIndex = 0; 
   int hasInitCoroutine = 0;
   Op *pOp;
   VdbeOpIter sIter;
@@ -79883,24 +79883,24 @@ SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *v, int mayAbort){
   while( (pOp = opIterNext(&sIter))!=0 ){
     int opcode = pOp->opcode;
     if( opcode==OP_Destroy || opcode==OP_VUpdate || opcode==OP_VRename
-     || opcode==OP_VDestroy
+     || opcode==OP_VDestroy 
      || opcode==OP_VCreate
      || opcode==OP_ParseSchema
      || ((opcode==OP_Halt || opcode==OP_HaltIfNull)
-      && ((pOp->p1)!=SQLITE_OK && pOp->p2==OE_Abort))
+      && ((pOp->p1)!=SQLITE_OK && pOp->p2==OE_Abort)) 
     ){
       hasAbort = 1;
       break;
     }
     if( opcode==OP_CreateBtree && pOp->p3==BTREE_INTKEY ) hasCreateTable = 1;
-    if( mayAbort ){
-      /* hasCreateIndex may also be set for some DELETE statements that use
+    if( mayAbort ){ 
+      /* hasCreateIndex may also be set for some DELETE statements that use 
       ** OP_Clear. So this routine may end up returning true in the case
-      ** where a "DELETE FROM tbl" has a statement-journal but does not
-      ** require one. This is not so bad - it is an inefficiency, not a bug. */
-      if( opcode==OP_CreateBtree && pOp->p3==BTREE_BLOBKEY ) hasCreateIndex = 1;
-      if( opcode==OP_Clear ) hasCreateIndex = 1;
-    }
+      ** where a "DELETE FROM tbl" has a statement-journal but does not 
+      ** require one. This is not so bad - it is an inefficiency, not a bug. */ 
+      if( opcode==OP_CreateBtree && pOp->p3==BTREE_BLOBKEY ) hasCreateIndex = 1; 
+      if( opcode==OP_Clear ) hasCreateIndex = 1; 
+    } 
     if( opcode==OP_InitCoroutine ) hasInitCoroutine = 1;
 #ifndef SQLITE_OMIT_FOREIGN_KEY
     if( opcode==OP_FkCounter && pOp->p1==0 && pOp->p2==1 ){
@@ -79916,38 +79916,38 @@ SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *v, int mayAbort){
   ** true for this case to prevent the assert() in the callers frame
   ** from failing.  */
   return ( v->db->mallocFailed || hasAbort==mayAbort || hasFkCounter
-        || (hasCreateTable && hasInitCoroutine) || hasCreateIndex
-  );
+        || (hasCreateTable && hasInitCoroutine) || hasCreateIndex 
+  ); 
 }
 #endif /* SQLITE_DEBUG - the sqlite3AssertMayAbort() function */
 
-#ifdef SQLITE_DEBUG
-/*
-** Increment the nWrite counter in the VDBE if the cursor is not an
-** ephemeral cursor, or if the cursor argument is NULL.
-*/
-SQLITE_PRIVATE void sqlite3VdbeIncrWriteCounter(Vdbe *p, VdbeCursor *pC){
-  if( pC==0
-   || (pC->eCurType!=CURTYPE_SORTER
-       && pC->eCurType!=CURTYPE_PSEUDO
-       && !pC->isEphemeral)
-  ){
-    p->nWrite++;
-  }
-}
-#endif
-
-#ifdef SQLITE_DEBUG
-/*
-** Assert if an Abort at this point in time might result in a corrupt
-** database.
-*/
-SQLITE_PRIVATE void sqlite3VdbeAssertAbortable(Vdbe *p){
-  assert( p->nWrite==0 || p->usesStmtJournal );
-}
-#endif
-
-/*
+#ifdef SQLITE_DEBUG 
+/*
+** Increment the nWrite counter in the VDBE if the cursor is not an 
+** ephemeral cursor, or if the cursor argument is NULL. 
+*/ 
+SQLITE_PRIVATE void sqlite3VdbeIncrWriteCounter(Vdbe *p, VdbeCursor *pC){ 
+  if( pC==0 
+   || (pC->eCurType!=CURTYPE_SORTER 
+       && pC->eCurType!=CURTYPE_PSEUDO 
+       && !pC->isEphemeral) 
+  ){ 
+    p->nWrite++; 
+  } 
+} 
+#endif 
+ 
+#ifdef SQLITE_DEBUG 
+/* 
+** Assert if an Abort at this point in time might result in a corrupt 
+** database. 
+*/ 
+SQLITE_PRIVATE void sqlite3VdbeAssertAbortable(Vdbe *p){ 
+  assert( p->nWrite==0 || p->usesStmtJournal ); 
+} 
+#endif 
+ 
+/* 
 ** This routine is called after all opcodes have been inserted.  It loops
 ** through all the opcodes and fixes up some details.
 **
@@ -80016,7 +80016,7 @@ static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){
           assert( pOp->p2>=0 );
           break;
         }
-        case OP_Prev: {
+        case OP_Prev: { 
           pOp->p4.xAdvance = sqlite3BtreePrevious;
           pOp->p4type = P4_ADVANCE;
           /* The code generator never codes any of these opcodes as a jump
@@ -80046,7 +80046,7 @@ static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){
             ** non-jump opcodes less than SQLITE_MX_JUMP_CODE are guaranteed to
             ** have non-negative values for P2. */
             assert( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_JUMP)!=0 );
-            assert( ADDR(pOp->p2)<-pParse->nLabel );
+            assert( ADDR(pOp->p2)<-pParse->nLabel ); 
             pOp->p2 = aLabel[ADDR(pOp->p2)];
           }
           break;
@@ -80085,7 +80085,7 @@ SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe *p){
 */
 #if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS)
 SQLITE_PRIVATE void sqlite3VdbeVerifyNoMallocRequired(Vdbe *p, int N){
-  assert( p->nOp + N <= p->nOpAlloc );
+  assert( p->nOp + N <= p->nOpAlloc ); 
 }
 #endif
 
@@ -80106,17 +80106,17 @@ SQLITE_PRIVATE void sqlite3VdbeVerifyNoResultRow(Vdbe *p){
 #endif
 
 /*
-** Generate code (a single OP_Abortable opcode) that will
-** verify that the VDBE program can safely call Abort in the current
-** context.
-*/
-#if defined(SQLITE_DEBUG)
-SQLITE_PRIVATE void sqlite3VdbeVerifyAbortable(Vdbe *p, int onError){
-  if( onError==OE_Abort ) sqlite3VdbeAddOp0(p, OP_Abortable);
-}
-#endif
-
-/*
+** Generate code (a single OP_Abortable opcode) that will 
+** verify that the VDBE program can safely call Abort in the current 
+** context. 
+*/ 
+#if defined(SQLITE_DEBUG) 
+SQLITE_PRIVATE void sqlite3VdbeVerifyAbortable(Vdbe *p, int onError){ 
+  if( onError==OE_Abort ) sqlite3VdbeAddOp0(p, OP_Abortable); 
+} 
+#endif 
+ 
+/* 
 ** This function returns a pointer to the array of opcodes associated with
 ** the Vdbe passed as the first argument. It is the callers responsibility
 ** to arrange for the returned array to be eventually freed using the
@@ -80157,7 +80157,7 @@ SQLITE_PRIVATE VdbeOp *sqlite3VdbeAddOpList(
   VdbeOp *pOut, *pFirst;
   assert( nOp>0 );
   assert( p->iVdbeMagic==VDBE_MAGIC_INIT );
-  if( p->nOp + nOp > p->nOpAlloc && growOpArray(p, nOp) ){
+  if( p->nOp + nOp > p->nOpAlloc && growOpArray(p, nOp) ){ 
     return 0;
   }
   pFirst = pOut = &p->aOp[p->nOp];
@@ -80203,7 +80203,7 @@ SQLITE_PRIVATE void sqlite3VdbeScanStatus(
   LogEst nEst,                    /* Estimated number of output rows */
   const char *zName               /* Name of table or index being scanned */
 ){
-  sqlite3_int64 nByte = (p->nScan+1) * sizeof(ScanStatus);
+  sqlite3_int64 nByte = (p->nScan+1) * sizeof(ScanStatus); 
   ScanStatus *aNew;
   aNew = (ScanStatus*)sqlite3DbRealloc(p->db, p->aScan, nByte);
   if( aNew ){
@@ -80739,23 +80739,23 @@ static void displayP4Expr(StrAccum *p, Expr *pExpr){
   switch( pExpr->op ){
     case TK_STRING:
       assert( !ExprHasProperty(pExpr, EP_IntValue) );
-      sqlite3_str_appendf(p, "%Q", pExpr->u.zToken);
+      sqlite3_str_appendf(p, "%Q", pExpr->u.zToken); 
       break;
     case TK_INTEGER:
-      sqlite3_str_appendf(p, "%d", pExpr->u.iValue);
+      sqlite3_str_appendf(p, "%d", pExpr->u.iValue); 
       break;
     case TK_NULL:
-      sqlite3_str_appendf(p, "NULL");
+      sqlite3_str_appendf(p, "NULL"); 
       break;
     case TK_REGISTER: {
-      sqlite3_str_appendf(p, "r[%d]", pExpr->iTable);
+      sqlite3_str_appendf(p, "r[%d]", pExpr->iTable); 
       break;
     }
     case TK_COLUMN: {
       if( pExpr->iColumn<0 ){
-        sqlite3_str_appendf(p, "rowid");
+        sqlite3_str_appendf(p, "rowid"); 
       }else{
-        sqlite3_str_appendf(p, "c%d", (int)pExpr->iColumn);
+        sqlite3_str_appendf(p, "c%d", (int)pExpr->iColumn); 
       }
       break;
     }
@@ -80787,18 +80787,18 @@ static void displayP4Expr(StrAccum *p, Expr *pExpr){
     case TK_NOTNULL: zOp = "NOTNULL"; break;
 
     default:
-      sqlite3_str_appendf(p, "%s", "expr");
+      sqlite3_str_appendf(p, "%s", "expr"); 
       break;
   }
 
   if( zOp ){
-    sqlite3_str_appendf(p, "%s(", zOp);
+    sqlite3_str_appendf(p, "%s(", zOp); 
     displayP4Expr(p, pExpr->pLeft);
     if( pExpr->pRight ){
-      sqlite3_str_append(p, ",", 1);
+      sqlite3_str_append(p, ",", 1); 
       displayP4Expr(p, pExpr->pRight);
     }
-    sqlite3_str_append(p, ")", 1);
+    sqlite3_str_append(p, ")", 1); 
   }
 }
 #endif /* VDBE_DISPLAY_P4 && defined(SQLITE_ENABLE_CURSOR_HINTS) */
@@ -80819,7 +80819,7 @@ SQLITE_PRIVATE char *sqlite3VdbeDisplayP4(sqlite3 *db, Op *pOp){
       int j;
       KeyInfo *pKeyInfo = pOp->p4.pKeyInfo;
       assert( pKeyInfo->aSortFlags!=0 );
-      sqlite3_str_appendf(&x, "k(%d", pKeyInfo->nKeyField);
+      sqlite3_str_appendf(&x, "k(%d", pKeyInfo->nKeyField); 
       for(j=0; j<pKeyInfo->nKeyField; j++){
         CollSeq *pColl = pKeyInfo->aColl[j];
         const char *zColl = pColl ? pColl->zName : "";
@@ -80829,7 +80829,7 @@ SQLITE_PRIVATE char *sqlite3VdbeDisplayP4(sqlite3 *db, Op *pOp){
                (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_BIGNULL)? "N." : "",
                zColl);
       }
-      sqlite3_str_append(&x, ")", 1);
+      sqlite3_str_append(&x, ")", 1); 
       break;
     }
 #ifdef SQLITE_ENABLE_CURSOR_HINTS
@@ -80848,34 +80848,34 @@ SQLITE_PRIVATE char *sqlite3VdbeDisplayP4(sqlite3 *db, Op *pOp){
     }
     case P4_FUNCDEF: {
       FuncDef *pDef = pOp->p4.pFunc;
-      sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
+      sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg); 
       break;
     }
     case P4_FUNCCTX: {
       FuncDef *pDef = pOp->p4.pCtx->pFunc;
-      sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg);
+      sqlite3_str_appendf(&x, "%s(%d)", pDef->zName, pDef->nArg); 
       break;
     }
     case P4_INT64: {
-      sqlite3_str_appendf(&x, "%lld", *pOp->p4.pI64);
+      sqlite3_str_appendf(&x, "%lld", *pOp->p4.pI64); 
       break;
     }
     case P4_INT32: {
-      sqlite3_str_appendf(&x, "%d", pOp->p4.i);
+      sqlite3_str_appendf(&x, "%d", pOp->p4.i); 
       break;
     }
     case P4_REAL: {
-      sqlite3_str_appendf(&x, "%.16g", *pOp->p4.pReal);
+      sqlite3_str_appendf(&x, "%.16g", *pOp->p4.pReal); 
       break;
     }
     case P4_MEM: {
       Mem *pMem = pOp->p4.pMem;
       if( pMem->flags & MEM_Str ){
         zP4 = pMem->z;
-      }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){
-        sqlite3_str_appendf(&x, "%lld", pMem->u.i);
+      }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){ 
+        sqlite3_str_appendf(&x, "%lld", pMem->u.i); 
       }else if( pMem->flags & MEM_Real ){
-        sqlite3_str_appendf(&x, "%.16g", pMem->u.r);
+        sqlite3_str_appendf(&x, "%.16g", pMem->u.r); 
       }else if( pMem->flags & MEM_Null ){
         zP4 = "NULL";
       }else{
@@ -80887,7 +80887,7 @@ SQLITE_PRIVATE char *sqlite3VdbeDisplayP4(sqlite3 *db, Op *pOp){
 #ifndef SQLITE_OMIT_VIRTUALTABLE
     case P4_VTAB: {
       sqlite3_vtab *pVtab = pOp->p4.pVtab->pVtab;
-      sqlite3_str_appendf(&x, "vtab:%p", pVtab);
+      sqlite3_str_appendf(&x, "vtab:%p", pVtab); 
       break;
     }
 #endif
@@ -80899,7 +80899,7 @@ SQLITE_PRIVATE char *sqlite3VdbeDisplayP4(sqlite3 *db, Op *pOp){
       for(i=1; i<=n; i++){
         sqlite3_str_appendf(&x, "%c%u", (i==1 ? '[' : ','), ai[i]);
       }
-      sqlite3_str_append(&x, "]", 1);
+      sqlite3_str_append(&x, "]", 1); 
       break;
     }
     case P4_SUBPROGRAM: {
@@ -81010,7 +81010,7 @@ SQLITE_PRIVATE void sqlite3VdbeLeave(Vdbe *p){
 /*
 ** Print a single opcode.  This routine is used for debugging only.
 */
-SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, VdbeOp *pOp){
+SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, VdbeOp *pOp){ 
   char *zP4;
   char *zCom;
   sqlite3 dummyDb;
@@ -81085,7 +81085,7 @@ static void releaseMemArray(Mem *p, int N){
       */
       testcase( p->flags & MEM_Agg );
       testcase( p->flags & MEM_Dyn );
-      if( p->flags&(MEM_Agg|MEM_Dyn) ){
+      if( p->flags&(MEM_Agg|MEM_Dyn) ){ 
         testcase( (p->flags & MEM_Dyn)!=0 && p->xDel==sqlite3VdbeFrameMemDel );
         sqlite3VdbeMemRelease(p);
       }else if( p->szMalloc ){
@@ -81098,34 +81098,34 @@ static void releaseMemArray(Mem *p, int N){
   }
 }
 
-#ifdef SQLITE_DEBUG
-/*
-** Verify that pFrame is a valid VdbeFrame pointer.  Return true if it is
-** and false if something is wrong.
-**
-** This routine is intended for use inside of assert() statements only.
-*/
-SQLITE_PRIVATE int sqlite3VdbeFrameIsValid(VdbeFrame *pFrame){
-  if( pFrame->iFrameMagic!=SQLITE_FRAME_MAGIC ) return 0;
-  return 1;
-}
-#endif
-
-
-/*
-** This is a destructor on a Mem object (which is really an sqlite3_value)
-** that deletes the Frame object that is attached to it as a blob.
-**
-** This routine does not delete the Frame right away.  It merely adds the
-** frame to a list of frames to be deleted when the Vdbe halts.
-*/
-SQLITE_PRIVATE void sqlite3VdbeFrameMemDel(void *pArg){
-  VdbeFrame *pFrame = (VdbeFrame*)pArg;
-  assert( sqlite3VdbeFrameIsValid(pFrame) );
-  pFrame->pParent = pFrame->v->pDelFrame;
-  pFrame->v->pDelFrame = pFrame;
-}
-
+#ifdef SQLITE_DEBUG 
+/*
+** Verify that pFrame is a valid VdbeFrame pointer.  Return true if it is 
+** and false if something is wrong. 
+** 
+** This routine is intended for use inside of assert() statements only. 
+*/ 
+SQLITE_PRIVATE int sqlite3VdbeFrameIsValid(VdbeFrame *pFrame){ 
+  if( pFrame->iFrameMagic!=SQLITE_FRAME_MAGIC ) return 0; 
+  return 1; 
+} 
+#endif 
+ 
+ 
+/* 
+** This is a destructor on a Mem object (which is really an sqlite3_value) 
+** that deletes the Frame object that is attached to it as a blob. 
+** 
+** This routine does not delete the Frame right away.  It merely adds the 
+** frame to a list of frames to be deleted when the Vdbe halts. 
+*/ 
+SQLITE_PRIVATE void sqlite3VdbeFrameMemDel(void *pArg){ 
+  VdbeFrame *pFrame = (VdbeFrame*)pArg; 
+  assert( sqlite3VdbeFrameIsValid(pFrame) ); 
+  pFrame->pParent = pFrame->v->pDelFrame; 
+  pFrame->v->pDelFrame = pFrame; 
+} 
+ 
 #if defined(SQLITE_ENABLE_BYTECODE_VTAB) || !defined(SQLITE_OMIT_EXPLAIN)
 /*
 ** Locate the next opcode to be displayed in EXPLAIN or EXPLAIN
@@ -81149,7 +81149,7 @@ SQLITE_PRIVATE int sqlite3VdbeNextOpcode(
   int rc = SQLITE_OK;                  /* Result code */
   Op *aOp = 0;                         /* Opcode array */
   int iPc;                             /* Rowid.  Copy of value in *piPc */
-
+ 
   /* When the number of output rows reaches nRow, that means the
   ** listing has finished and sqlite3_step() should return SQLITE_DONE.
   ** nRow is the sum of the number of rows in the main program, plus
@@ -81242,7 +81242,7 @@ SQLITE_PRIVATE int sqlite3VdbeNextOpcode(
 #endif /* SQLITE_ENABLE_BYTECODE_VTAB || !SQLITE_OMIT_EXPLAIN */
 
 
-/*
+/* 
 ** Delete a VdbeFrame object and its contents. VdbeFrame objects are
 ** allocated by the OP_Program opcode in sqlite3VdbeExec().
 */
@@ -81250,7 +81250,7 @@ SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame *p){
   int i;
   Mem *aMem = VdbeFrameMem(p);
   VdbeCursor **apCsr = (VdbeCursor **)&aMem[p->nChildMem];
-  assert( sqlite3VdbeFrameIsValid(p) );
+  assert( sqlite3VdbeFrameIsValid(p) ); 
   for(i=0; i<p->nChildCsr; i++){
     sqlite3VdbeFreeCursor(p->v, apCsr[i]);
   }
@@ -81271,9 +81271,9 @@ SQLITE_PRIVATE void sqlite3VdbeFrameDelete(VdbeFrame *p){
 ** p->explain==2, only OP_Explain instructions are listed and these
 ** are shown in a different format.  p->explain==2 is used to implement
 ** EXPLAIN QUERY PLAN.
-** 2018-04-24:  In p->explain==2 mode, the OP_Init opcodes of triggers
-** are also shown, so that the boundaries between the main program and
-** each trigger are clear.
+** 2018-04-24:  In p->explain==2 mode, the OP_Init opcodes of triggers 
+** are also shown, so that the boundaries between the main program and 
+** each trigger are clear. 
 **
 ** When p->explain==1, first the main program is listed, then each of
 ** the trigger subprograms are listed one by one.
@@ -81424,9 +81424,9 @@ SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe *p){
 ** of a ReusableSpace object by the allocSpace() routine below.
 */
 struct ReusableSpace {
-  u8 *pSpace;            /* Available memory */
-  sqlite3_int64 nFree;   /* Bytes of available memory */
-  sqlite3_int64 nNeeded; /* Total bytes that could not be allocated */
+  u8 *pSpace;            /* Available memory */ 
+  sqlite3_int64 nFree;   /* Bytes of available memory */ 
+  sqlite3_int64 nNeeded; /* Total bytes that could not be allocated */ 
 };
 
 /* Try to allocate nByte bytes of 8-byte aligned bulk memory for pBuf
@@ -81446,7 +81446,7 @@ struct ReusableSpace {
 static void *allocSpace(
   struct ReusableSpace *p,  /* Bulk memory available for allocation */
   void *pBuf,               /* Pointer to a prior allocation */
-  sqlite3_int64 nByte       /* Bytes of memory needed */
+  sqlite3_int64 nByte       /* Bytes of memory needed */ 
 ){
   assert( EIGHT_BYTE_ALIGNMENT(p->pSpace) );
   if( pBuf==0 ){
@@ -81600,27 +81600,27 @@ SQLITE_PRIVATE void sqlite3VdbeMakeReady(
   ** the leftover memory at the end of the opcode array.  This can significantly
   ** reduce the amount of memory held by a prepared statement.
   */
-  x.nNeeded = 0;
-  p->aMem = allocSpace(&x, 0, nMem*sizeof(Mem));
-  p->aVar = allocSpace(&x, 0, nVar*sizeof(Mem));
-  p->apArg = allocSpace(&x, 0, nArg*sizeof(Mem*));
-  p->apCsr = allocSpace(&x, 0, nCursor*sizeof(VdbeCursor*));
+  x.nNeeded = 0; 
+  p->aMem = allocSpace(&x, 0, nMem*sizeof(Mem)); 
+  p->aVar = allocSpace(&x, 0, nVar*sizeof(Mem)); 
+  p->apArg = allocSpace(&x, 0, nArg*sizeof(Mem*)); 
+  p->apCsr = allocSpace(&x, 0, nCursor*sizeof(VdbeCursor*)); 
 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
-  p->anExec = allocSpace(&x, 0, p->nOp*sizeof(i64));
+  p->anExec = allocSpace(&x, 0, p->nOp*sizeof(i64)); 
 #endif
-  if( x.nNeeded ){
+  if( x.nNeeded ){ 
     x.pSpace = p->pFree = sqlite3DbMallocRawNN(db, x.nNeeded);
     x.nFree = x.nNeeded;
-    if( !db->mallocFailed ){
-      p->aMem = allocSpace(&x, p->aMem, nMem*sizeof(Mem));
-      p->aVar = allocSpace(&x, p->aVar, nVar*sizeof(Mem));
-      p->apArg = allocSpace(&x, p->apArg, nArg*sizeof(Mem*));
-      p->apCsr = allocSpace(&x, p->apCsr, nCursor*sizeof(VdbeCursor*));
-#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
-      p->anExec = allocSpace(&x, p->anExec, p->nOp*sizeof(i64));
-#endif
-    }
-  }
+    if( !db->mallocFailed ){ 
+      p->aMem = allocSpace(&x, p->aMem, nMem*sizeof(Mem)); 
+      p->aVar = allocSpace(&x, p->aVar, nVar*sizeof(Mem)); 
+      p->apArg = allocSpace(&x, p->apArg, nArg*sizeof(Mem*)); 
+      p->apCsr = allocSpace(&x, p->apCsr, nCursor*sizeof(VdbeCursor*)); 
+#ifdef SQLITE_ENABLE_STMT_SCANSTATUS 
+      p->anExec = allocSpace(&x, p->anExec, p->nOp*sizeof(i64)); 
+#endif 
+    } 
+  } 
 
   if( db->mallocFailed ){
     p->nVar = 0;
@@ -82272,7 +82272,7 @@ SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){
     }
 
     /* Check for immediate foreign key violations. */
-    if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){
+    if( p->rc==SQLITE_OK || (p->errorAction==OE_Fail && !isSpecialError) ){ 
       sqlite3VdbeCheckFk(p, 0);
     }
 
@@ -82314,7 +82314,7 @@ SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){
         }else{
           db->nDeferredCons = 0;
           db->nDeferredImmCons = 0;
-          db->flags &= ~(u64)SQLITE_DeferFKs;
+          db->flags &= ~(u64)SQLITE_DeferFKs; 
           sqlite3CommitInternalChanges(db);
         }
       }else{
@@ -82479,7 +82479,7 @@ SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe *p){
   */
   sqlite3VdbeHalt(p);
 
-  /* If the VDBE has been run even partially, then transfer the error code
+  /* If the VDBE has been run even partially, then transfer the error code 
   ** and error message from the VDBE into the main database structure.  But
   ** if the VDBE has just been set to run but has not actually executed any
   ** instructions yet, leave the main database error information unchanged.
@@ -82515,9 +82515,9 @@ SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe *p){
     p->zErrMsg = 0;
   }
   p->pResultSet = 0;
-#ifdef SQLITE_DEBUG
-  p->nWrite = 0;
-#endif
+#ifdef SQLITE_DEBUG 
+  p->nWrite = 0; 
+#endif 
 
   /* Save profiling information from this VDBE run.
   */
@@ -82633,16 +82633,16 @@ SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){
   vdbeFreeOpArray(db, p->aOp, p->nOp);
   sqlite3DbFree(db, p->aColName);
   sqlite3DbFree(db, p->zSql);
-#ifdef SQLITE_ENABLE_NORMALIZE
-  sqlite3DbFree(db, p->zNormSql);
-  {
-    DblquoteStr *pThis, *pNext;
-    for(pThis=p->pDblStr; pThis; pThis=pNext){
-      pNext = pThis->pNextStr;
-      sqlite3DbFree(db, pThis);
-    }
-  }
-#endif
+#ifdef SQLITE_ENABLE_NORMALIZE 
+  sqlite3DbFree(db, p->zNormSql); 
+  { 
+    DblquoteStr *pThis, *pNext; 
+    for(pThis=p->pDblStr; pThis; pThis=pNext){ 
+      pNext = pThis->pNextStr; 
+      sqlite3DbFree(db, pThis); 
+    } 
+  } 
+#endif 
 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
   {
     int i;
@@ -82809,8 +82809,8 @@ SQLITE_PRIVATE int sqlite3VdbeCursorMoveto(VdbeCursor **pp, u32 *piCol){
 #if 0 /* Inlined into the OP_MakeRecord opcode */
 /*
 ** Return the serial-type for the value stored in pMem.
-**
-** This routine might convert a large MEM_IntReal value into MEM_Real.
+** 
+** This routine might convert a large MEM_IntReal value into MEM_Real. 
 **
 ** 2019-07-11:  The primary user of this subroutine was the OP_MakeRecord
 ** opcode in the byte-code engine.  But by moving this routine in-line, we
@@ -82827,13 +82827,13 @@ SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem *pMem, int file_format, u32 *pLen){
     *pLen = 0;
     return 0;
   }
-  if( flags&(MEM_Int|MEM_IntReal) ){
+  if( flags&(MEM_Int|MEM_IntReal) ){ 
     /* Figure out whether to use 1, 2, 4, 6 or 8 bytes. */
 #   define MAX_6BYTE ((((i64)0x00008000)<<32)-1)
     i64 i = pMem->u.i;
     u64 u;
-    testcase( flags & MEM_Int );
-    testcase( flags & MEM_IntReal );
+    testcase( flags & MEM_Int ); 
+    testcase( flags & MEM_IntReal ); 
     if( i<0 ){
       u = ~i;
     }else{
@@ -82853,15 +82853,15 @@ SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem *pMem, int file_format, u32 *pLen){
     if( u<=2147483647 ){ *pLen = 4; return 4; }
     if( u<=MAX_6BYTE ){ *pLen = 6; return 5; }
     *pLen = 8;
-    if( flags&MEM_IntReal ){
-      /* If the value is IntReal and is going to take up 8 bytes to store
-      ** as an integer, then we might as well make it an 8-byte floating
-      ** point value */
-      pMem->u.r = (double)pMem->u.i;
-      pMem->flags &= ~MEM_IntReal;
-      pMem->flags |= MEM_Real;
-      return 7;
-    }
+    if( flags&MEM_IntReal ){ 
+      /* If the value is IntReal and is going to take up 8 bytes to store 
+      ** as an integer, then we might as well make it an 8-byte floating 
+      ** point value */ 
+      pMem->u.r = (double)pMem->u.i; 
+      pMem->flags &= ~MEM_IntReal; 
+      pMem->flags |= MEM_Real; 
+      return 7; 
+    } 
     return 6;
   }
   if( flags&MEM_Real ){
@@ -83036,7 +83036,7 @@ SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(u8 *buf, Mem *pMem, u32 serial_type){
 ** routine so that in most cases the overhead of moving the stack pointer
 ** is avoided.
 */
-static u32 serialGet(
+static u32 serialGet( 
   const unsigned char *buf,     /* Buffer to deserialize from */
   u32 serial_type,              /* Serial type to deserialize */
   Mem *pMem                     /* Memory cell to write value into */
@@ -83068,7 +83068,7 @@ static u32 serialGet(
     assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 );
     swapMixedEndianFloat(x);
     memcpy(&pMem->u.r, &x, sizeof(x));
-    pMem->flags = IsNaN(x) ? MEM_Null : MEM_Real;
+    pMem->flags = IsNaN(x) ? MEM_Null : MEM_Real; 
   }
   return 8;
 }
@@ -83215,7 +83215,7 @@ SQLITE_PRIVATE void sqlite3VdbeRecordUnpack(
   idx = getVarint32(aKey, szHdr);
   d = szHdr;
   u = 0;
-  while( idx<szHdr && d<=(u32)nKey ){
+  while( idx<szHdr && d<=(u32)nKey ){ 
     u32 serial_type;
 
     idx += getVarint32(&aKey[idx], serial_type);
@@ -83228,13 +83228,13 @@ SQLITE_PRIVATE void sqlite3VdbeRecordUnpack(
     pMem++;
     if( (++u)>=p->nField ) break;
   }
-  if( d>(u32)nKey && u ){
-    assert( CORRUPT_DB );
+  if( d>(u32)nKey && u ){ 
+    assert( CORRUPT_DB ); 
     /* In a corrupt record entry, the last pMem might have been set up using
-    ** uninitialized memory. Overwrite its value with NULL, to prevent
-    ** warnings from MSAN. */
-    sqlite3VdbeMemSetNull(pMem-1);
-  }
+    ** uninitialized memory. Overwrite its value with NULL, to prevent 
+    ** warnings from MSAN. */ 
+    sqlite3VdbeMemSetNull(pMem-1); 
+  } 
   assert( u<=pKeyInfo->nKeyField + 1 );
   p->nField = u;
 }
@@ -83300,7 +83300,7 @@ static int vdbeRecordCompareDebug(
     ** Use that approximation to avoid the more expensive call to
     ** sqlite3VdbeSerialTypeLen() in the common case.
     */
-    if( d1+(u64)serial_type1+2>(u64)nKey1
+    if( d1+(u64)serial_type1+2>(u64)nKey1 
      && d1+(u64)sqlite3VdbeSerialTypeLen(serial_type1)>(u64)nKey1
     ){
       break;
@@ -83312,8 +83312,8 @@ static int vdbeRecordCompareDebug(
 
     /* Do the comparison
     */
-    rc = sqlite3MemCompare(&mem1, &pPKey2->aMem[i],
-                           pKeyInfo->nAllField>i ? pKeyInfo->aColl[i] : 0);
+    rc = sqlite3MemCompare(&mem1, &pPKey2->aMem[i], 
+                           pKeyInfo->nAllField>i ? pKeyInfo->aColl[i] : 0); 
     if( rc!=0 ){
       assert( mem1.szMalloc==0 );  /* See comment below */
       if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL)
@@ -83442,7 +83442,7 @@ static int isAllZero(const char *z, int n){
 ** is less than, equal to, or greater than the second, respectively.
 ** If one blob is a prefix of the other, then the shorter is the lessor.
 */
-SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3BlobCompare(const Mem *pB1, const Mem *pB2){
+SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3BlobCompare(const Mem *pB1, const Mem *pB2){ 
   int c;
   int n1 = pB1->n;
   int n2 = pB2->n;
@@ -83488,10 +83488,10 @@ SQLITE_PRIVATE int sqlite3IntFloatCompare(i64 i, double r){
     i64 y;
     double s;
     if( r<-9223372036854775808.0 ) return +1;
-    if( r>=9223372036854775808.0 ) return -1;
+    if( r>=9223372036854775808.0 ) return -1; 
     y = (i64)r;
     if( i<y ) return -1;
-    if( i>y ) return +1;
+    if( i>y ) return +1; 
     s = (double)i;
     if( s<r ) return -1;
     if( s>r ) return +1;
@@ -83515,7 +83515,7 @@ SQLITE_PRIVATE int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const C
   f1 = pMem1->flags;
   f2 = pMem2->flags;
   combined_flags = f1|f2;
-  assert( !sqlite3VdbeMemIsRowSet(pMem1) && !sqlite3VdbeMemIsRowSet(pMem2) );
+  assert( !sqlite3VdbeMemIsRowSet(pMem1) && !sqlite3VdbeMemIsRowSet(pMem2) ); 
 
   /* If one value is NULL, it is less than the other. If both values
   ** are NULL, return 0.
@@ -83526,13 +83526,13 @@ SQLITE_PRIVATE int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const C
 
   /* At least one of the two values is a number
   */
-  if( combined_flags&(MEM_Int|MEM_Real|MEM_IntReal) ){
-    testcase( combined_flags & MEM_Int );
-    testcase( combined_flags & MEM_Real );
-    testcase( combined_flags & MEM_IntReal );
-    if( (f1 & f2 & (MEM_Int|MEM_IntReal))!=0 ){
-      testcase( f1 & f2 & MEM_Int );
-      testcase( f1 & f2 & MEM_IntReal );
+  if( combined_flags&(MEM_Int|MEM_Real|MEM_IntReal) ){ 
+    testcase( combined_flags & MEM_Int ); 
+    testcase( combined_flags & MEM_Real ); 
+    testcase( combined_flags & MEM_IntReal ); 
+    if( (f1 & f2 & (MEM_Int|MEM_IntReal))!=0 ){ 
+      testcase( f1 & f2 & MEM_Int ); 
+      testcase( f1 & f2 & MEM_IntReal ); 
       if( pMem1->u.i < pMem2->u.i ) return -1;
       if( pMem1->u.i > pMem2->u.i ) return +1;
       return 0;
@@ -83542,23 +83542,23 @@ SQLITE_PRIVATE int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const C
       if( pMem1->u.r > pMem2->u.r ) return +1;
       return 0;
     }
-    if( (f1&(MEM_Int|MEM_IntReal))!=0 ){
-      testcase( f1 & MEM_Int );
-      testcase( f1 & MEM_IntReal );
+    if( (f1&(MEM_Int|MEM_IntReal))!=0 ){ 
+      testcase( f1 & MEM_Int ); 
+      testcase( f1 & MEM_IntReal ); 
       if( (f2&MEM_Real)!=0 ){
         return sqlite3IntFloatCompare(pMem1->u.i, pMem2->u.r);
-      }else if( (f2&(MEM_Int|MEM_IntReal))!=0 ){
-        if( pMem1->u.i < pMem2->u.i ) return -1;
-        if( pMem1->u.i > pMem2->u.i ) return +1;
-        return 0;
+      }else if( (f2&(MEM_Int|MEM_IntReal))!=0 ){ 
+        if( pMem1->u.i < pMem2->u.i ) return -1; 
+        if( pMem1->u.i > pMem2->u.i ) return +1; 
+        return 0; 
       }else{
         return -1;
       }
     }
     if( (f1&MEM_Real)!=0 ){
-      if( (f2&(MEM_Int|MEM_IntReal))!=0 ){
-        testcase( f2 & MEM_Int );
-        testcase( f2 & MEM_IntReal );
+      if( (f2&(MEM_Int|MEM_IntReal))!=0 ){ 
+        testcase( f2 & MEM_Int ); 
+        testcase( f2 & MEM_IntReal ); 
         return -sqlite3IntFloatCompare(pMem2->u.i, pMem1->u.r);
       }else{
         return -1;
@@ -83673,7 +83673,7 @@ SQLITE_PRIVATE int sqlite3VdbeRecordCompareWithSkip(
   u32 idx1;                       /* Offset of first type in header */
   int rc = 0;                     /* Return value */
   Mem *pRhs = pPKey2->aMem;       /* Next field of pPKey2 to compare */
-  KeyInfo *pKeyInfo;
+  KeyInfo *pKeyInfo; 
   const unsigned char *aKey1 = (const unsigned char *)pKey1;
   Mem mem1;
 
@@ -83693,9 +83693,9 @@ SQLITE_PRIVATE int sqlite3VdbeRecordCompareWithSkip(
     i = 0;
   }
   if( d1>(unsigned)nKey1 ){
-    pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
-    return 0;  /* Corruption */
-  }
+    pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT; 
+    return 0;  /* Corruption */ 
+  } 
 
   VVA_ONLY( mem1.szMalloc = 0; ) /* Only needed by assert() statements */
   assert( pPKey2->pKeyInfo->nAllField>=pPKey2->nField
@@ -83707,9 +83707,9 @@ SQLITE_PRIVATE int sqlite3VdbeRecordCompareWithSkip(
     u32 serial_type;
 
     /* RHS is an integer */
-    if( pRhs->flags & (MEM_Int|MEM_IntReal) ){
-      testcase( pRhs->flags & MEM_Int );
-      testcase( pRhs->flags & MEM_IntReal );
+    if( pRhs->flags & (MEM_Int|MEM_IntReal) ){ 
+      testcase( pRhs->flags & MEM_Int ); 
+      testcase( pRhs->flags & MEM_IntReal ); 
       serial_type = aKey1[idx1];
       testcase( serial_type==12 );
       if( serial_type>=10 ){
@@ -83767,9 +83767,9 @@ SQLITE_PRIVATE int sqlite3VdbeRecordCompareWithSkip(
         mem1.n = (serial_type - 12) / 2;
         testcase( (d1+mem1.n)==(unsigned)nKey1 );
         testcase( (d1+mem1.n+1)==(unsigned)nKey1 );
-        if( (d1+mem1.n) > (unsigned)nKey1
-         || (pKeyInfo = pPKey2->pKeyInfo)->nAllField<=i
-        ){
+        if( (d1+mem1.n) > (unsigned)nKey1 
+         || (pKeyInfo = pPKey2->pKeyInfo)->nAllField<=i 
+        ){ 
           pPKey2->errCode = (u8)SQLITE_CORRUPT_BKPT;
           return 0;                /* Corruption */
         }else if( pKeyInfo->aColl[i] ){
@@ -83838,11 +83838,11 @@ SQLITE_PRIVATE int sqlite3VdbeRecordCompareWithSkip(
     }
 
     i++;
-    if( i==pPKey2->nField ) break;
+    if( i==pPKey2->nField ) break; 
     pRhs++;
     d1 += sqlite3VdbeSerialTypeLen(serial_type);
     idx1 += sqlite3VarintLen(serial_type);
-  }while( idx1<(unsigned)szHdr1 && d1<=(unsigned)nKey1 );
+  }while( idx1<(unsigned)szHdr1 && d1<=(unsigned)nKey1 ); 
 
   /* No memory allocation is ever used on mem1.  Prove this using
   ** the following assert().  If the assert() fails, it indicates a
@@ -83854,7 +83854,7 @@ SQLITE_PRIVATE int sqlite3VdbeRecordCompareWithSkip(
   ** value.  */
   assert( CORRUPT_DB
        || vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, pPKey2->default_rc)
-       || pPKey2->pKeyInfo->db->mallocFailed
+       || pPKey2->pKeyInfo->db->mallocFailed 
   );
   pPKey2->eqSeen = 1;
   return pPKey2->default_rc;
@@ -84066,9 +84066,9 @@ SQLITE_PRIVATE RecordCompare sqlite3VdbeFindCompare(UnpackedRecord *p){
     testcase( flags & MEM_Real );
     testcase( flags & MEM_Null );
     testcase( flags & MEM_Blob );
-    if( (flags & (MEM_Real|MEM_IntReal|MEM_Null|MEM_Blob))==0
-     && p->pKeyInfo->aColl[0]==0
-    ){
+    if( (flags & (MEM_Real|MEM_IntReal|MEM_Null|MEM_Blob))==0 
+     && p->pKeyInfo->aColl[0]==0 
+    ){ 
       assert( flags & MEM_Str );
       return vdbeRecordCompareString;
     }
@@ -84113,9 +84113,9 @@ SQLITE_PRIVATE int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
   getVarint32NR((u8*)m.z, szHdr);
   testcase( szHdr==3 );
   testcase( szHdr==(u32)m.n );
-  testcase( szHdr>0x7fffffff );
-  assert( m.n>=0 );
-  if( unlikely(szHdr<3 || szHdr>(unsigned)m.n) ){
+  testcase( szHdr>0x7fffffff ); 
+  assert( m.n>=0 ); 
+  if( unlikely(szHdr<3 || szHdr>(unsigned)m.n) ){ 
     goto idx_rowid_corruption;
   }
 
@@ -84190,7 +84190,7 @@ SQLITE_PRIVATE int sqlite3VdbeIdxKeyCompare(
   if( rc ){
     return rc;
   }
-  *res = sqlite3VdbeRecordCompareWithSkip(m.n, m.z, pUnpacked, 0);
+  *res = sqlite3VdbeRecordCompareWithSkip(m.n, m.z, pUnpacked, 0); 
   sqlite3VdbeMemRelease(&m);
   return SQLITE_OK;
 }
@@ -84222,19 +84222,19 @@ SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe *v){
 ** programs obsolete.  Removing user-defined functions or collating
 ** sequences, or changing an authorization function are the types of
 ** things that make prepared statements obsolete.
-**
-** If iCode is 1, then expiration is advisory.  The statement should
-** be reprepared before being restarted, but if it is already running
-** it is allowed to run to completion.
-**
-** Internally, this function just sets the Vdbe.expired flag on all
-** prepared statements.  The flag is set to 1 for an immediate expiration
-** and set to 2 for an advisory expiration.
-*/
-SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3 *db, int iCode){
+** 
+** If iCode is 1, then expiration is advisory.  The statement should 
+** be reprepared before being restarted, but if it is already running 
+** it is allowed to run to completion. 
+** 
+** Internally, this function just sets the Vdbe.expired flag on all 
+** prepared statements.  The flag is set to 1 for an immediate expiration 
+** and set to 2 for an advisory expiration. 
+*/
+SQLITE_PRIVATE void sqlite3ExpirePreparedStatements(sqlite3 *db, int iCode){ 
   Vdbe *p;
   for(p = db->pVdbe; p; p=p->pNext){
-    p->expired = iCode+1;
+    p->expired = iCode+1; 
   }
 }
 
@@ -84502,16 +84502,16 @@ static SQLITE_NOINLINE void invokeProfileCallback(sqlite3 *db, Vdbe *p){
   sqlite3_int64 iNow;
   sqlite3_int64 iElapse;
   assert( p->startTime>0 );
-  assert( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0 );
+  assert( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0 ); 
   assert( db->init.busy==0 );
   assert( p->zSql!=0 );
   sqlite3OsCurrentTimeInt64(db->pVfs, &iNow);
   iElapse = (iNow - p->startTime)*1000000;
-#ifndef SQLITE_OMIT_DEPRECATED
+#ifndef SQLITE_OMIT_DEPRECATED 
   if( db->xProfile ){
     db->xProfile(db->pProfileArg, p->zSql, iElapse);
   }
-#endif
+#endif 
   if( db->mTrace & SQLITE_TRACE_PROFILE ){
     db->trace.xV2(SQLITE_TRACE_PROFILE, db->pTraceArg, p, (void*)&iElapse);
   }
@@ -84674,86 +84674,86 @@ SQLITE_API const void *sqlite3_value_text16le(sqlite3_value *pVal){
 */
 SQLITE_API int sqlite3_value_type(sqlite3_value* pVal){
   static const u8 aType[] = {
-     SQLITE_BLOB,     /* 0x00 (not possible) */
-     SQLITE_NULL,     /* 0x01 NULL */
-     SQLITE_TEXT,     /* 0x02 TEXT */
-     SQLITE_NULL,     /* 0x03 (not possible) */
-     SQLITE_INTEGER,  /* 0x04 INTEGER */
-     SQLITE_NULL,     /* 0x05 (not possible) */
-     SQLITE_INTEGER,  /* 0x06 INTEGER + TEXT */
-     SQLITE_NULL,     /* 0x07 (not possible) */
-     SQLITE_FLOAT,    /* 0x08 FLOAT */
-     SQLITE_NULL,     /* 0x09 (not possible) */
-     SQLITE_FLOAT,    /* 0x0a FLOAT + TEXT */
-     SQLITE_NULL,     /* 0x0b (not possible) */
-     SQLITE_INTEGER,  /* 0x0c (not possible) */
-     SQLITE_NULL,     /* 0x0d (not possible) */
-     SQLITE_INTEGER,  /* 0x0e (not possible) */
-     SQLITE_NULL,     /* 0x0f (not possible) */
-     SQLITE_BLOB,     /* 0x10 BLOB */
-     SQLITE_NULL,     /* 0x11 (not possible) */
-     SQLITE_TEXT,     /* 0x12 (not possible) */
-     SQLITE_NULL,     /* 0x13 (not possible) */
-     SQLITE_INTEGER,  /* 0x14 INTEGER + BLOB */
-     SQLITE_NULL,     /* 0x15 (not possible) */
-     SQLITE_INTEGER,  /* 0x16 (not possible) */
-     SQLITE_NULL,     /* 0x17 (not possible) */
-     SQLITE_FLOAT,    /* 0x18 FLOAT + BLOB */
-     SQLITE_NULL,     /* 0x19 (not possible) */
-     SQLITE_FLOAT,    /* 0x1a (not possible) */
-     SQLITE_NULL,     /* 0x1b (not possible) */
-     SQLITE_INTEGER,  /* 0x1c (not possible) */
-     SQLITE_NULL,     /* 0x1d (not possible) */
-     SQLITE_INTEGER,  /* 0x1e (not possible) */
-     SQLITE_NULL,     /* 0x1f (not possible) */
-     SQLITE_FLOAT,    /* 0x20 INTREAL */
-     SQLITE_NULL,     /* 0x21 (not possible) */
-     SQLITE_TEXT,     /* 0x22 INTREAL + TEXT */
-     SQLITE_NULL,     /* 0x23 (not possible) */
-     SQLITE_FLOAT,    /* 0x24 (not possible) */
-     SQLITE_NULL,     /* 0x25 (not possible) */
-     SQLITE_FLOAT,    /* 0x26 (not possible) */
-     SQLITE_NULL,     /* 0x27 (not possible) */
-     SQLITE_FLOAT,    /* 0x28 (not possible) */
-     SQLITE_NULL,     /* 0x29 (not possible) */
-     SQLITE_FLOAT,    /* 0x2a (not possible) */
-     SQLITE_NULL,     /* 0x2b (not possible) */
-     SQLITE_FLOAT,    /* 0x2c (not possible) */
-     SQLITE_NULL,     /* 0x2d (not possible) */
-     SQLITE_FLOAT,    /* 0x2e (not possible) */
-     SQLITE_NULL,     /* 0x2f (not possible) */
-     SQLITE_BLOB,     /* 0x30 (not possible) */
-     SQLITE_NULL,     /* 0x31 (not possible) */
-     SQLITE_TEXT,     /* 0x32 (not possible) */
-     SQLITE_NULL,     /* 0x33 (not possible) */
-     SQLITE_FLOAT,    /* 0x34 (not possible) */
-     SQLITE_NULL,     /* 0x35 (not possible) */
-     SQLITE_FLOAT,    /* 0x36 (not possible) */
-     SQLITE_NULL,     /* 0x37 (not possible) */
-     SQLITE_FLOAT,    /* 0x38 (not possible) */
-     SQLITE_NULL,     /* 0x39 (not possible) */
-     SQLITE_FLOAT,    /* 0x3a (not possible) */
-     SQLITE_NULL,     /* 0x3b (not possible) */
-     SQLITE_FLOAT,    /* 0x3c (not possible) */
-     SQLITE_NULL,     /* 0x3d (not possible) */
-     SQLITE_FLOAT,    /* 0x3e (not possible) */
-     SQLITE_NULL,     /* 0x3f (not possible) */
+     SQLITE_BLOB,     /* 0x00 (not possible) */ 
+     SQLITE_NULL,     /* 0x01 NULL */ 
+     SQLITE_TEXT,     /* 0x02 TEXT */ 
+     SQLITE_NULL,     /* 0x03 (not possible) */ 
+     SQLITE_INTEGER,  /* 0x04 INTEGER */ 
+     SQLITE_NULL,     /* 0x05 (not possible) */ 
+     SQLITE_INTEGER,  /* 0x06 INTEGER + TEXT */ 
+     SQLITE_NULL,     /* 0x07 (not possible) */ 
+     SQLITE_FLOAT,    /* 0x08 FLOAT */ 
+     SQLITE_NULL,     /* 0x09 (not possible) */ 
+     SQLITE_FLOAT,    /* 0x0a FLOAT + TEXT */ 
+     SQLITE_NULL,     /* 0x0b (not possible) */ 
+     SQLITE_INTEGER,  /* 0x0c (not possible) */ 
+     SQLITE_NULL,     /* 0x0d (not possible) */ 
+     SQLITE_INTEGER,  /* 0x0e (not possible) */ 
+     SQLITE_NULL,     /* 0x0f (not possible) */ 
+     SQLITE_BLOB,     /* 0x10 BLOB */ 
+     SQLITE_NULL,     /* 0x11 (not possible) */ 
+     SQLITE_TEXT,     /* 0x12 (not possible) */ 
+     SQLITE_NULL,     /* 0x13 (not possible) */ 
+     SQLITE_INTEGER,  /* 0x14 INTEGER + BLOB */ 
+     SQLITE_NULL,     /* 0x15 (not possible) */ 
+     SQLITE_INTEGER,  /* 0x16 (not possible) */ 
+     SQLITE_NULL,     /* 0x17 (not possible) */ 
+     SQLITE_FLOAT,    /* 0x18 FLOAT + BLOB */ 
+     SQLITE_NULL,     /* 0x19 (not possible) */ 
+     SQLITE_FLOAT,    /* 0x1a (not possible) */ 
+     SQLITE_NULL,     /* 0x1b (not possible) */ 
+     SQLITE_INTEGER,  /* 0x1c (not possible) */ 
+     SQLITE_NULL,     /* 0x1d (not possible) */ 
+     SQLITE_INTEGER,  /* 0x1e (not possible) */ 
+     SQLITE_NULL,     /* 0x1f (not possible) */ 
+     SQLITE_FLOAT,    /* 0x20 INTREAL */ 
+     SQLITE_NULL,     /* 0x21 (not possible) */ 
+     SQLITE_TEXT,     /* 0x22 INTREAL + TEXT */ 
+     SQLITE_NULL,     /* 0x23 (not possible) */ 
+     SQLITE_FLOAT,    /* 0x24 (not possible) */ 
+     SQLITE_NULL,     /* 0x25 (not possible) */ 
+     SQLITE_FLOAT,    /* 0x26 (not possible) */ 
+     SQLITE_NULL,     /* 0x27 (not possible) */ 
+     SQLITE_FLOAT,    /* 0x28 (not possible) */ 
+     SQLITE_NULL,     /* 0x29 (not possible) */ 
+     SQLITE_FLOAT,    /* 0x2a (not possible) */ 
+     SQLITE_NULL,     /* 0x2b (not possible) */ 
+     SQLITE_FLOAT,    /* 0x2c (not possible) */ 
+     SQLITE_NULL,     /* 0x2d (not possible) */ 
+     SQLITE_FLOAT,    /* 0x2e (not possible) */ 
+     SQLITE_NULL,     /* 0x2f (not possible) */ 
+     SQLITE_BLOB,     /* 0x30 (not possible) */ 
+     SQLITE_NULL,     /* 0x31 (not possible) */ 
+     SQLITE_TEXT,     /* 0x32 (not possible) */ 
+     SQLITE_NULL,     /* 0x33 (not possible) */ 
+     SQLITE_FLOAT,    /* 0x34 (not possible) */ 
+     SQLITE_NULL,     /* 0x35 (not possible) */ 
+     SQLITE_FLOAT,    /* 0x36 (not possible) */ 
+     SQLITE_NULL,     /* 0x37 (not possible) */ 
+     SQLITE_FLOAT,    /* 0x38 (not possible) */ 
+     SQLITE_NULL,     /* 0x39 (not possible) */ 
+     SQLITE_FLOAT,    /* 0x3a (not possible) */ 
+     SQLITE_NULL,     /* 0x3b (not possible) */ 
+     SQLITE_FLOAT,    /* 0x3c (not possible) */ 
+     SQLITE_NULL,     /* 0x3d (not possible) */ 
+     SQLITE_FLOAT,    /* 0x3e (not possible) */ 
+     SQLITE_NULL,     /* 0x3f (not possible) */ 
   };
-#ifdef SQLITE_DEBUG
-  {
-    int eType = SQLITE_BLOB;
-    if( pVal->flags & MEM_Null ){
-      eType = SQLITE_NULL;
-    }else if( pVal->flags & (MEM_Real|MEM_IntReal) ){
-      eType = SQLITE_FLOAT;
-    }else if( pVal->flags & MEM_Int ){
-      eType = SQLITE_INTEGER;
-    }else if( pVal->flags & MEM_Str ){
-      eType = SQLITE_TEXT;
-    }
-    assert( eType == aType[pVal->flags&MEM_AffMask] );
-  }
-#endif
+#ifdef SQLITE_DEBUG 
+  { 
+    int eType = SQLITE_BLOB; 
+    if( pVal->flags & MEM_Null ){ 
+      eType = SQLITE_NULL; 
+    }else if( pVal->flags & (MEM_Real|MEM_IntReal) ){ 
+      eType = SQLITE_FLOAT; 
+    }else if( pVal->flags & MEM_Int ){ 
+      eType = SQLITE_INTEGER; 
+    }else if( pVal->flags & MEM_Str ){ 
+      eType = SQLITE_TEXT; 
+    } 
+    assert( eType == aType[pVal->flags&MEM_AffMask] ); 
+  } 
+#endif 
   return aType[pVal->flags&MEM_AffMask];
 }
 
@@ -84762,11 +84762,11 @@ SQLITE_API int sqlite3_value_nochange(sqlite3_value *pVal){
   return (pVal->flags&(MEM_Null|MEM_Zero))==(MEM_Null|MEM_Zero);
 }
 
-/* Return true if a parameter value originated from an sqlite3_bind() */
-SQLITE_API int sqlite3_value_frombind(sqlite3_value *pVal){
-  return (pVal->flags&MEM_FromBind)!=0;
-}
-
+/* Return true if a parameter value originated from an sqlite3_bind() */ 
+SQLITE_API int sqlite3_value_frombind(sqlite3_value *pVal){ 
+  return (pVal->flags&MEM_FromBind)!=0; 
+} 
+ 
 /* Make a copy of an sqlite3_value object
 */
 SQLITE_API sqlite3_value *sqlite3_value_dup(const sqlite3_value *pOrig){
@@ -84989,7 +84989,7 @@ SQLITE_API int sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){
 #endif
 }
 SQLITE_API void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
-  pCtx->isError = errCode ? errCode : -1;
+  pCtx->isError = errCode ? errCode : -1; 
 #ifdef SQLITE_DEBUG
   if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode;
 #endif
@@ -85015,21 +85015,21 @@ SQLITE_API void sqlite3_result_error_nomem(sqlite3_context *pCtx){
   sqlite3OomFault(pCtx->pOut->db);
 }
 
-#ifndef SQLITE_UNTESTABLE
-/* Force the INT64 value currently stored as the result to be
-** a MEM_IntReal value.  See the SQLITE_TESTCTRL_RESULT_INTREAL
-** test-control.
-*/
+#ifndef SQLITE_UNTESTABLE 
+/* Force the INT64 value currently stored as the result to be 
+** a MEM_IntReal value.  See the SQLITE_TESTCTRL_RESULT_INTREAL 
+** test-control. 
+*/ 
 SQLITE_PRIVATE void sqlite3ResultIntReal(sqlite3_context *pCtx){
-  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
-  if( pCtx->pOut->flags & MEM_Int ){
-    pCtx->pOut->flags &= ~MEM_Int;
-    pCtx->pOut->flags |= MEM_IntReal;
-  }
-}
-#endif
-
-
+  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 
+  if( pCtx->pOut->flags & MEM_Int ){ 
+    pCtx->pOut->flags &= ~MEM_Int; 
+    pCtx->pOut->flags |= MEM_IntReal; 
+  } 
+} 
+#endif 
+ 
+ 
 /*
 ** This function is called after a transaction has been committed. It
 ** invokes callbacks registered with sqlite3_wal_hook() as required.
@@ -85104,7 +85104,7 @@ static int sqlite3Step(Vdbe *p){
     return SQLITE_NOMEM_BKPT;
   }
 
-  if( p->pc<0 && p->expired ){
+  if( p->pc<0 && p->expired ){ 
     p->rc = SQLITE_SCHEMA;
     rc = SQLITE_ERROR;
     if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ){
@@ -85130,7 +85130,7 @@ static int sqlite3Step(Vdbe *p){
     );
 
 #ifndef SQLITE_OMIT_TRACE
-    if( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0
+    if( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0 
         && !db->init.busy && p->zSql ){
       sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime);
     }else{
@@ -85157,18 +85157,18 @@ static int sqlite3Step(Vdbe *p){
     db->nVdbeExec--;
   }
 
-  if( rc!=SQLITE_ROW ){
+  if( rc!=SQLITE_ROW ){ 
 #ifndef SQLITE_OMIT_TRACE
-    /* If the statement completed successfully, invoke the profile callback */
-    checkProfileCallback(db, p);
+    /* If the statement completed successfully, invoke the profile callback */ 
+    checkProfileCallback(db, p); 
 #endif
 
-    if( rc==SQLITE_DONE && db->autoCommit ){
-      assert( p->rc==SQLITE_OK );
-      p->rc = doWalCallbacks(db);
-      if( p->rc!=SQLITE_OK ){
-        rc = SQLITE_ERROR;
-      }
+    if( rc==SQLITE_DONE && db->autoCommit ){ 
+      assert( p->rc==SQLITE_OK ); 
+      p->rc = doWalCallbacks(db); 
+      if( p->rc!=SQLITE_OK ){ 
+        rc = SQLITE_ERROR; 
+      } 
     }else if( rc!=SQLITE_DONE && (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ){
       /* If this statement was prepared using saved SQL and an
       ** error has occurred, then return the error code in p->rc to the
@@ -85412,7 +85412,7 @@ SQLITE_API void sqlite3_set_auxdata(
     pAuxData->iAuxArg = iArg;
     pAuxData->pNextAux = pVdbe->pAuxData;
     pVdbe->pAuxData = pAuxData;
-    if( pCtx->isError==0 ) pCtx->isError = -1;
+    if( pCtx->isError==0 ) pCtx->isError = -1; 
   }else if( pAuxData->xDeleteAux ){
     pAuxData->xDeleteAux(pAuxData->pAux);
   }
@@ -85492,7 +85492,7 @@ static const Mem *columnNullValue(void){
         /* .xDel       = */ (void(*)(void*))0,
 #ifdef SQLITE_DEBUG
         /* .pScopyFrom = */ (Mem*)0,
-        /* .mScopyFlags= */ 0,
+        /* .mScopyFlags= */ 0, 
 #endif
       };
   return &nullMem;
@@ -85638,10 +85638,10 @@ SQLITE_API int sqlite3_column_type(sqlite3_stmt *pStmt, int i){
 ** or a constant) then useTypes 2, 3, and 4 return NULL.
 */
 static const void *columnName(
-  sqlite3_stmt *pStmt,     /* The statement */
-  int N,                   /* Which column to get the name for */
-  int useUtf16,            /* True to return the name as UTF16 */
-  int useType              /* What type of name */
+  sqlite3_stmt *pStmt,     /* The statement */ 
+  int N,                   /* Which column to get the name for */ 
+  int useUtf16,            /* True to return the name as UTF16 */ 
+  int useType              /* What type of name */ 
 ){
   const void *ret;
   Vdbe *p;
@@ -85662,15 +85662,15 @@ static const void *columnName(
     N += useType*n;
     sqlite3_mutex_enter(db->mutex);
     assert( db->mallocFailed==0 );
-#ifndef SQLITE_OMIT_UTF16
-    if( useUtf16 ){
-      ret = sqlite3_value_text16((sqlite3_value*)&p->aColName[N]);
-    }else
-#endif
-    {
-      ret = sqlite3_value_text((sqlite3_value*)&p->aColName[N]);
-    }
-    /* A malloc may have failed inside of the _text() call. If this
+#ifndef SQLITE_OMIT_UTF16 
+    if( useUtf16 ){ 
+      ret = sqlite3_value_text16((sqlite3_value*)&p->aColName[N]); 
+    }else 
+#endif 
+    { 
+      ret = sqlite3_value_text((sqlite3_value*)&p->aColName[N]); 
+    } 
+    /* A malloc may have failed inside of the _text() call. If this 
     ** is the case, clear the mallocFailed flag and return NULL.
     */
     if( db->mallocFailed ){
@@ -85687,11 +85687,11 @@ static const void *columnName(
 ** statement pStmt.
 */
 SQLITE_API const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){
-  return columnName(pStmt, N, 0, COLNAME_NAME);
+  return columnName(pStmt, N, 0, COLNAME_NAME); 
 }
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
-  return columnName(pStmt, N, 1, COLNAME_NAME);
+  return columnName(pStmt, N, 1, COLNAME_NAME); 
 }
 #endif
 
@@ -85710,11 +85710,11 @@ SQLITE_API const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
 ** of the result set of SQL statement pStmt.
 */
 SQLITE_API const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){
-  return columnName(pStmt, N, 0, COLNAME_DECLTYPE);
+  return columnName(pStmt, N, 0, COLNAME_DECLTYPE); 
 }
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
-  return columnName(pStmt, N, 1, COLNAME_DECLTYPE);
+  return columnName(pStmt, N, 1, COLNAME_DECLTYPE); 
 }
 #endif /* SQLITE_OMIT_UTF16 */
 #endif /* SQLITE_OMIT_DECLTYPE */
@@ -85726,11 +85726,11 @@ SQLITE_API const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
 ** anything else which is not an unambiguous reference to a database column.
 */
 SQLITE_API const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){
-  return columnName(pStmt, N, 0, COLNAME_DATABASE);
+  return columnName(pStmt, N, 0, COLNAME_DATABASE); 
 }
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
-  return columnName(pStmt, N, 1, COLNAME_DATABASE);
+  return columnName(pStmt, N, 1, COLNAME_DATABASE); 
 }
 #endif /* SQLITE_OMIT_UTF16 */
 
@@ -85740,11 +85740,11 @@ SQLITE_API const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N
 ** anything else which is not an unambiguous reference to a database column.
 */
 SQLITE_API const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){
-  return columnName(pStmt, N, 0, COLNAME_TABLE);
+  return columnName(pStmt, N, 0, COLNAME_TABLE); 
 }
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
-  return columnName(pStmt, N, 1, COLNAME_TABLE);
+  return columnName(pStmt, N, 1, COLNAME_TABLE); 
 }
 #endif /* SQLITE_OMIT_UTF16 */
 
@@ -85754,11 +85754,11 @@ SQLITE_API const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
 ** anything else which is not an unambiguous reference to a database column.
 */
 SQLITE_API const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){
-  return columnName(pStmt, N, 0, COLNAME_COLUMN);
+  return columnName(pStmt, N, 0, COLNAME_COLUMN); 
 }
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
-  return columnName(pStmt, N, 1, COLNAME_COLUMN);
+  return columnName(pStmt, N, 1, COLNAME_COLUMN); 
 }
 #endif /* SQLITE_OMIT_UTF16 */
 #endif /* SQLITE_ENABLE_COLUMN_METADATA */
@@ -85801,7 +85801,7 @@ static int vdbeUnbind(Vdbe *p, int i){
   pVar = &p->aVar[i];
   sqlite3VdbeMemRelease(pVar);
   pVar->flags = MEM_Null;
-  p->db->errCode = SQLITE_OK;
+  p->db->errCode = SQLITE_OK; 
 
   /* If the bit corresponding to this variable in Vdbe.expmask is set, then
   ** binding a new value to this variable invalidates the current query plan.
@@ -86123,14 +86123,14 @@ SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt){
 }
 
 /*
-** Return 1 if the statement is an EXPLAIN and return 2 if the
-** statement is an EXPLAIN QUERY PLAN
-*/
-SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt){
-  return pStmt ? ((Vdbe*)pStmt)->explain : 0;
-}
-
-/*
+** Return 1 if the statement is an EXPLAIN and return 2 if the 
+** statement is an EXPLAIN QUERY PLAN 
+*/ 
+SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt){ 
+  return pStmt ? ((Vdbe*)pStmt)->explain : 0; 
+} 
+ 
+/* 
 ** Return true if the prepared statement is in need of being reset.
 */
 SQLITE_API int sqlite3_stmt_busy(sqlite3_stmt *pStmt){
@@ -86170,8 +86170,8 @@ SQLITE_API int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
   u32 v;
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !pStmt
-   || (op!=SQLITE_STMTSTATUS_MEMUSED && (op<0||op>=ArraySize(pVdbe->aCounter)))
-  ){
+   || (op!=SQLITE_STMTSTATUS_MEMUSED && (op<0||op>=ArraySize(pVdbe->aCounter))) 
+  ){ 
     (void)SQLITE_MISUSE_BKPT;
     return 0;
   }
@@ -86225,22 +86225,22 @@ SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt){
 #endif
 }
 
-#ifdef SQLITE_ENABLE_NORMALIZE
-/*
-** Return the normalized SQL associated with a prepared statement.
-*/
-SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt){
-  Vdbe *p = (Vdbe *)pStmt;
-  if( p==0 ) return 0;
-  if( p->zNormSql==0 && ALWAYS(p->zSql!=0) ){
-    sqlite3_mutex_enter(p->db->mutex);
-    p->zNormSql = sqlite3Normalize(p, p->zSql);
-    sqlite3_mutex_leave(p->db->mutex);
-  }
-  return p->zNormSql;
-}
-#endif /* SQLITE_ENABLE_NORMALIZE */
-
+#ifdef SQLITE_ENABLE_NORMALIZE 
+/* 
+** Return the normalized SQL associated with a prepared statement. 
+*/ 
+SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt){ 
+  Vdbe *p = (Vdbe *)pStmt; 
+  if( p==0 ) return 0; 
+  if( p->zNormSql==0 && ALWAYS(p->zSql!=0) ){ 
+    sqlite3_mutex_enter(p->db->mutex); 
+    p->zNormSql = sqlite3Normalize(p, p->zSql); 
+    sqlite3_mutex_leave(p->db->mutex); 
+  } 
+  return p->zNormSql; 
+} 
+#endif /* SQLITE_ENABLE_NORMALIZE */ 
+ 
 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
 /*
 ** Allocate and populate an UnpackedRecord structure based on the serialized
@@ -86312,9 +86312,9 @@ SQLITE_API int sqlite3_preupdate_old(sqlite3 *db, int iIdx, sqlite3_value **ppVa
   }else if( iIdx>=p->pUnpacked->nField ){
     *ppValue = (sqlite3_value *)columnNullValue();
   }else if( p->pTab->aCol[iIdx].affinity==SQLITE_AFF_REAL ){
-    if( pMem->flags & (MEM_Int|MEM_IntReal) ){
-      testcase( pMem->flags & MEM_Int );
-      testcase( pMem->flags & MEM_IntReal );
+    if( pMem->flags & (MEM_Int|MEM_IntReal) ){ 
+      testcase( pMem->flags & MEM_Int ); 
+      testcase( pMem->flags & MEM_IntReal ); 
       sqlite3VdbeMemRealify(pMem);
     }
   }
@@ -86605,17 +86605,17 @@ SQLITE_PRIVATE char *sqlite3VdbeExpandSql(
     while( *zRawSql ){
       const char *zStart = zRawSql;
       while( *(zRawSql++)!='\n' && *zRawSql );
-      sqlite3_str_append(&out, "-- ", 3);
+      sqlite3_str_append(&out, "-- ", 3); 
       assert( (zRawSql - zStart) > 0 );
-      sqlite3_str_append(&out, zStart, (int)(zRawSql-zStart));
+      sqlite3_str_append(&out, zStart, (int)(zRawSql-zStart)); 
     }
   }else if( p->nVar==0 ){
-    sqlite3_str_append(&out, zRawSql, sqlite3Strlen30(zRawSql));
+    sqlite3_str_append(&out, zRawSql, sqlite3Strlen30(zRawSql)); 
   }else{
     while( zRawSql[0] ){
       n = findNextHostParameter(zRawSql, &nToken);
       assert( n>0 );
-      sqlite3_str_append(&out, zRawSql, n);
+      sqlite3_str_append(&out, zRawSql, n); 
       zRawSql += n;
       assert( zRawSql[0] || nToken==0 );
       if( nToken==0 ) break;
@@ -86641,11 +86641,11 @@ SQLITE_PRIVATE char *sqlite3VdbeExpandSql(
       assert( idx>0 && idx<=p->nVar );
       pVar = &p->aVar[idx-1];
       if( pVar->flags & MEM_Null ){
-        sqlite3_str_append(&out, "NULL", 4);
-      }else if( pVar->flags & (MEM_Int|MEM_IntReal) ){
-        sqlite3_str_appendf(&out, "%lld", pVar->u.i);
+        sqlite3_str_append(&out, "NULL", 4); 
+      }else if( pVar->flags & (MEM_Int|MEM_IntReal) ){ 
+        sqlite3_str_appendf(&out, "%lld", pVar->u.i); 
       }else if( pVar->flags & MEM_Real ){
-        sqlite3_str_appendf(&out, "%!.15g", pVar->u.r);
+        sqlite3_str_appendf(&out, "%!.15g", pVar->u.r); 
       }else if( pVar->flags & MEM_Str ){
         int nOut;  /* Number of bytes of the string text to include in output */
 #ifndef SQLITE_OMIT_UTF16
@@ -86655,7 +86655,7 @@ SQLITE_PRIVATE char *sqlite3VdbeExpandSql(
           utf8.db = db;
           sqlite3VdbeMemSetStr(&utf8, pVar->z, pVar->n, enc, SQLITE_STATIC);
           if( SQLITE_NOMEM==sqlite3VdbeChangeEncoding(&utf8, SQLITE_UTF8) ){
-            out.accError = SQLITE_NOMEM;
+            out.accError = SQLITE_NOMEM; 
             out.nAlloc = 0;
           }
           pVar = &utf8;
@@ -86668,38 +86668,38 @@ SQLITE_PRIVATE char *sqlite3VdbeExpandSql(
           while( nOut<pVar->n && (pVar->z[nOut]&0xc0)==0x80 ){ nOut++; }
         }
 #endif
-        sqlite3_str_appendf(&out, "'%.*q'", nOut, pVar->z);
+        sqlite3_str_appendf(&out, "'%.*q'", nOut, pVar->z); 
 #ifdef SQLITE_TRACE_SIZE_LIMIT
         if( nOut<pVar->n ){
-          sqlite3_str_appendf(&out, "/*+%d bytes*/", pVar->n-nOut);
+          sqlite3_str_appendf(&out, "/*+%d bytes*/", pVar->n-nOut); 
         }
 #endif
 #ifndef SQLITE_OMIT_UTF16
         if( enc!=SQLITE_UTF8 ) sqlite3VdbeMemRelease(&utf8);
 #endif
       }else if( pVar->flags & MEM_Zero ){
-        sqlite3_str_appendf(&out, "zeroblob(%d)", pVar->u.nZero);
+        sqlite3_str_appendf(&out, "zeroblob(%d)", pVar->u.nZero); 
       }else{
         int nOut;  /* Number of bytes of the blob to include in output */
         assert( pVar->flags & MEM_Blob );
-        sqlite3_str_append(&out, "x'", 2);
+        sqlite3_str_append(&out, "x'", 2); 
         nOut = pVar->n;
 #ifdef SQLITE_TRACE_SIZE_LIMIT
         if( nOut>SQLITE_TRACE_SIZE_LIMIT ) nOut = SQLITE_TRACE_SIZE_LIMIT;
 #endif
         for(i=0; i<nOut; i++){
-          sqlite3_str_appendf(&out, "%02x", pVar->z[i]&0xff);
+          sqlite3_str_appendf(&out, "%02x", pVar->z[i]&0xff); 
         }
-        sqlite3_str_append(&out, "'", 1);
+        sqlite3_str_append(&out, "'", 1); 
 #ifdef SQLITE_TRACE_SIZE_LIMIT
         if( nOut<pVar->n ){
-          sqlite3_str_appendf(&out, "/*+%d bytes*/", pVar->n-nOut);
+          sqlite3_str_appendf(&out, "/*+%d bytes*/", pVar->n-nOut); 
         }
 #endif
       }
     }
   }
-  if( out.accError ) sqlite3_str_reset(&out);
+  if( out.accError ) sqlite3_str_reset(&out); 
   return sqlite3StrAccumFinish(&out);
 }
 
@@ -86851,76 +86851,76 @@ static void test_trace_breakpoint(int pc, Op *pOp, Vdbe *v){
 ** feature is used for test suite validation only and does not appear an
 ** production builds.
 **
-** M is the type of branch.  I is the direction taken for this instance of
-** the branch.
-**
-**   M: 2 - two-way branch (I=0: fall-thru   1: jump                )
-**      3 - two-way + NULL (I=0: fall-thru   1: jump      2: NULL   )
-**      4 - OP_Jump        (I=0: jump p1     1: jump p2   2: jump p3)
+** M is the type of branch.  I is the direction taken for this instance of 
+** the branch. 
 **
-** In other words, if M is 2, then I is either 0 (for fall-through) or
-** 1 (for when the branch is taken).  If M is 3, the I is 0 for an
+**   M: 2 - two-way branch (I=0: fall-thru   1: jump                ) 
+**      3 - two-way + NULL (I=0: fall-thru   1: jump      2: NULL   ) 
+**      4 - OP_Jump        (I=0: jump p1     1: jump p2   2: jump p3) 
+** 
+** In other words, if M is 2, then I is either 0 (for fall-through) or 
+** 1 (for when the branch is taken).  If M is 3, the I is 0 for an 
 ** ordinary fall-through, I is 1 if the branch was taken, and I is 2
-** if the result of comparison is NULL.  For M=3, I=2 the jump may or
-** may not be taken, depending on the SQLITE_JUMPIFNULL flags in p5.
-** When M is 4, that means that an OP_Jump is being run.  I is 0, 1, or 2
-** depending on if the operands are less than, equal, or greater than.
-**
+** if the result of comparison is NULL.  For M=3, I=2 the jump may or 
+** may not be taken, depending on the SQLITE_JUMPIFNULL flags in p5. 
+** When M is 4, that means that an OP_Jump is being run.  I is 0, 1, or 2 
+** depending on if the operands are less than, equal, or greater than. 
+** 
 ** iSrcLine is the source code line (from the __LINE__ macro) that
-** generated the VDBE instruction combined with flag bits.  The source
-** code line number is in the lower 24 bits of iSrcLine and the upper
-** 8 bytes are flags.  The lower three bits of the flags indicate
-** values for I that should never occur.  For example, if the branch is
-** always taken, the flags should be 0x05 since the fall-through and
-** alternate branch are never taken.  If a branch is never taken then
-** flags should be 0x06 since only the fall-through approach is allowed.
-**
-** Bit 0x08 of the flags indicates an OP_Jump opcode that is only
-** interested in equal or not-equal.  In other words, I==0 and I==2
-** should be treated as equivalent
-**
-** Since only a line number is retained, not the filename, this macro
-** only works for amalgamation builds.  But that is ok, since these macros
-** should be no-ops except for special builds used to measure test coverage.
+** generated the VDBE instruction combined with flag bits.  The source 
+** code line number is in the lower 24 bits of iSrcLine and the upper 
+** 8 bytes are flags.  The lower three bits of the flags indicate 
+** values for I that should never occur.  For example, if the branch is 
+** always taken, the flags should be 0x05 since the fall-through and 
+** alternate branch are never taken.  If a branch is never taken then 
+** flags should be 0x06 since only the fall-through approach is allowed. 
+** 
+** Bit 0x08 of the flags indicates an OP_Jump opcode that is only 
+** interested in equal or not-equal.  In other words, I==0 and I==2 
+** should be treated as equivalent 
+** 
+** Since only a line number is retained, not the filename, this macro 
+** only works for amalgamation builds.  But that is ok, since these macros 
+** should be no-ops except for special builds used to measure test coverage. 
 */
 #if !defined(SQLITE_VDBE_COVERAGE)
 # define VdbeBranchTaken(I,M)
 #else
 # define VdbeBranchTaken(I,M) vdbeTakeBranch(pOp->iSrcLine,I,M)
-  static void vdbeTakeBranch(u32 iSrcLine, u8 I, u8 M){
-    u8 mNever;
-    assert( I<=2 );  /* 0: fall through,  1: taken,  2: alternate taken */
-    assert( M<=4 );  /* 2: two-way branch, 3: three-way branch, 4: OP_Jump */
-    assert( I<M );   /* I can only be 2 if M is 3 or 4 */
-    /* Transform I from a integer [0,1,2] into a bitmask of [1,2,4] */
-    I = 1<<I;
-    /* The upper 8 bits of iSrcLine are flags.  The lower three bits of
-    ** the flags indicate directions that the branch can never go.  If
-    ** a branch really does go in one of those directions, assert right
-    ** away. */
-    mNever = iSrcLine >> 24;
-    assert( (I & mNever)==0 );
-    if( sqlite3GlobalConfig.xVdbeBranch==0 ) return;  /*NO_TEST*/
-    /* Invoke the branch coverage callback with three arguments:
-    **    iSrcLine - the line number of the VdbeCoverage() macro, with
-    **               flags removed.
-    **    I        - Mask of bits 0x07 indicating which cases are are
-    **               fulfilled by this instance of the jump.  0x01 means
-    **               fall-thru, 0x02 means taken, 0x04 means NULL.  Any
-    **               impossible cases (ex: if the comparison is never NULL)
-    **               are filled in automatically so that the coverage
-    **               measurement logic does not flag those impossible cases
-    **               as missed coverage.
-    **    M        - Type of jump.  Same as M argument above
-    */
-    I |= mNever;
-    if( M==2 ) I |= 0x04;
-    if( M==4 ){
-      I |= 0x08;
-      if( (mNever&0x08)!=0 && (I&0x05)!=0) I |= 0x05; /*NO_TEST*/
-    }
-    sqlite3GlobalConfig.xVdbeBranch(sqlite3GlobalConfig.pVdbeBranchArg,
-                                    iSrcLine&0xffffff, I, M);
+  static void vdbeTakeBranch(u32 iSrcLine, u8 I, u8 M){ 
+    u8 mNever; 
+    assert( I<=2 );  /* 0: fall through,  1: taken,  2: alternate taken */ 
+    assert( M<=4 );  /* 2: two-way branch, 3: three-way branch, 4: OP_Jump */ 
+    assert( I<M );   /* I can only be 2 if M is 3 or 4 */ 
+    /* Transform I from a integer [0,1,2] into a bitmask of [1,2,4] */ 
+    I = 1<<I; 
+    /* The upper 8 bits of iSrcLine are flags.  The lower three bits of 
+    ** the flags indicate directions that the branch can never go.  If 
+    ** a branch really does go in one of those directions, assert right 
+    ** away. */ 
+    mNever = iSrcLine >> 24; 
+    assert( (I & mNever)==0 ); 
+    if( sqlite3GlobalConfig.xVdbeBranch==0 ) return;  /*NO_TEST*/ 
+    /* Invoke the branch coverage callback with three arguments: 
+    **    iSrcLine - the line number of the VdbeCoverage() macro, with 
+    **               flags removed. 
+    **    I        - Mask of bits 0x07 indicating which cases are are 
+    **               fulfilled by this instance of the jump.  0x01 means 
+    **               fall-thru, 0x02 means taken, 0x04 means NULL.  Any 
+    **               impossible cases (ex: if the comparison is never NULL) 
+    **               are filled in automatically so that the coverage 
+    **               measurement logic does not flag those impossible cases 
+    **               as missed coverage. 
+    **    M        - Type of jump.  Same as M argument above 
+    */ 
+    I |= mNever; 
+    if( M==2 ) I |= 0x04; 
+    if( M==4 ){ 
+      I |= 0x08; 
+      if( (mNever&0x08)!=0 && (I&0x05)!=0) I |= 0x05; /*NO_TEST*/ 
+    }
+    sqlite3GlobalConfig.xVdbeBranch(sqlite3GlobalConfig.pVdbeBranchArg, 
+                                    iSrcLine&0xffffff, I, M); 
   }
 #endif
 
@@ -87019,21 +87019,21 @@ static VdbeCursor *allocateCursor(
 }
 
 /*
-** The string in pRec is known to look like an integer and to have a
-** floating point value of rValue.  Return true and set *piValue to the
-** integer value if the string is in range to be an integer.  Otherwise,
-** return false.
-*/
-static int alsoAnInt(Mem *pRec, double rValue, i64 *piValue){
-  i64 iValue = (double)rValue;
-  if( sqlite3RealSameAsInt(rValue,iValue) ){
-    *piValue = iValue;
-    return 1;
-  }
-  return 0==sqlite3Atoi64(pRec->z, piValue, pRec->n, pRec->enc);
-}
-
-/*
+** The string in pRec is known to look like an integer and to have a 
+** floating point value of rValue.  Return true and set *piValue to the 
+** integer value if the string is in range to be an integer.  Otherwise, 
+** return false. 
+*/ 
+static int alsoAnInt(Mem *pRec, double rValue, i64 *piValue){ 
+  i64 iValue = (double)rValue; 
+  if( sqlite3RealSameAsInt(rValue,iValue) ){ 
+    *piValue = iValue; 
+    return 1; 
+  } 
+  return 0==sqlite3Atoi64(pRec->z, piValue, pRec->n, pRec->enc); 
+} 
+ 
+/* 
 ** Try to convert a value into a numeric representation if we can
 ** do so without loss of information.  In other words, if the string
 ** looks like a number, convert it into a number.  If it does not
@@ -87051,22 +87051,22 @@ static int alsoAnInt(Mem *pRec, double rValue, i64 *piValue){
 static void applyNumericAffinity(Mem *pRec, int bTryForInt){
   double rValue;
   u8 enc = pRec->enc;
-  int rc;
-  assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real|MEM_IntReal))==MEM_Str );
-  rc = sqlite3AtoF(pRec->z, &rValue, pRec->n, enc);
-  if( rc<=0 ) return;
-  if( rc==1 && alsoAnInt(pRec, rValue, &pRec->u.i) ){
+  int rc; 
+  assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real|MEM_IntReal))==MEM_Str ); 
+  rc = sqlite3AtoF(pRec->z, &rValue, pRec->n, enc); 
+  if( rc<=0 ) return; 
+  if( rc==1 && alsoAnInt(pRec, rValue, &pRec->u.i) ){ 
     pRec->flags |= MEM_Int;
   }else{
     pRec->u.r = rValue;
     pRec->flags |= MEM_Real;
     if( bTryForInt ) sqlite3VdbeIntegerAffinity(pRec);
   }
-  /* TEXT->NUMERIC is many->one.  Hence, it is important to invalidate the
-  ** string representation after computing a numeric equivalent, because the
-  ** string representation might not be the canonical representation for the
-  ** numeric value.  Ticket [343634942dd54ab57b7024] 2018-01-31. */
-  pRec->flags &= ~MEM_Str;
+  /* TEXT->NUMERIC is many->one.  Hence, it is important to invalidate the 
+  ** string representation after computing a numeric equivalent, because the 
+  ** string representation might not be the canonical representation for the 
+  ** numeric value.  Ticket [343634942dd54ab57b7024] 2018-01-31. */ 
+  pRec->flags &= ~MEM_Str; 
 }
 
 /*
@@ -87110,14 +87110,14 @@ static void applyAffinity(
     ** there is already a string rep, but it is pointless to waste those
     ** CPU cycles. */
     if( 0==(pRec->flags&MEM_Str) ){ /*OPTIMIZATION-IF-FALSE*/
-      if( (pRec->flags&(MEM_Real|MEM_Int|MEM_IntReal)) ){
-        testcase( pRec->flags & MEM_Int );
-        testcase( pRec->flags & MEM_Real );
-        testcase( pRec->flags & MEM_IntReal );
+      if( (pRec->flags&(MEM_Real|MEM_Int|MEM_IntReal)) ){ 
+        testcase( pRec->flags & MEM_Int ); 
+        testcase( pRec->flags & MEM_Real ); 
+        testcase( pRec->flags & MEM_IntReal ); 
         sqlite3VdbeMemStringify(pRec, enc, 1);
       }
     }
-    pRec->flags &= ~(MEM_Real|MEM_Int|MEM_IntReal);
+    pRec->flags &= ~(MEM_Real|MEM_Int|MEM_IntReal); 
   }
 }
 
@@ -87156,24 +87156,24 @@ SQLITE_PRIVATE void sqlite3ValueApplyAffinity(
 ** accordingly.
 */
 static u16 SQLITE_NOINLINE computeNumericType(Mem *pMem){
-  int rc;
-  sqlite3_int64 ix;
-  assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 );
+  int rc; 
+  sqlite3_int64 ix; 
+  assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 ); 
   assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 );
   if( ExpandBlob(pMem) ){
     pMem->u.i = 0;
     return MEM_Int;
   }
-  rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
-  if( rc<=0 ){
-    if( rc==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1 ){
-      pMem->u.i = ix;
-      return MEM_Int;
-    }else{
-      return MEM_Real;
-    }
-  }else if( rc==1 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)==0 ){
-    pMem->u.i = ix;
+  rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc); 
+  if( rc<=0 ){ 
+    if( rc==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1 ){ 
+      pMem->u.i = ix; 
+      return MEM_Int; 
+    }else{ 
+      return MEM_Real; 
+    } 
+  }else if( rc==1 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)==0 ){ 
+    pMem->u.i = ix; 
     return MEM_Int;
   }
   return MEM_Real;
@@ -87187,15 +87187,15 @@ static u16 SQLITE_NOINLINE computeNumericType(Mem *pMem){
 ** But it does set pMem->u.r and pMem->u.i appropriately.
 */
 static u16 numericType(Mem *pMem){
-  if( pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal) ){
-    testcase( pMem->flags & MEM_Int );
-    testcase( pMem->flags & MEM_Real );
-    testcase( pMem->flags & MEM_IntReal );
-    return pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal);
+  if( pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal) ){ 
+    testcase( pMem->flags & MEM_Int ); 
+    testcase( pMem->flags & MEM_Real ); 
+    testcase( pMem->flags & MEM_IntReal ); 
+    return pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal); 
   }
   if( pMem->flags & (MEM_Str|MEM_Blob) ){
-    testcase( pMem->flags & MEM_Str );
-    testcase( pMem->flags & MEM_Blob );
+    testcase( pMem->flags & MEM_Str ); 
+    testcase( pMem->flags & MEM_Blob ); 
     return computeNumericType(pMem);
   }
   return 0;
@@ -87273,15 +87273,15 @@ static void memTracePrint(Mem *p){
     printf(p->flags & MEM_Zero ? " NULL-nochng" : " NULL");
   }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){
     printf(" si:%lld", p->u.i);
-  }else if( (p->flags & (MEM_IntReal))!=0 ){
-    printf(" ir:%lld", p->u.i);
+  }else if( (p->flags & (MEM_IntReal))!=0 ){ 
+    printf(" ir:%lld", p->u.i); 
   }else if( p->flags & MEM_Int ){
     printf(" i:%lld", p->u.i);
 #ifndef SQLITE_OMIT_FLOATING_POINT
   }else if( p->flags & MEM_Real ){
     printf(" r:%.17g", p->u.r);
 #endif
-  }else if( sqlite3VdbeMemIsRowSet(p) ){
+  }else if( sqlite3VdbeMemIsRowSet(p) ){ 
     printf(" (rowset)");
   }else{
     StrAccum acc;
@@ -87430,15 +87430,15 @@ SQLITE_PRIVATE int sqlite3VdbeExec(
 
   assert( p->iVdbeMagic==VDBE_MAGIC_RUN );  /* sqlite3_step() verifies this */
   sqlite3VdbeEnter(p);
-#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
-  if( db->xProgress ){
-    u32 iPrior = p->aCounter[SQLITE_STMTSTATUS_VM_STEP];
-    assert( 0 < db->nProgressOps );
-    nProgressLimit = db->nProgressOps - (iPrior % db->nProgressOps);
-  }else{
+#ifndef SQLITE_OMIT_PROGRESS_CALLBACK 
+  if( db->xProgress ){ 
+    u32 iPrior = p->aCounter[SQLITE_STMTSTATUS_VM_STEP]; 
+    assert( 0 < db->nProgressOps ); 
+    nProgressLimit = db->nProgressOps - (iPrior % db->nProgressOps); 
+  }else{ 
     nProgressLimit = LARGEST_UINT64;
-  }
-#endif
+  } 
+#endif 
   if( p->rc==SQLITE_NOMEM ){
     /* This happens if a malloc() inside a call to sqlite3_column_text() or
     ** sqlite3_column_text16() failed.  */
@@ -87488,7 +87488,7 @@ SQLITE_PRIVATE int sqlite3VdbeExec(
 
     assert( pOp>=aOp && pOp<&aOp[p->nOp]);
 #ifdef VDBE_PROFILE
-    start = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime();
+    start = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime(); 
 #endif
     nVmStep++;
 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
@@ -87644,9 +87644,9 @@ check_for_interrupt:
   ** If the progress callback returns non-zero, exit the virtual machine with
   ** a return code SQLITE_ABORT.
   */
-  while( nVmStep>=nProgressLimit && db->xProgress!=0 ){
+  while( nVmStep>=nProgressLimit && db->xProgress!=0 ){ 
     assert( db->nProgressOps!=0 );
-    nProgressLimit += db->nProgressOps;
+    nProgressLimit += db->nProgressOps; 
     if( db->xProgress(db->pProgressArg) ){
       nProgressLimit = LARGEST_UINT64;
       rc = SQLITE_INTERRUPT;
@@ -87771,9 +87771,9 @@ case OP_Yield: {            /* in1, jump */
 */
 case OP_HaltIfNull: {      /* in3 */
   pIn3 = &aMem[pOp->p3];
-#ifdef SQLITE_DEBUG
-  if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
-#endif
+#ifdef SQLITE_DEBUG 
+  if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); } 
+#endif 
   if( (pIn3->flags & MEM_Null)==0 ) break;
   /* Fall through into OP_Halt */
   /* no break */ deliberate_fall_through
@@ -87814,9 +87814,9 @@ case OP_Halt: {
   int pcx;
 
   pcx = (int)(pOp - aOp);
-#ifdef SQLITE_DEBUG
-  if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); }
-#endif
+#ifdef SQLITE_DEBUG 
+  if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); } 
+#endif 
   if( pOp->p1==SQLITE_OK && p->pFrame ){
     /* Halt the sub-program. Return control to the parent frame. */
     pFrame = p->pFrame;
@@ -87927,7 +87927,7 @@ case OP_String8: {         /* same as TK_STRING, out2 */
   if( encoding!=SQLITE_UTF8 ){
     rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC);
     assert( rc==SQLITE_OK || rc==SQLITE_TOOBIG );
-    if( rc ) goto too_big;
+    if( rc ) goto too_big; 
     if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
     assert( pOut->szMalloc>0 && pOut->zMalloc==pOut->z );
     assert( VdbeMemDynamic(pOut)==0 );
@@ -88001,9 +88001,9 @@ case OP_Null: {           /* out2 */
   assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
   pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null;
   pOut->n = 0;
-#ifdef SQLITE_DEBUG
-  pOut->uTemp = 0;
-#endif
+#ifdef SQLITE_DEBUG 
+  pOut->uTemp = 0; 
+#endif 
   while( cnt>0 ){
     pOut++;
     memAboutToChange(p, pOut);
@@ -88063,10 +88063,10 @@ case OP_Variable: {            /* out2 */
     goto too_big;
   }
   pOut = &aMem[pOp->p2];
-  if( VdbeMemDynamic(pOut) ) sqlite3VdbeMemSetNull(pOut);
-  memcpy(pOut, pVar, MEMCELLSIZE);
-  pOut->flags &= ~(MEM_Dyn|MEM_Ephem);
-  pOut->flags |= MEM_Static|MEM_FromBind;
+  if( VdbeMemDynamic(pOut) ) sqlite3VdbeMemSetNull(pOut); 
+  memcpy(pOut, pVar, MEMCELLSIZE); 
+  pOut->flags &= ~(MEM_Dyn|MEM_Ephem); 
+  pOut->flags |= MEM_Static|MEM_FromBind; 
   UPDATE_MAX_BLOBSIZE(pOut);
   break;
 }
@@ -88133,7 +88133,7 @@ case OP_Copy: {
   pOut = &aMem[pOp->p2];
   assert( pOut!=pIn1 );
   while( 1 ){
-    memAboutToChange(p, pOut);
+    memAboutToChange(p, pOut); 
     sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
     Deephemeralize(pOut);
 #ifdef SQLITE_DEBUG
@@ -88166,8 +88166,8 @@ case OP_SCopy: {            /* out2 */
   assert( pOut!=pIn1 );
   sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
 #ifdef SQLITE_DEBUG
-  pOut->pScopyFrom = pIn1;
-  pOut->mScopyFlags = pIn1->flags;
+  pOut->pScopyFrom = pIn1; 
+  pOut->mScopyFlags = pIn1->flags; 
 #endif
   break;
 }
@@ -88276,56 +88276,56 @@ case OP_ResultRow: {
 ** to avoid a memcpy().
 */
 case OP_Concat: {           /* same as TK_CONCAT, in1, in2, out3 */
-  i64 nByte;          /* Total size of the output string or blob */
-  u16 flags1;         /* Initial flags for P1 */
-  u16 flags2;         /* Initial flags for P2 */
+  i64 nByte;          /* Total size of the output string or blob */ 
+  u16 flags1;         /* Initial flags for P1 */ 
+  u16 flags2;         /* Initial flags for P2 */ 
 
   pIn1 = &aMem[pOp->p1];
   pIn2 = &aMem[pOp->p2];
   pOut = &aMem[pOp->p3];
-  testcase( pOut==pIn2 );
+  testcase( pOut==pIn2 ); 
   assert( pIn1!=pOut );
-  flags1 = pIn1->flags;
-  testcase( flags1 & MEM_Null );
-  testcase( pIn2->flags & MEM_Null );
-  if( (flags1 | pIn2->flags) & MEM_Null ){
+  flags1 = pIn1->flags; 
+  testcase( flags1 & MEM_Null ); 
+  testcase( pIn2->flags & MEM_Null ); 
+  if( (flags1 | pIn2->flags) & MEM_Null ){ 
     sqlite3VdbeMemSetNull(pOut);
     break;
   }
-  if( (flags1 & (MEM_Str|MEM_Blob))==0 ){
-    if( sqlite3VdbeMemStringify(pIn1,encoding,0) ) goto no_mem;
-    flags1 = pIn1->flags & ~MEM_Str;
-  }else if( (flags1 & MEM_Zero)!=0 ){
-    if( sqlite3VdbeMemExpandBlob(pIn1) ) goto no_mem;
-    flags1 = pIn1->flags & ~MEM_Str;
-  }
-  flags2 = pIn2->flags;
-  if( (flags2 & (MEM_Str|MEM_Blob))==0 ){
-    if( sqlite3VdbeMemStringify(pIn2,encoding,0) ) goto no_mem;
-    flags2 = pIn2->flags & ~MEM_Str;
-  }else if( (flags2 & MEM_Zero)!=0 ){
-    if( sqlite3VdbeMemExpandBlob(pIn2) ) goto no_mem;
-    flags2 = pIn2->flags & ~MEM_Str;
-  }
+  if( (flags1 & (MEM_Str|MEM_Blob))==0 ){ 
+    if( sqlite3VdbeMemStringify(pIn1,encoding,0) ) goto no_mem; 
+    flags1 = pIn1->flags & ~MEM_Str; 
+  }else if( (flags1 & MEM_Zero)!=0 ){ 
+    if( sqlite3VdbeMemExpandBlob(pIn1) ) goto no_mem; 
+    flags1 = pIn1->flags & ~MEM_Str; 
+  } 
+  flags2 = pIn2->flags; 
+  if( (flags2 & (MEM_Str|MEM_Blob))==0 ){ 
+    if( sqlite3VdbeMemStringify(pIn2,encoding,0) ) goto no_mem; 
+    flags2 = pIn2->flags & ~MEM_Str; 
+  }else if( (flags2 & MEM_Zero)!=0 ){ 
+    if( sqlite3VdbeMemExpandBlob(pIn2) ) goto no_mem; 
+    flags2 = pIn2->flags & ~MEM_Str; 
+  } 
   nByte = pIn1->n + pIn2->n;
   if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
     goto too_big;
   }
-  if( sqlite3VdbeMemGrow(pOut, (int)nByte+3, pOut==pIn2) ){
+  if( sqlite3VdbeMemGrow(pOut, (int)nByte+3, pOut==pIn2) ){ 
     goto no_mem;
   }
   MemSetTypeFlag(pOut, MEM_Str);
   if( pOut!=pIn2 ){
     memcpy(pOut->z, pIn2->z, pIn2->n);
-    assert( (pIn2->flags & MEM_Dyn) == (flags2 & MEM_Dyn) );
-    pIn2->flags = flags2;
+    assert( (pIn2->flags & MEM_Dyn) == (flags2 & MEM_Dyn) ); 
+    pIn2->flags = flags2; 
   }
   memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);
-  assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) );
-  pIn1->flags = flags1;
+  assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) ); 
+  pIn1->flags = flags1; 
   pOut->z[nByte]=0;
   pOut->z[nByte+1] = 0;
-  pOut->z[nByte+2] = 0;
+  pOut->z[nByte+2] = 0; 
   pOut->flags |= MEM_Term;
   pOut->n = (int)nByte;
   pOut->enc = encoding;
@@ -88429,8 +88429,8 @@ fp_math:
         break;
       }
       default: {
-        iA = sqlite3VdbeIntValue(pIn1);
-        iB = sqlite3VdbeIntValue(pIn2);
+        iA = sqlite3VdbeIntValue(pIn1); 
+        iB = sqlite3VdbeIntValue(pIn2); 
         if( iA==0 ) goto arithmetic_result_is_null;
         if( iA==-1 ) iA = 1;
         rB = (double)(iB % iA);
@@ -88588,7 +88588,7 @@ case OP_MustBeInt: {            /* jump, in1 */
   if( (pIn1->flags & MEM_Int)==0 ){
     applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding);
     if( (pIn1->flags & MEM_Int)==0 ){
-      VdbeBranchTaken(1, 2);
+      VdbeBranchTaken(1, 2); 
       if( pOp->p2==0 ){
         rc = SQLITE_MISMATCH;
         goto abort_due_to_error;
@@ -88597,7 +88597,7 @@ case OP_MustBeInt: {            /* jump, in1 */
       }
     }
   }
-  VdbeBranchTaken(0, 2);
+  VdbeBranchTaken(0, 2); 
   MemSetTypeFlag(pIn1, MEM_Int);
   break;
 }
@@ -88614,9 +88614,9 @@ case OP_MustBeInt: {            /* jump, in1 */
 */
 case OP_RealAffinity: {                  /* in1 */
   pIn1 = &aMem[pOp->p1];
-  if( pIn1->flags & (MEM_Int|MEM_IntReal) ){
-    testcase( pIn1->flags & MEM_Int );
-    testcase( pIn1->flags & MEM_IntReal );
+  if( pIn1->flags & (MEM_Int|MEM_IntReal) ){ 
+    testcase( pIn1->flags & MEM_Int ); 
+    testcase( pIn1->flags & MEM_IntReal ); 
     sqlite3VdbeMemRealify(pIn1);
     REGISTER_TRACE(pOp->p1, pIn1);
   }
@@ -88799,14 +88799,14 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
       ** or not both operands are null.
       */
       assert( (flags1 & MEM_Cleared)==0 );
-      assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 || CORRUPT_DB );
-      testcase( (pOp->p5 & SQLITE_JUMPIFNULL)!=0 );
+      assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 || CORRUPT_DB ); 
+      testcase( (pOp->p5 & SQLITE_JUMPIFNULL)!=0 ); 
       if( (flags1&flags3&MEM_Null)!=0
        && (flags3&MEM_Cleared)==0
       ){
         res = 0;  /* Operands are equal */
       }else{
-        res = ((flags3 & MEM_Null) ? -1 : +1);  /* Operands are not equal */
+        res = ((flags3 & MEM_Null) ? -1 : +1);  /* Operands are not equal */ 
       }
     }else{
       /* SQLITE_NULLEQ is clear and at least one operand is NULL,
@@ -88826,29 +88826,29 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
     affinity = pOp->p5 & SQLITE_AFF_MASK;
     if( affinity>=SQLITE_AFF_NUMERIC ){
       if( (flags1 | flags3)&MEM_Str ){
-        if( (flags1 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){
+        if( (flags1 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){ 
           applyNumericAffinity(pIn1,0);
           testcase( flags3==pIn3->flags );
           flags3 = pIn3->flags;
         }
-        if( (flags3 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){
+        if( (flags3 & (MEM_Int|MEM_IntReal|MEM_Real|MEM_Str))==MEM_Str ){ 
           applyNumericAffinity(pIn3,0);
         }
       }
     }else if( affinity==SQLITE_AFF_TEXT ){
-      if( (flags1 & MEM_Str)==0 && (flags1&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){
+      if( (flags1 & MEM_Str)==0 && (flags1&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){ 
         testcase( pIn1->flags & MEM_Int );
         testcase( pIn1->flags & MEM_Real );
-        testcase( pIn1->flags & MEM_IntReal );
+        testcase( pIn1->flags & MEM_IntReal ); 
         sqlite3VdbeMemStringify(pIn1, encoding, 1);
         testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) );
         flags1 = (pIn1->flags & ~MEM_TypeMask) | (flags1 & MEM_TypeMask);
         if( NEVER(pIn1==pIn3) ) flags3 = flags1 | MEM_Str;
       }
-      if( (flags3 & MEM_Str)==0 && (flags3&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){
+      if( (flags3 & MEM_Str)==0 && (flags3&(MEM_Int|MEM_Real|MEM_IntReal))!=0 ){ 
         testcase( pIn3->flags & MEM_Int );
         testcase( pIn3->flags & MEM_Real );
-        testcase( pIn3->flags & MEM_IntReal );
+        testcase( pIn3->flags & MEM_IntReal ); 
         sqlite3VdbeMemStringify(pIn3, encoding, 1);
         testcase( (flags3&MEM_Dyn) != (pIn3->flags&MEM_Dyn) );
         flags3 = (pIn3->flags & ~MEM_TypeMask) | (flags3 & MEM_TypeMask);
@@ -89026,11 +89026,11 @@ case OP_Compare: {
 */
 case OP_Jump: {             /* jump */
   if( iCompare<0 ){
-    VdbeBranchTaken(0,4); pOp = &aOp[pOp->p1 - 1];
+    VdbeBranchTaken(0,4); pOp = &aOp[pOp->p1 - 1]; 
   }else if( iCompare==0 ){
-    VdbeBranchTaken(1,4); pOp = &aOp[pOp->p2 - 1];
+    VdbeBranchTaken(1,4); pOp = &aOp[pOp->p2 - 1]; 
   }else{
-    VdbeBranchTaken(2,4); pOp = &aOp[pOp->p3 - 1];
+    VdbeBranchTaken(2,4); pOp = &aOp[pOp->p3 - 1]; 
   }
   break;
 }
@@ -89060,8 +89060,8 @@ case OP_Or: {             /* same as TK_OR, in1, in2, out3 */
   int v1;    /* Left operand:  0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
   int v2;    /* Right operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
 
-  v1 = sqlite3VdbeBooleanValue(&aMem[pOp->p1], 2);
-  v2 = sqlite3VdbeBooleanValue(&aMem[pOp->p2], 2);
+  v1 = sqlite3VdbeBooleanValue(&aMem[pOp->p1], 2); 
+  v2 = sqlite3VdbeBooleanValue(&aMem[pOp->p2], 2); 
   if( pOp->opcode==OP_And ){
     static const unsigned char and_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 };
     v1 = and_logic[v1*3+v2];
@@ -89079,35 +89079,35 @@ case OP_Or: {             /* same as TK_OR, in1, in2, out3 */
   break;
 }
 
-/* Opcode: IsTrue P1 P2 P3 P4 *
-** Synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4
-**
-** This opcode implements the IS TRUE, IS FALSE, IS NOT TRUE, and
-** IS NOT FALSE operators.
-**
-** Interpret the value in register P1 as a boolean value.  Store that
+/* Opcode: IsTrue P1 P2 P3 P4 * 
+** Synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4 
+** 
+** This opcode implements the IS TRUE, IS FALSE, IS NOT TRUE, and 
+** IS NOT FALSE operators. 
+** 
+** Interpret the value in register P1 as a boolean value.  Store that 
 ** boolean (a 0 or 1) in register P2.  Or if the value in register P1 is
-** NULL, then the P3 is stored in register P2.  Invert the answer if P4
-** is 1.
-**
-** The logic is summarized like this:
-**
+** NULL, then the P3 is stored in register P2.  Invert the answer if P4 
+** is 1. 
+** 
+** The logic is summarized like this: 
+** 
 ** <ul>
-** <li> If P3==0 and P4==0  then  r[P2] := r[P1] IS TRUE
-** <li> If P3==1 and P4==1  then  r[P2] := r[P1] IS FALSE
-** <li> If P3==0 and P4==1  then  r[P2] := r[P1] IS NOT TRUE
-** <li> If P3==1 and P4==0  then  r[P2] := r[P1] IS NOT FALSE
-** </ul>
-*/
-case OP_IsTrue: {               /* in1, out2 */
-  assert( pOp->p4type==P4_INT32 );
-  assert( pOp->p4.i==0 || pOp->p4.i==1 );
-  assert( pOp->p3==0 || pOp->p3==1 );
-  sqlite3VdbeMemSetInt64(&aMem[pOp->p2],
-      sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3) ^ pOp->p4.i);
-  break;
-}
-
+** <li> If P3==0 and P4==0  then  r[P2] := r[P1] IS TRUE 
+** <li> If P3==1 and P4==1  then  r[P2] := r[P1] IS FALSE 
+** <li> If P3==0 and P4==1  then  r[P2] := r[P1] IS NOT TRUE 
+** <li> If P3==1 and P4==0  then  r[P2] := r[P1] IS NOT FALSE 
+** </ul> 
+*/ 
+case OP_IsTrue: {               /* in1, out2 */ 
+  assert( pOp->p4type==P4_INT32 ); 
+  assert( pOp->p4.i==0 || pOp->p4.i==1 ); 
+  assert( pOp->p3==0 || pOp->p3==1 ); 
+  sqlite3VdbeMemSetInt64(&aMem[pOp->p2], 
+      sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3) ^ pOp->p4.i); 
+  break; 
+} 
+ 
 /* Opcode: Not P1 P2 * * *
 ** Synopsis: r[P2]= !r[P1]
 **
@@ -89119,15 +89119,15 @@ case OP_Not: {                /* same as TK_NOT, in1, out2 */
   pIn1 = &aMem[pOp->p1];
   pOut = &aMem[pOp->p2];
   if( (pIn1->flags & MEM_Null)==0 ){
-    sqlite3VdbeMemSetInt64(pOut, !sqlite3VdbeBooleanValue(pIn1,0));
-  }else{
-    sqlite3VdbeMemSetNull(pOut);
+    sqlite3VdbeMemSetInt64(pOut, !sqlite3VdbeBooleanValue(pIn1,0)); 
+  }else{ 
+    sqlite3VdbeMemSetNull(pOut); 
   }
   break;
 }
 
 /* Opcode: BitNot P1 P2 * * *
-** Synopsis: r[P2]= ~r[P1]
+** Synopsis: r[P2]= ~r[P1] 
 **
 ** Interpret the content of register P1 as an integer.  Store the
 ** ones-complement of the P1 value into register P2.  If P1 holds
@@ -89188,14 +89188,14 @@ case OP_Once: {             /* jump */
 ** is considered true if it is numeric and non-zero.  If the value
 ** in P1 is NULL then take the jump if and only if P3 is non-zero.
 */
-case OP_If:  {               /* jump, in1 */
-  int c;
-  c = sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3);
-  VdbeBranchTaken(c!=0, 2);
-  if( c ) goto jump_to_p2;
-  break;
-}
-
+case OP_If:  {               /* jump, in1 */ 
+  int c; 
+  c = sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3); 
+  VdbeBranchTaken(c!=0, 2); 
+  if( c ) goto jump_to_p2; 
+  break; 
+} 
+ 
 /* Opcode: IfNot P1 P2 P3 * *
 **
 ** Jump to P2 if the value in register P1 is False.  The value
@@ -89204,9 +89204,9 @@ case OP_If:  {               /* jump, in1 */
 */
 case OP_IfNot: {            /* jump, in1 */
   int c;
-  c = !sqlite3VdbeBooleanValue(&aMem[pOp->p1], !pOp->p3);
+  c = !sqlite3VdbeBooleanValue(&aMem[pOp->p1], !pOp->p3); 
   VdbeBranchTaken(c!=0, 2);
-  if( c ) goto jump_to_p2;
+  if( c ) goto jump_to_p2; 
   break;
 }
 
@@ -89301,7 +89301,7 @@ case OP_IfNullRow: {         /* jump */
 ** P2 is the column number for the argument to the sqlite_offset() function.
 ** This opcode does not use P2 itself, but the P2 value is used by the
 ** code generator.  The P1, P2, and P3 operands to this opcode are the
-** same as for OP_Column.
+** same as for OP_Column. 
 **
 ** This opcode is only available if SQLite is compiled with the
 ** -DSQLITE_ENABLE_OFFSET_SQL_FUNC option.
@@ -89477,15 +89477,15 @@ case OP_Column: {
       zEndHdr = zData + aOffset[0];
       testcase( zHdr>=zEndHdr );
       do{
-        if( (pC->aType[i] = t = zHdr[0])<0x80 ){
+        if( (pC->aType[i] = t = zHdr[0])<0x80 ){ 
           zHdr++;
           offset64 += sqlite3VdbeOneByteSerialTypeLen(t);
         }else{
           zHdr += sqlite3GetVarint32(zHdr, &t);
-          pC->aType[i] = t;
+          pC->aType[i] = t; 
           offset64 += sqlite3VdbeSerialTypeLen(t);
         }
-        aOffset[++i] = (u32)(offset64 & 0xffffffff);
+        aOffset[++i] = (u32)(offset64 & 0xffffffff); 
       }while( (u32)i<=p2 && zHdr<zEndHdr );
 
       /* The record is corrupt if any of the following are true:
@@ -89730,8 +89730,8 @@ case OP_Affinity: {
   while( 1 /*exit-by-break*/ ){
     assert( pIn1 <= &p->aMem[(p->nMem+1 - p->nCursor)] );
     assert( zAffinity[0]==SQLITE_AFF_NONE || memIsValid(pIn1) );
-    applyAffinity(pIn1, zAffinity[0], encoding);
-    if( zAffinity[0]==SQLITE_AFF_REAL && (pIn1->flags & MEM_Int)!=0 ){
+    applyAffinity(pIn1, zAffinity[0], encoding); 
+    if( zAffinity[0]==SQLITE_AFF_REAL && (pIn1->flags & MEM_Int)!=0 ){ 
       /* When applying REAL affinity, if the result is still an MEM_Int
       ** that will fit in 6 bytes, then change the type to MEM_IntReal
       ** so that we keep the high-resolution integer value but know that
@@ -89748,12 +89748,12 @@ case OP_Affinity: {
         pIn1->flags |= MEM_Real;
         pIn1->flags &= ~MEM_Int;
       }
-    }
-    REGISTER_TRACE((int)(pIn1-aMem), pIn1);
-    zAffinity++;
-    if( zAffinity[0]==0 ) break;
+    } 
+    REGISTER_TRACE((int)(pIn1-aMem), pIn1); 
+    zAffinity++; 
+    if( zAffinity[0]==0 ) break; 
     pIn1++;
-  }
+  } 
   break;
 }
 
@@ -89798,8 +89798,8 @@ case OP_MakeRecord: {
   char *zAffinity;       /* The affinity string for the record */
   int file_format;       /* File format to use for encoding */
   u32 len;               /* Length of a field */
-  u8 *zHdr;              /* Where to write next byte of the header */
-  u8 *zPayload;          /* Where to write next byte of the payload */
+  u8 *zHdr;              /* Where to write next byte of the header */ 
+  u8 *zPayload;          /* Where to write next byte of the payload */ 
 
   /* Assuming the record contains N fields, the record format looks
   ** like this:
@@ -89838,14 +89838,14 @@ case OP_MakeRecord: {
   if( zAffinity ){
     pRec = pData0;
     do{
-      applyAffinity(pRec, zAffinity[0], encoding);
-      if( zAffinity[0]==SQLITE_AFF_REAL && (pRec->flags & MEM_Int) ){
-        pRec->flags |= MEM_IntReal;
-        pRec->flags &= ~(MEM_Int);
-      }
-      REGISTER_TRACE((int)(pRec-aMem), pRec);
-      zAffinity++;
-      pRec++;
+      applyAffinity(pRec, zAffinity[0], encoding); 
+      if( zAffinity[0]==SQLITE_AFF_REAL && (pRec->flags & MEM_Int) ){ 
+        pRec->flags |= MEM_IntReal; 
+        pRec->flags &= ~(MEM_Int); 
+      } 
+      REGISTER_TRACE((int)(pRec-aMem), pRec); 
+      zAffinity++; 
+      pRec++; 
       assert( zAffinity[0]==0 || pRec<=pLast );
     }while( zAffinity[0] );
   }
@@ -90007,45 +90007,45 @@ case OP_MakeRecord: {
   ** be one of the input registers (because the following call to
   ** sqlite3VdbeMemClearAndResize() could clobber the value before it is used).
   */
-  if( nByte+nZero<=pOut->szMalloc ){
-    /* The output register is already large enough to hold the record.
-    ** No error checks or buffer enlargement is required */
-    pOut->z = pOut->zMalloc;
-  }else{
-    /* Need to make sure that the output is not too big and then enlarge
-    ** the output register to hold the full result */
-    if( nByte+nZero>db->aLimit[SQLITE_LIMIT_LENGTH] ){
-      goto too_big;
-    }
-    if( sqlite3VdbeMemClearAndResize(pOut, (int)nByte) ){
-      goto no_mem;
-    }
-  }
-  pOut->n = (int)nByte;
-  pOut->flags = MEM_Blob;
-  if( nZero ){
-    pOut->u.nZero = nZero;
-    pOut->flags |= MEM_Zero;
-  }
-  UPDATE_MAX_BLOBSIZE(pOut);
-  zHdr = (u8 *)pOut->z;
-  zPayload = zHdr + nHdr;
+  if( nByte+nZero<=pOut->szMalloc ){ 
+    /* The output register is already large enough to hold the record. 
+    ** No error checks or buffer enlargement is required */ 
+    pOut->z = pOut->zMalloc; 
+  }else{ 
+    /* Need to make sure that the output is not too big and then enlarge 
+    ** the output register to hold the full result */ 
+    if( nByte+nZero>db->aLimit[SQLITE_LIMIT_LENGTH] ){ 
+      goto too_big; 
+    } 
+    if( sqlite3VdbeMemClearAndResize(pOut, (int)nByte) ){ 
+      goto no_mem; 
+    } 
+  }
+  pOut->n = (int)nByte; 
+  pOut->flags = MEM_Blob; 
+  if( nZero ){ 
+    pOut->u.nZero = nZero; 
+    pOut->flags |= MEM_Zero; 
+  } 
+  UPDATE_MAX_BLOBSIZE(pOut); 
+  zHdr = (u8 *)pOut->z; 
+  zPayload = zHdr + nHdr; 
 
   /* Write the record */
-  zHdr += putVarint32(zHdr, nHdr);
+  zHdr += putVarint32(zHdr, nHdr); 
   assert( pData0<=pLast );
   pRec = pData0;
   do{
     serial_type = pRec->uTemp;
     /* EVIDENCE-OF: R-06529-47362 Following the size varint are one or more
     ** additional varints, one per column. */
-    zHdr += putVarint32(zHdr, serial_type);            /* serial type */
+    zHdr += putVarint32(zHdr, serial_type);            /* serial type */ 
     /* EVIDENCE-OF: R-64536-51728 The values for each column in the record
     ** immediately follow the header. */
-    zPayload += sqlite3VdbeSerialPut(zPayload, pRec, serial_type); /* content */
+    zPayload += sqlite3VdbeSerialPut(zPayload, pRec, serial_type); /* content */ 
   }while( (++pRec)<=pLast );
-  assert( nHdr==(int)(zHdr - (u8*)pOut->z) );
-  assert( nByte==(int)(zPayload - (u8*)pOut->z) );
+  assert( nHdr==(int)(zHdr - (u8*)pOut->z) ); 
+  assert( nByte==(int)(zPayload - (u8*)pOut->z) ); 
 
   assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
   REGISTER_TRACE(pOp->p3, pOut);
@@ -90084,9 +90084,9 @@ case OP_Count: {         /* out2 */
 /* Opcode: Savepoint P1 * * P4 *
 **
 ** Open, release or rollback the savepoint named by parameter P4, depending
-** on the value of P1. To open a new savepoint set P1==0 (SAVEPOINT_BEGIN).
-** To release (commit) an existing savepoint set P1==1 (SAVEPOINT_RELEASE).
-** To rollback an existing savepoint set P1==2 (SAVEPOINT_ROLLBACK).
+** on the value of P1. To open a new savepoint set P1==0 (SAVEPOINT_BEGIN). 
+** To release (commit) an existing savepoint set P1==1 (SAVEPOINT_RELEASE). 
+** To rollback an existing savepoint set P1==2 (SAVEPOINT_ROLLBACK). 
 */
 case OP_Savepoint: {
   int p1;                         /* Value of P1 operand */
@@ -90154,7 +90154,7 @@ case OP_Savepoint: {
       }
     }
   }else{
-    assert( p1==SAVEPOINT_RELEASE || p1==SAVEPOINT_ROLLBACK );
+    assert( p1==SAVEPOINT_RELEASE || p1==SAVEPOINT_ROLLBACK ); 
     iSavepoint = 0;
 
     /* Find the named savepoint. If there is no such savepoint, then an
@@ -90212,7 +90212,7 @@ case OP_Savepoint: {
             if( rc!=SQLITE_OK ) goto abort_due_to_error;
           }
         }else{
-          assert( p1==SAVEPOINT_RELEASE );
+          assert( p1==SAVEPOINT_RELEASE ); 
           isSchemaChange = 0;
         }
         for(ii=0; ii<db->nDb; ii++){
@@ -90222,7 +90222,7 @@ case OP_Savepoint: {
           }
         }
         if( isSchemaChange ){
-          sqlite3ExpirePreparedStatements(db, 0);
+          sqlite3ExpirePreparedStatements(db, 0); 
           sqlite3ResetAllSchemasOfConnection(db);
           db->mDbFlags |= DBFLAG_SchemaChange;
         }
@@ -90250,7 +90250,7 @@ case OP_Savepoint: {
           db->nSavepoint--;
         }
       }else{
-        assert( p1==SAVEPOINT_ROLLBACK );
+        assert( p1==SAVEPOINT_ROLLBACK ); 
         db->nDeferredCons = pSavepoint->nDeferredCons;
         db->nDeferredImmCons = pSavepoint->nDeferredImmCons;
       }
@@ -90366,7 +90366,7 @@ case OP_AutoCommit: {
 */
 case OP_Transaction: {
   Btree *pBt;
-  int iMeta = 0;
+  int iMeta = 0; 
 
   assert( p->bIsReader );
   assert( p->readOnly==0 || pOp->p2==0 );
@@ -90388,7 +90388,7 @@ case OP_Transaction: {
   pBt = db->aDb[pOp->p1].pBt;
 
   if( pBt ){
-    rc = sqlite3BtreeBeginTrans(pBt, pOp->p2, &iMeta);
+    rc = sqlite3BtreeBeginTrans(pBt, pOp->p2, &iMeta); 
     testcase( rc==SQLITE_BUSY_SNAPSHOT );
     testcase( rc==SQLITE_BUSY_RECOVERY );
     if( rc!=SQLITE_OK ){
@@ -90422,14 +90422,14 @@ case OP_Transaction: {
       p->nStmtDefCons = db->nDeferredCons;
       p->nStmtDefImmCons = db->nDeferredImmCons;
     }
-  }
-  assert( pOp->p5==0 || pOp->p4type==P4_INT32 );
+  } 
+  assert( pOp->p5==0 || pOp->p4type==P4_INT32 ); 
   if( rc==SQLITE_OK
    && pOp->p5
-   && (iMeta!=pOp->p3
-      || db->aDb[pOp->p1].pSchema->iGeneration!=pOp->p4.i)
-  ){
-    /*
+   && (iMeta!=pOp->p3 
+      || db->aDb[pOp->p1].pSchema->iGeneration!=pOp->p4.i) 
+  ){ 
+    /* 
     ** IMPLEMENTATION-OF: R-03189-51135 As each SQL statement runs, the schema
     ** version is checked to ensure that the schema has not changed since the
     ** SQL statement was prepared.
@@ -90507,8 +90507,8 @@ case OP_ReadCookie: {               /* out2 */
 */
 case OP_SetCookie: {
   Db *pDb;
-
-  sqlite3VdbeIncrWriteCounter(p, 0);
+ 
+  sqlite3VdbeIncrWriteCounter(p, 0); 
   assert( pOp->p2<SQLITE_N_BTREE_META );
   assert( pOp->p1>=0 && pOp->p1<db->nDb );
   assert( DbMaskTest(p->btreeMask, pOp->p1) );
@@ -90530,7 +90530,7 @@ case OP_SetCookie: {
   if( pOp->p1==1 ){
     /* Invalidate all prepared statements whenever the TEMP database
     ** schema is changed.  Ticket #1644 */
-    sqlite3ExpirePreparedStatements(db, 0);
+    sqlite3ExpirePreparedStatements(db, 0); 
     p->expired = 0;
   }
   if( rc ) goto abort_due_to_error;
@@ -90548,78 +90548,78 @@ case OP_SetCookie: {
 ** values need not be contiguous but all P1 values should be small integers.
 ** It is an error for P1 to be negative.
 **
-** Allowed P5 bits:
-** <ul>
-** <li>  <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
-**       equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT
+** Allowed P5 bits: 
+** <ul> 
+** <li>  <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for 
+**       equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT 
 **       of OP_SeekLE/OP_IdxLT)
-** </ul>
+** </ul> 
 **
 ** The P4 value may be either an integer (P4_INT32) or a pointer to
 ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
-** object, then table being opened must be an [index b-tree] where the
+** object, then table being opened must be an [index b-tree] where the 
 ** KeyInfo object defines the content and collating
 ** sequence of that index b-tree. Otherwise, if P4 is an integer
-** value, then the table being opened must be a [table b-tree] with a
-** number of columns no less than the value of P4.
+** value, then the table being opened must be a [table b-tree] with a 
+** number of columns no less than the value of P4. 
 **
 ** See also: OpenWrite, ReopenIdx
 */
 /* Opcode: ReopenIdx P1 P2 P3 P4 P5
 ** Synopsis: root=P2 iDb=P3
 **
-** The ReopenIdx opcode works like OP_OpenRead except that it first
-** checks to see if the cursor on P1 is already open on the same
-** b-tree and if it is this opcode becomes a no-op.  In other words,
+** The ReopenIdx opcode works like OP_OpenRead except that it first 
+** checks to see if the cursor on P1 is already open on the same 
+** b-tree and if it is this opcode becomes a no-op.  In other words, 
 ** if the cursor is already open, do not reopen it.
 **
-** The ReopenIdx opcode may only be used with P5==0 or P5==OPFLAG_SEEKEQ
-** and with P4 being a P4_KEYINFO object.  Furthermore, the P3 value must
-** be the same as every other ReopenIdx or OpenRead for the same cursor
-** number.
+** The ReopenIdx opcode may only be used with P5==0 or P5==OPFLAG_SEEKEQ 
+** and with P4 being a P4_KEYINFO object.  Furthermore, the P3 value must 
+** be the same as every other ReopenIdx or OpenRead for the same cursor 
+** number. 
 **
-** Allowed P5 bits:
-** <ul>
-** <li>  <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
-**       equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT
+** Allowed P5 bits: 
+** <ul> 
+** <li>  <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for 
+**       equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT 
 **       of OP_SeekLE/OP_IdxLT)
-** </ul>
-**
-** See also: OP_OpenRead, OP_OpenWrite
+** </ul> 
+** 
+** See also: OP_OpenRead, OP_OpenWrite 
 */
 /* Opcode: OpenWrite P1 P2 P3 P4 P5
 ** Synopsis: root=P2 iDb=P3
 **
 ** Open a read/write cursor named P1 on the table or index whose root
-** page is P2 (or whose root page is held in register P2 if the
-** OPFLAG_P2ISREG bit is set in P5 - see below).
+** page is P2 (or whose root page is held in register P2 if the 
+** OPFLAG_P2ISREG bit is set in P5 - see below). 
 **
 ** The P4 value may be either an integer (P4_INT32) or a pointer to
 ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
-** object, then table being opened must be an [index b-tree] where the
+** object, then table being opened must be an [index b-tree] where the 
 ** KeyInfo object defines the content and collating
 ** sequence of that index b-tree. Otherwise, if P4 is an integer
-** value, then the table being opened must be a [table b-tree] with a
-** number of columns no less than the value of P4.
+** value, then the table being opened must be a [table b-tree] with a 
+** number of columns no less than the value of P4. 
 **
-** Allowed P5 bits:
-** <ul>
-** <li>  <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for
-**       equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT
+** Allowed P5 bits: 
+** <ul> 
+** <li>  <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for 
+**       equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT 
 **       of OP_SeekLE/OP_IdxLT)
-** <li>  <b>0x08 OPFLAG_FORDELETE</b>: This cursor is used only to seek
-**       and subsequently delete entries in an index btree.  This is a
-**       hint to the storage engine that the storage engine is allowed to
-**       ignore.  The hint is not used by the official SQLite b*tree storage
-**       engine, but is used by COMDB2.
-** <li>  <b>0x10 OPFLAG_P2ISREG</b>: Use the content of register P2
-**       as the root page, not the value of P2 itself.
-** </ul>
-**
-** This instruction works like OpenRead except that it opens the cursor
-** in read/write mode.
-**
-** See also: OP_OpenRead, OP_ReopenIdx
+** <li>  <b>0x08 OPFLAG_FORDELETE</b>: This cursor is used only to seek 
+**       and subsequently delete entries in an index btree.  This is a 
+**       hint to the storage engine that the storage engine is allowed to 
+**       ignore.  The hint is not used by the official SQLite b*tree storage 
+**       engine, but is used by COMDB2. 
+** <li>  <b>0x10 OPFLAG_P2ISREG</b>: Use the content of register P2 
+**       as the root page, not the value of P2 itself. 
+** </ul> 
+**
+** This instruction works like OpenRead except that it opens the cursor 
+** in read/write mode. 
+** 
+** See also: OP_OpenRead, OP_ReopenIdx 
 */
 case OP_ReopenIdx: {
   int nField;
@@ -90650,7 +90650,7 @@ case OP_OpenWrite:
   assert( pOp->opcode==OP_OpenRead || pOp->opcode==OP_ReopenIdx
           || p->readOnly==0 );
 
-  if( p->expired==1 ){
+  if( p->expired==1 ){ 
     rc = SQLITE_ABORT_ROLLBACK;
     goto abort_due_to_error;
   }
@@ -90677,7 +90677,7 @@ case OP_OpenWrite:
   if( pOp->p5 & OPFLAG_P2ISREG ){
     assert( p2>0 );
     assert( p2<=(u32)(p->nMem+1 - p->nCursor) );
-    assert( pOp->opcode==OP_OpenWrite );
+    assert( pOp->opcode==OP_OpenWrite ); 
     pIn2 = &aMem[p2];
     assert( memIsValid(pIn2) );
     assert( (pIn2->flags & MEM_Int)!=0 );
@@ -90749,8 +90749,8 @@ case OP_OpenDup: {
   pCx->isEphemeral = 1;
   pCx->pKeyInfo = pOrig->pKeyInfo;
   pCx->isTable = pOrig->isTable;
-  pCx->pgnoRoot = pOrig->pgnoRoot;
-  pCx->isOrdered = pOrig->isOrdered;
+  pCx->pgnoRoot = pOrig->pgnoRoot; 
+  pCx->isOrdered = pOrig->isOrdered; 
   pCx->pBtx = pOrig->pBtx;
   pCx->hasBeenDuped = 1;
   pOrig->hasBeenDuped = 1;
@@ -90772,9 +90772,9 @@ case OP_OpenDup: {
 ** the main database is read-only.  The ephemeral
 ** table is deleted automatically when the cursor is closed.
 **
-** If the cursor P1 is already opened on an ephemeral table, the table
-** is cleared (all content is erased).
-**
+** If the cursor P1 is already opened on an ephemeral table, the table 
+** is cleared (all content is erased). 
+** 
 ** P2 is the number of columns in the ephemeral table.
 ** The cursor points to a BTree table if P4==0 and to a BTree index
 ** if P4 is not 0.  If P4 is not NULL, it points to a KeyInfo structure
@@ -90819,24 +90819,24 @@ case OP_OpenEphemeral: {
     aMem[pOp->p3].n = 0;
     aMem[pOp->p3].z = "";
   }
-  pCx = p->apCsr[pOp->p1];
+  pCx = p->apCsr[pOp->p1]; 
   if( pCx && !pCx->hasBeenDuped &&  ALWAYS(pOp->p2<=pCx->nField) ){
     /* If the ephermeral table is already open and has no duplicates from
     ** OP_OpenDup, then erase all existing content so that the table is
     ** empty again, rather than creating a new table. */
-    assert( pCx->isEphemeral );
-    pCx->seqCount = 0;
-    pCx->cacheStatus = CACHE_STALE;
+    assert( pCx->isEphemeral ); 
+    pCx->seqCount = 0; 
+    pCx->cacheStatus = CACHE_STALE; 
     rc = sqlite3BtreeClearTable(pCx->pBtx, pCx->pgnoRoot, 0);
-  }else{
-    pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, CURTYPE_BTREE);
-    if( pCx==0 ) goto no_mem;
-    pCx->isEphemeral = 1;
+  }else{ 
+    pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, CURTYPE_BTREE); 
+    if( pCx==0 ) goto no_mem; 
+    pCx->isEphemeral = 1; 
     rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->pBtx,
-                          BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5,
-                          vfsFlags);
-    if( rc==SQLITE_OK ){
-      rc = sqlite3BtreeBeginTrans(pCx->pBtx, 1, 0);
+                          BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5, 
+                          vfsFlags); 
+    if( rc==SQLITE_OK ){ 
+      rc = sqlite3BtreeBeginTrans(pCx->pBtx, 1, 0); 
       if( rc==SQLITE_OK ){
         /* If a transient index is required, create it by calling
         ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before
@@ -90860,7 +90860,7 @@ case OP_OpenEphemeral: {
           rc = sqlite3BtreeCursor(pCx->pBtx, SCHEMA_ROOT, BTREE_WRCSR,
               0, pCx->uc.pCursor);
           pCx->isTable = 1;
-        }
+        } 
       }
       pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED);
       if( rc ){
@@ -90869,7 +90869,7 @@ case OP_OpenEphemeral: {
     }
   }
   if( rc ) goto abort_due_to_error;
-  pCx->nullRow = 1;
+  pCx->nullRow = 1; 
   break;
 }
 
@@ -91073,10 +91073,10 @@ case OP_ColumnsUsed: {
 **
 ** See also: Found, NotFound, SeekGt, SeekGe, SeekLt
 */
-case OP_SeekLT:         /* jump, in3, group */
-case OP_SeekLE:         /* jump, in3, group */
-case OP_SeekGE:         /* jump, in3, group */
-case OP_SeekGT: {       /* jump, in3, group */
+case OP_SeekLT:         /* jump, in3, group */ 
+case OP_SeekLE:         /* jump, in3, group */ 
+case OP_SeekGE:         /* jump, in3, group */ 
+case OP_SeekGT: {       /* jump, in3, group */ 
   int res;           /* Comparison result */
   int oc;            /* Opcode */
   VdbeCursor *pC;    /* The cursor to seek */
@@ -91102,8 +91102,8 @@ case OP_SeekGT: {       /* jump, in3, group */
   pC->seekOp = pOp->opcode;
 #endif
 
-  pC->deferredMoveto = 0;
-  pC->cacheStatus = CACHE_STALE;
+  pC->deferredMoveto = 0; 
+  pC->cacheStatus = CACHE_STALE; 
   if( pC->isTable ){
     u16 flags3, newType;
     /* The OPFLAG_SEEKEQ/BTREE_SEEK_EQ flag is only set on index cursors */
@@ -91130,11 +91130,11 @@ case OP_SeekGT: {       /* jump, in3, group */
         if( (newType & MEM_Null) || oc>=OP_SeekGE ){
           VdbeBranchTaken(1,2);
           goto jump_to_p2;
-        }else{
-          rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
-          if( rc!=SQLITE_OK ) goto abort_due_to_error;
-          goto seek_not_found;
-        }
+        }else{ 
+          rc = sqlite3BtreeLast(pC->uc.pCursor, &res); 
+          if( rc!=SQLITE_OK ) goto abort_due_to_error; 
+          goto seek_not_found; 
+        } 
       }
       c = sqlite3IntFloatCompare(iKey, pIn3->u.r);
 
@@ -91160,7 +91160,7 @@ case OP_SeekGT: {       /* jump, in3, group */
         assert( (OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001) );
         if( (oc & 0x0001)==(OP_SeekLT & 0x0001) ) oc++;
       }
-    }
+    } 
     rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)iKey, 0, &res);
     pC->movetoTarget = iKey;  /* Used by OP_Delete */
     if( rc!=SQLITE_OK ){
@@ -91270,11 +91270,11 @@ seek_not_found:
 
 /* Opcode: SeekScan  P1 P2 * * *
 ** Synopsis: Scan-ahead up to P1 rows
-**
+** 
 ** This opcode is a prefix opcode to OP_SeekGE.  In other words, this
 ** opcode must be immediately followed by OP_SeekGE. This constraint is
 ** checked by assert() statements.
-**
+** 
 ** This opcode uses the P1 through P4 operands of the subsequent
 ** OP_SeekGE.  In the text that follows, the operands of the subsequent
 ** OP_SeekGE opcode are denoted as SeekOP.P1 through SeekOP.P4.   Only
@@ -91313,7 +91313,7 @@ seek_not_found:
 ** <li> If the cursor ends up past the target row (indicating the the target
 **      row does not exist in the btree) then jump to SeekOP.P2.
 ** </ol>
-*/
+*/ 
 case OP_SeekScan: {
   VdbeCursor *pC;
   int res;
@@ -91423,11 +91423,11 @@ case OP_SeekScan: {
 **
 ** P1 must be a valid b-tree cursor.
 */
-case OP_SeekHit: {
-  VdbeCursor *pC;
-  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
-  pC = p->apCsr[pOp->p1];
-  assert( pC!=0 );
+case OP_SeekHit: { 
+  VdbeCursor *pC; 
+  assert( pOp->p1>=0 && pOp->p1<p->nCursor ); 
+  pC = p->apCsr[pOp->p1]; 
+  assert( pC!=0 ); 
   assert( pOp->p3>=pOp->p2 );
   if( pC->seekHit<pOp->p2 ){
 #ifdef SQLITE_DEBUG
@@ -91444,9 +91444,9 @@ case OP_SeekHit: {
 #endif
     pC->seekHit = pOp->p3;
   }
-  break;
-}
-
+  break; 
+} 
+ 
 /* Opcode: IfNotOpen P1 P2 * * *
 ** Synopsis: if( !csr[P1] ) goto P2
 **
@@ -91495,39 +91495,39 @@ case OP_IfNotOpen: {        /* jump */
 ** advanced in either direction.  In other words, the Next and Prev
 ** opcodes do not work after this operation.
 **
-** See also: Found, NotExists, NoConflict, IfNoHope
+** See also: Found, NotExists, NoConflict, IfNoHope 
 */
-/* Opcode: IfNoHope P1 P2 P3 P4 *
-** Synopsis: key=r[P3@P4]
-**
-** Register P3 is the first of P4 registers that form an unpacked
+/* Opcode: IfNoHope P1 P2 P3 P4 * 
+** Synopsis: key=r[P3@P4] 
+** 
+** Register P3 is the first of P4 registers that form an unpacked 
 ** record.  Cursor P1 is an index btree.  P2 is a jump destination.
 ** In other words, the operands to this opcode are the same as the
 ** operands to OP_NotFound and OP_IdxGT.
-**
+** 
 ** This opcode is an optimization attempt only.  If this opcode always
 ** falls through, the correct answer is still obtained, but extra works
 ** is performed.
-**
+** 
 ** A value of N in the seekHit flag of cursor P1 means that there exists
 ** a key P3:N that will match some record in the index.  We want to know
 ** if it is possible for a record P3:P4 to match some record in the
 ** index.  If it is not possible, we can skips some work.  So if seekHit
 ** is less than P4, attempt to find out if a match is possible by running
 ** OP_NotFound.
-**
-** This opcode is used in IN clause processing for a multi-column key.
-** If an IN clause is attached to an element of the key other than the
-** left-most element, and if there are no matches on the most recent
-** seek over the whole key, then it might be that one of the key element
-** to the left is prohibiting a match, and hence there is "no hope" of
-** any match regardless of how many IN clause elements are checked.
-** In such a case, we abandon the IN clause search early, using this
-** opcode.  The opcode name comes from the fact that the
-** jump is taken if there is "no hope" of achieving a match.
-**
-** See also: NotFound, SeekHit
-*/
+** 
+** This opcode is used in IN clause processing for a multi-column key. 
+** If an IN clause is attached to an element of the key other than the 
+** left-most element, and if there are no matches on the most recent 
+** seek over the whole key, then it might be that one of the key element 
+** to the left is prohibiting a match, and hence there is "no hope" of 
+** any match regardless of how many IN clause elements are checked. 
+** In such a case, we abandon the IN clause search early, using this 
+** opcode.  The opcode name comes from the fact that the 
+** jump is taken if there is "no hope" of achieving a match. 
+** 
+** See also: NotFound, SeekHit 
+*/ 
 /* Opcode: NoConflict P1 P2 P3 P4 *
 ** Synopsis: key=r[P3@P4]
 **
@@ -91551,20 +91551,20 @@ case OP_IfNotOpen: {        /* jump */
 **
 ** See also: NotFound, Found, NotExists
 */
-case OP_IfNoHope: {     /* jump, in3 */
-  VdbeCursor *pC;
-  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
-  pC = p->apCsr[pOp->p1];
-  assert( pC!=0 );
+case OP_IfNoHope: {     /* jump, in3 */ 
+  VdbeCursor *pC; 
+  assert( pOp->p1>=0 && pOp->p1<p->nCursor ); 
+  pC = p->apCsr[pOp->p1]; 
+  assert( pC!=0 ); 
 #ifdef SQLITE_DEBUG
   if( db->flags&SQLITE_VdbeTrace ){
     printf("seekHit is %d\n", pC->seekHit);
   }
 #endif
   if( pC->seekHit>=pOp->p4.i ) break;
-  /* Fall through into OP_NotFound */
+  /* Fall through into OP_NotFound */ 
   /* no break */ deliberate_fall_through
-}
+} 
 case OP_NoConflict:     /* jump, in3 */
 case OP_NotFound:       /* jump, in3 */
 case OP_Found: {        /* jump, in3 */
@@ -91702,11 +91702,11 @@ case OP_SeekRowid: {        /* jump, in3 */
   u64 iKey;
 
   pIn3 = &aMem[pOp->p3];
-  testcase( pIn3->flags & MEM_Int );
-  testcase( pIn3->flags & MEM_IntReal );
+  testcase( pIn3->flags & MEM_Int ); 
+  testcase( pIn3->flags & MEM_IntReal ); 
   testcase( pIn3->flags & MEM_Real );
   testcase( (pIn3->flags & (MEM_Str|MEM_Int))==MEM_Str );
-  if( (pIn3->flags & (MEM_Int|MEM_IntReal))==0 ){
+  if( (pIn3->flags & (MEM_Int|MEM_IntReal))==0 ){ 
     /* If pIn3->u.i does not contain an integer, compute iKey as the
     ** integer value of pIn3.  Jump to P2 if pIn3 cannot be converted
     ** into an integer without loss of information.  Take care to avoid
@@ -91722,14 +91722,14 @@ case OP_SeekRowid: {        /* jump, in3 */
   /* no break */ deliberate_fall_through
 case OP_NotExists:          /* jump, in3 */
   pIn3 = &aMem[pOp->p3];
-  assert( (pIn3->flags & MEM_Int)!=0 || pOp->opcode==OP_SeekRowid );
+  assert( (pIn3->flags & MEM_Int)!=0 || pOp->opcode==OP_SeekRowid ); 
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   iKey = pIn3->u.i;
 notExistsWithKey:
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
 #ifdef SQLITE_DEBUG
-  if( pOp->opcode==OP_SeekRowid ) pC->seekOp = OP_SeekRowid;
+  if( pOp->opcode==OP_SeekRowid ) pC->seekOp = OP_SeekRowid; 
 #endif
   assert( pC->isTable );
   assert( pC->eCurType==CURTYPE_BTREE );
@@ -91805,7 +91805,7 @@ case OP_NewRowid: {           /* out2 */
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
-  assert( pC->isTable );
+  assert( pC->isTable ); 
   assert( pC->eCurType==CURTYPE_BTREE );
   assert( pC->uc.pCursor!=0 );
   {
@@ -91948,7 +91948,7 @@ case OP_NewRowid: {           /* out2 */
 ** This instruction only works on tables.  The equivalent instruction
 ** for indices is OP_IdxInsert.
 */
-case OP_Insert: {
+case OP_Insert: { 
   Mem *pData;       /* MEM cell holding data for the record to be inserted */
   Mem *pKey;        /* MEM cell holding key  for the record */
   VdbeCursor *pC;   /* Cursor to table into which insert is written */
@@ -91968,13 +91968,13 @@ case OP_Insert: {
   assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable );
   assert( pOp->p4type==P4_TABLE || pOp->p4type>=P4_STATIC );
   REGISTER_TRACE(pOp->p2, pData);
-  sqlite3VdbeIncrWriteCounter(p, pC);
+  sqlite3VdbeIncrWriteCounter(p, pC); 
 
-  pKey = &aMem[pOp->p3];
-  assert( pKey->flags & MEM_Int );
-  assert( memIsValid(pKey) );
-  REGISTER_TRACE(pOp->p3, pKey);
-  x.nKey = pKey->u.i;
+  pKey = &aMem[pOp->p3]; 
+  assert( pKey->flags & MEM_Int ); 
+  assert( memIsValid(pKey) ); 
+  REGISTER_TRACE(pOp->p3, pKey); 
+  x.nKey = pKey->u.i; 
 
   if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){
     assert( pC->iDb>=0 );
@@ -92106,7 +92106,7 @@ case OP_Delete: {
   assert( pC->eCurType==CURTYPE_BTREE );
   assert( pC->uc.pCursor!=0 );
   assert( pC->deferredMoveto==0 );
-  sqlite3VdbeIncrWriteCounter(p, pC);
+  sqlite3VdbeIncrWriteCounter(p, pC); 
 
 #ifdef SQLITE_DEBUG
   if( pOp->p4type==P4_TABLE
@@ -92118,7 +92118,7 @@ case OP_Delete: {
     ** OP_Delete will have also set the pC->movetoTarget field to the rowid of
     ** the row that is being deleted */
     i64 iKey = sqlite3BtreeIntegerKey(pC->uc.pCursor);
-    assert( CORRUPT_DB || pC->movetoTarget==iKey );
+    assert( CORRUPT_DB || pC->movetoTarget==iKey ); 
   }
 #endif
 
@@ -92280,10 +92280,10 @@ case OP_SorterData: {
 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
 ** of a real table, not a pseudo-table.
 **
-** If P3!=0 then this opcode is allowed to make an ephemeral pointer
+** If P3!=0 then this opcode is allowed to make an ephemeral pointer 
 ** into the database page.  That means that the content of the output
 ** register will be invalidated as soon as the cursor moves - including
-** moves caused by other cursors that "save" the current cursors
+** moves caused by other cursors that "save" the current cursors 
 ** position in order that they can write to the same table.  If P3==0
 ** then a copy of the data is made into memory.  P3!=0 is faster, but
 ** P3==0 is safer.
@@ -92402,9 +92402,9 @@ case OP_NullRow: {
     assert( pC->uc.pCursor!=0 );
     sqlite3BtreeClearCursor(pC->uc.pCursor);
   }
-#ifdef SQLITE_DEBUG
-  if( pC->seekOp==0 ) pC->seekOp = OP_NullRow;
-#endif
+#ifdef SQLITE_DEBUG 
+  if( pC->seekOp==0 ) pC->seekOp = OP_NullRow; 
+#endif 
   break;
 }
 
@@ -92542,7 +92542,7 @@ case OP_Rewind: {        /* jump */
   int res;
 
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
-  assert( pOp->p5==0 );
+  assert( pOp->p5==0 ); 
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );
@@ -92593,7 +92593,7 @@ case OP_Rewind: {        /* jump */
 ** If P5 is positive and the jump is taken, then event counter
 ** number P5-1 in the prepared statement is incremented.
 **
-** See also: Prev
+** See also: Prev 
 */
 /* Opcode: Prev P1 P2 P3 P4 P5
 **
@@ -92646,17 +92646,17 @@ case OP_Next:          /* jump */
   assert( pOp->opcode!=OP_Next || pOp->p4.xAdvance==sqlite3BtreeNext );
   assert( pOp->opcode!=OP_Prev || pOp->p4.xAdvance==sqlite3BtreePrevious );
 
-  /* The Next opcode is only used after SeekGT, SeekGE, Rewind, and Found.
+  /* The Next opcode is only used after SeekGT, SeekGE, Rewind, and Found. 
   ** The Prev opcode is only used after SeekLT, SeekLE, and Last. */
-  assert( pOp->opcode!=OP_Next
+  assert( pOp->opcode!=OP_Next 
        || pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE
        || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found
        || pC->seekOp==OP_NullRow|| pC->seekOp==OP_SeekRowid
        || pC->seekOp==OP_IfNoHope);
-  assert( pOp->opcode!=OP_Prev
+  assert( pOp->opcode!=OP_Prev 
        || pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE
        || pC->seekOp==OP_Last   || pC->seekOp==OP_IfNoHope
-       || pC->seekOp==OP_NullRow);
+       || pC->seekOp==OP_NullRow); 
 
   rc = pOp->p4.xAdvance(pC->uc.pCursor, pOp->p3);
 next_tail:
@@ -92746,7 +92746,7 @@ case OP_SorterInsert: {     /* in2 */
 
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   pC = p->apCsr[pOp->p1];
-  sqlite3VdbeIncrWriteCounter(p, pC);
+  sqlite3VdbeIncrWriteCounter(p, pC); 
   assert( pC!=0 );
   assert( isSorter(pC) );
   pIn2 = &aMem[pOp->p2];
@@ -92786,7 +92786,7 @@ case OP_IdxDelete: {
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   assert( pC->eCurType==CURTYPE_BTREE );
-  sqlite3VdbeIncrWriteCounter(p, pC);
+  sqlite3VdbeIncrWriteCounter(p, pC); 
   pCrsr = pC->uc.pCursor;
   assert( pCrsr!=0 );
   r.pKeyInfo = pC->pKeyInfo;
@@ -92981,13 +92981,13 @@ case OP_IdxGE:  {       /* jump */
   }
   r.aMem = &aMem[pOp->p3];
 #ifdef SQLITE_DEBUG
-  {
-    int i;
-    for(i=0; i<r.nField; i++){
-      assert( memIsValid(&r.aMem[i]) );
-      REGISTER_TRACE(pOp->p3+i, &aMem[pOp->p3+i]);
-    }
-  }
+  { 
+    int i; 
+    for(i=0; i<r.nField; i++){ 
+      assert( memIsValid(&r.aMem[i]) ); 
+      REGISTER_TRACE(pOp->p3+i, &aMem[pOp->p3+i]); 
+    } 
+  } 
 #endif
 
   /* Inlined version of sqlite3VdbeIdxKeyCompare() */
@@ -93059,7 +93059,7 @@ case OP_Destroy: {     /* out2 */
   int iMoved;
   int iDb;
 
-  sqlite3VdbeIncrWriteCounter(p, 0);
+  sqlite3VdbeIncrWriteCounter(p, 0); 
   assert( p->readOnly==0 );
   assert( pOp->p1>1 );
   pOut = out2Prerelease(p, pOp);
@@ -93108,7 +93108,7 @@ case OP_Destroy: {     /* out2 */
 case OP_Clear: {
   i64 nChange;
 
-  sqlite3VdbeIncrWriteCounter(p, 0);
+  sqlite3VdbeIncrWriteCounter(p, 0); 
   nChange = 0;
   assert( p->readOnly==0 );
   assert( DbMaskTest(p->btreeMask, pOp->p2) );
@@ -93156,14 +93156,14 @@ case OP_ResetSorter: {
 ** Allocate a new b-tree in the main database file if P1==0 or in the
 ** TEMP database file if P1==1 or in an attached database if
 ** P1>1.  The P3 argument must be 1 (BTREE_INTKEY) for a rowid table
-** it must be 2 (BTREE_BLOBKEY) for an index or WITHOUT ROWID table.
+** it must be 2 (BTREE_BLOBKEY) for an index or WITHOUT ROWID table. 
 ** The root page number of the new b-tree is stored in register P2.
 */
 case OP_CreateBtree: {          /* out2 */
   Pgno pgno;
   Db *pDb;
 
-  sqlite3VdbeIncrWriteCounter(p, 0);
+  sqlite3VdbeIncrWriteCounter(p, 0); 
   pOut = out2Prerelease(p, pOp);
   pgno = 0;
   assert( pOp->p3==BTREE_INTKEY || pOp->p3==BTREE_BLOBKEY );
@@ -93183,7 +93183,7 @@ case OP_CreateBtree: {          /* out2 */
 ** Run the SQL statement or statements specified in the P4 string.
 */
 case OP_SqlExec: {
-  sqlite3VdbeIncrWriteCounter(p, 0);
+  sqlite3VdbeIncrWriteCounter(p, 0); 
   db->nSqlExec++;
   rc = sqlite3_exec(db, pOp->p4.z, 0, 0, 0);
   db->nSqlExec--;
@@ -93194,8 +93194,8 @@ case OP_SqlExec: {
 /* Opcode: ParseSchema P1 * * P4 *
 **
 ** Read and parse all entries from the schema table of database P1
-** that match the WHERE clause P4.  If P4 is a NULL pointer, then the
-** entire schema for P1 is reparsed.
+** that match the WHERE clause P4.  If P4 is a NULL pointer, then the 
+** entire schema for P1 is reparsed. 
 **
 ** This opcode invokes the parser to create a new virtual machine,
 ** then runs the new virtual machine.  It is thus a re-entrant opcode.
@@ -93221,22 +93221,22 @@ case OP_ParseSchema: {
   assert( DbHasProperty(db, iDb, DB_SchemaLoaded)
            || db->mallocFailed
            || (CORRUPT_DB && (db->flags & SQLITE_NoSchemaError)!=0) );
-
-#ifndef SQLITE_OMIT_ALTERTABLE
-  if( pOp->p4.z==0 ){
-    sqlite3SchemaClear(db->aDb[iDb].pSchema);
-    db->mDbFlags &= ~DBFLAG_SchemaKnownOk;
+ 
+#ifndef SQLITE_OMIT_ALTERTABLE 
+  if( pOp->p4.z==0 ){ 
+    sqlite3SchemaClear(db->aDb[iDb].pSchema); 
+    db->mDbFlags &= ~DBFLAG_SchemaKnownOk; 
     rc = sqlite3InitOne(db, iDb, &p->zErrMsg, pOp->p5);
-    db->mDbFlags |= DBFLAG_SchemaChange;
-    p->expired = 0;
-  }else
-#endif
-  {
+    db->mDbFlags |= DBFLAG_SchemaChange; 
+    p->expired = 0; 
+  }else 
+#endif 
+  { 
     zSchema = LEGACY_SCHEMA_TABLE;
     initData.db = db;
-    initData.iDb = iDb;
+    initData.iDb = iDb; 
     initData.pzErrMsg = &p->zErrMsg;
-    initData.mInitFlags = 0;
+    initData.mInitFlags = 0; 
     initData.mxPage = sqlite3BtreeLastPage(db->aDb[iDb].pBt);
     zSql = sqlite3MPrintf(db,
        "SELECT*FROM\"%w\".%s WHERE %s ORDER BY rowid",
@@ -93247,16 +93247,16 @@ case OP_ParseSchema: {
       assert( db->init.busy==0 );
       db->init.busy = 1;
       initData.rc = SQLITE_OK;
-      initData.nInitRow = 0;
+      initData.nInitRow = 0; 
       assert( !db->mallocFailed );
       rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
       if( rc==SQLITE_OK ) rc = initData.rc;
-      if( rc==SQLITE_OK && initData.nInitRow==0 ){
-        /* The OP_ParseSchema opcode with a non-NULL P4 argument should parse
-        ** at least one SQL statement. Any less than that indicates that
+      if( rc==SQLITE_OK && initData.nInitRow==0 ){ 
+        /* The OP_ParseSchema opcode with a non-NULL P4 argument should parse 
+        ** at least one SQL statement. Any less than that indicates that 
         ** the sqlite_schema table is corrupt. */
-        rc = SQLITE_CORRUPT_BKPT;
-      }
+        rc = SQLITE_CORRUPT_BKPT; 
+      } 
       sqlite3DbFreeNN(db, zSql);
       db->init.busy = 0;
     }
@@ -93295,7 +93295,7 @@ case OP_LoadAnalysis: {
 ** schema consistent with what is on disk.
 */
 case OP_DropTable: {
-  sqlite3VdbeIncrWriteCounter(p, 0);
+  sqlite3VdbeIncrWriteCounter(p, 0); 
   sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z);
   break;
 }
@@ -93309,7 +93309,7 @@ case OP_DropTable: {
 ** schema consistent with what is on disk.
 */
 case OP_DropIndex: {
-  sqlite3VdbeIncrWriteCounter(p, 0);
+  sqlite3VdbeIncrWriteCounter(p, 0); 
   sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z);
   break;
 }
@@ -93323,7 +93323,7 @@ case OP_DropIndex: {
 ** schema consistent with what is on disk.
 */
 case OP_DropTrigger: {
-  sqlite3VdbeIncrWriteCounter(p, 0);
+  sqlite3VdbeIncrWriteCounter(p, 0); 
   sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z);
   break;
 }
@@ -93397,11 +93397,11 @@ case OP_RowSetAdd: {       /* in1, in2 */
   pIn1 = &aMem[pOp->p1];
   pIn2 = &aMem[pOp->p2];
   assert( (pIn2->flags & MEM_Int)!=0 );
-  if( (pIn1->flags & MEM_Blob)==0 ){
-    if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem;
+  if( (pIn1->flags & MEM_Blob)==0 ){ 
+    if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem; 
   }
-  assert( sqlite3VdbeMemIsRowSet(pIn1) );
-  sqlite3RowSetInsert((RowSet*)pIn1->z, pIn2->u.i);
+  assert( sqlite3VdbeMemIsRowSet(pIn1) ); 
+  sqlite3RowSetInsert((RowSet*)pIn1->z, pIn2->u.i); 
   break;
 }
 
@@ -93417,9 +93417,9 @@ case OP_RowSetRead: {       /* jump, in1, out3 */
   i64 val;
 
   pIn1 = &aMem[pOp->p1];
-  assert( (pIn1->flags & MEM_Blob)==0 || sqlite3VdbeMemIsRowSet(pIn1) );
+  assert( (pIn1->flags & MEM_Blob)==0 || sqlite3VdbeMemIsRowSet(pIn1) ); 
   if( (pIn1->flags & MEM_Blob)==0
-   || sqlite3RowSetNext((RowSet*)pIn1->z, &val)==0
+   || sqlite3RowSetNext((RowSet*)pIn1->z, &val)==0 
   ){
     /* The boolean index is empty */
     sqlite3VdbeMemSetNull(pIn1);
@@ -93468,19 +93468,19 @@ case OP_RowSetTest: {                     /* jump, in1, in3 */
   /* If there is anything other than a rowset object in memory cell P1,
   ** delete it now and initialize P1 with an empty rowset
   */
-  if( (pIn1->flags & MEM_Blob)==0 ){
-    if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem;
+  if( (pIn1->flags & MEM_Blob)==0 ){ 
+    if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem; 
   }
-  assert( sqlite3VdbeMemIsRowSet(pIn1) );
+  assert( sqlite3VdbeMemIsRowSet(pIn1) ); 
   assert( pOp->p4type==P4_INT32 );
   assert( iSet==-1 || iSet>=0 );
   if( iSet ){
-    exists = sqlite3RowSetTest((RowSet*)pIn1->z, iSet, pIn3->u.i);
+    exists = sqlite3RowSetTest((RowSet*)pIn1->z, iSet, pIn3->u.i); 
     VdbeBranchTaken(exists!=0,2);
     if( exists ) goto jump_to_p2;
   }
   if( iSet>=0 ){
-    sqlite3RowSetInsert((RowSet*)pIn1->z, pIn3->u.i);
+    sqlite3RowSetInsert((RowSet*)pIn1->z, pIn3->u.i); 
   }
   break;
 }
@@ -93544,7 +93544,7 @@ case OP_Program: {        /* jump */
   ** of the current program, and the memory required at runtime to execute
   ** the trigger program. If this trigger has been fired before, then pRt
   ** is already allocated. Otherwise, it must be initialized.  */
-  if( (pRt->flags&MEM_Blob)==0 ){
+  if( (pRt->flags&MEM_Blob)==0 ){ 
     /* SubProgram.nMem is set to the number of memory cells used by the
     ** program stored in SubProgram.aOp. As well as these, one memory
     ** cell is required for each cursor used by the program. Set local
@@ -93562,10 +93562,10 @@ case OP_Program: {        /* jump */
       goto no_mem;
     }
     sqlite3VdbeMemRelease(pRt);
-    pRt->flags = MEM_Blob|MEM_Dyn;
-    pRt->z = (char*)pFrame;
-    pRt->n = nByte;
-    pRt->xDel = sqlite3VdbeFrameMemDel;
+    pRt->flags = MEM_Blob|MEM_Dyn; 
+    pRt->z = (char*)pFrame; 
+    pRt->n = nByte; 
+    pRt->xDel = sqlite3VdbeFrameMemDel; 
 
     pFrame->v = p;
     pFrame->nChildMem = nMem;
@@ -93581,9 +93581,9 @@ case OP_Program: {        /* jump */
 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
     pFrame->anExec = p->anExec;
 #endif
-#ifdef SQLITE_DEBUG
-    pFrame->iFrameMagic = SQLITE_FRAME_MAGIC;
-#endif
+#ifdef SQLITE_DEBUG 
+    pFrame->iFrameMagic = SQLITE_FRAME_MAGIC; 
+#endif 
 
     pEnd = &VdbeFrameMem(pFrame)[pFrame->nChildMem];
     for(pMem=VdbeFrameMem(pFrame); pMem!=pEnd; pMem++){
@@ -93591,8 +93591,8 @@ case OP_Program: {        /* jump */
       pMem->db = db;
     }
   }else{
-    pFrame = (VdbeFrame*)pRt->z;
-    assert( pRt->xDel==sqlite3VdbeFrameMemDel );
+    pFrame = (VdbeFrame*)pRt->z; 
+    assert( pRt->xDel==sqlite3VdbeFrameMemDel ); 
     assert( pProgram->nMem+pProgram->nCsr==pFrame->nChildMem
         || (pProgram->nCsr==0 && pProgram->nMem+1==pFrame->nChildMem) );
     assert( pProgram->nCsr==pFrame->nChildCsr );
@@ -93620,19 +93620,19 @@ case OP_Program: {        /* jump */
 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
   p->anExec = 0;
 #endif
-#ifdef SQLITE_DEBUG
-  /* Verify that second and subsequent executions of the same trigger do not
-  ** try to reuse register values from the first use. */
-  {
-    int i;
-    for(i=0; i<p->nMem; i++){
-      aMem[i].pScopyFrom = 0;  /* Prevent false-positive AboutToChange() errs */
+#ifdef SQLITE_DEBUG 
+  /* Verify that second and subsequent executions of the same trigger do not 
+  ** try to reuse register values from the first use. */ 
+  { 
+    int i; 
+    for(i=0; i<p->nMem; i++){ 
+      aMem[i].pScopyFrom = 0;  /* Prevent false-positive AboutToChange() errs */ 
       MemSetTypeFlag(&aMem[i], MEM_Undefined); /* Fault if this reg is reused */
-    }
-  }
-#endif
+    } 
+  } 
+#endif 
   pOp = &aOp[-1];
-  goto check_for_interrupt;
+  goto check_for_interrupt; 
 }
 
 /* Opcode: Param P1 P2 * * *
@@ -93831,35 +93831,35 @@ case OP_DecrJumpZero: {      /* jump, in1 */
 }
 
 
-/* Opcode: AggStep * P2 P3 P4 P5
+/* Opcode: AggStep * P2 P3 P4 P5 
 ** Synopsis: accum=r[P3] step(r[P2@P5])
 **
-** Execute the xStep function for an aggregate.
+** Execute the xStep function for an aggregate. 
 ** The function has P5 arguments.  P4 is a pointer to the
-** FuncDef structure that specifies the function.  Register P3 is the
+** FuncDef structure that specifies the function.  Register P3 is the 
 ** accumulator.
 **
 ** The P5 arguments are taken from register P2 and its
 ** successors.
 */
-/* Opcode: AggInverse * P2 P3 P4 P5
-** Synopsis: accum=r[P3] inverse(r[P2@P5])
-**
-** Execute the xInverse function for an aggregate.
+/* Opcode: AggInverse * P2 P3 P4 P5 
+** Synopsis: accum=r[P3] inverse(r[P2@P5]) 
+** 
+** Execute the xInverse function for an aggregate. 
 ** The function has P5 arguments.  P4 is a pointer to the
-** FuncDef structure that specifies the function.  Register P3 is the
-** accumulator.
-**
-** The P5 arguments are taken from register P2 and its
-** successors.
-*/
-/* Opcode: AggStep1 P1 P2 P3 P4 P5
+** FuncDef structure that specifies the function.  Register P3 is the 
+** accumulator. 
+** 
+** The P5 arguments are taken from register P2 and its 
+** successors. 
+*/ 
+/* Opcode: AggStep1 P1 P2 P3 P4 P5 
 ** Synopsis: accum=r[P3] step(r[P2@P5])
 **
-** Execute the xStep (if P1==0) or xInverse (if P1!=0) function for an
+** Execute the xStep (if P1==0) or xInverse (if P1!=0) function for an 
 ** aggregate.  The function has P5 arguments.  P4 is a pointer to the
-** FuncDef structure that specifies the function.  Register P3 is the
-** accumulator.
+** FuncDef structure that specifies the function.  Register P3 is the 
+** accumulator. 
 **
 ** The P5 arguments are taken from register P2 and its
 ** successors.
@@ -93870,8 +93870,8 @@ case OP_DecrJumpZero: {      /* jump, in1 */
 ** sqlite3_context only happens once, instead of on each call to the
 ** step function.
 */
-case OP_AggInverse:
-case OP_AggStep: {
+case OP_AggInverse: 
+case OP_AggStep: { 
   int n;
   sqlite3_context *pCtx;
 
@@ -93880,29 +93880,29 @@ case OP_AggStep: {
   assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
   assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) );
   assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
-  pCtx = sqlite3DbMallocRawNN(db, n*sizeof(sqlite3_value*) +
-               (sizeof(pCtx[0]) + sizeof(Mem) - sizeof(sqlite3_value*)));
+  pCtx = sqlite3DbMallocRawNN(db, n*sizeof(sqlite3_value*) + 
+               (sizeof(pCtx[0]) + sizeof(Mem) - sizeof(sqlite3_value*))); 
   if( pCtx==0 ) goto no_mem;
   pCtx->pMem = 0;
-  pCtx->pOut = (Mem*)&(pCtx->argv[n]);
-  sqlite3VdbeMemInit(pCtx->pOut, db, MEM_Null);
+  pCtx->pOut = (Mem*)&(pCtx->argv[n]); 
+  sqlite3VdbeMemInit(pCtx->pOut, db, MEM_Null); 
   pCtx->pFunc = pOp->p4.pFunc;
   pCtx->iOp = (int)(pOp - aOp);
   pCtx->pVdbe = p;
-  pCtx->skipFlag = 0;
-  pCtx->isError = 0;
+  pCtx->skipFlag = 0; 
+  pCtx->isError = 0; 
   pCtx->argc = n;
   pOp->p4type = P4_FUNCCTX;
   pOp->p4.pCtx = pCtx;
-
-  /* OP_AggInverse must have P1==1 and OP_AggStep must have P1==0 */
-  assert( pOp->p1==(pOp->opcode==OP_AggInverse) );
-
-  pOp->opcode = OP_AggStep1;
+ 
+  /* OP_AggInverse must have P1==1 and OP_AggStep must have P1==0 */ 
+  assert( pOp->p1==(pOp->opcode==OP_AggInverse) ); 
+ 
+  pOp->opcode = OP_AggStep1; 
   /* Fall through into OP_AggStep */
   /* no break */ deliberate_fall_through
 }
-case OP_AggStep1: {
+case OP_AggStep1: { 
   int i;
   sqlite3_context *pCtx;
   Mem *pMem;
@@ -93911,17 +93911,17 @@ case OP_AggStep1: {
   pCtx = pOp->p4.pCtx;
   pMem = &aMem[pOp->p3];
 
-#ifdef SQLITE_DEBUG
-  if( pOp->p1 ){
-    /* This is an OP_AggInverse call.  Verify that xStep has always
-    ** been called at least once prior to any xInverse call. */
-    assert( pMem->uTemp==0x1122e0e3 );
-  }else{
-    /* This is an OP_AggStep call.  Mark it as such. */
-    pMem->uTemp = 0x1122e0e3;
-  }
-#endif
-
+#ifdef SQLITE_DEBUG 
+  if( pOp->p1 ){ 
+    /* This is an OP_AggInverse call.  Verify that xStep has always 
+    ** been called at least once prior to any xInverse call. */ 
+    assert( pMem->uTemp==0x1122e0e3 ); 
+  }else{ 
+    /* This is an OP_AggStep call.  Mark it as such. */ 
+    pMem->uTemp = 0x1122e0e3; 
+  } 
+#endif 
+ 
   /* If this function is inside of a trigger, the register array in aMem[]
   ** might change from one evaluation to the next.  The next block of code
   ** checks to see if the register array has changed, and if so it
@@ -93939,80 +93939,80 @@ case OP_AggStep1: {
 #endif
 
   pMem->n++;
-  assert( pCtx->pOut->flags==MEM_Null );
-  assert( pCtx->isError==0 );
-  assert( pCtx->skipFlag==0 );
-#ifndef SQLITE_OMIT_WINDOWFUNC
-  if( pOp->p1 ){
-    (pCtx->pFunc->xInverse)(pCtx,pCtx->argc,pCtx->argv);
-  }else
-#endif
+  assert( pCtx->pOut->flags==MEM_Null ); 
+  assert( pCtx->isError==0 ); 
+  assert( pCtx->skipFlag==0 ); 
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+  if( pOp->p1 ){ 
+    (pCtx->pFunc->xInverse)(pCtx,pCtx->argc,pCtx->argv); 
+  }else 
+#endif 
   (pCtx->pFunc->xSFunc)(pCtx,pCtx->argc,pCtx->argv); /* IMP: R-24505-23230 */
-
-  if( pCtx->isError ){
-    if( pCtx->isError>0 ){
-      sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut));
+ 
+  if( pCtx->isError ){ 
+    if( pCtx->isError>0 ){ 
+      sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut)); 
       rc = pCtx->isError;
     }
-    if( pCtx->skipFlag ){
-      assert( pOp[-1].opcode==OP_CollSeq );
-      i = pOp[-1].p1;
-      if( i ) sqlite3VdbeMemSetInt64(&aMem[i], 1);
-      pCtx->skipFlag = 0;
-    }
-    sqlite3VdbeMemRelease(pCtx->pOut);
-    pCtx->pOut->flags = MEM_Null;
-    pCtx->isError = 0;
+    if( pCtx->skipFlag ){ 
+      assert( pOp[-1].opcode==OP_CollSeq ); 
+      i = pOp[-1].p1; 
+      if( i ) sqlite3VdbeMemSetInt64(&aMem[i], 1); 
+      pCtx->skipFlag = 0; 
+    } 
+    sqlite3VdbeMemRelease(pCtx->pOut); 
+    pCtx->pOut->flags = MEM_Null; 
+    pCtx->isError = 0; 
     if( rc ) goto abort_due_to_error;
   }
-  assert( pCtx->pOut->flags==MEM_Null );
-  assert( pCtx->skipFlag==0 );
+  assert( pCtx->pOut->flags==MEM_Null ); 
+  assert( pCtx->skipFlag==0 ); 
   break;
 }
 
 /* Opcode: AggFinal P1 P2 * P4 *
 ** Synopsis: accum=r[P1] N=P2
 **
-** P1 is the memory location that is the accumulator for an aggregate
+** P1 is the memory location that is the accumulator for an aggregate 
 ** or window function.  Execute the finalizer function
-** for an aggregate and store the result in P1.
+** for an aggregate and store the result in P1. 
 **
 ** P2 is the number of arguments that the step function takes and
 ** P4 is a pointer to the FuncDef for this function.  The P2
 ** argument is not used by this opcode.  It is only there to disambiguate
 ** functions that can take varying numbers of arguments.  The
-** P4 argument is only needed for the case where
+** P4 argument is only needed for the case where 
 ** the step function was not previously called.
 */
-/* Opcode: AggValue * P2 P3 P4 *
-** Synopsis: r[P3]=value N=P2
-**
-** Invoke the xValue() function and store the result in register P3.
-**
-** P2 is the number of arguments that the step function takes and
-** P4 is a pointer to the FuncDef for this function.  The P2
-** argument is not used by this opcode.  It is only there to disambiguate
-** functions that can take varying numbers of arguments.  The
-** P4 argument is only needed for the case where
-** the step function was not previously called.
-*/
-case OP_AggValue:
+/* Opcode: AggValue * P2 P3 P4 * 
+** Synopsis: r[P3]=value N=P2 
+** 
+** Invoke the xValue() function and store the result in register P3. 
+** 
+** P2 is the number of arguments that the step function takes and 
+** P4 is a pointer to the FuncDef for this function.  The P2 
+** argument is not used by this opcode.  It is only there to disambiguate 
+** functions that can take varying numbers of arguments.  The 
+** P4 argument is only needed for the case where 
+** the step function was not previously called. 
+*/ 
+case OP_AggValue: 
 case OP_AggFinal: {
   Mem *pMem;
   assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
-  assert( pOp->p3==0 || pOp->opcode==OP_AggValue );
+  assert( pOp->p3==0 || pOp->opcode==OP_AggValue ); 
   pMem = &aMem[pOp->p1];
   assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
-#ifndef SQLITE_OMIT_WINDOWFUNC
-  if( pOp->p3 ){
-    memAboutToChange(p, &aMem[pOp->p3]);
-    rc = sqlite3VdbeMemAggValue(pMem, &aMem[pOp->p3], pOp->p4.pFunc);
-    pMem = &aMem[pOp->p3];
-  }else
-#endif
-  {
-    rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc);
-  }
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+  if( pOp->p3 ){ 
+    memAboutToChange(p, &aMem[pOp->p3]); 
+    rc = sqlite3VdbeMemAggValue(pMem, &aMem[pOp->p3], pOp->p4.pFunc); 
+    pMem = &aMem[pOp->p3]; 
+  }else 
+#endif 
+  { 
+    rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc); 
+  } 
 
   if( rc ){
     sqlite3VdbeError(p, "%s", sqlite3_value_text(pMem));
@@ -94171,19 +94171,19 @@ case OP_JournalMode: {    /* out2 */
 #endif /* SQLITE_OMIT_PRAGMA */
 
 #if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH)
-/* Opcode: Vacuum P1 P2 * * *
+/* Opcode: Vacuum P1 P2 * * * 
 **
 ** Vacuum the entire database P1.  P1 is 0 for "main", and 2 or more
 ** for an attached database.  The "temp" database may not be vacuumed.
-**
-** If P2 is not zero, then it is a register holding a string which is
-** the file into which the result of vacuum should be written.  When
-** P2 is zero, the vacuum overwrites the original database.
+** 
+** If P2 is not zero, then it is a register holding a string which is 
+** the file into which the result of vacuum should be written.  When 
+** P2 is zero, the vacuum overwrites the original database. 
 */
 case OP_Vacuum: {
   assert( p->readOnly==0 );
-  rc = sqlite3RunVacuum(&p->zErrMsg, db, pOp->p1,
-                        pOp->p2 ? &aMem[pOp->p2] : 0);
+  rc = sqlite3RunVacuum(&p->zErrMsg, db, pOp->p1, 
+                        pOp->p2 ? &aMem[pOp->p2] : 0); 
   if( rc ) goto abort_due_to_error;
   break;
 }
@@ -94214,7 +94214,7 @@ case OP_IncrVacuum: {        /* jump */
 }
 #endif
 
-/* Opcode: Expire P1 P2 * * *
+/* Opcode: Expire P1 P2 * * * 
 **
 ** Cause precompiled statements to expire.  When an expired statement
 ** is executed using sqlite3_step() it will either automatically
@@ -94223,19 +94223,19 @@ case OP_IncrVacuum: {        /* jump */
 **
 ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
 ** then only the currently executing statement is expired.
-**
-** If P2 is 0, then SQL statements are expired immediately.  If P2 is 1,
-** then running SQL statements are allowed to continue to run to completion.
-** The P2==1 case occurs when a CREATE INDEX or similar schema change happens
-** that might help the statement run faster but which does not affect the
-** correctness of operation.
+** 
+** If P2 is 0, then SQL statements are expired immediately.  If P2 is 1, 
+** then running SQL statements are allowed to continue to run to completion. 
+** The P2==1 case occurs when a CREATE INDEX or similar schema change happens 
+** that might help the statement run faster but which does not affect the 
+** correctness of operation. 
 */
 case OP_Expire: {
-  assert( pOp->p2==0 || pOp->p2==1 );
+  assert( pOp->p2==0 || pOp->p2==1 ); 
   if( !pOp->p1 ){
-    sqlite3ExpirePreparedStatements(db, pOp->p2);
+    sqlite3ExpirePreparedStatements(db, pOp->p2); 
   }else{
-    p->expired = pOp->p2+1;
+    p->expired = pOp->p2+1; 
   }
   break;
 }
@@ -94365,7 +94365,7 @@ case OP_VDestroy: {
   db->nVDestroy++;
   rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z);
   db->nVDestroy--;
-  assert( p->errorAction==OE_Abort && p->usesStmtJournal );
+  assert( p->errorAction==OE_Abort && p->usesStmtJournal ); 
   if( rc ) goto abort_due_to_error;
   break;
 }
@@ -94488,11 +94488,11 @@ case OP_VFilter: {   /* jump */
 **
 ** If the VColumn opcode is being used to fetch the value of
 ** an unchanging column during an UPDATE operation, then the P5
-** value is OPFLAG_NOCHNG.  This will cause the sqlite3_vtab_nochange()
-** function to return true inside the xColumn method of the virtual
-** table implementation.  The P5 column might also contain other
-** bits (OPFLAG_LENGTHARG or OPFLAG_TYPEOFARG) but those bits are
-** unused by OP_VColumn.
+** value is OPFLAG_NOCHNG.  This will cause the sqlite3_vtab_nochange() 
+** function to return true inside the xColumn method of the virtual 
+** table implementation.  The P5 column might also contain other 
+** bits (OPFLAG_LENGTHARG or OPFLAG_TYPEOFARG) but those bits are 
+** unused by OP_VColumn. 
 */
 case OP_VColumn: {
   sqlite3_vtab *pVtab;
@@ -94516,7 +94516,7 @@ case OP_VColumn: {
   memset(&sContext, 0, sizeof(sContext));
   sContext.pOut = pDest;
   assert( pOp->p5==OPFLAG_NOCHNG || pOp->p5==0 );
-  if( pOp->p5 & OPFLAG_NOCHNG ){
+  if( pOp->p5 & OPFLAG_NOCHNG ){ 
     sqlite3VdbeMemSetNull(pDest);
     pDest->flags = MEM_Null|MEM_Zero;
     pDest->u.nZero = 0;
@@ -94525,8 +94525,8 @@ case OP_VColumn: {
   }
   rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2);
   sqlite3VtabImportErrmsg(p, pVtab);
-  if( sContext.isError>0 ){
-    sqlite3VdbeError(p, "%s", sqlite3_value_text(pDest));
+  if( sContext.isError>0 ){ 
+    sqlite3VdbeError(p, "%s", sqlite3_value_text(pDest)); 
     rc = sContext.isError;
   }
   sqlite3VdbeChangeEncoding(pDest, encoding);
@@ -94593,10 +94593,10 @@ case OP_VNext: {   /* jump */
 case OP_VRename: {
   sqlite3_vtab *pVtab;
   Mem *pName;
-  int isLegacy;
+  int isLegacy; 
 
-  isLegacy = (db->flags & SQLITE_LegacyAlter);
-  db->flags |= SQLITE_LegacyAlter;
+  isLegacy = (db->flags & SQLITE_LegacyAlter); 
+  db->flags |= SQLITE_LegacyAlter; 
   pVtab = pOp->p4.pVtab->pVtab;
   pName = &aMem[pOp->p1];
   assert( pVtab->pModule->xRename );
@@ -94610,7 +94610,7 @@ case OP_VRename: {
   rc = sqlite3VdbeChangeEncoding(pName, SQLITE_UTF8);
   if( rc ) goto abort_due_to_error;
   rc = pVtab->pModule->xRename(pVtab, pName->z);
-  if( isLegacy==0 ) db->flags &= ~(u64)SQLITE_LegacyAlter;
+  if( isLegacy==0 ) db->flags &= ~(u64)SQLITE_LegacyAlter; 
   sqlite3VtabImportErrmsg(p, pVtab);
   p->expired = 0;
   if( rc ) goto abort_due_to_error;
@@ -94659,8 +94659,8 @@ case OP_VUpdate: {
        || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace
   );
   assert( p->readOnly==0 );
-  if( db->mallocFailed ) goto no_mem;
-  sqlite3VdbeIncrWriteCounter(p, 0);
+  if( db->mallocFailed ) goto no_mem; 
+  sqlite3VdbeIncrWriteCounter(p, 0); 
   pVtab = pOp->p4.pVtab->pVtab;
   if( pVtab==0 || NEVER(pVtab->pModule==0) ){
     rc = SQLITE_LOCKED;
@@ -94786,8 +94786,8 @@ case OP_MaxPgcnt: {            /* out2 */
 **
 ** See also: AggStep, AggFinal, Function
 */
-case OP_PureFunc:              /* group */
-case OP_Function: {            /* group */
+case OP_PureFunc:              /* group */ 
+case OP_Function: {            /* group */ 
   int i;
   sqlite3_context *pCtx;
 
@@ -94814,17 +94814,17 @@ case OP_Function: {            /* group */
   }
 #endif
   MemSetTypeFlag(pOut, MEM_Null);
-  assert( pCtx->isError==0 );
+  assert( pCtx->isError==0 ); 
   (*pCtx->pFunc->xSFunc)(pCtx, pCtx->argc, pCtx->argv);/* IMP: R-24505-23230 */
 
   /* If the function returned an error, throw an exception */
-  if( pCtx->isError ){
-    if( pCtx->isError>0 ){
+  if( pCtx->isError ){ 
+    if( pCtx->isError>0 ){ 
       sqlite3VdbeError(p, "%s", sqlite3_value_text(pOut));
       rc = pCtx->isError;
     }
     sqlite3VdbeDeleteAuxData(db, &p->pAuxData, pCtx->iOp, pOp->p1);
-    pCtx->isError = 0;
+    pCtx->isError = 0; 
     if( rc ) goto abort_due_to_error;
   }
 
@@ -94866,10 +94866,10 @@ case OP_Function: {            /* group */
 */
 case OP_Trace:
 case OP_Init: {          /* jump */
-  int i;
-#ifndef SQLITE_OMIT_TRACE
+  int i; 
+#ifndef SQLITE_OMIT_TRACE 
   char *zTrace;
-#endif
+#endif 
 
   /* If the P4 argument is not NULL, then it must be an SQL comment string.
   ** The "--" string is broken up to prevent false-positives with srcck1.c.
@@ -94959,22 +94959,22 @@ case OP_CursorHint: {
 }
 #endif /* SQLITE_ENABLE_CURSOR_HINTS */
 
-#ifdef SQLITE_DEBUG
-/* Opcode:  Abortable   * * * * *
-**
-** Verify that an Abort can happen.  Assert if an Abort at this point
-** might cause database corruption.  This opcode only appears in debugging
-** builds.
-**
-** An Abort is safe if either there have been no writes, or if there is
-** an active statement journal.
-*/
-case OP_Abortable: {
-  sqlite3VdbeAssertAbortable(p);
-  break;
-}
-#endif
-
+#ifdef SQLITE_DEBUG 
+/* Opcode:  Abortable   * * * * * 
+** 
+** Verify that an Abort can happen.  Assert if an Abort at this point 
+** might cause database corruption.  This opcode only appears in debugging 
+** builds. 
+** 
+** An Abort is safe if either there have been no writes, or if there is 
+** an active statement journal. 
+*/ 
+case OP_Abortable: { 
+  sqlite3VdbeAssertAbortable(p); 
+  break; 
+} 
+#endif 
+ 
 #ifdef SQLITE_DEBUG
 /* Opcode:  ReleaseReg   P1 P2 P3 * P5
 ** Synopsis: release r[P1@P2] mask P3
@@ -95035,9 +95035,9 @@ case OP_ReleaseReg: {
 ** This opcode records information from the optimizer.  It is the
 ** the same as a no-op.  This opcodesnever appears in a real VM program.
 */
-default: {          /* This is really OP_Noop, OP_Explain */
+default: {          /* This is really OP_Noop, OP_Explain */ 
   assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain );
-
+ 
   break;
 }
 
@@ -95051,7 +95051,7 @@ default: {          /* This is really OP_Noop, OP_Explain */
 
 #ifdef VDBE_PROFILE
     {
-      u64 endTime = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime();
+      u64 endTime = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime(); 
       if( endTime>start ) pOrigOp->cycles += endTime - start;
       pOrigOp->cnt++;
     }
@@ -95130,16 +95130,16 @@ abort_due_to_error:
   ** release the mutexes on btrees that were acquired at the
   ** top. */
 vdbe_return:
-#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
-  while( nVmStep>=nProgressLimit && db->xProgress!=0 ){
-    nProgressLimit += db->nProgressOps;
-    if( db->xProgress(db->pProgressArg) ){
+#ifndef SQLITE_OMIT_PROGRESS_CALLBACK 
+  while( nVmStep>=nProgressLimit && db->xProgress!=0 ){ 
+    nProgressLimit += db->nProgressOps; 
+    if( db->xProgress(db->pProgressArg) ){ 
       nProgressLimit = LARGEST_UINT64;
-      rc = SQLITE_INTERRUPT;
-      goto abort_due_to_error;
-    }
-  }
-#endif
+      rc = SQLITE_INTERRUPT; 
+      goto abort_due_to_error; 
+    } 
+  } 
+#endif 
   p->aCounter[SQLITE_STMTSTATUS_VM_STEP] += (int)nVmStep;
   sqlite3VdbeLeave(p);
   assert( rc!=SQLITE_OK || nExtraDelete==0
@@ -96232,7 +96232,7 @@ static int vdbePmaReadBlob(
     /* Extend the p->aAlloc[] allocation if required. */
     if( p->nAlloc<nByte ){
       u8 *aNew;
-      sqlite3_int64 nNew = MAX(128, 2*(sqlite3_int64)p->nAlloc);
+      sqlite3_int64 nNew = MAX(128, 2*(sqlite3_int64)p->nAlloc); 
       while( nByte>nNew ) nNew = nNew*2;
       aNew = sqlite3Realloc(p->aAlloc, nNew);
       if( !aNew ) return SQLITE_NOMEM_BKPT;
@@ -97528,19 +97528,19 @@ SQLITE_PRIVATE int sqlite3VdbeSorterWrite(
 
     if( nMin>pSorter->nMemory ){
       u8 *aNew;
-      sqlite3_int64 nNew = 2 * (sqlite3_int64)pSorter->nMemory;
-      int iListOff = -1;
-      if( pSorter->list.pList ){
-        iListOff = (u8*)pSorter->list.pList - pSorter->list.aMemory;
-      }
+      sqlite3_int64 nNew = 2 * (sqlite3_int64)pSorter->nMemory; 
+      int iListOff = -1; 
+      if( pSorter->list.pList ){ 
+        iListOff = (u8*)pSorter->list.pList - pSorter->list.aMemory; 
+      } 
       while( nNew < nMin ) nNew = nNew*2;
       if( nNew > pSorter->mxPmaSize ) nNew = pSorter->mxPmaSize;
       if( nNew < nMin ) nNew = nMin;
       aNew = sqlite3Realloc(pSorter->list.aMemory, nNew);
       if( !aNew ) return SQLITE_NOMEM_BKPT;
-      if( iListOff>=0 ){
-        pSorter->list.pList = (SorterRecord*)&aNew[iListOff];
-      }
+      if( iListOff>=0 ){ 
+        pSorter->list.pList = (SorterRecord*)&aNew[iListOff]; 
+      } 
       pSorter->list.aMemory = aNew;
       pSorter->nMemory = nNew;
     }
@@ -97812,12 +97812,12 @@ static int vdbeMergeEngineInit(
 ){
   int rc = SQLITE_OK;             /* Return code */
   int i;                          /* For looping over PmaReader objects */
-  int nTree;                      /* Number of subtrees to merge */
-
-  /* Failure to allocate the merge would have been detected prior to
-  ** invoking this routine */
-  assert( pMerger!=0 );
+  int nTree;                      /* Number of subtrees to merge */ 
 
+  /* Failure to allocate the merge would have been detected prior to 
+  ** invoking this routine */ 
+  assert( pMerger!=0 ); 
+ 
   /* eMode is always INCRINIT_NORMAL in single-threaded mode */
   assert( SQLITE_MAX_WORKER_THREADS>0 || eMode==INCRINIT_NORMAL );
 
@@ -97825,7 +97825,7 @@ static int vdbeMergeEngineInit(
   assert( pMerger->pTask==0 );
   pMerger->pTask = pTask;
 
-  nTree = pMerger->nTree;
+  nTree = pMerger->nTree; 
   for(i=0; i<nTree; i++){
     if( SQLITE_MAX_WORKER_THREADS>0 && eMode==INCRINIT_ROOT ){
       /* PmaReaders should be normally initialized in order, as if they are
@@ -99346,14 +99346,14 @@ SQLITE_PRIVATE int sqlite3JournalSize(sqlite3_vfs *pVfs){
 /* #include <string.h> */
 
 
-#if !defined(SQLITE_OMIT_WINDOWFUNC)
+#if !defined(SQLITE_OMIT_WINDOWFUNC) 
 /*
-** Walk all expressions linked into the list of Window objects passed
-** as the second argument.
-*/
+** Walk all expressions linked into the list of Window objects passed 
+** as the second argument. 
+*/ 
 static int walkWindowList(Walker *pWalker, Window *pList, int bOneOnly){
-  Window *pWin;
-  for(pWin=pList; pWin; pWin=pWin->pNextWin){
+  Window *pWin; 
+  for(pWin=pList; pWin; pWin=pWin->pNextWin){ 
     int rc;
     rc = sqlite3WalkExprList(pWalker, pWin->pOrderBy);
     if( rc ) return WRC_Abort;
@@ -99366,12 +99366,12 @@ static int walkWindowList(Walker *pWalker, Window *pList, int bOneOnly){
     rc = sqlite3WalkExpr(pWalker, pWin->pEnd);
     if( rc ) return WRC_Abort;
     if( bOneOnly ) break;
-  }
-  return WRC_Continue;
-}
-#endif
-
-/*
+  } 
+  return WRC_Continue; 
+} 
+#endif 
+ 
+/* 
 ** Walk an expression tree.  Invoke the callback once for each node
 ** of the expression, while descending.  (In other words, the callback
 ** is invoked before visiting children.)
@@ -99411,12 +99411,12 @@ static SQLITE_NOINLINE int walkExpr(Walker *pWalker, Expr *pExpr){
         if( pExpr->x.pList ){
           if( sqlite3WalkExprList(pWalker, pExpr->x.pList) ) return WRC_Abort;
         }
-#ifndef SQLITE_OMIT_WINDOWFUNC
+#ifndef SQLITE_OMIT_WINDOWFUNC 
         if( ExprHasProperty(pExpr, EP_WinFunc) ){
           if( walkWindowList(pWalker, pExpr->y.pWin, 1) ) return WRC_Abort;
         }
 #endif
-      }
+      } 
     }
     break;
   }
@@ -99476,10 +99476,10 @@ SQLITE_PRIVATE int sqlite3WalkSelectExpr(Walker *pWalker, Select *p){
       /* The following may return WRC_Abort if there are unresolvable
       ** symbols (e.g. a table that does not exist) in a window definition. */
       int rc = walkWindowList(pWalker, p->pWinDefn, 0);
-      return rc;
-    }
-  }
-#endif
+      return rc; 
+    } 
+  } 
+#endif 
   return WRC_Continue;
 }
 
@@ -99675,32 +99675,32 @@ static void resolveAlias(
     pDup = 0;
   }else{
     incrAggFunctionDepth(pDup, nSubquery);
-    if( pExpr->op==TK_COLLATE ){
+    if( pExpr->op==TK_COLLATE ){ 
       assert( !ExprHasProperty(pExpr, EP_IntValue) );
-      pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
-    }
+      pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken); 
+    } 
 
     /* Before calling sqlite3ExprDelete(), set the EP_Static flag. This
-    ** prevents ExprDelete() from deleting the Expr structure itself,
-    ** allowing it to be repopulated by the memcpy() on the following line.
-    ** The pExpr->u.zToken might point into memory that will be freed by the
-    ** sqlite3DbFree(db, pDup) on the last line of this block, so be sure to
-    ** make a copy of the token before doing the sqlite3DbFree().
-    */
-    ExprSetProperty(pExpr, EP_Static);
-    sqlite3ExprDelete(db, pExpr);
-    memcpy(pExpr, pDup, sizeof(*pExpr));
-    if( !ExprHasProperty(pExpr, EP_IntValue) && pExpr->u.zToken!=0 ){
-      assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 );
-      pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken);
-      pExpr->flags |= EP_MemToken;
-    }
+    ** prevents ExprDelete() from deleting the Expr structure itself, 
+    ** allowing it to be repopulated by the memcpy() on the following line. 
+    ** The pExpr->u.zToken might point into memory that will be freed by the 
+    ** sqlite3DbFree(db, pDup) on the last line of this block, so be sure to 
+    ** make a copy of the token before doing the sqlite3DbFree(). 
+    */ 
+    ExprSetProperty(pExpr, EP_Static); 
+    sqlite3ExprDelete(db, pExpr); 
+    memcpy(pExpr, pDup, sizeof(*pExpr)); 
+    if( !ExprHasProperty(pExpr, EP_IntValue) && pExpr->u.zToken!=0 ){ 
+      assert( (pExpr->flags & (EP_Reduced|EP_TokenOnly))==0 ); 
+      pExpr->u.zToken = sqlite3DbStrDup(db, pExpr->u.zToken); 
+      pExpr->flags |= EP_MemToken; 
+    } 
     if( ExprHasProperty(pExpr, EP_WinFunc) ){
       if( ALWAYS(pExpr->y.pWin!=0) ){
         pExpr->y.pWin->pOwner = pExpr;
       }
     }
-    sqlite3DbFree(db, pDup);
+    sqlite3DbFree(db, pDup); 
   }
 }
 
@@ -99755,23 +99755,23 @@ SQLITE_PRIVATE int sqlite3MatchEName(
 }
 
 /*
-** Return TRUE if the double-quoted string  mis-feature should be supported.
-*/
-static int areDoubleQuotedStringsEnabled(sqlite3 *db, NameContext *pTopNC){
-  if( db->init.busy ) return 1;  /* Always support for legacy schemas */
-  if( pTopNC->ncFlags & NC_IsDDL ){
-    /* Currently parsing a DDL statement */
-    if( sqlite3WritableSchema(db) && (db->flags & SQLITE_DqsDML)!=0 ){
-      return 1;
-    }
-    return (db->flags & SQLITE_DqsDDL)!=0;
-  }else{
-    /* Currently parsing a DML statement */
-    return (db->flags & SQLITE_DqsDML)!=0;
-  }
-}
-
-/*
+** Return TRUE if the double-quoted string  mis-feature should be supported. 
+*/ 
+static int areDoubleQuotedStringsEnabled(sqlite3 *db, NameContext *pTopNC){ 
+  if( db->init.busy ) return 1;  /* Always support for legacy schemas */ 
+  if( pTopNC->ncFlags & NC_IsDDL ){ 
+    /* Currently parsing a DDL statement */ 
+    if( sqlite3WritableSchema(db) && (db->flags & SQLITE_DqsDML)!=0 ){ 
+      return 1; 
+    } 
+    return (db->flags & SQLITE_DqsDDL)!=0; 
+  }else{ 
+    /* Currently parsing a DML statement */ 
+    return (db->flags & SQLITE_DqsDML)!=0; 
+  } 
+} 
+ 
+/* 
 ** The argument is guaranteed to be a non-NULL Expr node of type TK_COLUMN.
 ** return the appropriate colUsed mask.
 */
@@ -99807,7 +99807,7 @@ SQLITE_PRIVATE Bitmask sqlite3ExprColUsed(Expr *pExpr){
 **                         (even if X is implied).
 **    pExpr->iTable        Set to the cursor number for the table obtained
 **                         from pSrcList.
-**    pExpr->y.pTab        Points to the Table structure of X.Y (even if
+**    pExpr->y.pTab        Points to the Table structure of X.Y (even if 
 **                         X and/or Y are implied.)
 **    pExpr->iColumn       Set to the column number within the table.
 **    pExpr->op            Set to TK_COLUMN.
@@ -99841,7 +99841,7 @@ static int lookupName(
   SrcItem *pMatch = 0;              /* The matching pSrcList item */
   NameContext *pTopNC = pNC;        /* First namecontext in the list */
   Schema *pSchema = 0;              /* Schema of the expression */
-  int eNewExprOp = TK_COLUMN;       /* New value for pExpr->op on success */
+  int eNewExprOp = TK_COLUMN;       /* New value for pExpr->op on success */ 
   Table *pTab = 0;                  /* Table hold the row */
   Column *pCol;                     /* A column of pTab */
 
@@ -99919,9 +99919,9 @@ static int lookupName(
             continue;
           }
           assert( ExprUseYTab(pExpr) );
-          if( IN_RENAME_OBJECT && pItem->zAlias ){
-            sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
-          }
+          if( IN_RENAME_OBJECT && pItem->zAlias ){ 
+            sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab); 
+          } 
         }
         hCol = sqlite3StrIHash(zCol);
         for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){
@@ -99951,28 +99951,28 @@ static int lookupName(
       if( pMatch ){
         pExpr->iTable = pMatch->iCursor;
         assert( ExprUseYTab(pExpr) );
-        pExpr->y.pTab = pMatch->pTab;
+        pExpr->y.pTab = pMatch->pTab; 
         /* RIGHT JOIN not (yet) supported */
         assert( (pMatch->fg.jointype & JT_RIGHT)==0 );
         if( (pMatch->fg.jointype & JT_LEFT)!=0 ){
           ExprSetProperty(pExpr, EP_CanBeNull);
         }
-        pSchema = pExpr->y.pTab->pSchema;
+        pSchema = pExpr->y.pTab->pSchema; 
       }
     } /* if( pSrcList ) */
 
-#if !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT)
+#if !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT) 
     /* If we have not already resolved the name, then maybe
-    ** it is a new.* or old.* trigger argument reference.  Or
+    ** it is a new.* or old.* trigger argument reference.  Or 
     ** maybe it is an excluded.* from an upsert.  Or maybe it is
     ** a reference in the RETURNING clause to a table being modified.
     */
     if( cnt==0 && zDb==0 ){
-      pTab = 0;
-#ifndef SQLITE_OMIT_TRIGGER
-      if( pParse->pTriggerTab!=0 ){
-        int op = pParse->eTriggerOp;
-        assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT );
+      pTab = 0; 
+#ifndef SQLITE_OMIT_TRIGGER 
+      if( pParse->pTriggerTab!=0 ){ 
+        int op = pParse->eTriggerOp; 
+        assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT ); 
         if( pParse->bReturning ){
           if( (pNC->ncFlags & NC_UBaseReg)!=0
            && (zTab==0 || sqlite3StrICmp(zTab,pParse->pTriggerTab->zName)==0)
@@ -99981,23 +99981,23 @@ static int lookupName(
             pTab = pParse->pTriggerTab;
           }
         }else if( op!=TK_DELETE && zTab && sqlite3StrICmp("new",zTab) == 0 ){
-          pExpr->iTable = 1;
-          pTab = pParse->pTriggerTab;
+          pExpr->iTable = 1; 
+          pTab = pParse->pTriggerTab; 
         }else if( op!=TK_INSERT && zTab && sqlite3StrICmp("old",zTab)==0 ){
-          pExpr->iTable = 0;
-          pTab = pParse->pTriggerTab;
-        }
+          pExpr->iTable = 0; 
+          pTab = pParse->pTriggerTab; 
+        } 
       }
-#endif /* SQLITE_OMIT_TRIGGER */
-#ifndef SQLITE_OMIT_UPSERT
+#endif /* SQLITE_OMIT_TRIGGER */ 
+#ifndef SQLITE_OMIT_UPSERT 
       if( (pNC->ncFlags & NC_UUpsert)!=0 && zTab!=0 ){
-        Upsert *pUpsert = pNC->uNC.pUpsert;
-        if( pUpsert && sqlite3StrICmp("excluded",zTab)==0 ){
-          pTab = pUpsert->pUpsertSrc->a[0].pTab;
+        Upsert *pUpsert = pNC->uNC.pUpsert; 
+        if( pUpsert && sqlite3StrICmp("excluded",zTab)==0 ){ 
+          pTab = pUpsert->pUpsertSrc->a[0].pTab; 
           pExpr->iTable = EXCLUDED_TABLE_NUMBER;
-        }
-      }
-#endif /* SQLITE_OMIT_UPSERT */
+        } 
+      } 
+#endif /* SQLITE_OMIT_UPSERT */ 
 
       if( pTab ){
         int iCol;
@@ -100021,22 +100021,22 @@ static int lookupName(
         if( iCol<pTab->nCol ){
           cnt++;
           pMatch = 0;
-#ifndef SQLITE_OMIT_UPSERT
+#ifndef SQLITE_OMIT_UPSERT 
           if( pExpr->iTable==EXCLUDED_TABLE_NUMBER ){
-            testcase( iCol==(-1) );
+            testcase( iCol==(-1) ); 
             assert( ExprUseYTab(pExpr) );
-            if( IN_RENAME_OBJECT ){
-              pExpr->iColumn = iCol;
-              pExpr->y.pTab = pTab;
-              eNewExprOp = TK_COLUMN;
-            }else{
+            if( IN_RENAME_OBJECT ){ 
+              pExpr->iColumn = iCol; 
+              pExpr->y.pTab = pTab; 
+              eNewExprOp = TK_COLUMN; 
+            }else{ 
               pExpr->iTable = pNC->uNC.pUpsert->regData +
                  sqlite3TableColumnToStorage(pTab, iCol);
-              eNewExprOp = TK_REGISTER;
-            }
-          }else
-#endif /* SQLITE_OMIT_UPSERT */
-          {
+              eNewExprOp = TK_REGISTER; 
+            } 
+          }else 
+#endif /* SQLITE_OMIT_UPSERT */ 
+          { 
             assert( ExprUseYTab(pExpr) );
             pExpr->y.pTab = pTab;
             if( pParse->bReturning ){
@@ -100046,7 +100046,7 @@ static int lookupName(
             }else{
               pExpr->iColumn = (i16)iCol;
               eNewExprOp = TK_TRIGGER;
-#ifndef SQLITE_OMIT_TRIGGER
+#ifndef SQLITE_OMIT_TRIGGER 
               if( iCol<0 ){
                 pExpr->affExpr = SQLITE_AFF_INTEGER;
               }else if( pExpr->iTable==0 ){
@@ -100059,12 +100059,12 @@ static int lookupName(
                 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
               }
 #endif /* SQLITE_OMIT_TRIGGER */
-            }
+            } 
           }
         }
       }
     }
-#endif /* !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT) */
+#endif /* !defined(SQLITE_OMIT_TRIGGER) || !defined(SQLITE_OMIT_UPSERT) */ 
 
     /*
     ** Perhaps the name is a reference to the ROWID
@@ -100103,8 +100103,8 @@ static int lookupName(
      && (pNC->ncFlags & NC_UEList)!=0
      && zTab==0
     ){
-      pEList = pNC->uNC.pEList;
-      assert( pEList!=0 );
+      pEList = pNC->uNC.pEList; 
+      assert( pEList!=0 ); 
       for(j=0; j<pEList->nExpr; j++){
         char *zAs = pEList->a[j].zEName;
         if( pEList->a[j].eEName==ENAME_NAME
@@ -100122,9 +100122,9 @@ static int lookupName(
           if( ExprHasProperty(pOrig, EP_Win)
            && ((pNC->ncFlags&NC_AllowWin)==0 || pNC!=pTopNC )
           ){
-            sqlite3ErrorMsg(pParse, "misuse of aliased window function %s",zAs);
-            return WRC_Abort;
-          }
+            sqlite3ErrorMsg(pParse, "misuse of aliased window function %s",zAs); 
+            return WRC_Abort; 
+          } 
           if( sqlite3ExprVectorSize(pOrig)!=1 ){
             sqlite3ErrorMsg(pParse, "row value misused");
             return WRC_Abort;
@@ -100133,9 +100133,9 @@ static int lookupName(
           cnt = 1;
           pMatch = 0;
           assert( zTab==0 && zDb==0 );
-          if( IN_RENAME_OBJECT ){
-            sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr);
-          }
+          if( IN_RENAME_OBJECT ){ 
+            sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr); 
+          } 
           goto lookupname_end;
         }
       }
@@ -100160,37 +100160,37 @@ static int lookupName(
   ** Because no reference was made to outer contexts, the pNC->nRef
   ** fields are not changed in any context.
   */
-  if( cnt==0 && zTab==0 ){
-    assert( pExpr->op==TK_ID );
-    if( ExprHasProperty(pExpr,EP_DblQuoted)
-     && areDoubleQuotedStringsEnabled(db, pTopNC)
-    ){
-      /* If a double-quoted identifier does not match any known column name,
-      ** then treat it as a string.
-      **
-      ** This hack was added in the early days of SQLite in a misguided attempt
-      ** to be compatible with MySQL 3.x, which used double-quotes for strings.
-      ** I now sorely regret putting in this hack. The effect of this hack is
-      ** that misspelled identifier names are silently converted into strings
-      ** rather than causing an error, to the frustration of countless
-      ** programmers. To all those frustrated programmers, my apologies.
-      **
-      ** Someday, I hope to get rid of this hack. Unfortunately there is
-      ** a huge amount of legacy SQL that uses it. So for now, we just
-      ** issue a warning.
-      */
-      sqlite3_log(SQLITE_WARNING,
-        "double-quoted string literal: \"%w\"", zCol);
-#ifdef SQLITE_ENABLE_NORMALIZE
-      sqlite3VdbeAddDblquoteStr(db, pParse->pVdbe, zCol);
-#endif
-      pExpr->op = TK_STRING;
+  if( cnt==0 && zTab==0 ){ 
+    assert( pExpr->op==TK_ID ); 
+    if( ExprHasProperty(pExpr,EP_DblQuoted) 
+     && areDoubleQuotedStringsEnabled(db, pTopNC) 
+    ){ 
+      /* If a double-quoted identifier does not match any known column name, 
+      ** then treat it as a string. 
+      ** 
+      ** This hack was added in the early days of SQLite in a misguided attempt 
+      ** to be compatible with MySQL 3.x, which used double-quotes for strings. 
+      ** I now sorely regret putting in this hack. The effect of this hack is 
+      ** that misspelled identifier names are silently converted into strings 
+      ** rather than causing an error, to the frustration of countless 
+      ** programmers. To all those frustrated programmers, my apologies. 
+      ** 
+      ** Someday, I hope to get rid of this hack. Unfortunately there is 
+      ** a huge amount of legacy SQL that uses it. So for now, we just 
+      ** issue a warning. 
+      */ 
+      sqlite3_log(SQLITE_WARNING, 
+        "double-quoted string literal: \"%w\"", zCol); 
+#ifdef SQLITE_ENABLE_NORMALIZE 
+      sqlite3VdbeAddDblquoteStr(db, pParse->pVdbe, zCol); 
+#endif 
+      pExpr->op = TK_STRING; 
       memset(&pExpr->y, 0, sizeof(pExpr->y));
-      return WRC_Prune;
-    }
-    if( sqlite3ExprIdToTrueFalse(pExpr) ){
-      return WRC_Prune;
-    }
+      return WRC_Prune; 
+    } 
+    if( sqlite3ExprIdToTrueFalse(pExpr) ){ 
+      return WRC_Prune; 
+    } 
   }
 
   /*
@@ -100237,7 +100237,7 @@ static int lookupName(
     sqlite3ExprDelete(db, pExpr->pRight);
     pExpr->pRight = 0;
   }
-  pExpr->op = eNewExprOp;
+  pExpr->op = eNewExprOp; 
   ExprSetProperty(pExpr, EP_Leaf);
 lookupname_end:
   if( cnt==1 ){
@@ -100275,7 +100275,7 @@ SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(sqlite3 *db, SrcList *pSrc, int iSr
     assert( ExprUseYTab(p) );
     pTab = p->y.pTab = pItem->pTab;
     p->iTable = pItem->iCursor;
-    if( p->y.pTab->iPKey==iCol ){
+    if( p->y.pTab->iPKey==iCol ){ 
       p->iColumn = -1;
     }else{
       p->iColumn = (ynVar)iCol;
@@ -100390,7 +100390,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
       pItem = pSrcList->a;
       pExpr->op = TK_COLUMN;
       assert( ExprUseYTab(pExpr) );
-      pExpr->y.pTab = pItem->pTab;
+      pExpr->y.pTab = pItem->pTab; 
       pExpr->iTable = pItem->iCursor;
       pExpr->iColumn--;
       pExpr->affExpr = SQLITE_AFF_INTEGER;
@@ -100461,7 +100461,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
         assert( !ExprHasProperty(pExpr, EP_IntValue) );
         zColumn = pExpr->u.zToken;
       }else{
-        Expr *pLeft = pExpr->pLeft;
+        Expr *pLeft = pExpr->pLeft; 
         testcase( pNC->ncFlags & NC_IdxExpr );
         testcase( pNC->ncFlags & NC_GenCol );
         sqlite3ResolveNotValid(pParse, pNC, "the \".\" operator",
@@ -100472,18 +100472,18 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
         }else{
           assert( pRight->op==TK_DOT );
           assert( !ExprHasProperty(pRight, EP_IntValue) );
-          zDb = pLeft->u.zToken;
-          pLeft = pRight->pLeft;
-          pRight = pRight->pRight;
+          zDb = pLeft->u.zToken; 
+          pLeft = pRight->pLeft; 
+          pRight = pRight->pRight; 
         }
         assert( ExprUseUToken(pLeft) && ExprUseUToken(pRight) );
-        zTable = pLeft->u.zToken;
-        zColumn = pRight->u.zToken;
+        zTable = pLeft->u.zToken; 
+        zColumn = pRight->u.zToken; 
         assert( ExprUseYTab(pExpr) );
-        if( IN_RENAME_OBJECT ){
-          sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight);
-          sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
-        }
+        if( IN_RENAME_OBJECT ){ 
+          sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight); 
+          sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft); 
+        } 
       }
       return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
     }
@@ -100500,7 +100500,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
       const char *zId;            /* The function name. */
       FuncDef *pDef;              /* Information about the function */
       u8 enc = ENC(pParse->db);   /* The database encoding */
-      int savedAllowFlags = (pNC->ncFlags & (NC_AllowAgg | NC_AllowWin));
+      int savedAllowFlags = (pNC->ncFlags & (NC_AllowAgg | NC_AllowWin)); 
 #ifndef SQLITE_OMIT_WINDOWFUNC
       Window *pWin = (IsWindowFunc(pExpr) ? pExpr->y.pWin : 0);
 #endif
@@ -100518,7 +100518,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
       }else{
         is_agg = pDef->xFinalize!=0;
         if( pDef->funcFlags & SQLITE_FUNC_UNLIKELY ){
-          ExprSetProperty(pExpr, EP_Unlikely);
+          ExprSetProperty(pExpr, EP_Unlikely); 
           if( n==2 ){
             pExpr->iTable = exprProbability(pList->a[1].pExpr);
             if( pExpr->iTable<0 ){
@@ -100575,69 +100575,69 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
           pExpr->op2 = pNC->ncFlags & NC_SelfRef;
           if( pNC->ncFlags & NC_FromDDL ) ExprSetProperty(pExpr, EP_FromDDL);
         }
-        if( (pDef->funcFlags & SQLITE_FUNC_INTERNAL)!=0
-         && pParse->nested==0
+        if( (pDef->funcFlags & SQLITE_FUNC_INTERNAL)!=0 
+         && pParse->nested==0 
          && (pParse->db->mDbFlags & DBFLAG_InternalFunc)==0
-        ){
-          /* Internal-use-only functions are disallowed unless the
+        ){ 
+          /* Internal-use-only functions are disallowed unless the 
           ** SQL is being compiled using sqlite3NestedParse() or
           ** the SQLITE_TESTCTRL_INTERNAL_FUNCTIONS test-control has be
           ** used to activate internal functionsn for testing purposes */
-          no_such_func = 1;
-          pDef = 0;
+          no_such_func = 1; 
+          pDef = 0; 
         }else
         if( (pDef->funcFlags & (SQLITE_FUNC_DIRECT|SQLITE_FUNC_UNSAFE))!=0
          && !IN_RENAME_OBJECT
         ){
           sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
-        }
-      }
-
-      if( 0==IN_RENAME_OBJECT ){
-#ifndef SQLITE_OMIT_WINDOWFUNC
-        assert( is_agg==0 || (pDef->funcFlags & SQLITE_FUNC_MINMAX)
-          || (pDef->xValue==0 && pDef->xInverse==0)
-          || (pDef->xValue && pDef->xInverse && pDef->xSFunc && pDef->xFinalize)
-        );
+        } 
+      }
+ 
+      if( 0==IN_RENAME_OBJECT ){ 
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+        assert( is_agg==0 || (pDef->funcFlags & SQLITE_FUNC_MINMAX) 
+          || (pDef->xValue==0 && pDef->xInverse==0) 
+          || (pDef->xValue && pDef->xInverse && pDef->xSFunc && pDef->xFinalize) 
+        ); 
         if( pDef && pDef->xValue==0 && pWin ){
           sqlite3ErrorMsg(pParse,
-              "%.*s() may not be used as a window function", nId, zId
-          );
+              "%.*s() may not be used as a window function", nId, zId 
+          ); 
           pNC->nNcErr++;
         }else if(
-              (is_agg && (pNC->ncFlags & NC_AllowAgg)==0)
+              (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) 
            || (is_agg && (pDef->funcFlags&SQLITE_FUNC_WINDOW) && !pWin)
            || (is_agg && pWin && (pNC->ncFlags & NC_AllowWin)==0)
-        ){
-          const char *zType;
+        ){ 
+          const char *zType; 
           if( (pDef->funcFlags & SQLITE_FUNC_WINDOW) || pWin ){
-            zType = "window";
-          }else{
-            zType = "aggregate";
-          }
-          sqlite3ErrorMsg(pParse, "misuse of %s function %.*s()",zType,nId,zId);
+            zType = "window"; 
+          }else{ 
+            zType = "aggregate"; 
+          } 
+          sqlite3ErrorMsg(pParse, "misuse of %s function %.*s()",zType,nId,zId); 
           pNC->nNcErr++;
-          is_agg = 0;
-        }
-#else
-        if( (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) ){
-          sqlite3ErrorMsg(pParse,"misuse of aggregate function %.*s()",nId,zId);
+          is_agg = 0; 
+        } 
+#else 
+        if( (is_agg && (pNC->ncFlags & NC_AllowAgg)==0) ){ 
+          sqlite3ErrorMsg(pParse,"misuse of aggregate function %.*s()",nId,zId); 
           pNC->nNcErr++;
-          is_agg = 0;
-        }
-#endif
-        else if( no_such_func && pParse->db->init.busy==0
+          is_agg = 0; 
+        } 
+#endif 
+        else if( no_such_func && pParse->db->init.busy==0 
 #ifdef SQLITE_ENABLE_UNKNOWN_SQL_FUNCTION
-                  && pParse->explain==0
+                  && pParse->explain==0 
 #endif
-        ){
-          sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
+        ){ 
+          sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId); 
           pNC->nNcErr++;
-        }else if( wrong_num_args ){
-          sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
-               nId, zId);
+        }else if( wrong_num_args ){ 
+          sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()", 
+               nId, zId); 
           pNC->nNcErr++;
-        }
+        } 
 #ifndef SQLITE_OMIT_WINDOWFUNC
         else if( is_agg==0 && ExprHasProperty(pExpr, EP_WinFunc) ){
           sqlite3ErrorMsg(pParse,
@@ -100647,16 +100647,16 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
           pNC->nNcErr++;
         }
 #endif
-        if( is_agg ){
-          /* Window functions may not be arguments of aggregate functions.
-          ** Or arguments of other window functions. But aggregate functions
-          ** may be arguments for window functions.  */
-#ifndef SQLITE_OMIT_WINDOWFUNC
+        if( is_agg ){ 
+          /* Window functions may not be arguments of aggregate functions. 
+          ** Or arguments of other window functions. But aggregate functions 
+          ** may be arguments for window functions.  */ 
+#ifndef SQLITE_OMIT_WINDOWFUNC 
           pNC->ncFlags &= ~(NC_AllowWin | (!pWin ? NC_AllowAgg : 0));
-#else
-          pNC->ncFlags &= ~NC_AllowAgg;
-#endif
-        }
+#else 
+          pNC->ncFlags &= ~NC_AllowAgg; 
+#endif 
+        } 
       }
 #ifndef SQLITE_OMIT_WINDOWFUNC
       else if( ExprHasProperty(pExpr, EP_WinFunc) ){
@@ -100665,25 +100665,25 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
 #endif
       sqlite3WalkExprList(pWalker, pList);
       if( is_agg ){
-#ifndef SQLITE_OMIT_WINDOWFUNC
+#ifndef SQLITE_OMIT_WINDOWFUNC 
         if( pWin ){
-          Select *pSel = pNC->pWinSelect;
+          Select *pSel = pNC->pWinSelect; 
           assert( pWin==0 || (ExprUseYWin(pExpr) && pWin==pExpr->y.pWin) );
-          if( IN_RENAME_OBJECT==0 ){
+          if( IN_RENAME_OBJECT==0 ){ 
             sqlite3WindowUpdate(pParse, pSel ? pSel->pWinDefn : 0, pWin, pDef);
             if( pParse->db->mallocFailed ) break;
-          }
+          } 
           sqlite3WalkExprList(pWalker, pWin->pPartition);
           sqlite3WalkExprList(pWalker, pWin->pOrderBy);
           sqlite3WalkExpr(pWalker, pWin->pFilter);
           sqlite3WindowLink(pSel, pWin);
-          pNC->ncFlags |= NC_HasWin;
-        }else
-#endif /* SQLITE_OMIT_WINDOWFUNC */
-        {
+          pNC->ncFlags |= NC_HasWin; 
+        }else 
+#endif /* SQLITE_OMIT_WINDOWFUNC */ 
+        { 
           NameContext *pNC2;          /* For looping up thru outer contexts */
-          pExpr->op = TK_AGG_FUNCTION;
-          pExpr->op2 = 0;
+          pExpr->op = TK_AGG_FUNCTION; 
+          pExpr->op2 = 0; 
 #ifndef SQLITE_OMIT_WINDOWFUNC
           if( ExprHasProperty(pExpr, EP_WinFunc) ){
             sqlite3WalkExpr(pWalker, pExpr->y.pWin->pFilter);
@@ -100693,21 +100693,21 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
           while( pNC2
               && sqlite3ReferencesSrcList(pParse, pExpr, pNC2->pSrcList)==0
           ){
-            pExpr->op2++;
-            pNC2 = pNC2->pNext;
-          }
+            pExpr->op2++; 
+            pNC2 = pNC2->pNext; 
+          } 
           assert( pDef!=0 || IN_RENAME_OBJECT );
           if( pNC2 && pDef ){
-            assert( SQLITE_FUNC_MINMAX==NC_MinMaxAgg );
+            assert( SQLITE_FUNC_MINMAX==NC_MinMaxAgg ); 
             assert( SQLITE_FUNC_ANYORDER==NC_OrderAgg );
-            testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 );
+            testcase( (pDef->funcFlags & SQLITE_FUNC_MINMAX)!=0 ); 
             testcase( (pDef->funcFlags & SQLITE_FUNC_ANYORDER)!=0 );
             pNC2->ncFlags |= NC_HasAgg
               | ((pDef->funcFlags^SQLITE_FUNC_ANYORDER)
                   & (SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER));
-          }
+          } 
         }
-        pNC->ncFlags |= savedAllowFlags;
+        pNC->ncFlags |= savedAllowFlags; 
       }
       /* FIX ME:  Compute pExpr->affinity based on the expected return
       ** type of the function
@@ -100748,30 +100748,30 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
                NC_IsCheck|NC_PartIdx|NC_IdxExpr|NC_GenCol, pExpr);
       break;
     }
-    case TK_IS:
-    case TK_ISNOT: {
+    case TK_IS: 
+    case TK_ISNOT: { 
       Expr *pRight = sqlite3ExprSkipCollateAndLikely(pExpr->pRight);
-      assert( !ExprHasProperty(pExpr, EP_Reduced) );
-      /* Handle special cases of "x IS TRUE", "x IS FALSE", "x IS NOT TRUE",
-      ** and "x IS NOT FALSE". */
+      assert( !ExprHasProperty(pExpr, EP_Reduced) ); 
+      /* Handle special cases of "x IS TRUE", "x IS FALSE", "x IS NOT TRUE", 
+      ** and "x IS NOT FALSE". */ 
       if( ALWAYS(pRight) && (pRight->op==TK_ID || pRight->op==TK_TRUEFALSE) ){
-        int rc = resolveExprStep(pWalker, pRight);
-        if( rc==WRC_Abort ) return WRC_Abort;
-        if( pRight->op==TK_TRUEFALSE ){
-          pExpr->op2 = pExpr->op;
-          pExpr->op = TK_TRUTH;
-          return WRC_Continue;
-        }
-      }
+        int rc = resolveExprStep(pWalker, pRight); 
+        if( rc==WRC_Abort ) return WRC_Abort; 
+        if( pRight->op==TK_TRUEFALSE ){ 
+          pExpr->op2 = pExpr->op; 
+          pExpr->op = TK_TRUTH; 
+          return WRC_Continue; 
+        } 
+      } 
       /* no break */ deliberate_fall_through
-    }
+    } 
     case TK_BETWEEN:
     case TK_EQ:
     case TK_NE:
     case TK_LT:
     case TK_LE:
     case TK_GT:
-    case TK_GE: {
+    case TK_GE: { 
       int nLeft, nRight;
       if( pParse->db->mallocFailed ) break;
       assert( pExpr->pLeft!=0 );
@@ -100878,7 +100878,7 @@ static int resolveOrderByTermToExprList(
   memset(&nc, 0, sizeof(nc));
   nc.pParse = pParse;
   nc.pSrcList = pSelect->pSrc;
-  nc.uNC.pEList = pEList;
+  nc.uNC.pEList = pEList; 
   nc.ncFlags = NC_AllowAgg|NC_UEList|NC_NoSelect;
   nc.nNcErr = 0;
   db = pParse->db;
@@ -100975,13 +100975,13 @@ static int resolveCompoundOrderBy(
       }else{
         iCol = resolveAsName(pParse, pEList, pE);
         if( iCol==0 ){
-          /* Now test if expression pE matches one of the values returned
+          /* Now test if expression pE matches one of the values returned 
           ** by pSelect. In the usual case this is done by duplicating the
-          ** expression, resolving any symbols in it, and then comparing
-          ** it against each expression returned by the SELECT statement.
-          ** Once the comparisons are finished, the duplicate expression
-          ** is deleted.
-          **
+          ** expression, resolving any symbols in it, and then comparing 
+          ** it against each expression returned by the SELECT statement. 
+          ** Once the comparisons are finished, the duplicate expression 
+          ** is deleted. 
+          ** 
           ** If this is running as part of an ALTER TABLE operation and
           ** the symbols resolve successfully, also resolve the symbols in the
           ** actual expression. This allows the code in alter.c to modify
@@ -101000,22 +101000,22 @@ static int resolveCompoundOrderBy(
       if( iCol>0 ){
         /* Convert the ORDER BY term into an integer column number iCol,
         ** taking care to preserve the COLLATE clause if it exists. */
-        if( !IN_RENAME_OBJECT ){
-          Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0);
-          if( pNew==0 ) return 1;
-          pNew->flags |= EP_IntValue;
-          pNew->u.iValue = iCol;
-          if( pItem->pExpr==pE ){
-            pItem->pExpr = pNew;
-          }else{
-            Expr *pParent = pItem->pExpr;
-            assert( pParent->op==TK_COLLATE );
-            while( pParent->pLeft->op==TK_COLLATE ) pParent = pParent->pLeft;
-            assert( pParent->pLeft==pE );
-            pParent->pLeft = pNew;
-          }
-          sqlite3ExprDelete(db, pE);
-          pItem->u.x.iOrderByCol = (u16)iCol;
+        if( !IN_RENAME_OBJECT ){ 
+          Expr *pNew = sqlite3Expr(db, TK_INTEGER, 0); 
+          if( pNew==0 ) return 1; 
+          pNew->flags |= EP_IntValue; 
+          pNew->u.iValue = iCol; 
+          if( pItem->pExpr==pE ){ 
+            pItem->pExpr = pNew; 
+          }else{ 
+            Expr *pParent = pItem->pExpr; 
+            assert( pParent->op==TK_COLLATE ); 
+            while( pParent->pLeft->op==TK_COLLATE ) pParent = pParent->pLeft; 
+            assert( pParent->pLeft==pE ); 
+            pParent->pLeft = pNew; 
+          } 
+          sqlite3ExprDelete(db, pE); 
+          pItem->u.x.iOrderByCol = (u16)iCol; 
         }
         pItem->done = 1;
       }else{
@@ -101074,23 +101074,23 @@ SQLITE_PRIVATE int sqlite3ResolveOrderGroupBy(
   return 0;
 }
 
-#ifndef SQLITE_OMIT_WINDOWFUNC
+#ifndef SQLITE_OMIT_WINDOWFUNC 
 /*
 ** Walker callback for windowRemoveExprFromSelect().
-*/
-static int resolveRemoveWindowsCb(Walker *pWalker, Expr *pExpr){
+*/ 
+static int resolveRemoveWindowsCb(Walker *pWalker, Expr *pExpr){ 
   UNUSED_PARAMETER(pWalker);
-  if( ExprHasProperty(pExpr, EP_WinFunc) ){
+  if( ExprHasProperty(pExpr, EP_WinFunc) ){ 
     Window *pWin = pExpr->y.pWin;
     sqlite3WindowUnlinkFromSelect(pWin);
-  }
-  return WRC_Continue;
-}
-
-/*
-** Remove any Window objects owned by the expression pExpr from the
-** Select.pWin list of Select object pSelect.
-*/
+  } 
+  return WRC_Continue; 
+} 
+ 
+/* 
+** Remove any Window objects owned by the expression pExpr from the 
+** Select.pWin list of Select object pSelect. 
+*/ 
 static void windowRemoveExprFromSelect(Select *pSelect, Expr *pExpr){
   if( pSelect->pWin ){
     Walker sWalker;
@@ -101099,12 +101099,12 @@ static void windowRemoveExprFromSelect(Select *pSelect, Expr *pExpr){
     sWalker.u.pSelect = pSelect;
     sqlite3WalkExpr(&sWalker, pExpr);
   }
-}
-#else
+} 
+#else 
 # define windowRemoveExprFromSelect(a, b)
 #endif /* SQLITE_OMIT_WINDOWFUNC */
-
-/*
+ 
+/* 
 ** pOrderBy is an ORDER BY or GROUP BY clause in SELECT statement pSelect.
 ** The Name context of the SELECT statement is pNC.  zType is either
 ** "ORDER" or "GROUP" depending on which type of clause pOrderBy is.
@@ -101171,9 +101171,9 @@ static int resolveOrderGroupBy(
     }
     for(j=0; j<pSelect->pEList->nExpr; j++){
       if( sqlite3ExprCompare(0, pE, pSelect->pEList->a[j].pExpr, -1)==0 ){
-        /* Since this expresion is being changed into a reference
-        ** to an identical expression in the result set, remove all Window
-        ** objects belonging to the expression from the Select.pWin list. */
+        /* Since this expresion is being changed into a reference 
+        ** to an identical expression in the result set, remove all Window 
+        ** objects belonging to the expression from the Select.pWin list. */ 
         windowRemoveExprFromSelect(pSelect, pE);
         pItem->u.x.iOrderByCol = j+1;
       }
@@ -101233,7 +101233,7 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
     */
     memset(&sNC, 0, sizeof(sNC));
     sNC.pParse = pParse;
-    sNC.pWinSelect = p;
+    sNC.pWinSelect = p; 
     if( sqlite3ResolveExprNames(&sNC, p->pLimit) ){
       return WRC_Abort;
     }
@@ -101256,7 +101256,7 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
     */
     for(i=0; i<p->pSrc->nSrc; i++){
       SrcItem *pItem = &p->pSrc->a[i];
-      if( pItem->pSelect && (pItem->pSelect->selFlags & SF_Resolved)==0 ){
+      if( pItem->pSelect && (pItem->pSelect->selFlags & SF_Resolved)==0 ){ 
         int nRef = pOuterNC ? pOuterNC->nRef : 0;
         const char *zSavedContext = pParse->zAuthContext;
 
@@ -101281,13 +101281,13 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
     /* Set up the local name-context to pass to sqlite3ResolveExprNames() to
     ** resolve the result-set expression list.
     */
-    sNC.ncFlags = NC_AllowAgg|NC_AllowWin;
+    sNC.ncFlags = NC_AllowAgg|NC_AllowWin; 
     sNC.pSrcList = p->pSrc;
     sNC.pNext = pOuterNC;
 
     /* Resolve names in the result set. */
     if( sqlite3ResolveExprListNames(&sNC, p->pEList) ) return WRC_Abort;
-    sNC.ncFlags &= ~NC_AllowWin;
+    sNC.ncFlags &= ~NC_AllowWin; 
 
     /* If there are no aggregate functions in the result-set, and no GROUP BY
     ** expression, do not allow aggregates in any of the other expressions.
@@ -101311,8 +101311,8 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
     ** re-evaluated for each reference to it.
     */
     assert( (sNC.ncFlags & (NC_UAggInfo|NC_UUpsert|NC_UBaseReg))==0 );
-    sNC.uNC.pEList = p->pEList;
-    sNC.ncFlags |= NC_UEList;
+    sNC.uNC.pEList = p->pEList; 
+    sNC.ncFlags |= NC_UEList; 
     if( p->pHaving ){
       if( !pGroupBy ){
         sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
@@ -101349,7 +101349,7 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
     ** outer queries
     */
     sNC.pNext = 0;
-    sNC.ncFlags |= NC_AllowAgg|NC_AllowWin;
+    sNC.ncFlags |= NC_AllowAgg|NC_AllowWin; 
 
     /* If this is a converted compound query, move the ORDER BY clause from
     ** the sub-query back to the parent query. At this point each term
@@ -101381,7 +101381,7 @@ static int resolveSelectStep(Walker *pWalker, Select *p){
     if( db->mallocFailed ){
       return WRC_Abort;
     }
-    sNC.ncFlags &= ~NC_AllowWin;
+    sNC.ncFlags &= ~NC_AllowWin; 
 
     /* Resolve the GROUP BY clause.  At the same time, make sure
     ** the GROUP BY clause does not contain aggregate functions.
@@ -101476,7 +101476,7 @@ SQLITE_PRIVATE int sqlite3ResolveExprNames(
   NameContext *pNC,       /* Namespace to resolve expressions in. */
   Expr *pExpr             /* The expression to be analyzed. */
 ){
-  int savedHasAgg;
+  int savedHasAgg; 
   Walker w;
 
   if( pExpr==0 ) return SQLITE_OK;
@@ -101497,11 +101497,11 @@ SQLITE_PRIVATE int sqlite3ResolveExprNames(
 #if SQLITE_MAX_EXPR_DEPTH>0
   w.pParse->nHeight -= pExpr->nHeight;
 #endif
-  assert( EP_Agg==NC_HasAgg );
-  assert( EP_Win==NC_HasWin );
-  testcase( pNC->ncFlags & NC_HasAgg );
-  testcase( pNC->ncFlags & NC_HasWin );
-  ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) );
+  assert( EP_Agg==NC_HasAgg ); 
+  assert( EP_Win==NC_HasWin ); 
+  testcase( pNC->ncFlags & NC_HasAgg ); 
+  testcase( pNC->ncFlags & NC_HasWin ); 
+  ExprSetProperty(pExpr, pNC->ncFlags & (NC_HasAgg|NC_HasWin) ); 
   pNC->ncFlags |= savedHasAgg;
   return pNC->nNcErr>0 || w.pParse->nErr>0;
 }
@@ -101584,8 +101584,8 @@ SQLITE_PRIVATE void sqlite3ResolveSelectNames(
 }
 
 /*
-** Resolve names in expressions that can only reference a single table
-** or which cannot reference any tables at all.  Examples:
+** Resolve names in expressions that can only reference a single table 
+** or which cannot reference any tables at all.  Examples: 
 **
 **                                                    "type" flag
 **                                                    ------------
@@ -101595,13 +101595,13 @@ SQLITE_PRIVATE void sqlite3ResolveSelectNames(
 **    (4)   Expression arguments to VACUUM INTO.      0
 **    (5)   GENERATED ALWAYS as expressions           NC_GenCol
 **
-** In all cases except (4), the Expr.iTable value for Expr.op==TK_COLUMN
-** nodes of the expression is set to -1 and the Expr.iColumn value is
-** set to the column number.  In case (4), TK_COLUMN nodes cause an error.
+** In all cases except (4), the Expr.iTable value for Expr.op==TK_COLUMN 
+** nodes of the expression is set to -1 and the Expr.iColumn value is 
+** set to the column number.  In case (4), TK_COLUMN nodes cause an error. 
 **
 ** Any errors cause an error message to be set in pParse.
 */
-SQLITE_PRIVATE int sqlite3ResolveSelfReference(
+SQLITE_PRIVATE int sqlite3ResolveSelfReference( 
   Parse *pParse,   /* Parsing context */
   Table *pTab,     /* The table being referenced, or NULL */
   int type,        /* NC_IsCheck, NC_PartIdx, NC_IdxExpr, NC_GenCol, or 0 */
@@ -101610,30 +101610,30 @@ SQLITE_PRIVATE int sqlite3ResolveSelfReference(
 ){
   SrcList sSrc;                   /* Fake SrcList for pParse->pNewTable */
   NameContext sNC;                /* Name context for pParse->pNewTable */
-  int rc;
+  int rc; 
 
-  assert( type==0 || pTab!=0 );
+  assert( type==0 || pTab!=0 ); 
   assert( type==NC_IsCheck || type==NC_PartIdx || type==NC_IdxExpr
           || type==NC_GenCol || pTab==0 );
   memset(&sNC, 0, sizeof(sNC));
   memset(&sSrc, 0, sizeof(sSrc));
-  if( pTab ){
-    sSrc.nSrc = 1;
-    sSrc.a[0].zName = pTab->zName;
-    sSrc.a[0].pTab = pTab;
-    sSrc.a[0].iCursor = -1;
+  if( pTab ){ 
+    sSrc.nSrc = 1; 
+    sSrc.a[0].zName = pTab->zName; 
+    sSrc.a[0].pTab = pTab; 
+    sSrc.a[0].iCursor = -1; 
     if( pTab->pSchema!=pParse->db->aDb[1].pSchema ){
       /* Cause EP_FromDDL to be set on TK_FUNCTION nodes of non-TEMP
       ** schema elements */
       type |= NC_FromDDL;
     }
-  }
+  } 
   sNC.pParse = pParse;
   sNC.pSrcList = &sSrc;
-  sNC.ncFlags = type | NC_IsDDL;
-  if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc;
-  if( pList ) rc = sqlite3ResolveExprListNames(&sNC, pList);
-  return rc;
+  sNC.ncFlags = type | NC_IsDDL; 
+  if( (rc = sqlite3ResolveExprNames(&sNC, pExpr))!=SQLITE_OK ) return rc; 
+  if( pList ) rc = sqlite3ResolveExprListNames(&sNC, pList); 
+  return rc; 
 }
 
 /************** End of resolve.c *********************************************/
@@ -101688,9 +101688,9 @@ SQLITE_PRIVATE char sqlite3ExprAffinity(const Expr *pExpr){
     assert( pExpr->op==TK_COLLATE
          || pExpr->op==TK_IF_NULL_ROW
          || (pExpr->op==TK_REGISTER && pExpr->op2==TK_IF_NULL_ROW) );
-    pExpr = pExpr->pLeft;
-    assert( pExpr!=0 );
-  }
+    pExpr = pExpr->pLeft; 
+    assert( pExpr!=0 ); 
+  } 
   op = pExpr->op;
   if( op==TK_REGISTER ) op = pExpr->op2;
   if( op==TK_COLUMN || op==TK_AGG_COLUMN ){
@@ -101779,7 +101779,7 @@ SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr *pExpr){
 ** expression.
 */
 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollateAndLikely(Expr *pExpr){
-  while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){
+  while( pExpr && ExprHasProperty(pExpr, EP_Skip|EP_Unlikely) ){ 
     if( ExprHasProperty(pExpr, EP_Unlikely) ){
       assert( ExprUseXList(pExpr) );
       assert( pExpr->x.pList->nExpr>0 );
@@ -101813,7 +101813,7 @@ SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr){
   const Expr *p = pExpr;
   while( p ){
     int op = p->op;
-    if( op==TK_REGISTER ) op = p->op2;
+    if( op==TK_REGISTER ) op = p->op2; 
     if( op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_TRIGGER ){
       assert( ExprUseYTab(p) );
       if( p->y.pTab!=0 ){
@@ -101827,20 +101827,20 @@ SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr){
         break;
       }
     }
-    if( op==TK_CAST || op==TK_UPLUS ){
-      p = p->pLeft;
-      continue;
-    }
+    if( op==TK_CAST || op==TK_UPLUS ){ 
+      p = p->pLeft; 
+      continue; 
+    } 
     if( op==TK_VECTOR ){
       assert( ExprUseXList(p) );
       p = p->x.pList->a[0].pExpr;
       continue;
     }
-    if( op==TK_COLLATE ){
+    if( op==TK_COLLATE ){ 
       assert( !ExprHasProperty(p, EP_IntValue) );
-      pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken);
-      break;
-    }
+      pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken); 
+      break; 
+    } 
     if( p->flags & EP_Collate ){
       if( p->pLeft && (p->pLeft->flags & EP_Collate)!=0 ){
         p = p->pLeft;
@@ -102193,7 +102193,7 @@ static int exprCodeSubselect(Parse *pParse, Expr *pExpr){
   int reg = 0;
 #ifndef SQLITE_OMIT_SUBQUERY
   if( pExpr->op==TK_SELECT ){
-    reg = sqlite3CodeSubselect(pParse, pExpr);
+    reg = sqlite3CodeSubselect(pParse, pExpr); 
   }
 #endif
   return reg;
@@ -102271,7 +102271,7 @@ static void codeVectorCompare(
   int regRight = 0;
   u8 opx = op;
   int addrCmp = 0;
-  int addrDone = sqlite3VdbeMakeLabel(pParse);
+  int addrDone = sqlite3VdbeMakeLabel(pParse); 
   int isCommuted = ExprHasProperty(pExpr,EP_Commuted);
 
   assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
@@ -102503,7 +102503,7 @@ SQLITE_PRIVATE Expr *sqlite3ExprAlloc(
     pNew->iAgg = -1;
     if( pToken ){
       if( nExtra==0 ){
-        pNew->flags |= EP_IntValue|EP_Leaf|(iValue?EP_IsTrue:EP_IsFalse);
+        pNew->flags |= EP_IntValue|EP_Leaf|(iValue?EP_IsTrue:EP_IsFalse); 
         pNew->u.iValue = iValue;
       }else{
         pNew->u.zToken = (char*)&pNew[1];
@@ -102511,7 +102511,7 @@ SQLITE_PRIVATE Expr *sqlite3ExprAlloc(
         if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n);
         pNew->u.zToken[pToken->n] = 0;
         if( dequote && sqlite3Isquote(pNew->u.zToken[0]) ){
-          sqlite3DequoteExpr(pNew);
+          sqlite3DequoteExpr(pNew); 
         }
       }
     }
@@ -102580,16 +102580,16 @@ SQLITE_PRIVATE Expr *sqlite3PExpr(
   Expr *pRight            /* Right operand */
 ){
   Expr *p;
-  p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr));
-  if( p ){
-    memset(p, 0, sizeof(Expr));
-    p->op = op & 0xff;
-    p->iAgg = -1;
+  p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)); 
+  if( p ){ 
+    memset(p, 0, sizeof(Expr)); 
+    p->op = op & 0xff; 
+    p->iAgg = -1; 
     sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
     sqlite3ExprCheckHeight(pParse, p->nHeight);
-  }else{
-    sqlite3ExprDelete(pParse->db, pLeft);
-    sqlite3ExprDelete(pParse->db, pRight);
+  }else{ 
+    sqlite3ExprDelete(pParse->db, pLeft); 
+    sqlite3ExprDelete(pParse->db, pRight); 
   }
   return p;
 }
@@ -102675,9 +102675,9 @@ SQLITE_PRIVATE Select *sqlite3ExprListToValues(Parse *pParse, int nElem, ExprLis
 ** of returning an AND expression, just return a constant expression with
 ** a value of false.
 */
-SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse *pParse, Expr *pLeft, Expr *pRight){
-  sqlite3 *db = pParse->db;
-  if( pLeft==0  ){
+SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse *pParse, Expr *pLeft, Expr *pRight){ 
+  sqlite3 *db = pParse->db; 
+  if( pLeft==0  ){ 
     return pRight;
   }else if( pRight==0 ){
     return pLeft;
@@ -102688,7 +102688,7 @@ SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse *pParse, Expr *pLeft, Expr *pRight){
     sqlite3ExprDeferredDelete(pParse, pRight);
     return sqlite3Expr(db, TK_INTEGER, "0");
   }else{
-    return sqlite3PExpr(pParse, TK_AND, pLeft, pRight);
+    return sqlite3PExpr(pParse, TK_AND, pLeft, pRight); 
   }
 }
 
@@ -102696,12 +102696,12 @@ SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse *pParse, Expr *pLeft, Expr *pRight){
 ** Construct a new expression node for a function with multiple
 ** arguments.
 */
-SQLITE_PRIVATE Expr *sqlite3ExprFunction(
-  Parse *pParse,        /* Parsing context */
-  ExprList *pList,      /* Argument list */
+SQLITE_PRIVATE Expr *sqlite3ExprFunction( 
+  Parse *pParse,        /* Parsing context */ 
+  ExprList *pList,      /* Argument list */ 
   const Token *pToken,  /* Name of the function */
-  int eDistinct         /* SF_Distinct or SF_ALL or 0 */
-){
+  int eDistinct         /* SF_Distinct or SF_ALL or 0 */ 
+){ 
   Expr *pNew;
   sqlite3 *db = pParse->db;
   assert( pToken );
@@ -102714,13 +102714,13 @@ SQLITE_PRIVATE Expr *sqlite3ExprFunction(
    && pList->nExpr > pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG]
    && !pParse->nested
   ){
-    sqlite3ErrorMsg(pParse, "too many arguments on function %T", pToken);
-  }
+    sqlite3ErrorMsg(pParse, "too many arguments on function %T", pToken); 
+  } 
   pNew->x.pList = pList;
   ExprSetProperty(pNew, EP_HasFunc);
   assert( ExprUseXList(pNew) );
   sqlite3ExprSetHeightAndFlags(pParse, pNew);
-  if( eDistinct==SF_Distinct ) ExprSetProperty(pNew, EP_Distinct);
+  if( eDistinct==SF_Distinct ) ExprSetProperty(pNew, EP_Distinct); 
   return pNew;
 }
 
@@ -102903,18 +102903,18 @@ SQLITE_PRIVATE void sqlite3ExprDeferredDelete(Parse *pParse, Expr *pExpr){
       sqlite3ExprListAppend(pParse, pParse->pConstExpr, pExpr);
 }
 
-/* Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the
-** expression.
-*/
-SQLITE_PRIVATE void sqlite3ExprUnmapAndDelete(Parse *pParse, Expr *p){
-  if( p ){
-    if( IN_RENAME_OBJECT ){
-      sqlite3RenameExprUnmap(pParse, p);
-    }
-    sqlite3ExprDeleteNN(pParse->db, p);
-  }
-}
-
+/* Invoke sqlite3RenameExprUnmap() and sqlite3ExprDelete() on the 
+** expression. 
+*/ 
+SQLITE_PRIVATE void sqlite3ExprUnmapAndDelete(Parse *pParse, Expr *p){ 
+  if( p ){ 
+    if( IN_RENAME_OBJECT ){ 
+      sqlite3RenameExprUnmap(pParse, p); 
+    } 
+    sqlite3ExprDeleteNN(pParse->db, p); 
+  } 
+} 
+ 
 /*
 ** Return the number of bytes allocated for the expression structure
 ** passed as the first argument. This is always one of EXPR_FULLSIZE,
@@ -102953,7 +102953,7 @@ static int exprStructSize(const Expr *p){
 ** Note that with flags==EXPRDUP_REDUCE, this routines works on full-size
 ** (unreduced) Expr objects as they or originally constructed by the parser.
 ** During expression analysis, extra information is computed and moved into
-** later parts of the Expr object and that extra information might get chopped
+** later parts of the Expr object and that extra information might get chopped 
 ** off if the expression is reduced.  Note also that it does not work to
 ** make an EXPRDUP_REDUCE copy of a reduced expression.  It is only legal
 ** to reduce a pristine expression tree from the parser.  The implementation
@@ -102966,10 +102966,10 @@ static int dupedExprStructSize(const Expr *p, int flags){
   assert( EXPR_FULLSIZE<=0xfff );
   assert( (0xfff & (EP_Reduced|EP_TokenOnly))==0 );
   if( 0==flags || p->op==TK_SELECT_COLUMN
-#ifndef SQLITE_OMIT_WINDOWFUNC
-   || ExprHasProperty(p, EP_WinFunc)
-#endif
-  ){
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+   || ExprHasProperty(p, EP_WinFunc) 
+#endif 
+  ){ 
     nSize = EXPR_FULLSIZE;
   }else{
     assert( !ExprHasProperty(p, EP_TokenOnly|EP_Reduced) );
@@ -102994,7 +102994,7 @@ static int dupedExprStructSize(const Expr *p, int flags){
 static int dupedExprNodeSize(const Expr *p, int flags){
   int nByte = dupedExprStructSize(p, flags) & 0xfff;
   if( !ExprHasProperty(p, EP_IntValue) && p->u.zToken ){
-    nByte += sqlite3Strlen30NN(p->u.zToken)+1;
+    nByte += sqlite3Strlen30NN(p->u.zToken)+1; 
   }
   return ROUND8(nByte);
 }
@@ -103102,7 +103102,7 @@ static Expr *exprDup(sqlite3 *db, const Expr *p, int dupFlags, u8 **pzBuffer){
     }
 
     /* Fill in pNew->pLeft and pNew->pRight. */
-    if( ExprHasProperty(pNew, EP_Reduced|EP_TokenOnly|EP_WinFunc) ){
+    if( ExprHasProperty(pNew, EP_Reduced|EP_TokenOnly|EP_WinFunc) ){ 
       zAlloc += dupedExprNodeSize(p, dupFlags);
       if( !ExprHasProperty(pNew, EP_TokenOnly|EP_Leaf) ){
         pNew->pLeft = p->pLeft ?
@@ -103110,12 +103110,12 @@ static Expr *exprDup(sqlite3 *db, const Expr *p, int dupFlags, u8 **pzBuffer){
         pNew->pRight = p->pRight ?
                        exprDup(db, p->pRight, EXPRDUP_REDUCE, &zAlloc) : 0;
       }
-#ifndef SQLITE_OMIT_WINDOWFUNC
-      if( ExprHasProperty(p, EP_WinFunc) ){
-        pNew->y.pWin = sqlite3WindowDup(db, pNew, p->y.pWin);
-        assert( ExprHasProperty(pNew, EP_WinFunc) );
-      }
-#endif /* SQLITE_OMIT_WINDOWFUNC */
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+      if( ExprHasProperty(p, EP_WinFunc) ){ 
+        pNew->y.pWin = sqlite3WindowDup(db, pNew, p->y.pWin); 
+        assert( ExprHasProperty(pNew, EP_WinFunc) ); 
+      } 
+#endif /* SQLITE_OMIT_WINDOWFUNC */ 
       if( pzBuffer ){
         *pzBuffer = zAlloc;
       }
@@ -103144,7 +103144,7 @@ static Expr *exprDup(sqlite3 *db, const Expr *p, int dupFlags, u8 **pzBuffer){
 SQLITE_PRIVATE With *sqlite3WithDup(sqlite3 *db, With *p){
   With *pRet = 0;
   if( p ){
-    sqlite3_int64 nByte = sizeof(*p) + sizeof(p->a[0]) * (p->nCte-1);
+    sqlite3_int64 nByte = sizeof(*p) + sizeof(p->a[0]) * (p->nCte-1); 
     pRet = sqlite3DbMallocZero(db, nByte);
     if( pRet ){
       int i;
@@ -103162,14 +103162,14 @@ SQLITE_PRIVATE With *sqlite3WithDup(sqlite3 *db, With *p){
 # define sqlite3WithDup(x,y) 0
 #endif
 
-#ifndef SQLITE_OMIT_WINDOWFUNC
+#ifndef SQLITE_OMIT_WINDOWFUNC 
 /*
-** The gatherSelectWindows() procedure and its helper routine
-** gatherSelectWindowsCallback() are used to scan all the expressions
-** an a newly duplicated SELECT statement and gather all of the Window
-** objects found there, assembling them onto the linked list at Select->pWin.
-*/
-static int gatherSelectWindowsCallback(Walker *pWalker, Expr *pExpr){
+** The gatherSelectWindows() procedure and its helper routine 
+** gatherSelectWindowsCallback() are used to scan all the expressions 
+** an a newly duplicated SELECT statement and gather all of the Window 
+** objects found there, assembling them onto the linked list at Select->pWin. 
+*/ 
+static int gatherSelectWindowsCallback(Walker *pWalker, Expr *pExpr){ 
   if( pExpr->op==TK_FUNCTION && ExprHasProperty(pExpr, EP_WinFunc) ){
     Select *pSelect = pWalker->u.pSelect;
     Window *pWin = pExpr->y.pWin;
@@ -103177,25 +103177,25 @@ static int gatherSelectWindowsCallback(Walker *pWalker, Expr *pExpr){
     assert( IsWindowFunc(pExpr) );
     assert( pWin->ppThis==0 );
     sqlite3WindowLink(pSelect, pWin);
-  }
-  return WRC_Continue;
-}
-static int gatherSelectWindowsSelectCallback(Walker *pWalker, Select *p){
-  return p==pWalker->u.pSelect ? WRC_Continue : WRC_Prune;
-}
-static void gatherSelectWindows(Select *p){
-  Walker w;
-  w.xExprCallback = gatherSelectWindowsCallback;
-  w.xSelectCallback = gatherSelectWindowsSelectCallback;
-  w.xSelectCallback2 = 0;
-  w.pParse = 0;
-  w.u.pSelect = p;
-  sqlite3WalkSelect(&w, p);
-}
-#endif
-
-
-/*
+  } 
+  return WRC_Continue; 
+} 
+static int gatherSelectWindowsSelectCallback(Walker *pWalker, Select *p){ 
+  return p==pWalker->u.pSelect ? WRC_Continue : WRC_Prune; 
+} 
+static void gatherSelectWindows(Select *p){ 
+  Walker w; 
+  w.xExprCallback = gatherSelectWindowsCallback; 
+  w.xSelectCallback = gatherSelectWindowsSelectCallback; 
+  w.xSelectCallback2 = 0; 
+  w.pParse = 0; 
+  w.u.pSelect = p; 
+  sqlite3WalkSelect(&w, p); 
+} 
+#endif 
+ 
+ 
+/* 
 ** The following group of routines make deep copies of expressions,
 ** expression lists, ID lists, and select statements.  The copies can
 ** be deleted (by being passed to their respective ...Delete() routines)
@@ -103257,7 +103257,7 @@ SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, const ExprList *p, int
     pItem->eEName = pOldItem->eEName;
     pItem->done = 0;
     pItem->bNulls = pOldItem->bNulls;
-    pItem->bSorterRef = pOldItem->bSorterRef;
+    pItem->bSorterRef = pOldItem->bSorterRef; 
     pItem->u = pOldItem->u;
   }
   return pNew;
@@ -103366,12 +103366,12 @@ SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, const Select *pDup, int fla
     pNew->addrOpenEphm[1] = -1;
     pNew->nSelectRow = p->nSelectRow;
     pNew->pWith = sqlite3WithDup(db, p->pWith);
-#ifndef SQLITE_OMIT_WINDOWFUNC
-    pNew->pWin = 0;
-    pNew->pWinDefn = sqlite3WindowListDup(db, p->pWinDefn);
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+    pNew->pWin = 0; 
+    pNew->pWinDefn = sqlite3WindowListDup(db, p->pWinDefn); 
     if( p->pWin && db->mallocFailed==0 ) gatherSelectWindows(pNew);
-#endif
-    pNew->selId = p->selId;
+#endif 
+    pNew->selId = p->selId; 
     if( db->mallocFailed ){
       /* Any prior OOM might have left the Select object incomplete.
       ** Delete the whole thing rather than allow an incomplete Select
@@ -103535,7 +103535,7 @@ SQLITE_PRIVATE ExprList *sqlite3ExprListAppendVector(
   }
 
 vector_append_error:
-  sqlite3ExprUnmapAndDelete(pParse, pExpr);
+  sqlite3ExprUnmapAndDelete(pParse, pExpr); 
   sqlite3IdListDelete(db, pColumns);
   return pList;
 }
@@ -103604,7 +103604,7 @@ SQLITE_PRIVATE void sqlite3ExprListSetName(
       if( IN_RENAME_OBJECT ){
         sqlite3RenameTokenMap(pParse, (const void*)pItem->zEName, pName);
       }
-    }
+    } 
   }
 }
 
@@ -103714,65 +103714,65 @@ SQLITE_PRIVATE u32 sqlite3IsTrueOrFalse(const char *zIn){
 
 
 /*
-** If the input expression is an ID with the name "true" or "false"
-** then convert it into an TK_TRUEFALSE term.  Return non-zero if
-** the conversion happened, and zero if the expression is unaltered.
-*/
-SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){
+** If the input expression is an ID with the name "true" or "false" 
+** then convert it into an TK_TRUEFALSE term.  Return non-zero if 
+** the conversion happened, and zero if the expression is unaltered. 
+*/ 
+SQLITE_PRIVATE int sqlite3ExprIdToTrueFalse(Expr *pExpr){ 
   u32 v;
-  assert( pExpr->op==TK_ID || pExpr->op==TK_STRING );
+  assert( pExpr->op==TK_ID || pExpr->op==TK_STRING ); 
   if( !ExprHasProperty(pExpr, EP_Quoted|EP_IntValue)
    && (v = sqlite3IsTrueOrFalse(pExpr->u.zToken))!=0
-  ){
-    pExpr->op = TK_TRUEFALSE;
+  ){ 
+    pExpr->op = TK_TRUEFALSE; 
     ExprSetProperty(pExpr, v);
-    return 1;
-  }
-  return 0;
-}
-
-/*
-** The argument must be a TK_TRUEFALSE Expr node.  Return 1 if it is TRUE
-** and 0 if it is FALSE.
-*/
-SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr *pExpr){
-  pExpr = sqlite3ExprSkipCollate((Expr*)pExpr);
-  assert( pExpr->op==TK_TRUEFALSE );
+    return 1; 
+  } 
+  return 0; 
+} 
+ 
+/* 
+** The argument must be a TK_TRUEFALSE Expr node.  Return 1 if it is TRUE 
+** and 0 if it is FALSE. 
+*/ 
+SQLITE_PRIVATE int sqlite3ExprTruthValue(const Expr *pExpr){ 
+  pExpr = sqlite3ExprSkipCollate((Expr*)pExpr); 
+  assert( pExpr->op==TK_TRUEFALSE ); 
   assert( !ExprHasProperty(pExpr, EP_IntValue) );
-  assert( sqlite3StrICmp(pExpr->u.zToken,"true")==0
-       || sqlite3StrICmp(pExpr->u.zToken,"false")==0 );
-  return pExpr->u.zToken[4]==0;
-}
-
-/*
-** If pExpr is an AND or OR expression, try to simplify it by eliminating
-** terms that are always true or false.  Return the simplified expression.
-** Or return the original expression if no simplification is possible.
-**
-** Examples:
-**
-**     (x<10) AND true                =>   (x<10)
-**     (x<10) AND false               =>   false
-**     (x<10) AND (y=22 OR false)     =>   (x<10) AND (y=22)
-**     (x<10) AND (y=22 OR true)      =>   (x<10)
-**     (y=22) OR true                 =>   true
-*/
-SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr *pExpr){
-  assert( pExpr!=0 );
-  if( pExpr->op==TK_AND || pExpr->op==TK_OR ){
-    Expr *pRight = sqlite3ExprSimplifiedAndOr(pExpr->pRight);
-    Expr *pLeft = sqlite3ExprSimplifiedAndOr(pExpr->pLeft);
-    if( ExprAlwaysTrue(pLeft) || ExprAlwaysFalse(pRight) ){
-      pExpr = pExpr->op==TK_AND ? pRight : pLeft;
-    }else if( ExprAlwaysTrue(pRight) || ExprAlwaysFalse(pLeft) ){
-      pExpr = pExpr->op==TK_AND ? pLeft : pRight;
-    }
-  }
-  return pExpr;
-}
-
-
-/*
+  assert( sqlite3StrICmp(pExpr->u.zToken,"true")==0 
+       || sqlite3StrICmp(pExpr->u.zToken,"false")==0 ); 
+  return pExpr->u.zToken[4]==0; 
+} 
+ 
+/* 
+** If pExpr is an AND or OR expression, try to simplify it by eliminating 
+** terms that are always true or false.  Return the simplified expression. 
+** Or return the original expression if no simplification is possible. 
+** 
+** Examples: 
+** 
+**     (x<10) AND true                =>   (x<10) 
+**     (x<10) AND false               =>   false 
+**     (x<10) AND (y=22 OR false)     =>   (x<10) AND (y=22) 
+**     (x<10) AND (y=22 OR true)      =>   (x<10) 
+**     (y=22) OR true                 =>   true 
+*/ 
+SQLITE_PRIVATE Expr *sqlite3ExprSimplifiedAndOr(Expr *pExpr){ 
+  assert( pExpr!=0 ); 
+  if( pExpr->op==TK_AND || pExpr->op==TK_OR ){ 
+    Expr *pRight = sqlite3ExprSimplifiedAndOr(pExpr->pRight); 
+    Expr *pLeft = sqlite3ExprSimplifiedAndOr(pExpr->pLeft); 
+    if( ExprAlwaysTrue(pLeft) || ExprAlwaysFalse(pRight) ){ 
+      pExpr = pExpr->op==TK_AND ? pRight : pLeft; 
+    }else if( ExprAlwaysTrue(pRight) || ExprAlwaysFalse(pLeft) ){ 
+      pExpr = pExpr->op==TK_AND ? pLeft : pRight; 
+    } 
+  } 
+  return pExpr; 
+} 
+ 
+ 
+/* 
 ** These routines are Walker callbacks used to check expressions to
 ** see if they are "constant" for some definition of constant.  The
 ** Walker.eCode value determines the type of "constant" we are looking
@@ -103823,11 +103823,11 @@ static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
         return WRC_Abort;
       }
     case TK_ID:
-      /* Convert "true" or "false" in a DEFAULT clause into the
-      ** appropriate TK_TRUEFALSE operator */
-      if( sqlite3ExprIdToTrueFalse(pExpr) ){
-        return WRC_Prune;
-      }
+      /* Convert "true" or "false" in a DEFAULT clause into the 
+      ** appropriate TK_TRUEFALSE operator */ 
+      if( sqlite3ExprIdToTrueFalse(pExpr) ){ 
+        return WRC_Prune; 
+      } 
       /* no break */ deliberate_fall_through
     case TK_COLUMN:
     case TK_AGG_FUNCTION:
@@ -103836,17 +103836,17 @@ static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
       testcase( pExpr->op==TK_COLUMN );
       testcase( pExpr->op==TK_AGG_FUNCTION );
       testcase( pExpr->op==TK_AGG_COLUMN );
-      if( ExprHasProperty(pExpr, EP_FixedCol) && pWalker->eCode!=2 ){
-        return WRC_Continue;
-      }
+      if( ExprHasProperty(pExpr, EP_FixedCol) && pWalker->eCode!=2 ){ 
+        return WRC_Continue; 
+      } 
       if( pWalker->eCode==3 && pExpr->iTable==pWalker->u.iCur ){
         return WRC_Continue;
       }
       /* no break */ deliberate_fall_through
     case TK_IF_NULL_ROW:
-    case TK_REGISTER:
+    case TK_REGISTER: 
     case TK_DOT:
-      testcase( pExpr->op==TK_REGISTER );
+      testcase( pExpr->op==TK_REGISTER ); 
       testcase( pExpr->op==TK_IF_NULL_ROW );
       testcase( pExpr->op==TK_DOT );
       pWalker->eCode = 0;
@@ -103865,8 +103865,8 @@ static int exprNodeIsConstant(Walker *pWalker, Expr *pExpr){
       }
       /* no break */ deliberate_fall_through
     default:
-      testcase( pExpr->op==TK_SELECT ); /* sqlite3SelectWalkFail() disallows */
-      testcase( pExpr->op==TK_EXISTS ); /* sqlite3SelectWalkFail() disallows */
+      testcase( pExpr->op==TK_SELECT ); /* sqlite3SelectWalkFail() disallows */ 
+      testcase( pExpr->op==TK_EXISTS ); /* sqlite3SelectWalkFail() disallows */ 
       return WRC_Continue;
   }
 }
@@ -103896,16 +103896,16 @@ SQLITE_PRIVATE int sqlite3ExprIsConstant(Expr *p){
 }
 
 /*
-** Walk an expression tree.  Return non-zero if
-**
-**   (1) the expression is constant, and
-**   (2) the expression does originate in the ON or USING clause
-**       of a LEFT JOIN, and
-**   (3) the expression does not contain any EP_FixedCol TK_COLUMN
-**       operands created by the constant propagation optimization.
-**
-** When this routine returns true, it indicates that the expression
-** can be added to the pParse->pConstExpr list and evaluated once when
+** Walk an expression tree.  Return non-zero if 
+** 
+**   (1) the expression is constant, and 
+**   (2) the expression does originate in the ON or USING clause 
+**       of a LEFT JOIN, and 
+**   (3) the expression does not contain any EP_FixedCol TK_COLUMN 
+**       operands created by the constant propagation optimization. 
+** 
+** When this routine returns true, it indicates that the expression 
+** can be added to the pParse->pConstExpr list and evaluated once when 
 ** the prepared statement starts up.  See sqlite3ExprCodeRunJustOnce().
 */
 SQLITE_PRIVATE int sqlite3ExprIsConstantNotJoin(Expr *p){
@@ -103936,7 +103936,7 @@ static int exprNodeIsConstantOrGroupBy(Walker *pWalker, Expr *pExpr){
     Expr *p = pGroupBy->a[i].pExpr;
     if( sqlite3ExprCompare(0, pExpr, p, -1)<2 ){
       CollSeq *pColl = sqlite3ExprNNCollSeq(pWalker->pParse, p);
-      if( sqlite3IsBinary(pColl) ){
+      if( sqlite3IsBinary(pColl) ){ 
         return WRC_Prune;
       }
     }
@@ -104033,7 +104033,7 @@ SQLITE_PRIVATE int sqlite3ExprContainsSubquery(Expr *p){
 */
 SQLITE_PRIVATE int sqlite3ExprIsInteger(const Expr *p, int *pValue){
   int rc = 0;
-  if( NEVER(p==0) ) return 0;  /* Used to only happen following on OOM */
+  if( NEVER(p==0) ) return 0;  /* Used to only happen following on OOM */ 
 
   /* If an expression is an integer literal that fits in a signed 32-bit
   ** integer, then the EP_IntValue flag will have already been set */
@@ -104080,10 +104080,10 @@ SQLITE_PRIVATE int sqlite3ExprIsInteger(const Expr *p, int *pValue){
 SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr *p){
   u8 op;
   assert( p!=0 );
-  while( p->op==TK_UPLUS || p->op==TK_UMINUS ){
-    p = p->pLeft;
+  while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ 
+    p = p->pLeft; 
     assert( p!=0 );
-  }
+  } 
   op = p->op;
   if( op==TK_REGISTER ) op = p->op2;
   switch( op ){
@@ -104095,7 +104095,7 @@ SQLITE_PRIVATE int sqlite3ExprCanBeNull(const Expr *p){
     case TK_COLUMN:
       assert( ExprUseYTab(p) );
       return ExprHasProperty(p, EP_CanBeNull) ||
-             p->y.pTab==0 ||  /* Reference to column of index on expression */
+             p->y.pTab==0 ||  /* Reference to column of index on expression */ 
              (p->iColumn>=0
               && p->y.pTab->aCol!=0 /* Possible due to prior error */
               && p->y.pTab->aCol[p->iColumn].notNull==0);
@@ -104325,8 +104325,8 @@ SQLITE_PRIVATE int sqlite3FindInIndex(
   Expr *pX,                  /* The IN expression */
   u32 inFlags,               /* IN_INDEX_LOOP, _MEMBERSHIP, and/or _NOOP_OK */
   int *prRhsHasNull,         /* Register holding NULL status.  See notes */
-  int *aiMap,                /* Mapping from Index fields to RHS fields */
-  int *piTab                 /* OUT: index to use */
+  int *aiMap,                /* Mapping from Index fields to RHS fields */ 
+  int *piTab                 /* OUT: index to use */ 
 ){
   Select *p;                            /* SELECT to the right of IN operator */
   int eType = 0;                        /* Type of RHS table. IN_INDEX_* */
@@ -104382,8 +104382,8 @@ SQLITE_PRIVATE int sqlite3FindInIndex(
 
       sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
       eType = IN_INDEX_ROWID;
-      ExplainQueryPlan((pParse, 0,
-            "USING ROWID SEARCH ON TABLE %s FOR IN-OPERATOR",pTab->zName));
+      ExplainQueryPlan((pParse, 0, 
+            "USING ROWID SEARCH ON TABLE %s FOR IN-OPERATOR",pTab->zName)); 
       sqlite3VdbeJumpHere(v, iAddr);
     }else{
       Index *pIdx;                         /* Iterator variable */
@@ -104422,7 +104422,7 @@ SQLITE_PRIVATE int sqlite3FindInIndex(
           Bitmask colUsed;      /* Columns of the index used */
           Bitmask mCol;         /* Mask for the current column */
           if( pIdx->nColumn<nExpr ) continue;
-          if( pIdx->pPartIdxWhere!=0 ) continue;
+          if( pIdx->pPartIdxWhere!=0 ) continue; 
           /* Maximum nColumn is BMS-2, not BMS-1, so that we can compute
           ** BITMASK(nExpr) without overflowing */
           testcase( pIdx->nColumn==BMS-2 );
@@ -104464,8 +104464,8 @@ SQLITE_PRIVATE int sqlite3FindInIndex(
           if( colUsed==(MASKBIT(nExpr)-1) ){
             /* If we reach this point, that means the index pIdx is usable */
             int iAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
-            ExplainQueryPlan((pParse, 0,
-                              "USING INDEX %s FOR IN-OPERATOR",pIdx->zName));
+            ExplainQueryPlan((pParse, 0, 
+                              "USING INDEX %s FOR IN-OPERATOR",pIdx->zName)); 
             sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb);
             sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
             VdbeComment((v, "%s", pIdx->zName));
@@ -104517,11 +104517,11 @@ SQLITE_PRIVATE int sqlite3FindInIndex(
     }else if( prRhsHasNull ){
       *prRhsHasNull = rMayHaveNull = ++pParse->nMem;
     }
-    assert( pX->op==TK_IN );
-    sqlite3CodeRhsOfIN(pParse, pX, iTab);
-    if( rMayHaveNull ){
-      sqlite3SetHasNullFlag(v, iTab, rMayHaveNull);
-    }
+    assert( pX->op==TK_IN ); 
+    sqlite3CodeRhsOfIN(pParse, pX, iTab); 
+    if( rMayHaveNull ){ 
+      sqlite3SetHasNullFlag(v, iTab, rMayHaveNull); 
+    } 
     pParse->nQueryLoop = savedNQueryLoop;
   }
 
@@ -104530,7 +104530,7 @@ SQLITE_PRIVATE int sqlite3FindInIndex(
     n = sqlite3ExprVectorSize(pX->pLeft);
     for(i=0; i<n; i++) aiMap[i] = i;
   }
-  *piTab = iTab;
+  *piTab = iTab; 
   return eType;
 }
 #endif
@@ -104606,240 +104606,240 @@ SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse *pParse, Expr *pExpr){
   }
 }
 
-#ifndef SQLITE_OMIT_SUBQUERY
+#ifndef SQLITE_OMIT_SUBQUERY 
 /*
-** Generate code that will construct an ephemeral table containing all terms
-** in the RHS of an IN operator.  The IN operator can be in either of two
-** forms:
+** Generate code that will construct an ephemeral table containing all terms 
+** in the RHS of an IN operator.  The IN operator can be in either of two 
+** forms: 
 **
 **     x IN (4,5,11)              -- IN operator with list on right-hand side
 **     x IN (SELECT a FROM b)     -- IN operator with subquery on the right
 **
-** The pExpr parameter is the IN operator.  The cursor number for the
-** constructed ephermeral table is returned.  The first time the ephemeral
-** table is computed, the cursor number is also stored in pExpr->iTable,
-** however the cursor number returned might not be the same, as it might
-** have been duplicated using OP_OpenDup.
-**
-** If the LHS expression ("x" in the examples) is a column value, or
-** the SELECT statement returns a column value, then the affinity of that
-** column is used to build the index keys. If both 'x' and the
-** SELECT... statement are columns, then numeric affinity is used
-** if either column has NUMERIC or INTEGER affinity. If neither
-** 'x' nor the SELECT... statement are columns, then numeric affinity
-** is used.
-*/
-SQLITE_PRIVATE void sqlite3CodeRhsOfIN(
+** The pExpr parameter is the IN operator.  The cursor number for the 
+** constructed ephermeral table is returned.  The first time the ephemeral 
+** table is computed, the cursor number is also stored in pExpr->iTable, 
+** however the cursor number returned might not be the same, as it might 
+** have been duplicated using OP_OpenDup. 
+**
+** If the LHS expression ("x" in the examples) is a column value, or 
+** the SELECT statement returns a column value, then the affinity of that 
+** column is used to build the index keys. If both 'x' and the 
+** SELECT... statement are columns, then numeric affinity is used 
+** if either column has NUMERIC or INTEGER affinity. If neither 
+** 'x' nor the SELECT... statement are columns, then numeric affinity 
+** is used. 
+*/
+SQLITE_PRIVATE void sqlite3CodeRhsOfIN( 
   Parse *pParse,          /* Parsing context */
-  Expr *pExpr,            /* The IN operator */
-  int iTab                /* Use this cursor number */
-){
-  int addrOnce = 0;           /* Address of the OP_Once instruction at top */
-  int addr;                   /* Address of OP_OpenEphemeral instruction */
-  Expr *pLeft;                /* the LHS of the IN operator */
-  KeyInfo *pKeyInfo = 0;      /* Key information */
-  int nVal;                   /* Size of vector pLeft */
-  Vdbe *v;                    /* The prepared statement under construction */
-
-  v = pParse->pVdbe;
-  assert( v!=0 );
-
-  /* The evaluation of the IN must be repeated every time it
+  Expr *pExpr,            /* The IN operator */ 
+  int iTab                /* Use this cursor number */ 
+){
+  int addrOnce = 0;           /* Address of the OP_Once instruction at top */ 
+  int addr;                   /* Address of OP_OpenEphemeral instruction */ 
+  Expr *pLeft;                /* the LHS of the IN operator */ 
+  KeyInfo *pKeyInfo = 0;      /* Key information */ 
+  int nVal;                   /* Size of vector pLeft */ 
+  Vdbe *v;                    /* The prepared statement under construction */ 
+
+  v = pParse->pVdbe; 
+  assert( v!=0 ); 
+ 
+  /* The evaluation of the IN must be repeated every time it 
   ** is encountered if any of the following is true:
   **
   **    *  The right-hand side is a correlated subquery
   **    *  The right-hand side is an expression list containing variables
   **    *  We are inside a trigger
   **
-  ** If all of the above are false, then we can compute the RHS just once
-  ** and reuse it many names.
+  ** If all of the above are false, then we can compute the RHS just once 
+  ** and reuse it many names. 
   */
-  if( !ExprHasProperty(pExpr, EP_VarSelect) && pParse->iSelfTab==0 ){
-    /* Reuse of the RHS is allowed */
-    /* If this routine has already been coded, but the previous code
+  if( !ExprHasProperty(pExpr, EP_VarSelect) && pParse->iSelfTab==0 ){ 
+    /* Reuse of the RHS is allowed */ 
+    /* If this routine has already been coded, but the previous code 
     ** might not have been invoked yet, so invoke it now as a subroutine.
-    */
-    if( ExprHasProperty(pExpr, EP_Subrtn) ){
-      addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
+    */ 
+    if( ExprHasProperty(pExpr, EP_Subrtn) ){ 
+      addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); 
       if( ExprUseXSelect(pExpr) ){
-        ExplainQueryPlan((pParse, 0, "REUSE LIST SUBQUERY %d",
-              pExpr->x.pSelect->selId));
-      }
+        ExplainQueryPlan((pParse, 0, "REUSE LIST SUBQUERY %d", 
+              pExpr->x.pSelect->selId)); 
+      } 
       assert( ExprUseYSub(pExpr) );
-      sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
-                        pExpr->y.sub.iAddr);
-      sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable);
-      sqlite3VdbeJumpHere(v, addrOnce);
-      return;
-    }
-
-    /* Begin coding the subroutine */
+      sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn, 
+                        pExpr->y.sub.iAddr); 
+      sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable); 
+      sqlite3VdbeJumpHere(v, addrOnce); 
+      return; 
+    } 
+ 
+    /* Begin coding the subroutine */ 
     assert( !ExprUseYWin(pExpr) );
-    ExprSetProperty(pExpr, EP_Subrtn);
+    ExprSetProperty(pExpr, EP_Subrtn); 
     assert( !ExprHasProperty(pExpr, EP_TokenOnly|EP_Reduced) );
-    pExpr->y.sub.regReturn = ++pParse->nMem;
-    pExpr->y.sub.iAddr =
-      sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1;
-    VdbeComment((v, "return address"));
-
-    addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
-  }
-
-  /* Check to see if this is a vector IN operator */
-  pLeft = pExpr->pLeft;
-  nVal = sqlite3ExprVectorSize(pLeft);
-
-  /* Construct the ephemeral table that will contain the content of
-  ** RHS of the IN operator.
-  */
-  pExpr->iTable = iTab;
-  addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, nVal);
-#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
+    pExpr->y.sub.regReturn = ++pParse->nMem; 
+    pExpr->y.sub.iAddr = 
+      sqlite3VdbeAddOp2(v, OP_Integer, 0, pExpr->y.sub.regReturn) + 1; 
+    VdbeComment((v, "return address")); 
+ 
+    addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); 
+  }
+
+  /* Check to see if this is a vector IN operator */ 
+  pLeft = pExpr->pLeft; 
+  nVal = sqlite3ExprVectorSize(pLeft); 
+ 
+  /* Construct the ephemeral table that will contain the content of 
+  ** RHS of the IN operator. 
+  */ 
+  pExpr->iTable = iTab; 
+  addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, nVal); 
+#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS 
   if( ExprUseXSelect(pExpr) ){
-    VdbeComment((v, "Result of SELECT %u", pExpr->x.pSelect->selId));
-  }else{
-    VdbeComment((v, "RHS of IN operator"));
+    VdbeComment((v, "Result of SELECT %u", pExpr->x.pSelect->selId)); 
+  }else{ 
+    VdbeComment((v, "RHS of IN operator")); 
   }
 #endif
-  pKeyInfo = sqlite3KeyInfoAlloc(pParse->db, nVal, 1);
+  pKeyInfo = sqlite3KeyInfoAlloc(pParse->db, nVal, 1); 
 
   if( ExprUseXSelect(pExpr) ){
-    /* Case 1:     expr IN (SELECT ...)
-    **
-    ** Generate code to write the results of the select into the temporary
-    ** table allocated and opened above.
-    */
-    Select *pSelect = pExpr->x.pSelect;
-    ExprList *pEList = pSelect->pEList;
-
-    ExplainQueryPlan((pParse, 1, "%sLIST SUBQUERY %d",
-        addrOnce?"":"CORRELATED ", pSelect->selId
-    ));
-    /* If the LHS and RHS of the IN operator do not match, that
-    ** error will have been caught long before we reach this point. */
-    if( ALWAYS(pEList->nExpr==nVal) ){
+    /* Case 1:     expr IN (SELECT ...) 
+    ** 
+    ** Generate code to write the results of the select into the temporary 
+    ** table allocated and opened above. 
+    */ 
+    Select *pSelect = pExpr->x.pSelect; 
+    ExprList *pEList = pSelect->pEList; 
+
+    ExplainQueryPlan((pParse, 1, "%sLIST SUBQUERY %d", 
+        addrOnce?"":"CORRELATED ", pSelect->selId 
+    )); 
+    /* If the LHS and RHS of the IN operator do not match, that 
+    ** error will have been caught long before we reach this point. */ 
+    if( ALWAYS(pEList->nExpr==nVal) ){ 
       Select *pCopy;
-      SelectDest dest;
-      int i;
+      SelectDest dest; 
+      int i; 
       int rc;
-      sqlite3SelectDestInit(&dest, SRT_Set, iTab);
-      dest.zAffSdst = exprINAffinity(pParse, pExpr);
-      pSelect->iLimit = 0;
-      testcase( pSelect->selFlags & SF_Distinct );
-      testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
+      sqlite3SelectDestInit(&dest, SRT_Set, iTab); 
+      dest.zAffSdst = exprINAffinity(pParse, pExpr); 
+      pSelect->iLimit = 0; 
+      testcase( pSelect->selFlags & SF_Distinct ); 
+      testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */ 
       pCopy = sqlite3SelectDup(pParse->db, pSelect, 0);
       rc = pParse->db->mallocFailed ? 1 :sqlite3Select(pParse, pCopy, &dest);
       sqlite3SelectDelete(pParse->db, pCopy);
       sqlite3DbFree(pParse->db, dest.zAffSdst);
       if( rc ){
-        sqlite3KeyInfoUnref(pKeyInfo);
-        return;
-      }
-      assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */
-      assert( pEList!=0 );
-      assert( pEList->nExpr>0 );
-      assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
-      for(i=0; i<nVal; i++){
-        Expr *p = sqlite3VectorFieldSubexpr(pLeft, i);
-        pKeyInfo->aColl[i] = sqlite3BinaryCompareCollSeq(
-            pParse, p, pEList->a[i].pExpr
-        );
-      }
-    }
-  }else if( ALWAYS(pExpr->x.pList!=0) ){
-    /* Case 2:     expr IN (exprlist)
-    **
-    ** For each expression, build an index key from the evaluation and
-    ** store it in the temporary table. If <expr> is a column, then use
-    ** that columns affinity when building index keys. If <expr> is not
-    ** a column, use numeric affinity.
-    */
-    char affinity;            /* Affinity of the LHS of the IN */
-    int i;
-    ExprList *pList = pExpr->x.pList;
-    struct ExprList_item *pItem;
+        sqlite3KeyInfoUnref(pKeyInfo); 
+        return; 
+      } 
+      assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */ 
+      assert( pEList!=0 ); 
+      assert( pEList->nExpr>0 ); 
+      assert( sqlite3KeyInfoIsWriteable(pKeyInfo) ); 
+      for(i=0; i<nVal; i++){ 
+        Expr *p = sqlite3VectorFieldSubexpr(pLeft, i); 
+        pKeyInfo->aColl[i] = sqlite3BinaryCompareCollSeq( 
+            pParse, p, pEList->a[i].pExpr 
+        ); 
+      } 
+    } 
+  }else if( ALWAYS(pExpr->x.pList!=0) ){ 
+    /* Case 2:     expr IN (exprlist) 
+    ** 
+    ** For each expression, build an index key from the evaluation and 
+    ** store it in the temporary table. If <expr> is a column, then use 
+    ** that columns affinity when building index keys. If <expr> is not 
+    ** a column, use numeric affinity. 
+    */ 
+    char affinity;            /* Affinity of the LHS of the IN */ 
+    int i; 
+    ExprList *pList = pExpr->x.pList; 
+    struct ExprList_item *pItem; 
     int r1, r2;
-    affinity = sqlite3ExprAffinity(pLeft);
+    affinity = sqlite3ExprAffinity(pLeft); 
     if( affinity<=SQLITE_AFF_NONE ){
-      affinity = SQLITE_AFF_BLOB;
+      affinity = SQLITE_AFF_BLOB; 
     }else if( affinity==SQLITE_AFF_REAL ){
       affinity = SQLITE_AFF_NUMERIC;
-    }
-    if( pKeyInfo ){
-      assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
-      pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
-    }
-
-    /* Loop through each expression in <exprlist>. */
-    r1 = sqlite3GetTempReg(pParse);
-    r2 = sqlite3GetTempReg(pParse);
-    for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){
-      Expr *pE2 = pItem->pExpr;
-
-      /* If the expression is not constant then we will need to
-      ** disable the test that was generated above that makes sure
-      ** this code only executes once.  Because for a non-constant
-      ** expression we need to rerun this code each time.
-      */
-      if( addrOnce && !sqlite3ExprIsConstant(pE2) ){
-        sqlite3VdbeChangeToNoop(v, addrOnce);
-        ExprClearProperty(pExpr, EP_Subrtn);
-        addrOnce = 0;
-      }
-
-      /* Evaluate the expression and insert it into the temp table */
+    } 
+    if( pKeyInfo ){ 
+      assert( sqlite3KeyInfoIsWriteable(pKeyInfo) ); 
+      pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft); 
+    } 
+
+    /* Loop through each expression in <exprlist>. */ 
+    r1 = sqlite3GetTempReg(pParse); 
+    r2 = sqlite3GetTempReg(pParse); 
+    for(i=pList->nExpr, pItem=pList->a; i>0; i--, pItem++){ 
+      Expr *pE2 = pItem->pExpr; 
+
+      /* If the expression is not constant then we will need to 
+      ** disable the test that was generated above that makes sure 
+      ** this code only executes once.  Because for a non-constant 
+      ** expression we need to rerun this code each time. 
+      */ 
+      if( addrOnce && !sqlite3ExprIsConstant(pE2) ){ 
+        sqlite3VdbeChangeToNoop(v, addrOnce); 
+        ExprClearProperty(pExpr, EP_Subrtn); 
+        addrOnce = 0; 
+      } 
+
+      /* Evaluate the expression and insert it into the temp table */ 
       sqlite3ExprCode(pParse, pE2, r1);
       sqlite3VdbeAddOp4(v, OP_MakeRecord, r1, 1, r2, &affinity, 1);
       sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r2, r1, 1);
-    }
-    sqlite3ReleaseTempReg(pParse, r1);
-    sqlite3ReleaseTempReg(pParse, r2);
-  }
-  if( pKeyInfo ){
-    sqlite3VdbeChangeP4(v, addr, (void *)pKeyInfo, P4_KEYINFO);
-  }
-  if( addrOnce ){
-    sqlite3VdbeJumpHere(v, addrOnce);
-    /* Subroutine return */
+    } 
+    sqlite3ReleaseTempReg(pParse, r1); 
+    sqlite3ReleaseTempReg(pParse, r2); 
+  } 
+  if( pKeyInfo ){ 
+    sqlite3VdbeChangeP4(v, addr, (void *)pKeyInfo, P4_KEYINFO); 
+  } 
+  if( addrOnce ){ 
+    sqlite3VdbeJumpHere(v, addrOnce); 
+    /* Subroutine return */ 
     assert( ExprUseYSub(pExpr) );
-    sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn);
-    sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1);
+    sqlite3VdbeAddOp1(v, OP_Return, pExpr->y.sub.regReturn); 
+    sqlite3VdbeChangeP1(v, pExpr->y.sub.iAddr-1, sqlite3VdbeCurrentAddr(v)-1); 
     sqlite3ClearTempRegCache(pParse);
-  }
-}
-#endif /* SQLITE_OMIT_SUBQUERY */
-
-/*
-** Generate code for scalar subqueries used as a subquery expression
-** or EXISTS operator:
-**
-**     (SELECT a FROM b)          -- subquery
-**     EXISTS (SELECT a FROM b)   -- EXISTS subquery
-**
-** The pExpr parameter is the SELECT or EXISTS operator to be coded.
-**
+  } 
+} 
+#endif /* SQLITE_OMIT_SUBQUERY */ 
+
+/* 
+** Generate code for scalar subqueries used as a subquery expression 
+** or EXISTS operator: 
+** 
+**     (SELECT a FROM b)          -- subquery 
+**     EXISTS (SELECT a FROM b)   -- EXISTS subquery 
+** 
+** The pExpr parameter is the SELECT or EXISTS operator to be coded. 
+** 
 ** Return the register that holds the result.  For a multi-column SELECT,
-** the result is stored in a contiguous array of registers and the
-** return value is the register of the left-most result column.
-** Return 0 if an error occurs.
-*/
-#ifndef SQLITE_OMIT_SUBQUERY
-SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
-  int addrOnce = 0;           /* Address of OP_Once at top of subroutine */
-  int rReg = 0;               /* Register storing resulting */
-  Select *pSel;               /* SELECT statement to encode */
-  SelectDest dest;            /* How to deal with SELECT result */
-  int nReg;                   /* Registers to allocate */
-  Expr *pLimit;               /* New limit expression */
-
-  Vdbe *v = pParse->pVdbe;
-  assert( v!=0 );
+** the result is stored in a contiguous array of registers and the 
+** return value is the register of the left-most result column. 
+** Return 0 if an error occurs. 
+*/ 
+#ifndef SQLITE_OMIT_SUBQUERY 
+SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){ 
+  int addrOnce = 0;           /* Address of OP_Once at top of subroutine */ 
+  int rReg = 0;               /* Register storing resulting */ 
+  Select *pSel;               /* SELECT statement to encode */ 
+  SelectDest dest;            /* How to deal with SELECT result */ 
+  int nReg;                   /* Registers to allocate */ 
+  Expr *pLimit;               /* New limit expression */ 
+
+  Vdbe *v = pParse->pVdbe; 
+  assert( v!=0 ); 
   if( pParse->nErr ) return 0;
-  testcase( pExpr->op==TK_EXISTS );
-  testcase( pExpr->op==TK_SELECT );
-  assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
+  testcase( pExpr->op==TK_EXISTS ); 
+  testcase( pExpr->op==TK_SELECT ); 
+  assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT ); 
   assert( ExprUseXSelect(pExpr) );
-  pSel = pExpr->x.pSelect;
+  pSel = pExpr->x.pSelect; 
 
   /* If this routine has already been coded, then invoke it as a
   ** subroutine. */
@@ -104861,47 +104861,47 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
   VdbeComment((v, "return address"));
 
 
-  /* The evaluation of the EXISTS/SELECT must be repeated every time it
-  ** is encountered if any of the following is true:
-  **
-  **    *  The right-hand side is a correlated subquery
-  **    *  The right-hand side is an expression list containing variables
-  **    *  We are inside a trigger
-  **
-  ** If all of the above are false, then we can run this code just once
-  ** save the results, and reuse the same result on subsequent invocations.
-  */
-  if( !ExprHasProperty(pExpr, EP_VarSelect) ){
-    addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
-  }
-
-  /* For a SELECT, generate code to put the values for all columns of
-  ** the first row into an array of registers and return the index of
-  ** the first register.
-  **
-  ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists)
-  ** into a register and return that register number.
-  **
+  /* The evaluation of the EXISTS/SELECT must be repeated every time it 
+  ** is encountered if any of the following is true: 
+  ** 
+  **    *  The right-hand side is a correlated subquery 
+  **    *  The right-hand side is an expression list containing variables 
+  **    *  We are inside a trigger 
+  ** 
+  ** If all of the above are false, then we can run this code just once 
+  ** save the results, and reuse the same result on subsequent invocations. 
+  */ 
+  if( !ExprHasProperty(pExpr, EP_VarSelect) ){ 
+    addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); 
+  }
+
+  /* For a SELECT, generate code to put the values for all columns of 
+  ** the first row into an array of registers and return the index of 
+  ** the first register. 
+  ** 
+  ** If this is an EXISTS, write an integer 0 (not exists) or 1 (exists) 
+  ** into a register and return that register number. 
+  ** 
   ** In both cases, the query is augmented with "LIMIT 1".  Any
-  ** preexisting limit is discarded in place of the new LIMIT 1.
-  */
-  ExplainQueryPlan((pParse, 1, "%sSCALAR SUBQUERY %d",
-        addrOnce?"":"CORRELATED ", pSel->selId));
-  nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1;
-  sqlite3SelectDestInit(&dest, 0, pParse->nMem+1);
-  pParse->nMem += nReg;
-  if( pExpr->op==TK_SELECT ){
-    dest.eDest = SRT_Mem;
-    dest.iSdst = dest.iSDParm;
-    dest.nSdst = nReg;
-    sqlite3VdbeAddOp3(v, OP_Null, 0, dest.iSDParm, dest.iSDParm+nReg-1);
-    VdbeComment((v, "Init subquery result"));
-  }else{
-    dest.eDest = SRT_Exists;
-    sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iSDParm);
-    VdbeComment((v, "Init EXISTS result"));
-  }
-  if( pSel->pLimit ){
+  ** preexisting limit is discarded in place of the new LIMIT 1. 
+  */ 
+  ExplainQueryPlan((pParse, 1, "%sSCALAR SUBQUERY %d", 
+        addrOnce?"":"CORRELATED ", pSel->selId)); 
+  nReg = pExpr->op==TK_SELECT ? pSel->pEList->nExpr : 1; 
+  sqlite3SelectDestInit(&dest, 0, pParse->nMem+1); 
+  pParse->nMem += nReg; 
+  if( pExpr->op==TK_SELECT ){ 
+    dest.eDest = SRT_Mem; 
+    dest.iSdst = dest.iSDParm; 
+    dest.nSdst = nReg; 
+    sqlite3VdbeAddOp3(v, OP_Null, 0, dest.iSDParm, dest.iSDParm+nReg-1); 
+    VdbeComment((v, "Init subquery result")); 
+  }else{ 
+    dest.eDest = SRT_Exists; 
+    sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iSDParm); 
+    VdbeComment((v, "Init EXISTS result")); 
+  }
+  if( pSel->pLimit ){ 
     /* The subquery already has a limit.  If the pre-existing limit is X
     ** then make the new limit X<>0 so that the new limit is either 1 or 0 */
     sqlite3 *db = pParse->db;
@@ -104912,24 +104912,24 @@ SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
                             sqlite3ExprDup(db, pSel->pLimit->pLeft, 0), pLimit);
     }
     sqlite3ExprDelete(db, pSel->pLimit->pLeft);
-    pSel->pLimit->pLeft = pLimit;
-  }else{
+    pSel->pLimit->pLeft = pLimit; 
+  }else{ 
     /* If there is no pre-existing limit add a limit of 1 */
     pLimit = sqlite3Expr(pParse->db, TK_INTEGER, "1");
-    pSel->pLimit = sqlite3PExpr(pParse, TK_LIMIT, pLimit, 0);
-  }
-  pSel->iLimit = 0;
-  if( sqlite3Select(pParse, pSel, &dest) ){
+    pSel->pLimit = sqlite3PExpr(pParse, TK_LIMIT, pLimit, 0); 
+  } 
+  pSel->iLimit = 0; 
+  if( sqlite3Select(pParse, pSel, &dest) ){ 
     if( pParse->nErr ){
       pExpr->op2 = pExpr->op;
       pExpr->op = TK_ERROR;
     }
-    return 0;
-  }
-  pExpr->iTable = rReg = dest.iSDParm;
-  ExprSetVVAProperty(pExpr, EP_NoReduce);
-  if( addrOnce ){
-    sqlite3VdbeJumpHere(v, addrOnce);
+    return 0; 
+  } 
+  pExpr->iTable = rReg = dest.iSDParm; 
+  ExprSetVVAProperty(pExpr, EP_NoReduce); 
+  if( addrOnce ){ 
+    sqlite3VdbeJumpHere(v, addrOnce); 
   }
 
   /* Subroutine return */
@@ -105011,7 +105011,7 @@ static void sqlite3ExprCodeIN(
   int addrTruthOp;      /* Address of opcode that determines the IN is true */
   int destNotNull;      /* Jump here if a comparison is not true in step 6 */
   int addrTop;          /* Top of the step-6 loop */
-  int iTab = 0;         /* Index to use */
+  int iTab = 0;         /* Index to use */ 
   u8 okConstFactor = pParse->okConstFactor;
 
   assert( !ExprHasVVAProperty(pExpr,EP_Immutable) );
@@ -105025,7 +105025,7 @@ static void sqlite3ExprCodeIN(
   if( pParse->db->mallocFailed ) goto sqlite3ExprCodeIN_oom_error;
 
   /* Attempt to compute the RHS. After this step, if anything other than
-  ** IN_INDEX_NOOP is returned, the table opened with cursor iTab
+  ** IN_INDEX_NOOP is returned, the table opened with cursor iTab 
   ** contains the values that make up the RHS. If IN_INDEX_NOOP is returned,
   ** the RHS has not yet been coded.  */
   v = pParse->pVdbe;
@@ -105033,8 +105033,8 @@ static void sqlite3ExprCodeIN(
   VdbeNoopComment((v, "begin IN expr"));
   eType = sqlite3FindInIndex(pParse, pExpr,
                              IN_INDEX_MEMBERSHIP | IN_INDEX_NOOP_OK,
-                             destIfFalse==destIfNull ? 0 : &rRhsHasNull,
-                             aiMap, &iTab);
+                             destIfFalse==destIfNull ? 0 : &rRhsHasNull, 
+                             aiMap, &iTab); 
 
   assert( pParse->nErr || nVector==1 || eType==IN_INDEX_EPH
        || eType==IN_INDEX_INDEX_ASC || eType==IN_INDEX_INDEX_DESC
@@ -105086,7 +105086,7 @@ static void sqlite3ExprCodeIN(
   if( eType==IN_INDEX_NOOP ){
     ExprList *pList;
     CollSeq *pColl;
-    int labelOk = sqlite3VdbeMakeLabel(pParse);
+    int labelOk = sqlite3VdbeMakeLabel(pParse); 
     int r2, regToFree;
     int regCkNull = 0;
     int ii;
@@ -105138,7 +105138,7 @@ static void sqlite3ExprCodeIN(
   if( destIfNull==destIfFalse ){
     destStep2 = destIfFalse;
   }else{
-    destStep2 = destStep6 = sqlite3VdbeMakeLabel(pParse);
+    destStep2 = destStep6 = sqlite3VdbeMakeLabel(pParse); 
   }
   if( pParse->nErr ) goto sqlite3ExprCodeIN_finished;
   for(i=0; i<nVector; i++){
@@ -105158,19 +105158,19 @@ static void sqlite3ExprCodeIN(
     /* In this case, the RHS is the ROWID of table b-tree and so we also
     ** know that the RHS is non-NULL.  Hence, we combine steps 3 and 4
     ** into a single opcode. */
-    sqlite3VdbeAddOp3(v, OP_SeekRowid, iTab, destIfFalse, rLhs);
+    sqlite3VdbeAddOp3(v, OP_SeekRowid, iTab, destIfFalse, rLhs); 
     VdbeCoverage(v);
     addrTruthOp = sqlite3VdbeAddOp0(v, OP_Goto);  /* Return True */
   }else{
     sqlite3VdbeAddOp4(v, OP_Affinity, rLhs, nVector, 0, zAff, nVector);
     if( destIfFalse==destIfNull ){
       /* Combine Step 3 and Step 5 into a single opcode */
-      sqlite3VdbeAddOp4Int(v, OP_NotFound, iTab, destIfFalse,
+      sqlite3VdbeAddOp4Int(v, OP_NotFound, iTab, destIfFalse, 
                            rLhs, nVector); VdbeCoverage(v);
       goto sqlite3ExprCodeIN_finished;
     }
     /* Ordinary Step 3, for the case where FALSE and NULL are distinct */
-    addrTruthOp = sqlite3VdbeAddOp4Int(v, OP_Found, iTab, 0,
+    addrTruthOp = sqlite3VdbeAddOp4Int(v, OP_Found, iTab, 0, 
                                       rLhs, nVector); VdbeCoverage(v);
   }
 
@@ -105195,10 +105195,10 @@ static void sqlite3ExprCodeIN(
   ** of the RHS.
   */
   if( destStep6 ) sqlite3VdbeResolveLabel(v, destStep6);
-  addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, destIfFalse);
+  addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, destIfFalse); 
   VdbeCoverage(v);
   if( nVector>1 ){
-    destNotNull = sqlite3VdbeMakeLabel(pParse);
+    destNotNull = sqlite3VdbeMakeLabel(pParse); 
   }else{
     /* For nVector==1, combine steps 6 and 7 by immediately returning
     ** FALSE if the first comparison is not NULL */
@@ -105210,7 +105210,7 @@ static void sqlite3ExprCodeIN(
     int r3 = sqlite3GetTempReg(pParse);
     p = sqlite3VectorFieldSubexpr(pLeft, i);
     pColl = sqlite3ExprCollSeq(pParse, p);
-    sqlite3VdbeAddOp3(v, OP_Column, iTab, i, r3);
+    sqlite3VdbeAddOp3(v, OP_Column, iTab, i, r3); 
     sqlite3VdbeAddOp4(v, OP_Ne, rLhs+i, destNotNull, r3,
                       (void*)pColl, P4_COLLSEQ);
     VdbeCoverage(v);
@@ -105219,7 +105219,7 @@ static void sqlite3ExprCodeIN(
   sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfNull);
   if( nVector>1 ){
     sqlite3VdbeResolveLabel(v, destNotNull);
-    sqlite3VdbeAddOp2(v, OP_Next, iTab, addrTop+1);
+    sqlite3VdbeAddOp2(v, OP_Next, iTab, addrTop+1); 
     VdbeCoverage(v);
 
     /* Step 7:  If we reach this point, we know that the result must
@@ -105431,7 +105431,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeGetColumn(
 
 /*
 ** Generate code to move content from registers iFrom...iFrom+nReg-1
-** over to iTo..iTo+nReg-1.
+** over to iTo..iTo+nReg-1. 
 */
 SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){
   sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg);
@@ -105442,7 +105442,7 @@ SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int n
 ** register iReg.  The caller must ensure that iReg already contains
 ** the correct value for the expression.
 */
-static void exprToRegister(Expr *pExpr, int iReg){
+static void exprToRegister(Expr *pExpr, int iReg){ 
   Expr *p = sqlite3ExprSkipCollateAndLikely(pExpr);
   if( NEVER(p==0) ) return;
   p->op2 = p->op;
@@ -105472,7 +105472,7 @@ static int exprCodeVector(Parse *pParse, Expr *p, int *piFreeable){
 #if SQLITE_OMIT_SUBQUERY
       iResult = 0;
 #else
-      iResult = sqlite3CodeSubselect(pParse, p);
+      iResult = sqlite3CodeSubselect(pParse, p); 
 #endif
     }else{
       int i;
@@ -105630,7 +105630,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
   assert( target>0 && target<=pParse->nMem );
   assert( v!=0 );
 
-expr_code_doover:
+expr_code_doover: 
   if( pExpr==0 ){
     op = TK_NULL;
   }else{
@@ -105668,13 +105668,13 @@ expr_code_doover:
     case TK_COLUMN: {
       int iTab = pExpr->iTable;
       int iReg;
-      if( ExprHasProperty(pExpr, EP_FixedCol) ){
-        /* This COLUMN expression is really a constant due to WHERE clause
-        ** constraints, and that constant is coded by the pExpr->pLeft
-        ** expresssion.  However, make sure the constant has the correct
-        ** datatype by applying the Affinity of the table column to the
-        ** constant.
-        */
+      if( ExprHasProperty(pExpr, EP_FixedCol) ){ 
+        /* This COLUMN expression is really a constant due to WHERE clause 
+        ** constraints, and that constant is coded by the pExpr->pLeft 
+        ** expresssion.  However, make sure the constant has the correct 
+        ** datatype by applying the Affinity of the table column to the 
+        ** constant. 
+        */ 
         int aff;
         iReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft,target);
         assert( ExprUseYTab(pExpr) );
@@ -105684,14 +105684,14 @@ expr_code_doover:
           aff = pExpr->affExpr;
         }
         if( aff>SQLITE_AFF_BLOB ){
-          static const char zAff[] = "B\000C\000D\000E";
-          assert( SQLITE_AFF_BLOB=='A' );
-          assert( SQLITE_AFF_TEXT=='B' );
-          sqlite3VdbeAddOp4(v, OP_Affinity, iReg, 1, 0,
-                            &zAff[(aff-'B')*2], P4_STATIC);
-        }
-        return iReg;
-      }
+          static const char zAff[] = "B\000C\000D\000E"; 
+          assert( SQLITE_AFF_BLOB=='A' ); 
+          assert( SQLITE_AFF_TEXT=='B' ); 
+          sqlite3VdbeAddOp4(v, OP_Affinity, iReg, 1, 0, 
+                            &zAff[(aff-'B')*2], P4_STATIC); 
+        } 
+        return iReg; 
+      } 
       if( iTab<0 ){
         if( pParse->iSelfTab<0 ){
           /* Other columns in the same row for CHECK constraints or
@@ -105756,10 +105756,10 @@ expr_code_doover:
       codeInteger(pParse, pExpr, 0, target);
       return target;
     }
-    case TK_TRUEFALSE: {
-      sqlite3VdbeAddOp2(v, OP_Integer, sqlite3ExprTruthValue(pExpr), target);
-      return target;
-    }
+    case TK_TRUEFALSE: { 
+      sqlite3VdbeAddOp2(v, OP_Integer, sqlite3ExprTruthValue(pExpr), target); 
+      return target; 
+    } 
 #ifndef SQLITE_OMIT_FLOATING_POINT
     case TK_FLOAT: {
       assert( !ExprHasProperty(pExpr, EP_IntValue) );
@@ -105927,18 +105927,18 @@ expr_code_doover:
       sqlite3VdbeAddOp2(v, op, r1, inReg);
       break;
     }
-    case TK_TRUTH: {
-      int isTrue;    /* IS TRUE or IS NOT TRUE */
-      int bNormal;   /* IS TRUE or IS FALSE */
-      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1);
-      testcase( regFree1==0 );
-      isTrue = sqlite3ExprTruthValue(pExpr->pRight);
-      bNormal = pExpr->op2==TK_IS;
-      testcase( isTrue && bNormal);
-      testcase( !isTrue && bNormal);
-      sqlite3VdbeAddOp4Int(v, OP_IsTrue, r1, inReg, !isTrue, isTrue ^ bNormal);
-      break;
-    }
+    case TK_TRUTH: { 
+      int isTrue;    /* IS TRUE or IS NOT TRUE */ 
+      int bNormal;   /* IS TRUE or IS FALSE */ 
+      r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, &regFree1); 
+      testcase( regFree1==0 ); 
+      isTrue = sqlite3ExprTruthValue(pExpr->pRight); 
+      bNormal = pExpr->op2==TK_IS; 
+      testcase( isTrue && bNormal); 
+      testcase( !isTrue && bNormal); 
+      sqlite3VdbeAddOp4Int(v, OP_IsTrue, r1, inReg, !isTrue, isTrue ^ bNormal); 
+      break; 
+    } 
     case TK_ISNULL:
     case TK_NOTNULL: {
       int addr;
@@ -105978,12 +105978,12 @@ expr_code_doover:
       u8 enc = ENC(db);      /* The text encoding used by this database */
       CollSeq *pColl = 0;    /* A collating sequence */
 
-#ifndef SQLITE_OMIT_WINDOWFUNC
-      if( ExprHasProperty(pExpr, EP_WinFunc) ){
-        return pExpr->y.pWin->regResult;
-      }
-#endif
-
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+      if( ExprHasProperty(pExpr, EP_WinFunc) ){ 
+        return pExpr->y.pWin->regResult; 
+      } 
+#endif 
+ 
       if( ConstFactorOk(pParse) && sqlite3ExprIsConstantNotJoin(pExpr) ){
         /* SQL functions can be expensive. So try to avoid running them
         ** multiple times if we know they always give the same result */
@@ -106068,7 +106068,7 @@ expr_code_doover:
       ** "glob(B,A).  We want to use the A in "A glob B" to test
       ** for function overloading.  But we use the B term in "glob(B,A)".
       */
-      if( nFarg>=2 && ExprHasProperty(pExpr, EP_InfixFunc) ){
+      if( nFarg>=2 && ExprHasProperty(pExpr, EP_InfixFunc) ){ 
         pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[1].pExpr);
       }else if( nFarg>0 ){
         pDef = sqlite3VtabOverloadFunction(db, pDef, nFarg, pFarg->a[0].pExpr);
@@ -106115,14 +106115,14 @@ expr_code_doover:
       ){
         sqlite3SubselectError(pParse, nCol, 1);
       }else{
-        return sqlite3CodeSubselect(pParse, pExpr);
+        return sqlite3CodeSubselect(pParse, pExpr); 
       }
       break;
     }
     case TK_SELECT_COLUMN: {
       int n;
       if( pExpr->pLeft->iTable==0 ){
-        pExpr->pLeft->iTable = sqlite3CodeSubselect(pParse, pExpr->pLeft);
+        pExpr->pLeft->iTable = sqlite3CodeSubselect(pParse, pExpr->pLeft); 
       }
       assert( pExpr->pLeft->op==TK_SELECT || pExpr->pLeft->op==TK_ERROR );
       n = sqlite3ExprVectorSize(pExpr->pLeft);
@@ -106133,8 +106133,8 @@ expr_code_doover:
       return pExpr->pLeft->iTable + pExpr->iColumn;
     }
     case TK_IN: {
-      int destIfFalse = sqlite3VdbeMakeLabel(pParse);
-      int destIfNull = sqlite3VdbeMakeLabel(pParse);
+      int destIfFalse = sqlite3VdbeMakeLabel(pParse); 
+      int destIfNull = sqlite3VdbeMakeLabel(pParse); 
       sqlite3VdbeAddOp2(v, OP_Null, 0, target);
       sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
       sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
@@ -106164,8 +106164,8 @@ expr_code_doover:
     case TK_SPAN:
     case TK_COLLATE:
     case TK_UPLUS: {
-      pExpr = pExpr->pLeft;
-      goto expr_code_doover; /* 2018-04-28: Prevent deep recursion. OSSFuzz. */
+      pExpr = pExpr->pLeft; 
+      goto expr_code_doover; /* 2018-04-28: Prevent deep recursion. OSSFuzz. */ 
     }
 
     case TK_TRIGGER: {
@@ -106210,7 +106210,7 @@ expr_code_doover:
       assert( p1>=0 && p1<(pTab->nCol*2+2) );
 
       sqlite3VdbeAddOp2(v, OP_Param, p1, target);
-      VdbeComment((v, "r[%d]=%s.%s", target,
+      VdbeComment((v, "r[%d]=%s.%s", target, 
         (pExpr->iTable ? "new" : "old"),
         (pExpr->iColumn<0 ? "rowid" : pExpr->y.pTab->aCol[iCol].zCnName)
       ));
@@ -106294,7 +106294,7 @@ expr_code_doover:
       pEList = pExpr->x.pList;
       aListelem = pEList->a;
       nExpr = pEList->nExpr;
-      endLabel = sqlite3VdbeMakeLabel(pParse);
+      endLabel = sqlite3VdbeMakeLabel(pParse); 
       if( (pX = pExpr->pLeft)!=0 ){
         pDel = sqlite3ExprDup(db, pX, 0);
         if( db->mallocFailed ){
@@ -106321,7 +106321,7 @@ expr_code_doover:
         }else{
           pTest = aListelem[i].pExpr;
         }
-        nextCase = sqlite3VdbeMakeLabel(pParse);
+        nextCase = sqlite3VdbeMakeLabel(pParse); 
         testcase( pTest->op==TK_COLUMN );
         sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL);
         testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
@@ -106514,7 +106514,7 @@ SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, Expr *pExpr, int target){
 ** might choose to code the expression at initialization time.
 */
 SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
-  if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pExpr) ){
+  if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pExpr) ){ 
     sqlite3ExprCodeRunJustOnce(pParse, pExpr, target);
   }else{
     sqlite3ExprCodeCopy(pParse, pExpr, target);
@@ -106559,12 +106559,12 @@ SQLITE_PRIVATE int sqlite3ExprCodeExprList(
   if( !ConstFactorOk(pParse) ) flags &= ~SQLITE_ECEL_FACTOR;
   for(pItem=pList->a, i=0; i<n; i++, pItem++){
     Expr *pExpr = pItem->pExpr;
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-    if( pItem->bSorterRef ){
-      i--;
-      n--;
-    }else
-#endif
+#ifdef SQLITE_ENABLE_SORTER_REFERENCES 
+    if( pItem->bSorterRef ){ 
+      i--; 
+      n--; 
+    }else 
+#endif 
     if( (flags & SQLITE_ECEL_REF)!=0 && (j = pItem->u.x.iOrderByCol)>0 ){
       if( flags & SQLITE_ECEL_OMITREF ){
         i--;
@@ -106572,9 +106572,9 @@ SQLITE_PRIVATE int sqlite3ExprCodeExprList(
       }else{
         sqlite3VdbeAddOp2(v, copyOp, j+srcReg-1, target+i);
       }
-    }else if( (flags & SQLITE_ECEL_FACTOR)!=0
-           && sqlite3ExprIsConstantNotJoin(pExpr)
-    ){
+    }else if( (flags & SQLITE_ECEL_FACTOR)!=0 
+           && sqlite3ExprIsConstantNotJoin(pExpr) 
+    ){ 
       sqlite3ExprCodeRunJustOnce(pParse, pExpr, target+i);
     }else{
       int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
@@ -106701,23 +106701,23 @@ SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int
   assert( !ExprHasVVAProperty(pExpr, EP_Immutable) );
   op = pExpr->op;
   switch( op ){
-    case TK_AND:
+    case TK_AND: 
     case TK_OR: {
-      Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
-      if( pAlt!=pExpr ){
-        sqlite3ExprIfTrue(pParse, pAlt, dest, jumpIfNull);
-      }else if( op==TK_AND ){
-        int d2 = sqlite3VdbeMakeLabel(pParse);
-        testcase( jumpIfNull==0 );
-        sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,
-                           jumpIfNull^SQLITE_JUMPIFNULL);
-        sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
-        sqlite3VdbeResolveLabel(v, d2);
-      }else{
-        testcase( jumpIfNull==0 );
-        sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
-        sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
-      }
+      Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr); 
+      if( pAlt!=pExpr ){ 
+        sqlite3ExprIfTrue(pParse, pAlt, dest, jumpIfNull); 
+      }else if( op==TK_AND ){ 
+        int d2 = sqlite3VdbeMakeLabel(pParse); 
+        testcase( jumpIfNull==0 ); 
+        sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2, 
+                           jumpIfNull^SQLITE_JUMPIFNULL); 
+        sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); 
+        sqlite3VdbeResolveLabel(v, d2); 
+      }else{ 
+        testcase( jumpIfNull==0 ); 
+        sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); 
+        sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); 
+      } 
       break;
     }
     case TK_NOT: {
@@ -106725,23 +106725,23 @@ SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int
       sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
       break;
     }
-    case TK_TRUTH: {
-      int isNot;      /* IS NOT TRUE or IS NOT FALSE */
-      int isTrue;     /* IS TRUE or IS NOT TRUE */
-      testcase( jumpIfNull==0 );
-      isNot = pExpr->op2==TK_ISNOT;
-      isTrue = sqlite3ExprTruthValue(pExpr->pRight);
-      testcase( isTrue && isNot );
-      testcase( !isTrue && isNot );
-      if( isTrue ^ isNot ){
-        sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
-                          isNot ? SQLITE_JUMPIFNULL : 0);
-      }else{
-        sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
-                           isNot ? SQLITE_JUMPIFNULL : 0);
-      }
-      break;
-    }
+    case TK_TRUTH: { 
+      int isNot;      /* IS NOT TRUE or IS NOT FALSE */ 
+      int isTrue;     /* IS TRUE or IS NOT TRUE */ 
+      testcase( jumpIfNull==0 ); 
+      isNot = pExpr->op2==TK_ISNOT; 
+      isTrue = sqlite3ExprTruthValue(pExpr->pRight); 
+      testcase( isTrue && isNot ); 
+      testcase( !isTrue && isNot ); 
+      if( isTrue ^ isNot ){ 
+        sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, 
+                          isNot ? SQLITE_JUMPIFNULL : 0); 
+      }else{ 
+        sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, 
+                           isNot ? SQLITE_JUMPIFNULL : 0); 
+      } 
+      break; 
+    } 
     case TK_IS:
     case TK_ISNOT:
       testcase( op==TK_IS );
@@ -106793,7 +106793,7 @@ SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int
     }
 #ifndef SQLITE_OMIT_SUBQUERY
     case TK_IN: {
-      int destIfFalse = sqlite3VdbeMakeLabel(pParse);
+      int destIfFalse = sqlite3VdbeMakeLabel(pParse); 
       int destIfNull = jumpIfNull ? dest : destIfFalse;
       sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
       sqlite3VdbeGoto(v, dest);
@@ -106803,9 +106803,9 @@ SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int
 #endif
     default: {
     default_expr:
-      if( ExprAlwaysTrue(pExpr) ){
+      if( ExprAlwaysTrue(pExpr) ){ 
         sqlite3VdbeGoto(v, dest);
-      }else if( ExprAlwaysFalse(pExpr) ){
+      }else if( ExprAlwaysFalse(pExpr) ){ 
         /* No-op */
       }else{
         r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
@@ -106874,23 +106874,23 @@ SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int
   assert( pExpr->op!=TK_GE || op==OP_Lt );
 
   switch( pExpr->op ){
-    case TK_AND:
+    case TK_AND: 
     case TK_OR: {
-      Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr);
-      if( pAlt!=pExpr ){
-        sqlite3ExprIfFalse(pParse, pAlt, dest, jumpIfNull);
-      }else if( pExpr->op==TK_AND ){
-        testcase( jumpIfNull==0 );
-        sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
-        sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
-      }else{
-        int d2 = sqlite3VdbeMakeLabel(pParse);
-        testcase( jumpIfNull==0 );
-        sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2,
-                          jumpIfNull^SQLITE_JUMPIFNULL);
-        sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
-        sqlite3VdbeResolveLabel(v, d2);
-      }
+      Expr *pAlt = sqlite3ExprSimplifiedAndOr(pExpr); 
+      if( pAlt!=pExpr ){ 
+        sqlite3ExprIfFalse(pParse, pAlt, dest, jumpIfNull); 
+      }else if( pExpr->op==TK_AND ){ 
+        testcase( jumpIfNull==0 ); 
+        sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); 
+        sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); 
+      }else{ 
+        int d2 = sqlite3VdbeMakeLabel(pParse); 
+        testcase( jumpIfNull==0 ); 
+        sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, 
+                          jumpIfNull^SQLITE_JUMPIFNULL); 
+        sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); 
+        sqlite3VdbeResolveLabel(v, d2); 
+      } 
       break;
     }
     case TK_NOT: {
@@ -106898,26 +106898,26 @@ SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int
       sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
       break;
     }
-    case TK_TRUTH: {
-      int isNot;   /* IS NOT TRUE or IS NOT FALSE */
-      int isTrue;  /* IS TRUE or IS NOT TRUE */
-      testcase( jumpIfNull==0 );
-      isNot = pExpr->op2==TK_ISNOT;
-      isTrue = sqlite3ExprTruthValue(pExpr->pRight);
-      testcase( isTrue && isNot );
-      testcase( !isTrue && isNot );
-      if( isTrue ^ isNot ){
-        /* IS TRUE and IS NOT FALSE */
-        sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
-                           isNot ? 0 : SQLITE_JUMPIFNULL);
-
-      }else{
-        /* IS FALSE and IS NOT TRUE */
-        sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
-                          isNot ? 0 : SQLITE_JUMPIFNULL);
-      }
-      break;
-    }
+    case TK_TRUTH: { 
+      int isNot;   /* IS NOT TRUE or IS NOT FALSE */ 
+      int isTrue;  /* IS TRUE or IS NOT TRUE */ 
+      testcase( jumpIfNull==0 ); 
+      isNot = pExpr->op2==TK_ISNOT; 
+      isTrue = sqlite3ExprTruthValue(pExpr->pRight); 
+      testcase( isTrue && isNot ); 
+      testcase( !isTrue && isNot ); 
+      if( isTrue ^ isNot ){ 
+        /* IS TRUE and IS NOT FALSE */ 
+        sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, 
+                           isNot ? 0 : SQLITE_JUMPIFNULL); 
+ 
+      }else{ 
+        /* IS FALSE and IS NOT TRUE */ 
+        sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, 
+                          isNot ? 0 : SQLITE_JUMPIFNULL); 
+      } 
+      break; 
+    } 
     case TK_IS:
     case TK_ISNOT:
       testcase( pExpr->op==TK_IS );
@@ -106970,7 +106970,7 @@ SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int
       if( jumpIfNull ){
         sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
       }else{
-        int destIfNull = sqlite3VdbeMakeLabel(pParse);
+        int destIfNull = sqlite3VdbeMakeLabel(pParse); 
         sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
         sqlite3VdbeResolveLabel(v, destIfNull);
       }
@@ -106979,9 +106979,9 @@ SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int
 #endif
     default: {
     default_expr:
-      if( ExprAlwaysFalse(pExpr) ){
+      if( ExprAlwaysFalse(pExpr) ){ 
         sqlite3VdbeGoto(v, dest);
-      }else if( ExprAlwaysTrue(pExpr) ){
+      }else if( ExprAlwaysTrue(pExpr) ){ 
         /* no-op */
       }else{
         r1 = sqlite3ExprCodeTemp(pParse, pExpr, &regFree1);
@@ -107100,7 +107100,7 @@ SQLITE_PRIVATE int sqlite3ExprCompare(
     }
     return 2;
   }
-  if( pA->op!=pB->op || pA->op==TK_RAISE ){
+  if( pA->op!=pB->op || pA->op==TK_RAISE ){ 
     if( pA->op==TK_COLLATE && sqlite3ExprCompare(pParse, pA->pLeft,pB,iTab)<2 ){
       return 1;
     }
@@ -107114,42 +107114,42 @@ SQLITE_PRIVATE int sqlite3ExprCompare(
   if( pA->u.zToken ){
     if( pA->op==TK_FUNCTION || pA->op==TK_AGG_FUNCTION ){
       if( sqlite3StrICmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2;
-#ifndef SQLITE_OMIT_WINDOWFUNC
+#ifndef SQLITE_OMIT_WINDOWFUNC 
       assert( pA->op==pB->op );
       if( ExprHasProperty(pA,EP_WinFunc)!=ExprHasProperty(pB,EP_WinFunc) ){
         return 2;
       }
-      if( ExprHasProperty(pA,EP_WinFunc) ){
+      if( ExprHasProperty(pA,EP_WinFunc) ){ 
         if( sqlite3WindowCompare(pParse, pA->y.pWin, pB->y.pWin, 1)!=0 ){
           return 2;
         }
-      }
-#endif
-    }else if( pA->op==TK_NULL ){
-      return 0;
-    }else if( pA->op==TK_COLLATE ){
-      if( sqlite3_stricmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2;
+      } 
+#endif 
+    }else if( pA->op==TK_NULL ){ 
+      return 0; 
+    }else if( pA->op==TK_COLLATE ){ 
+      if( sqlite3_stricmp(pA->u.zToken,pB->u.zToken)!=0 ) return 2; 
     }else
     if( pB->u.zToken!=0
      && pA->op!=TK_COLUMN
      && pA->op!=TK_AGG_COLUMN
      && strcmp(pA->u.zToken,pB->u.zToken)!=0
     ){
-      return 2;
+      return 2; 
     }
   }
   if( (pA->flags & (EP_Distinct|EP_Commuted))
      != (pB->flags & (EP_Distinct|EP_Commuted)) ) return 2;
   if( ALWAYS((combinedFlags & EP_TokenOnly)==0) ){
     if( combinedFlags & EP_xIsSelect ) return 2;
-    if( (combinedFlags & EP_FixedCol)==0
-     && sqlite3ExprCompare(pParse, pA->pLeft, pB->pLeft, iTab) ) return 2;
+    if( (combinedFlags & EP_FixedCol)==0 
+     && sqlite3ExprCompare(pParse, pA->pLeft, pB->pLeft, iTab) ) return 2; 
     if( sqlite3ExprCompare(pParse, pA->pRight, pB->pRight, iTab) ) return 2;
     if( sqlite3ExprListCompare(pA->x.pList, pB->x.pList, iTab) ) return 2;
-    if( pA->op!=TK_STRING
-     && pA->op!=TK_TRUEFALSE
+    if( pA->op!=TK_STRING 
+     && pA->op!=TK_TRUEFALSE 
      && ALWAYS((combinedFlags & EP_Reduced)==0)
-    ){
+    ){ 
       if( pA->iColumn!=pB->iColumn ) return 2;
       if( pA->op2!=pB->op2 && pA->op==TK_TRUTH ) return 2;
       if( pA->op!=TK_IN && pA->iTable!=pB->iTable && pA->iTable!=iTab ){
@@ -107203,84 +107203,84 @@ SQLITE_PRIVATE int sqlite3ExprCompareSkip(Expr *pA,Expr *pB, int iTab){
 }
 
 /*
-** Return non-zero if Expr p can only be true if pNN is not NULL.
+** Return non-zero if Expr p can only be true if pNN is not NULL. 
 **
 ** Or if seenNot is true, return non-zero if Expr p can only be
 ** non-NULL if pNN is not NULL
-*/
-static int exprImpliesNotNull(
+*/ 
+static int exprImpliesNotNull( 
   const Parse *pParse,/* Parsing context */
   const Expr *p,      /* The expression to be checked */
   const Expr *pNN,    /* The expression that is NOT NULL */
-  int iTab,           /* Table being evaluated */
+  int iTab,           /* Table being evaluated */ 
   int seenNot         /* Return true only if p can be any non-NULL value */
-){
-  assert( p );
-  assert( pNN );
+){ 
+  assert( p ); 
+  assert( pNN ); 
   if( sqlite3ExprCompare(pParse, p, pNN, iTab)==0 ){
     return pNN->op!=TK_NULL;
   }
-  switch( p->op ){
-    case TK_IN: {
-      if( seenNot && ExprHasProperty(p, EP_xIsSelect) ) return 0;
+  switch( p->op ){ 
+    case TK_IN: { 
+      if( seenNot && ExprHasProperty(p, EP_xIsSelect) ) return 0; 
       assert( ExprUseXSelect(p) || (p->x.pList!=0 && p->x.pList->nExpr>0) );
       return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1);
-    }
-    case TK_BETWEEN: {
+    } 
+    case TK_BETWEEN: { 
       ExprList *pList;
       assert( ExprUseXList(p) );
       pList = p->x.pList;
-      assert( pList!=0 );
-      assert( pList->nExpr==2 );
-      if( seenNot ) return 0;
+      assert( pList!=0 ); 
+      assert( pList->nExpr==2 ); 
+      if( seenNot ) return 0; 
       if( exprImpliesNotNull(pParse, pList->a[0].pExpr, pNN, iTab, 1)
        || exprImpliesNotNull(pParse, pList->a[1].pExpr, pNN, iTab, 1)
-      ){
-        return 1;
-      }
+      ){ 
+        return 1; 
+      } 
       return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1);
-    }
-    case TK_EQ:
-    case TK_NE:
-    case TK_LT:
-    case TK_LE:
-    case TK_GT:
-    case TK_GE:
-    case TK_PLUS:
-    case TK_MINUS:
+    } 
+    case TK_EQ: 
+    case TK_NE: 
+    case TK_LT: 
+    case TK_LE: 
+    case TK_GT: 
+    case TK_GE: 
+    case TK_PLUS: 
+    case TK_MINUS: 
     case TK_BITOR:
     case TK_LSHIFT:
     case TK_RSHIFT:
     case TK_CONCAT:
       seenNot = 1;
       /* no break */ deliberate_fall_through
-    case TK_STAR:
-    case TK_REM:
-    case TK_BITAND:
+    case TK_STAR: 
+    case TK_REM: 
+    case TK_BITAND: 
     case TK_SLASH: {
-      if( exprImpliesNotNull(pParse, p->pRight, pNN, iTab, seenNot) ) return 1;
+      if( exprImpliesNotNull(pParse, p->pRight, pNN, iTab, seenNot) ) return 1; 
       /* no break */ deliberate_fall_through
-    }
-    case TK_SPAN:
-    case TK_COLLATE:
-    case TK_UPLUS:
-    case TK_UMINUS: {
-      return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, seenNot);
-    }
-    case TK_TRUTH: {
-      if( seenNot ) return 0;
-      if( p->op2!=TK_IS ) return 0;
+    } 
+    case TK_SPAN: 
+    case TK_COLLATE: 
+    case TK_UPLUS: 
+    case TK_UMINUS: { 
+      return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, seenNot); 
+    } 
+    case TK_TRUTH: { 
+      if( seenNot ) return 0; 
+      if( p->op2!=TK_IS ) return 0; 
       return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1);
-    }
+    } 
     case TK_BITNOT:
-    case TK_NOT: {
-      return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1);
-    }
-  }
-  return 0;
-}
-
-/*
+    case TK_NOT: { 
+      return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1); 
+    } 
+  } 
+  return 0; 
+} 
+ 
+/* 
 ** Return true if we can prove the pE2 will always be true if pE1 is
 ** true.  Return false if we cannot complete the proof or if pE2 might
 ** be false.  Examples:
@@ -107320,56 +107320,56 @@ SQLITE_PRIVATE int sqlite3ExprImpliesExpr(
   ){
     return 1;
   }
-  if( pE2->op==TK_NOTNULL
-   && exprImpliesNotNull(pParse, pE1, pE2->pLeft, iTab, 0)
-  ){
-    return 1;
+  if( pE2->op==TK_NOTNULL 
+   && exprImpliesNotNull(pParse, pE1, pE2->pLeft, iTab, 0) 
+  ){ 
+    return 1; 
   }
   return 0;
 }
 
 /*
 ** This is the Expr node callback for sqlite3ExprImpliesNonNullRow().
-** If the expression node requires that the table at pWalker->iCur
-** have one or more non-NULL column, then set pWalker->eCode to 1 and abort.
-**
-** This routine controls an optimization.  False positives (setting
-** pWalker->eCode to 1 when it should not be) are deadly, but false-negatives
-** (never setting pWalker->eCode) is a harmless missed optimization.
-*/
-static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){
-  testcase( pExpr->op==TK_AGG_COLUMN );
-  testcase( pExpr->op==TK_AGG_FUNCTION );
-  if( ExprHasProperty(pExpr, EP_FromJoin) ) return WRC_Prune;
-  switch( pExpr->op ){
-    case TK_ISNOT:
-    case TK_ISNULL:
-    case TK_NOTNULL:
-    case TK_IS:
-    case TK_OR:
+** If the expression node requires that the table at pWalker->iCur 
+** have one or more non-NULL column, then set pWalker->eCode to 1 and abort. 
+** 
+** This routine controls an optimization.  False positives (setting 
+** pWalker->eCode to 1 when it should not be) are deadly, but false-negatives 
+** (never setting pWalker->eCode) is a harmless missed optimization. 
+*/ 
+static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){ 
+  testcase( pExpr->op==TK_AGG_COLUMN ); 
+  testcase( pExpr->op==TK_AGG_FUNCTION ); 
+  if( ExprHasProperty(pExpr, EP_FromJoin) ) return WRC_Prune; 
+  switch( pExpr->op ){ 
+    case TK_ISNOT: 
+    case TK_ISNULL: 
+    case TK_NOTNULL: 
+    case TK_IS: 
+    case TK_OR: 
     case TK_VECTOR:
-    case TK_CASE:
-    case TK_IN:
-    case TK_FUNCTION:
+    case TK_CASE: 
+    case TK_IN: 
+    case TK_FUNCTION: 
     case TK_TRUTH:
-      testcase( pExpr->op==TK_ISNOT );
-      testcase( pExpr->op==TK_ISNULL );
-      testcase( pExpr->op==TK_NOTNULL );
-      testcase( pExpr->op==TK_IS );
-      testcase( pExpr->op==TK_OR );
+      testcase( pExpr->op==TK_ISNOT ); 
+      testcase( pExpr->op==TK_ISNULL ); 
+      testcase( pExpr->op==TK_NOTNULL ); 
+      testcase( pExpr->op==TK_IS ); 
+      testcase( pExpr->op==TK_OR ); 
       testcase( pExpr->op==TK_VECTOR );
-      testcase( pExpr->op==TK_CASE );
-      testcase( pExpr->op==TK_IN );
-      testcase( pExpr->op==TK_FUNCTION );
+      testcase( pExpr->op==TK_CASE ); 
+      testcase( pExpr->op==TK_IN ); 
+      testcase( pExpr->op==TK_FUNCTION ); 
       testcase( pExpr->op==TK_TRUTH );
-      return WRC_Prune;
-    case TK_COLUMN:
-      if( pWalker->u.iCur==pExpr->iTable ){
-        pWalker->eCode = 1;
-        return WRC_Abort;
-      }
-      return WRC_Prune;
-
+      return WRC_Prune; 
+    case TK_COLUMN: 
+      if( pWalker->u.iCur==pExpr->iTable ){ 
+        pWalker->eCode = 1; 
+        return WRC_Abort; 
+      } 
+      return WRC_Prune; 
+ 
     case TK_AND:
       if( pWalker->eCode==0 ){
         sqlite3WalkExpr(pWalker, pExpr->pLeft);
@@ -107387,23 +107387,23 @@ static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){
       }
       return WRC_Prune;
 
-    /* Virtual tables are allowed to use constraints like x=NULL.  So
-    ** a term of the form x=y does not prove that y is not null if x
-    ** is the column of a virtual table */
-    case TK_EQ:
-    case TK_NE:
-    case TK_LT:
-    case TK_LE:
-    case TK_GT:
+    /* Virtual tables are allowed to use constraints like x=NULL.  So 
+    ** a term of the form x=y does not prove that y is not null if x 
+    ** is the column of a virtual table */ 
+    case TK_EQ: 
+    case TK_NE: 
+    case TK_LT: 
+    case TK_LE: 
+    case TK_GT: 
     case TK_GE: {
       Expr *pLeft = pExpr->pLeft;
       Expr *pRight = pExpr->pRight;
-      testcase( pExpr->op==TK_EQ );
-      testcase( pExpr->op==TK_NE );
-      testcase( pExpr->op==TK_LT );
-      testcase( pExpr->op==TK_LE );
-      testcase( pExpr->op==TK_GT );
-      testcase( pExpr->op==TK_GE );
+      testcase( pExpr->op==TK_EQ ); 
+      testcase( pExpr->op==TK_NE ); 
+      testcase( pExpr->op==TK_LT ); 
+      testcase( pExpr->op==TK_LE ); 
+      testcase( pExpr->op==TK_GT ); 
+      testcase( pExpr->op==TK_GE ); 
       /* The y.pTab=0 assignment in wherecode.c always happens after the
       ** impliesNotNullRow() test */
       assert( pLeft->op!=TK_COLUMN || ExprUseYTab(pLeft) );
@@ -107414,60 +107414,60 @@ static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){
        || (pRight->op==TK_COLUMN
            && pRight->y.pTab!=0
            && IsVirtual(pRight->y.pTab))
-      ){
+      ){ 
         return WRC_Prune;
-      }
+      } 
       /* no break */ deliberate_fall_through
     }
-    default:
-      return WRC_Continue;
-  }
-}
-
-/*
-** Return true (non-zero) if expression p can only be true if at least
-** one column of table iTab is non-null.  In other words, return true
-** if expression p will always be NULL or false if every column of iTab
-** is NULL.
-**
-** False negatives are acceptable.  In other words, it is ok to return
-** zero even if expression p will never be true of every column of iTab
-** is NULL.  A false negative is merely a missed optimization opportunity.
-**
-** False positives are not allowed, however.  A false positive may result
-** in an incorrect answer.
-**
-** Terms of p that are marked with EP_FromJoin (and hence that come from
-** the ON or USING clauses of LEFT JOINS) are excluded from the analysis.
-**
-** This routine is used to check if a LEFT JOIN can be converted into
-** an ordinary JOIN.  The p argument is the WHERE clause.  If the WHERE
-** clause requires that some column of the right table of the LEFT JOIN
-** be non-NULL, then the LEFT JOIN can be safely converted into an
-** ordinary join.
-*/
-SQLITE_PRIVATE int sqlite3ExprImpliesNonNullRow(Expr *p, int iTab){
-  Walker w;
+    default: 
+      return WRC_Continue; 
+  } 
+} 
+ 
+/* 
+** Return true (non-zero) if expression p can only be true if at least 
+** one column of table iTab is non-null.  In other words, return true 
+** if expression p will always be NULL or false if every column of iTab 
+** is NULL. 
+** 
+** False negatives are acceptable.  In other words, it is ok to return 
+** zero even if expression p will never be true of every column of iTab 
+** is NULL.  A false negative is merely a missed optimization opportunity. 
+** 
+** False positives are not allowed, however.  A false positive may result 
+** in an incorrect answer. 
+** 
+** Terms of p that are marked with EP_FromJoin (and hence that come from 
+** the ON or USING clauses of LEFT JOINS) are excluded from the analysis. 
+** 
+** This routine is used to check if a LEFT JOIN can be converted into 
+** an ordinary JOIN.  The p argument is the WHERE clause.  If the WHERE 
+** clause requires that some column of the right table of the LEFT JOIN 
+** be non-NULL, then the LEFT JOIN can be safely converted into an 
+** ordinary join. 
+*/ 
+SQLITE_PRIVATE int sqlite3ExprImpliesNonNullRow(Expr *p, int iTab){ 
+  Walker w; 
   p = sqlite3ExprSkipCollateAndLikely(p);
   if( p==0 ) return 0;
   if( p->op==TK_NOTNULL ){
     p = p->pLeft;
   }else{
     while( p->op==TK_AND ){
-      if( sqlite3ExprImpliesNonNullRow(p->pLeft, iTab) ) return 1;
-      p = p->pRight;
-    }
-  }
-  w.xExprCallback = impliesNotNullRow;
-  w.xSelectCallback = 0;
-  w.xSelectCallback2 = 0;
-  w.eCode = 0;
-  w.u.iCur = iTab;
-  sqlite3WalkExpr(&w, p);
-  return w.eCode;
-}
-
-/*
+      if( sqlite3ExprImpliesNonNullRow(p->pLeft, iTab) ) return 1; 
+      p = p->pRight; 
+    } 
+  } 
+  w.xExprCallback = impliesNotNullRow; 
+  w.xSelectCallback = 0; 
+  w.xSelectCallback2 = 0; 
+  w.eCode = 0; 
+  w.u.iCur = iTab; 
+  sqlite3WalkExpr(&w, p); 
+  return w.eCode; 
+} 
+ 
+/* 
 ** An instance of the following structure is used by the tree walker
 ** to determine if an expression can be evaluated by reference to the
 ** index only, without having to do a search for the corresponding
@@ -107741,9 +107741,9 @@ static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
   NameContext *pNC = pWalker->u.pNC;
   Parse *pParse = pNC->pParse;
   SrcList *pSrcList = pNC->pSrcList;
-  AggInfo *pAggInfo = pNC->uNC.pAggInfo;
+  AggInfo *pAggInfo = pNC->uNC.pAggInfo; 
 
-  assert( pNC->ncFlags & NC_UAggInfo );
+  assert( pNC->ncFlags & NC_UAggInfo ); 
   switch( pExpr->op ){
     case TK_AGG_COLUMN:
     case TK_COLUMN: {
@@ -107776,7 +107776,7 @@ static int analyzeAggregate(Walker *pWalker, Expr *pExpr){
             ){
               pCol = &pAggInfo->aCol[k];
               assert( ExprUseYTab(pExpr) );
-              pCol->pTab = pExpr->y.pTab;
+              pCol->pTab = pExpr->y.pTab; 
               pCol->iTable = pExpr->iTable;
               pCol->iColumn = pExpr->iColumn;
               pCol->iMem = ++pParse->nMem;
@@ -107881,7 +107881,7 @@ SQLITE_PRIVATE void sqlite3ExprAnalyzeAggregates(NameContext *pNC, Expr *pExpr){
   w.xSelectCallback2 = sqlite3WalkerDepthDecrease;
   w.walkerDepth = 0;
   w.u.pNC = pNC;
-  w.pParse = 0;
+  w.pParse = 0; 
   assert( pNC->pSrcList!=0 );
   sqlite3WalkExpr(&w, pExpr);
 }
@@ -108015,34 +108015,34 @@ SQLITE_PRIVATE int sqlite3NoTempsInRange(Parse *pParse, int iFirst, int iLast){
 #ifndef SQLITE_OMIT_ALTERTABLE
 
 /*
-** Parameter zName is the name of a table that is about to be altered
-** (either with ALTER TABLE ... RENAME TO or ALTER TABLE ... ADD COLUMN).
-** If the table is a system table, this function leaves an error message
-** in pParse->zErr (system tables may not be altered) and returns non-zero.
+** Parameter zName is the name of a table that is about to be altered 
+** (either with ALTER TABLE ... RENAME TO or ALTER TABLE ... ADD COLUMN). 
+** If the table is a system table, this function leaves an error message 
+** in pParse->zErr (system tables may not be altered) and returns non-zero. 
 **
-** Or, if zName is not a system table, zero is returned.
+** Or, if zName is not a system table, zero is returned. 
 */
-static int isAlterableTable(Parse *pParse, Table *pTab){
+static int isAlterableTable(Parse *pParse, Table *pTab){ 
   if( 0==sqlite3StrNICmp(pTab->zName, "sqlite_", 7)
-#ifndef SQLITE_OMIT_VIRTUALTABLE
+#ifndef SQLITE_OMIT_VIRTUALTABLE 
    || (pTab->tabFlags & TF_Eponymous)!=0
    || ( (pTab->tabFlags & TF_Shadow)!=0
         && sqlite3ReadOnlyShadowTables(pParse->db)
-   )
+   ) 
 #endif
-  ){
-    sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
-    return 1;
+  ){ 
+    sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName); 
+    return 1; 
   }
-  return 0;
+  return 0; 
 }
 
 /*
-** Generate code to verify that the schemas of database zDb and, if
-** bTemp is not true, database "temp", can still be parsed. This is
-** called at the end of the generation of an ALTER TABLE ... RENAME ...
-** statement to ensure that the operation has not rendered any schema
-** objects unusable.
+** Generate code to verify that the schemas of database zDb and, if 
+** bTemp is not true, database "temp", can still be parsed. This is 
+** called at the end of the generation of an ALTER TABLE ... RENAME ... 
+** statement to ensure that the operation has not rendered any schema 
+** objects unusable. 
 */
 static void renameTestSchema(
   Parse *pParse,                  /* Parse context */
@@ -108053,24 +108053,24 @@ static void renameTestSchema(
 ){
   pParse->colNamesSet = 1;
   sqlite3NestedParse(pParse,
-      "SELECT 1 "
+      "SELECT 1 " 
       "FROM \"%w\"." LEGACY_SCHEMA_TABLE " "
-      "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
-      " AND sql NOT LIKE 'create virtual%%'"
+      "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'" 
+      " AND sql NOT LIKE 'create virtual%%'" 
       " AND sqlite_rename_test(%Q, sql, type, name, %d, %Q, %d)=NULL ",
       zDb,
       zDb, bTemp, zWhen, bNoDQS
-  );
+  ); 
 
-  if( bTemp==0 ){
+  if( bTemp==0 ){ 
     sqlite3NestedParse(pParse,
-        "SELECT 1 "
+        "SELECT 1 " 
         "FROM temp." LEGACY_SCHEMA_TABLE " "
-        "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
-        " AND sql NOT LIKE 'create virtual%%'"
+        "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X'" 
+        " AND sql NOT LIKE 'create virtual%%'" 
         " AND sqlite_rename_test(%Q, sql, type, name, 1, %Q, %d)=NULL ",
         zDb, zWhen, bNoDQS
-    );
+    ); 
   }
 }
 
@@ -108099,13 +108099,13 @@ static void renameFixQuotes(Parse *pParse, const char *zDb, int bTemp){
 }
 
 /*
-** Generate code to reload the schema for database iDb. And, if iDb!=1, for
-** the temp database as well.
+** Generate code to reload the schema for database iDb. And, if iDb!=1, for 
+** the temp database as well. 
 */
 static void renameReloadSchema(Parse *pParse, int iDb, u16 p5){
-  Vdbe *v = pParse->pVdbe;
-  if( v ){
-    sqlite3ChangeCookie(pParse, iDb);
+  Vdbe *v = pParse->pVdbe; 
+  if( v ){ 
+    sqlite3ChangeCookie(pParse, iDb); 
     sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0, p5);
     if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0, p5);
   }
@@ -108158,7 +108158,7 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable(
   /* Make sure it is not a system table being altered, or a reserved name
   ** that the table is being renamed to.
   */
-  if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){
+  if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){ 
     goto exit_rename_table;
   }
   if( SQLITE_OK!=sqlite3CheckObjectName(pParse,zName,"table",zName) ){
@@ -108191,46 +108191,46 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable(
   }
 #endif
 
-  /* Begin a transaction for database iDb. Then modify the schema cookie
-  ** (since the ALTER TABLE modifies the schema). Call sqlite3MayAbort(),
+  /* Begin a transaction for database iDb. Then modify the schema cookie 
+  ** (since the ALTER TABLE modifies the schema). Call sqlite3MayAbort(), 
   ** as the scalar functions (e.g. sqlite_rename_table()) invoked by the
-  ** nested SQL may raise an exception.  */
+  ** nested SQL may raise an exception.  */ 
   v = sqlite3GetVdbe(pParse);
   if( v==0 ){
     goto exit_rename_table;
   }
-  sqlite3MayAbort(pParse);
+  sqlite3MayAbort(pParse); 
 
   /* figure out how many UTF-8 characters are in zName */
   zTabName = pTab->zName;
   nTabName = sqlite3Utf8CharLen(zTabName, -1);
 
-  /* Rewrite all CREATE TABLE, INDEX, TRIGGER or VIEW statements in
-  ** the schema to use the new table name.  */
+  /* Rewrite all CREATE TABLE, INDEX, TRIGGER or VIEW statements in 
+  ** the schema to use the new table name.  */ 
   sqlite3NestedParse(pParse,
       "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET "
-      "sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, %d) "
-      "WHERE (type!='index' OR tbl_name=%Q COLLATE nocase)"
-      "AND   name NOT LIKE 'sqliteX_%%' ESCAPE 'X'"
+      "sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, %d) " 
+      "WHERE (type!='index' OR tbl_name=%Q COLLATE nocase)" 
+      "AND   name NOT LIKE 'sqliteX_%%' ESCAPE 'X'" 
       , zDb, zDb, zTabName, zName, (iDb==1), zTabName
-  );
+  ); 
 
   /* Update the tbl_name and name columns of the sqlite_schema table
-  ** as required.  */
+  ** as required.  */ 
   sqlite3NestedParse(pParse,
       "UPDATE %Q." LEGACY_SCHEMA_TABLE " SET "
           "tbl_name = %Q, "
           "name = CASE "
             "WHEN type='table' THEN %Q "
-            "WHEN name LIKE 'sqliteX_autoindex%%' ESCAPE 'X' "
-            "     AND type='index' THEN "
+            "WHEN name LIKE 'sqliteX_autoindex%%' ESCAPE 'X' " 
+            "     AND type='index' THEN " 
              "'sqlite_autoindex_' || %Q || substr(name,%d+18) "
             "ELSE name END "
       "WHERE tbl_name=%Q COLLATE nocase AND "
           "(type='table' OR type='index' OR type='trigger');",
       zDb,
       zName, zName, zName,
-      nTabName, zTabName
+      nTabName, zTabName 
   );
 
 #ifndef SQLITE_OMIT_AUTOINCREMENT
@@ -108244,31 +108244,31 @@ SQLITE_PRIVATE void sqlite3AlterRenameTable(
   }
 #endif
 
-  /* If the table being renamed is not itself part of the temp database,
+  /* If the table being renamed is not itself part of the temp database, 
   ** edit view and trigger definitions within the temp database
-  ** as required.  */
-  if( iDb!=1 ){
+  ** as required.  */ 
+  if( iDb!=1 ){ 
     sqlite3NestedParse(pParse,
         "UPDATE sqlite_temp_schema SET "
-            "sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, 1), "
-            "tbl_name = "
-              "CASE WHEN tbl_name=%Q COLLATE nocase AND "
+            "sql = sqlite_rename_table(%Q, type, name, sql, %Q, %Q, 1), " 
+            "tbl_name = " 
+              "CASE WHEN tbl_name=%Q COLLATE nocase AND " 
               "  sqlite_rename_test(%Q, sql, type, name, 1, 'after rename', 0) "
-              "THEN %Q ELSE tbl_name END "
-            "WHERE type IN ('view', 'trigger')"
-        , zDb, zTabName, zName, zTabName, zDb, zName);
+              "THEN %Q ELSE tbl_name END " 
+            "WHERE type IN ('view', 'trigger')" 
+        , zDb, zTabName, zName, zTabName, zDb, zName); 
   }
 
-  /* If this is a virtual table, invoke the xRename() function if
-  ** one is defined. The xRename() callback will modify the names
-  ** of any resources used by the v-table implementation (including other
-  ** SQLite tables) that are identified by the name of the virtual table.
-  */
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-  if( pVTab ){
-    int i = ++pParse->nMem;
-    sqlite3VdbeLoadString(v, i, zName);
-    sqlite3VdbeAddOp4(v, OP_VRename, i, 0, 0,(const char*)pVTab, P4_VTAB);
+  /* If this is a virtual table, invoke the xRename() function if 
+  ** one is defined. The xRename() callback will modify the names 
+  ** of any resources used by the v-table implementation (including other 
+  ** SQLite tables) that are identified by the name of the virtual table. 
+  */ 
+#ifndef SQLITE_OMIT_VIRTUALTABLE 
+  if( pVTab ){ 
+    int i = ++pParse->nMem; 
+    sqlite3VdbeLoadString(v, i, zName); 
+    sqlite3VdbeAddOp4(v, OP_VRename, i, 0, 0,(const char*)pVTab, P4_VTAB); 
   }
 #endif
 
@@ -108314,7 +108314,7 @@ SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
   Column *pCol;             /* The new column */
   Expr *pDflt;              /* Default value for the new column */
   sqlite3 *db;              /* The database connection; */
-  Vdbe *v;                  /* The prepared statement under construction */
+  Vdbe *v;                  /* The prepared statement under construction */ 
   int r1;                   /* Temporary registers */
 
   db = pParse->db;
@@ -108417,20 +108417,20 @@ SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
     sqlite3DbFree(db, zCol);
   }
 
-  v = sqlite3GetVdbe(pParse);
-  if( v ){
+  v = sqlite3GetVdbe(pParse); 
+  if( v ){ 
     /* Make sure the schema version is at least 3.  But do not upgrade
     ** from less than 3 to 4, as that will corrupt any preexisting DESC
     ** index.
     */
-    r1 = sqlite3GetTempReg(pParse);
-    sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);
-    sqlite3VdbeUsesBtree(v, iDb);
-    sqlite3VdbeAddOp2(v, OP_AddImm, r1, -2);
-    sqlite3VdbeAddOp2(v, OP_IfPos, r1, sqlite3VdbeCurrentAddr(v)+2);
-    VdbeCoverage(v);
-    sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 3);
-    sqlite3ReleaseTempReg(pParse, r1);
+    r1 = sqlite3GetTempReg(pParse); 
+    sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT); 
+    sqlite3VdbeUsesBtree(v, iDb); 
+    sqlite3VdbeAddOp2(v, OP_AddImm, r1, -2); 
+    sqlite3VdbeAddOp2(v, OP_IfPos, r1, sqlite3VdbeCurrentAddr(v)+2); 
+    VdbeCoverage(v); 
+    sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 3); 
+    sqlite3ReleaseTempReg(pParse, r1); 
 
     /* Reload the table definition */
     renameReloadSchema(pParse, iDb, INITFLAG_AlterAdd);
@@ -108449,7 +108449,7 @@ SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
         zTab, zDb
       );
     }
-  }
+  } 
 }
 
 /*
@@ -108494,7 +108494,7 @@ SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
     sqlite3ErrorMsg(pParse, "Cannot add a column to a view");
     goto exit_begin_add_column;
   }
-  if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){
+  if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){ 
     goto exit_begin_add_column;
   }
 
@@ -108540,230 +108540,230 @@ exit_begin_add_column:
   sqlite3SrcListDelete(db, pSrc);
   return;
 }
-
-/*
-** Parameter pTab is the subject of an ALTER TABLE ... RENAME COLUMN
-** command. This function checks if the table is a view or virtual
-** table (columns of views or virtual tables may not be renamed). If so,
-** it loads an error message into pParse and returns non-zero.
-**
-** Or, if pTab is not a view or virtual table, zero is returned.
-*/
-#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
+ 
+/* 
+** Parameter pTab is the subject of an ALTER TABLE ... RENAME COLUMN 
+** command. This function checks if the table is a view or virtual 
+** table (columns of views or virtual tables may not be renamed). If so, 
+** it loads an error message into pParse and returns non-zero. 
+** 
+** Or, if pTab is not a view or virtual table, zero is returned. 
+*/ 
+#if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) 
 static int isRealTable(Parse *pParse, Table *pTab, int bDrop){
-  const char *zType = 0;
-#ifndef SQLITE_OMIT_VIEW
+  const char *zType = 0; 
+#ifndef SQLITE_OMIT_VIEW 
   if( IsView(pTab) ){
-    zType = "view";
-  }
-#endif
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-  if( IsVirtual(pTab) ){
-    zType = "virtual table";
-  }
-#endif
-  if( zType ){
+    zType = "view"; 
+  } 
+#endif 
+#ifndef SQLITE_OMIT_VIRTUALTABLE 
+  if( IsVirtual(pTab) ){ 
+    zType = "virtual table"; 
+  } 
+#endif 
+  if( zType ){ 
     sqlite3ErrorMsg(pParse, "cannot %s %s \"%s\"",
         (bDrop ? "drop column from" : "rename columns of"),
         zType, pTab->zName
-    );
-    return 1;
-  }
-  return 0;
-}
-#else /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */
+    ); 
+    return 1; 
+  } 
+  return 0; 
+} 
+#else /* !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) */ 
 # define isRealTable(x,y,z) (0)
-#endif
-
-/*
-** Handles the following parser reduction:
-**
-**  cmd ::= ALTER TABLE pSrc RENAME COLUMN pOld TO pNew
-*/
-SQLITE_PRIVATE void sqlite3AlterRenameColumn(
-  Parse *pParse,                  /* Parsing context */
-  SrcList *pSrc,                  /* Table being altered.  pSrc->nSrc==1 */
-  Token *pOld,                    /* Name of column being changed */
-  Token *pNew                     /* New column name */
-){
-  sqlite3 *db = pParse->db;       /* Database connection */
-  Table *pTab;                    /* Table being updated */
-  int iCol;                       /* Index of column being renamed */
-  char *zOld = 0;                 /* Old column name */
-  char *zNew = 0;                 /* New column name */
-  const char *zDb;                /* Name of schema containing the table */
-  int iSchema;                    /* Index of the schema */
-  int bQuote;                     /* True to quote the new name */
-
-  /* Locate the table to be altered */
-  pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
-  if( !pTab ) goto exit_rename_column;
-
-  /* Cannot alter a system table */
-  if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_rename_column;
+#endif 
+ 
+/* 
+** Handles the following parser reduction: 
+** 
+**  cmd ::= ALTER TABLE pSrc RENAME COLUMN pOld TO pNew 
+*/ 
+SQLITE_PRIVATE void sqlite3AlterRenameColumn( 
+  Parse *pParse,                  /* Parsing context */ 
+  SrcList *pSrc,                  /* Table being altered.  pSrc->nSrc==1 */ 
+  Token *pOld,                    /* Name of column being changed */ 
+  Token *pNew                     /* New column name */ 
+){ 
+  sqlite3 *db = pParse->db;       /* Database connection */ 
+  Table *pTab;                    /* Table being updated */ 
+  int iCol;                       /* Index of column being renamed */ 
+  char *zOld = 0;                 /* Old column name */ 
+  char *zNew = 0;                 /* New column name */ 
+  const char *zDb;                /* Name of schema containing the table */ 
+  int iSchema;                    /* Index of the schema */ 
+  int bQuote;                     /* True to quote the new name */ 
+ 
+  /* Locate the table to be altered */ 
+  pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]); 
+  if( !pTab ) goto exit_rename_column; 
+ 
+  /* Cannot alter a system table */ 
+  if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_rename_column; 
   if( SQLITE_OK!=isRealTable(pParse, pTab, 0) ) goto exit_rename_column;
-
+ 
   /* Which schema holds the table to be altered */
-  iSchema = sqlite3SchemaToIndex(db, pTab->pSchema);
-  assert( iSchema>=0 );
-  zDb = db->aDb[iSchema].zDbSName;
-
-#ifndef SQLITE_OMIT_AUTHORIZATION
-  /* Invoke the authorization callback. */
-  if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
-    goto exit_rename_column;
-  }
-#endif
-
-  /* Make sure the old name really is a column name in the table to be
-  ** altered.  Set iCol to be the index of the column being renamed */
-  zOld = sqlite3NameFromToken(db, pOld);
-  if( !zOld ) goto exit_rename_column;
-  for(iCol=0; iCol<pTab->nCol; iCol++){
+  iSchema = sqlite3SchemaToIndex(db, pTab->pSchema); 
+  assert( iSchema>=0 ); 
+  zDb = db->aDb[iSchema].zDbSName; 
+ 
+#ifndef SQLITE_OMIT_AUTHORIZATION 
+  /* Invoke the authorization callback. */ 
+  if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){ 
+    goto exit_rename_column; 
+  } 
+#endif 
+ 
+  /* Make sure the old name really is a column name in the table to be 
+  ** altered.  Set iCol to be the index of the column being renamed */ 
+  zOld = sqlite3NameFromToken(db, pOld); 
+  if( !zOld ) goto exit_rename_column; 
+  for(iCol=0; iCol<pTab->nCol; iCol++){ 
     if( 0==sqlite3StrICmp(pTab->aCol[iCol].zCnName, zOld) ) break;
-  }
-  if( iCol==pTab->nCol ){
-    sqlite3ErrorMsg(pParse, "no such column: \"%s\"", zOld);
-    goto exit_rename_column;
-  }
-
+  } 
+  if( iCol==pTab->nCol ){ 
+    sqlite3ErrorMsg(pParse, "no such column: \"%s\"", zOld); 
+    goto exit_rename_column; 
+  } 
+ 
   /* Ensure the schema contains no double-quoted strings */
   renameTestSchema(pParse, zDb, iSchema==1, "", 0);
   renameFixQuotes(pParse, zDb, iSchema==1);
 
-  /* Do the rename operation using a recursive UPDATE statement that
-  ** uses the sqlite_rename_column() SQL function to compute the new
+  /* Do the rename operation using a recursive UPDATE statement that 
+  ** uses the sqlite_rename_column() SQL function to compute the new 
   ** CREATE statement text for the sqlite_schema table.
-  */
-  sqlite3MayAbort(pParse);
-  zNew = sqlite3NameFromToken(db, pNew);
-  if( !zNew ) goto exit_rename_column;
-  assert( pNew->n>0 );
-  bQuote = sqlite3Isquote(pNew->z[0]);
+  */ 
+  sqlite3MayAbort(pParse); 
+  zNew = sqlite3NameFromToken(db, pNew); 
+  if( !zNew ) goto exit_rename_column; 
+  assert( pNew->n>0 ); 
+  bQuote = sqlite3Isquote(pNew->z[0]); 
   sqlite3NestedParse(pParse,
       "UPDATE \"%w\"." LEGACY_SCHEMA_TABLE " SET "
-      "sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, %d) "
-      "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X' "
+      "sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, %d) " 
+      "WHERE name NOT LIKE 'sqliteX_%%' ESCAPE 'X' " 
       " AND (type != 'index' OR tbl_name = %Q)",
       zDb,
-      zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1,
-      pTab->zName
-  );
-
+      zDb, pTab->zName, iCol, zNew, bQuote, iSchema==1, 
+      pTab->zName 
+  ); 
+ 
   sqlite3NestedParse(pParse,
       "UPDATE temp." LEGACY_SCHEMA_TABLE " SET "
-      "sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, 1) "
-      "WHERE type IN ('trigger', 'view')",
-      zDb, pTab->zName, iCol, zNew, bQuote
-  );
-
-  /* Drop and reload the database schema. */
+      "sql = sqlite_rename_column(sql, type, name, %Q, %Q, %d, %Q, %d, 1) " 
+      "WHERE type IN ('trigger', 'view')", 
+      zDb, pTab->zName, iCol, zNew, bQuote 
+  ); 
+ 
+  /* Drop and reload the database schema. */ 
   renameReloadSchema(pParse, iSchema, INITFLAG_AlterRename);
   renameTestSchema(pParse, zDb, iSchema==1, "after rename", 1);
-
- exit_rename_column:
-  sqlite3SrcListDelete(db, pSrc);
-  sqlite3DbFree(db, zOld);
-  sqlite3DbFree(db, zNew);
-  return;
-}
-
-/*
-** Each RenameToken object maps an element of the parse tree into
-** the token that generated that element.  The parse tree element
-** might be one of:
-**
-**     *  A pointer to an Expr that represents an ID
-**     *  The name of a table column in Column.zName
-**
-** A list of RenameToken objects can be constructed during parsing.
-** Each new object is created by sqlite3RenameTokenMap().
-** As the parse tree is transformed, the sqlite3RenameTokenRemap()
-** routine is used to keep the mapping current.
-**
-** After the parse finishes, renameTokenFind() routine can be used
-** to look up the actual token value that created some element in
-** the parse tree.
-*/
-struct RenameToken {
+ 
+ exit_rename_column: 
+  sqlite3SrcListDelete(db, pSrc); 
+  sqlite3DbFree(db, zOld); 
+  sqlite3DbFree(db, zNew); 
+  return; 
+} 
+ 
+/* 
+** Each RenameToken object maps an element of the parse tree into 
+** the token that generated that element.  The parse tree element 
+** might be one of: 
+** 
+**     *  A pointer to an Expr that represents an ID 
+**     *  The name of a table column in Column.zName 
+** 
+** A list of RenameToken objects can be constructed during parsing. 
+** Each new object is created by sqlite3RenameTokenMap(). 
+** As the parse tree is transformed, the sqlite3RenameTokenRemap() 
+** routine is used to keep the mapping current. 
+** 
+** After the parse finishes, renameTokenFind() routine can be used 
+** to look up the actual token value that created some element in 
+** the parse tree. 
+*/ 
+struct RenameToken { 
   const void *p;         /* Parse tree element created by token t */
-  Token t;               /* The token that created parse tree element p */
-  RenameToken *pNext;    /* Next is a list of all RenameToken objects */
-};
-
-/*
-** The context of an ALTER TABLE RENAME COLUMN operation that gets passed
-** down into the Walker.
-*/
-typedef struct RenameCtx RenameCtx;
-struct RenameCtx {
-  RenameToken *pList;             /* List of tokens to overwrite */
-  int nList;                      /* Number of tokens in pList */
-  int iCol;                       /* Index of column being renamed */
+  Token t;               /* The token that created parse tree element p */ 
+  RenameToken *pNext;    /* Next is a list of all RenameToken objects */ 
+}; 
+ 
+/* 
+** The context of an ALTER TABLE RENAME COLUMN operation that gets passed 
+** down into the Walker. 
+*/ 
+typedef struct RenameCtx RenameCtx; 
+struct RenameCtx { 
+  RenameToken *pList;             /* List of tokens to overwrite */ 
+  int nList;                      /* Number of tokens in pList */ 
+  int iCol;                       /* Index of column being renamed */ 
   Table *pTab;                    /* Table being ALTERed */
-  const char *zOld;               /* Old column name */
-};
-
-#ifdef SQLITE_DEBUG
-/*
-** This function is only for debugging. It performs two tasks:
-**
+  const char *zOld;               /* Old column name */ 
+}; 
+ 
+#ifdef SQLITE_DEBUG 
+/* 
+** This function is only for debugging. It performs two tasks: 
+** 
 **   1. Checks that pointer pPtr does not already appear in the
-**      rename-token list.
-**
-**   2. Dereferences each pointer in the rename-token list.
-**
-** The second is most effective when debugging under valgrind or
+**      rename-token list. 
+** 
+**   2. Dereferences each pointer in the rename-token list. 
+** 
+** The second is most effective when debugging under valgrind or 
 ** address-sanitizer or similar. If any of these pointers no longer
 ** point to valid objects, an exception is raised by the memory-checking
-** tool.
-**
-** The point of this is to prevent comparisons of invalid pointer values.
-** Even though this always seems to work, it is undefined according to the
-** C standard. Example of undefined comparison:
-**
-**     sqlite3_free(x);
-**     if( x==y ) ...
-**
-** Technically, as x no longer points into a valid object or to the byte
-** following a valid object, it may not be used in comparison operations.
-*/
+** tool. 
+** 
+** The point of this is to prevent comparisons of invalid pointer values. 
+** Even though this always seems to work, it is undefined according to the 
+** C standard. Example of undefined comparison: 
+** 
+**     sqlite3_free(x); 
+**     if( x==y ) ... 
+** 
+** Technically, as x no longer points into a valid object or to the byte 
+** following a valid object, it may not be used in comparison operations. 
+*/ 
 static void renameTokenCheckAll(Parse *pParse, const void *pPtr){
-  if( pParse->nErr==0 && pParse->db->mallocFailed==0 ){
+  if( pParse->nErr==0 && pParse->db->mallocFailed==0 ){ 
     const RenameToken *p;
-    u8 i = 0;
-    for(p=pParse->pRename; p; p=p->pNext){
-      if( p->p ){
-        assert( p->p!=pPtr );
-        i += *(u8*)(p->p);
-      }
-    }
-  }
-}
-#else
-# define renameTokenCheckAll(x,y)
-#endif
-
-/*
-** Remember that the parser tree element pPtr was created using
-** the token pToken.
-**
-** In other words, construct a new RenameToken object and add it
-** to the list of RenameToken objects currently being built up
-** in pParse->pRename.
-**
-** The pPtr argument is returned so that this routine can be used
-** with tail recursion in tokenExpr() routine, for a small performance
-** improvement.
-*/
+    u8 i = 0; 
+    for(p=pParse->pRename; p; p=p->pNext){ 
+      if( p->p ){ 
+        assert( p->p!=pPtr ); 
+        i += *(u8*)(p->p); 
+      } 
+    } 
+  } 
+} 
+#else 
+# define renameTokenCheckAll(x,y) 
+#endif 
+ 
+/* 
+** Remember that the parser tree element pPtr was created using 
+** the token pToken. 
+** 
+** In other words, construct a new RenameToken object and add it 
+** to the list of RenameToken objects currently being built up 
+** in pParse->pRename. 
+** 
+** The pPtr argument is returned so that this routine can be used 
+** with tail recursion in tokenExpr() routine, for a small performance 
+** improvement. 
+*/ 
 SQLITE_PRIVATE const void *sqlite3RenameTokenMap(
   Parse *pParse,
   const void *pPtr,
   const Token *pToken
 ){
-  RenameToken *pNew;
-  assert( pPtr || pParse->db->mallocFailed );
-  renameTokenCheckAll(pParse, pPtr);
+  RenameToken *pNew; 
+  assert( pPtr || pParse->db->mallocFailed ); 
+  renameTokenCheckAll(pParse, pPtr); 
   if( ALWAYS(pParse->eParseMode!=PARSE_MODE_UNMAP) ){
     pNew = sqlite3DbMallocZero(pParse->db, sizeof(RenameToken));
     if( pNew ){
@@ -108772,40 +108772,40 @@ SQLITE_PRIVATE const void *sqlite3RenameTokenMap(
       pNew->pNext = pParse->pRename;
       pParse->pRename = pNew;
     }
-  }
-
-  return pPtr;
-}
-
-/*
-** It is assumed that there is already a RenameToken object associated
-** with parse tree element pFrom. This function remaps the associated token
-** to parse tree element pTo.
-*/
+  } 
+ 
+  return pPtr; 
+} 
+ 
+/* 
+** It is assumed that there is already a RenameToken object associated 
+** with parse tree element pFrom. This function remaps the associated token 
+** to parse tree element pTo. 
+*/ 
 SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse *pParse, const void *pTo, const void *pFrom){
-  RenameToken *p;
-  renameTokenCheckAll(pParse, pTo);
-  for(p=pParse->pRename; p; p=p->pNext){
-    if( p->p==pFrom ){
-      p->p = pTo;
-      break;
-    }
-  }
-}
-
-/*
-** Walker callback used by sqlite3RenameExprUnmap().
-*/
-static int renameUnmapExprCb(Walker *pWalker, Expr *pExpr){
-  Parse *pParse = pWalker->pParse;
+  RenameToken *p; 
+  renameTokenCheckAll(pParse, pTo); 
+  for(p=pParse->pRename; p; p=p->pNext){ 
+    if( p->p==pFrom ){ 
+      p->p = pTo; 
+      break; 
+    } 
+  } 
+} 
+ 
+/* 
+** Walker callback used by sqlite3RenameExprUnmap(). 
+*/ 
+static int renameUnmapExprCb(Walker *pWalker, Expr *pExpr){ 
+  Parse *pParse = pWalker->pParse; 
   sqlite3RenameTokenRemap(pParse, 0, (const void*)pExpr);
   if( ExprUseYTab(pExpr) ){
     sqlite3RenameTokenRemap(pParse, 0, (const void*)&pExpr->y.pTab);
   }
-  return WRC_Continue;
-}
-
-/*
+  return WRC_Continue; 
+} 
+ 
+/* 
 ** Iterate through the Select objects that are part of WITH clauses attached
 ** to select statement pSelect.
 */
@@ -108857,106 +108857,106 @@ static void unmapColumnIdlistNames(
 }
 
 /*
-** Walker callback used by sqlite3RenameExprUnmap().
-*/
-static int renameUnmapSelectCb(Walker *pWalker, Select *p){
-  Parse *pParse = pWalker->pParse;
-  int i;
+** Walker callback used by sqlite3RenameExprUnmap(). 
+*/ 
+static int renameUnmapSelectCb(Walker *pWalker, Select *p){ 
+  Parse *pParse = pWalker->pParse; 
+  int i; 
   if( pParse->nErr ) return WRC_Abort;
   testcase( p->selFlags & SF_View );
   testcase( p->selFlags & SF_CopyCte );
   if( p->selFlags & (SF_View|SF_CopyCte) ){
     return WRC_Prune;
   }
-  if( ALWAYS(p->pEList) ){
-    ExprList *pList = p->pEList;
-    for(i=0; i<pList->nExpr; i++){
+  if( ALWAYS(p->pEList) ){ 
+    ExprList *pList = p->pEList; 
+    for(i=0; i<pList->nExpr; i++){ 
       if( pList->a[i].zEName && pList->a[i].eEName==ENAME_NAME ){
         sqlite3RenameTokenRemap(pParse, 0, (void*)pList->a[i].zEName);
-      }
-    }
-  }
-  if( ALWAYS(p->pSrc) ){  /* Every Select as a SrcList, even if it is empty */
-    SrcList *pSrc = p->pSrc;
-    for(i=0; i<pSrc->nSrc; i++){
-      sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName);
+      } 
+    } 
+  } 
+  if( ALWAYS(p->pSrc) ){  /* Every Select as a SrcList, even if it is empty */ 
+    SrcList *pSrc = p->pSrc; 
+    for(i=0; i<pSrc->nSrc; i++){ 
+      sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName); 
       sqlite3WalkExpr(pWalker, pSrc->a[i].pOn);
       unmapColumnIdlistNames(pParse, pSrc->a[i].pUsing);
-    }
-  }
+    } 
+  } 
 
   renameWalkWith(pWalker, p);
-  return WRC_Continue;
-}
-
-/*
-** Remove all nodes that are part of expression pExpr from the rename list.
-*/
-SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse *pParse, Expr *pExpr){
+  return WRC_Continue; 
+} 
+ 
+/* 
+** Remove all nodes that are part of expression pExpr from the rename list. 
+*/ 
+SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse *pParse, Expr *pExpr){ 
   u8 eMode = pParse->eParseMode;
-  Walker sWalker;
-  memset(&sWalker, 0, sizeof(Walker));
-  sWalker.pParse = pParse;
-  sWalker.xExprCallback = renameUnmapExprCb;
-  sWalker.xSelectCallback = renameUnmapSelectCb;
+  Walker sWalker; 
+  memset(&sWalker, 0, sizeof(Walker)); 
+  sWalker.pParse = pParse; 
+  sWalker.xExprCallback = renameUnmapExprCb; 
+  sWalker.xSelectCallback = renameUnmapSelectCb; 
   pParse->eParseMode = PARSE_MODE_UNMAP;
-  sqlite3WalkExpr(&sWalker, pExpr);
+  sqlite3WalkExpr(&sWalker, pExpr); 
   pParse->eParseMode = eMode;
-}
-
-/*
+} 
+ 
+/* 
 ** Remove all nodes that are part of expression-list pEList from the
-** rename list.
-*/
-SQLITE_PRIVATE void sqlite3RenameExprlistUnmap(Parse *pParse, ExprList *pEList){
-  if( pEList ){
-    int i;
-    Walker sWalker;
-    memset(&sWalker, 0, sizeof(Walker));
-    sWalker.pParse = pParse;
-    sWalker.xExprCallback = renameUnmapExprCb;
-    sqlite3WalkExprList(&sWalker, pEList);
-    for(i=0; i<pEList->nExpr; i++){
+** rename list. 
+*/ 
+SQLITE_PRIVATE void sqlite3RenameExprlistUnmap(Parse *pParse, ExprList *pEList){ 
+  if( pEList ){ 
+    int i; 
+    Walker sWalker; 
+    memset(&sWalker, 0, sizeof(Walker)); 
+    sWalker.pParse = pParse; 
+    sWalker.xExprCallback = renameUnmapExprCb; 
+    sqlite3WalkExprList(&sWalker, pEList); 
+    for(i=0; i<pEList->nExpr; i++){ 
       if( ALWAYS(pEList->a[i].eEName==ENAME_NAME) ){
         sqlite3RenameTokenRemap(pParse, 0, (void*)pEList->a[i].zEName);
       }
-    }
-  }
-}
-
-/*
-** Free the list of RenameToken objects given in the second argument
-*/
-static void renameTokenFree(sqlite3 *db, RenameToken *pToken){
-  RenameToken *pNext;
-  RenameToken *p;
-  for(p=pToken; p; p=pNext){
-    pNext = p->pNext;
-    sqlite3DbFree(db, p);
-  }
-}
-
-/*
-** Search the Parse object passed as the first argument for a RenameToken
+    } 
+  } 
+} 
+ 
+/* 
+** Free the list of RenameToken objects given in the second argument 
+*/ 
+static void renameTokenFree(sqlite3 *db, RenameToken *pToken){ 
+  RenameToken *pNext; 
+  RenameToken *p; 
+  for(p=pToken; p; p=pNext){ 
+    pNext = p->pNext; 
+    sqlite3DbFree(db, p); 
+  } 
+} 
+ 
+/* 
+** Search the Parse object passed as the first argument for a RenameToken 
 ** object associated with parse tree element pPtr. If found, return a pointer
 ** to it. Otherwise, return NULL.
 **
 ** If the second argument passed to this function is not NULL and a matching
 ** RenameToken object is found, remove it from the Parse object and add it to
 ** the list maintained by the RenameCtx object.
-*/
+*/ 
 static RenameToken *renameTokenFind(
   Parse *pParse,
   struct RenameCtx *pCtx,
   const void *pPtr
 ){
-  RenameToken **pp;
+  RenameToken **pp; 
   if( NEVER(pPtr==0) ){
     return 0;
   }
-  for(pp=&pParse->pRename; (*pp); pp=&(*pp)->pNext){
-    if( (*pp)->p==pPtr ){
-      RenameToken *pToken = *pp;
+  for(pp=&pParse->pRename; (*pp); pp=&(*pp)->pNext){ 
+    if( (*pp)->p==pPtr ){ 
+      RenameToken *pToken = *pp; 
       if( pCtx ){
         *pp = pToken->pNext;
         pToken->pNext = pCtx->pList;
@@ -108964,226 +108964,226 @@ static RenameToken *renameTokenFind(
         pCtx->nList++;
       }
       return pToken;
-    }
-  }
+    } 
+  } 
   return 0;
-}
-
-/*
-** This is a Walker select callback. It does nothing. It is only required
-** because without a dummy callback, sqlite3WalkExpr() and similar do not
-** descend into sub-select statements.
-*/
-static int renameColumnSelectCb(Walker *pWalker, Select *p){
+} 
+ 
+/* 
+** This is a Walker select callback. It does nothing. It is only required 
+** because without a dummy callback, sqlite3WalkExpr() and similar do not 
+** descend into sub-select statements. 
+*/ 
+static int renameColumnSelectCb(Walker *pWalker, Select *p){ 
   if( p->selFlags & (SF_View|SF_CopyCte) ){
     testcase( p->selFlags & SF_View );
     testcase( p->selFlags & SF_CopyCte );
     return WRC_Prune;
   }
-  renameWalkWith(pWalker, p);
-  return WRC_Continue;
-}
-
-/*
-** This is a Walker expression callback.
-**
-** For every TK_COLUMN node in the expression tree, search to see
-** if the column being references is the column being renamed by an
-** ALTER TABLE statement.  If it is, then attach its associated
-** RenameToken object to the list of RenameToken objects being
-** constructed in RenameCtx object at pWalker->u.pRename.
-*/
-static int renameColumnExprCb(Walker *pWalker, Expr *pExpr){
-  RenameCtx *p = pWalker->u.pRename;
+  renameWalkWith(pWalker, p); 
+  return WRC_Continue; 
+} 
+ 
+/* 
+** This is a Walker expression callback. 
+** 
+** For every TK_COLUMN node in the expression tree, search to see 
+** if the column being references is the column being renamed by an 
+** ALTER TABLE statement.  If it is, then attach its associated 
+** RenameToken object to the list of RenameToken objects being 
+** constructed in RenameCtx object at pWalker->u.pRename. 
+*/ 
+static int renameColumnExprCb(Walker *pWalker, Expr *pExpr){ 
+  RenameCtx *p = pWalker->u.pRename; 
   if( pExpr->op==TK_TRIGGER
    && pExpr->iColumn==p->iCol
-   && pWalker->pParse->pTriggerTab==p->pTab
-  ){
-    renameTokenFind(pWalker->pParse, p, (void*)pExpr);
+   && pWalker->pParse->pTriggerTab==p->pTab 
+  ){ 
+    renameTokenFind(pWalker->pParse, p, (void*)pExpr); 
   }else if( pExpr->op==TK_COLUMN
    && pExpr->iColumn==p->iCol
    && ALWAYS(ExprUseYTab(pExpr))
-   && p->pTab==pExpr->y.pTab
-  ){
-    renameTokenFind(pWalker->pParse, p, (void*)pExpr);
-  }
-  return WRC_Continue;
-}
-
-/*
-** The RenameCtx contains a list of tokens that reference a column that
-** is being renamed by an ALTER TABLE statement.  Return the "last"
-** RenameToken in the RenameCtx and remove that RenameToken from the
-** RenameContext.  "Last" means the last RenameToken encountered when
-** the input SQL is parsed from left to right.  Repeated calls to this routine
-** return all column name tokens in the order that they are encountered
-** in the SQL statement.
-*/
-static RenameToken *renameColumnTokenNext(RenameCtx *pCtx){
-  RenameToken *pBest = pCtx->pList;
-  RenameToken *pToken;
-  RenameToken **pp;
-
-  for(pToken=pBest->pNext; pToken; pToken=pToken->pNext){
-    if( pToken->t.z>pBest->t.z ) pBest = pToken;
-  }
-  for(pp=&pCtx->pList; *pp!=pBest; pp=&(*pp)->pNext);
-  *pp = pBest->pNext;
-
-  return pBest;
-}
-
-/*
-** An error occured while parsing or otherwise processing a database
-** object (either pParse->pNewTable, pNewIndex or pNewTrigger) as part of an
-** ALTER TABLE RENAME COLUMN program. The error message emitted by the
-** sub-routine is currently stored in pParse->zErrMsg. This function
-** adds context to the error message and then stores it in pCtx.
-*/
-static void renameColumnParseError(
+   && p->pTab==pExpr->y.pTab 
+  ){ 
+    renameTokenFind(pWalker->pParse, p, (void*)pExpr); 
+  } 
+  return WRC_Continue; 
+} 
+ 
+/* 
+** The RenameCtx contains a list of tokens that reference a column that 
+** is being renamed by an ALTER TABLE statement.  Return the "last" 
+** RenameToken in the RenameCtx and remove that RenameToken from the 
+** RenameContext.  "Last" means the last RenameToken encountered when 
+** the input SQL is parsed from left to right.  Repeated calls to this routine 
+** return all column name tokens in the order that they are encountered 
+** in the SQL statement. 
+*/ 
+static RenameToken *renameColumnTokenNext(RenameCtx *pCtx){ 
+  RenameToken *pBest = pCtx->pList; 
+  RenameToken *pToken; 
+  RenameToken **pp; 
+ 
+  for(pToken=pBest->pNext; pToken; pToken=pToken->pNext){ 
+    if( pToken->t.z>pBest->t.z ) pBest = pToken; 
+  } 
+  for(pp=&pCtx->pList; *pp!=pBest; pp=&(*pp)->pNext); 
+  *pp = pBest->pNext; 
+ 
+  return pBest; 
+} 
+ 
+/* 
+** An error occured while parsing or otherwise processing a database 
+** object (either pParse->pNewTable, pNewIndex or pNewTrigger) as part of an 
+** ALTER TABLE RENAME COLUMN program. The error message emitted by the 
+** sub-routine is currently stored in pParse->zErrMsg. This function 
+** adds context to the error message and then stores it in pCtx. 
+*/ 
+static void renameColumnParseError( 
   sqlite3_context *pCtx,
   const char *zWhen,
-  sqlite3_value *pType,
-  sqlite3_value *pObject,
-  Parse *pParse
-){
-  const char *zT = (const char*)sqlite3_value_text(pType);
-  const char *zN = (const char*)sqlite3_value_text(pObject);
-  char *zErr;
-
+  sqlite3_value *pType, 
+  sqlite3_value *pObject, 
+  Parse *pParse 
+){ 
+  const char *zT = (const char*)sqlite3_value_text(pType); 
+  const char *zN = (const char*)sqlite3_value_text(pObject); 
+  char *zErr; 
+ 
   zErr = sqlite3_mprintf("error in %s %s%s%s: %s",
       zT, zN, (zWhen[0] ? " " : ""), zWhen,
-      pParse->zErrMsg
-  );
-  sqlite3_result_error(pCtx, zErr, -1);
-  sqlite3_free(zErr);
-}
-
-/*
-** For each name in the the expression-list pEList (i.e. each
+      pParse->zErrMsg 
+  ); 
+  sqlite3_result_error(pCtx, zErr, -1); 
+  sqlite3_free(zErr); 
+} 
+ 
+/* 
+** For each name in the the expression-list pEList (i.e. each 
 ** pEList->a[i].zName) that matches the string in zOld, extract the
-** corresponding rename-token from Parse object pParse and add it
-** to the RenameCtx pCtx.
-*/
-static void renameColumnElistNames(
+** corresponding rename-token from Parse object pParse and add it 
+** to the RenameCtx pCtx. 
+*/ 
+static void renameColumnElistNames( 
   Parse *pParse,
   RenameCtx *pCtx,
   const ExprList *pEList,
-  const char *zOld
-){
-  if( pEList ){
-    int i;
-    for(i=0; i<pEList->nExpr; i++){
+  const char *zOld 
+){ 
+  if( pEList ){ 
+    int i; 
+    for(i=0; i<pEList->nExpr; i++){ 
       const char *zName = pEList->a[i].zEName;
       if( ALWAYS(pEList->a[i].eEName==ENAME_NAME)
        && ALWAYS(zName!=0)
        && 0==sqlite3_stricmp(zName, zOld)
       ){
         renameTokenFind(pParse, pCtx, (const void*)zName);
-      }
-    }
-  }
-}
-
-/*
+      } 
+    } 
+  } 
+} 
+ 
+/* 
 ** For each name in the the id-list pIdList (i.e. each pIdList->a[i].zName)
 ** that matches the string in zOld, extract the corresponding rename-token
-** from Parse object pParse and add it to the RenameCtx pCtx.
-*/
-static void renameColumnIdlistNames(
+** from Parse object pParse and add it to the RenameCtx pCtx. 
+*/ 
+static void renameColumnIdlistNames( 
   Parse *pParse,
   RenameCtx *pCtx,
   const IdList *pIdList,
-  const char *zOld
-){
-  if( pIdList ){
-    int i;
-    for(i=0; i<pIdList->nId; i++){
+  const char *zOld 
+){ 
+  if( pIdList ){ 
+    int i; 
+    for(i=0; i<pIdList->nId; i++){ 
       const char *zName = pIdList->a[i].zName;
-      if( 0==sqlite3_stricmp(zName, zOld) ){
+      if( 0==sqlite3_stricmp(zName, zOld) ){ 
         renameTokenFind(pParse, pCtx, (const void*)zName);
-      }
-    }
-  }
-}
-
-
-/*
-** Parse the SQL statement zSql using Parse object (*p). The Parse object
-** is initialized by this function before it is used.
-*/
-static int renameParseSql(
-  Parse *p,                       /* Memory to use for Parse object */
-  const char *zDb,                /* Name of schema SQL belongs to */
-  sqlite3 *db,                    /* Database handle */
-  const char *zSql,               /* SQL to parse */
-  int bTemp                       /* True if SQL is from temp schema */
-){
-  int rc;
-  char *zErr = 0;
-
-  db->init.iDb = bTemp ? 1 : sqlite3FindDbName(db, zDb);
-
-  /* Parse the SQL statement passed as the first argument. If no error
-  ** occurs and the parse does not result in a new table, index or
-  ** trigger object, the database must be corrupt. */
-  memset(p, 0, sizeof(Parse));
+      } 
+    } 
+  } 
+} 
+ 
+
+/* 
+** Parse the SQL statement zSql using Parse object (*p). The Parse object 
+** is initialized by this function before it is used. 
+*/ 
+static int renameParseSql( 
+  Parse *p,                       /* Memory to use for Parse object */ 
+  const char *zDb,                /* Name of schema SQL belongs to */ 
+  sqlite3 *db,                    /* Database handle */ 
+  const char *zSql,               /* SQL to parse */ 
+  int bTemp                       /* True if SQL is from temp schema */ 
+){ 
+  int rc; 
+  char *zErr = 0; 
+ 
+  db->init.iDb = bTemp ? 1 : sqlite3FindDbName(db, zDb); 
+ 
+  /* Parse the SQL statement passed as the first argument. If no error 
+  ** occurs and the parse does not result in a new table, index or 
+  ** trigger object, the database must be corrupt. */ 
+  memset(p, 0, sizeof(Parse)); 
   p->eParseMode = PARSE_MODE_RENAME;
-  p->db = db;
-  p->nQueryLoop = 1;
+  p->db = db; 
+  p->nQueryLoop = 1; 
   rc = zSql ? sqlite3RunParser(p, zSql, &zErr) : SQLITE_NOMEM;
-  assert( p->zErrMsg==0 );
-  assert( rc!=SQLITE_OK || zErr==0 );
-  p->zErrMsg = zErr;
-  if( db->mallocFailed ) rc = SQLITE_NOMEM;
+  assert( p->zErrMsg==0 ); 
+  assert( rc!=SQLITE_OK || zErr==0 ); 
+  p->zErrMsg = zErr; 
+  if( db->mallocFailed ) rc = SQLITE_NOMEM; 
   if( rc==SQLITE_OK
    && p->pNewTable==0 && p->pNewIndex==0 && p->pNewTrigger==0
-  ){
-    rc = SQLITE_CORRUPT_BKPT;
-  }
-
-#ifdef SQLITE_DEBUG
-  /* Ensure that all mappings in the Parse.pRename list really do map to
-  ** a part of the input string.  */
-  if( rc==SQLITE_OK ){
-    int nSql = sqlite3Strlen30(zSql);
-    RenameToken *pToken;
-    for(pToken=p->pRename; pToken; pToken=pToken->pNext){
-      assert( pToken->t.z>=zSql && &pToken->t.z[pToken->t.n]<=&zSql[nSql] );
-    }
-  }
-#endif
-
-  db->init.iDb = 0;
-  return rc;
-}
-
-/*
-** This function edits SQL statement zSql, replacing each token identified
-** by the linked list pRename with the text of zNew. If argument bQuote is
-** true, then zNew is always quoted first. If no error occurs, the result
-** is loaded into context object pCtx as the result.
-**
-** Or, if an error occurs (i.e. an OOM condition), an error is left in
-** pCtx and an SQLite error code returned.
-*/
-static int renameEditSql(
-  sqlite3_context *pCtx,          /* Return result here */
-  RenameCtx *pRename,             /* Rename context */
-  const char *zSql,               /* SQL statement to edit */
-  const char *zNew,               /* New token text */
-  int bQuote                      /* True to always quote token */
-){
+  ){ 
+    rc = SQLITE_CORRUPT_BKPT; 
+  } 
+ 
+#ifdef SQLITE_DEBUG 
+  /* Ensure that all mappings in the Parse.pRename list really do map to 
+  ** a part of the input string.  */ 
+  if( rc==SQLITE_OK ){ 
+    int nSql = sqlite3Strlen30(zSql); 
+    RenameToken *pToken; 
+    for(pToken=p->pRename; pToken; pToken=pToken->pNext){ 
+      assert( pToken->t.z>=zSql && &pToken->t.z[pToken->t.n]<=&zSql[nSql] ); 
+    } 
+  } 
+#endif 
+ 
+  db->init.iDb = 0; 
+  return rc; 
+} 
+ 
+/* 
+** This function edits SQL statement zSql, replacing each token identified 
+** by the linked list pRename with the text of zNew. If argument bQuote is 
+** true, then zNew is always quoted first. If no error occurs, the result 
+** is loaded into context object pCtx as the result. 
+** 
+** Or, if an error occurs (i.e. an OOM condition), an error is left in 
+** pCtx and an SQLite error code returned. 
+*/ 
+static int renameEditSql( 
+  sqlite3_context *pCtx,          /* Return result here */ 
+  RenameCtx *pRename,             /* Rename context */ 
+  const char *zSql,               /* SQL statement to edit */ 
+  const char *zNew,               /* New token text */ 
+  int bQuote                      /* True to always quote token */ 
+){ 
   i64 nNew = sqlite3Strlen30(zNew);
   i64 nSql = sqlite3Strlen30(zSql);
-  sqlite3 *db = sqlite3_context_db_handle(pCtx);
-  int rc = SQLITE_OK;
+  sqlite3 *db = sqlite3_context_db_handle(pCtx); 
+  int rc = SQLITE_OK; 
   char *zQuot = 0;
-  char *zOut;
+  char *zOut; 
   i64 nQuot = 0;
   char *zBuf1 = 0;
   char *zBuf2 = 0;
-
+ 
   if( zNew ){
     /* Set zQuot to point to a buffer containing a quoted copy of the
     ** identifier zNew. If the corresponding identifier in the original
@@ -109199,27 +109199,27 @@ static int renameEditSql(
 
     assert( nQuot>=nNew );
     zOut = sqlite3DbMallocZero(db, nSql + pRename->nList*nQuot + 1);
-  }else{
+  }else{ 
     zOut = (char*)sqlite3DbMallocZero(db, (nSql*2+1) * 3);
     if( zOut ){
       zBuf1 = &zOut[nSql*2+1];
       zBuf2 = &zOut[nSql*4+2];
     }
-  }
-
-  /* At this point pRename->pList contains a list of RenameToken objects
-  ** corresponding to all tokens in the input SQL that must be replaced
+  } 
+ 
+  /* At this point pRename->pList contains a list of RenameToken objects 
+  ** corresponding to all tokens in the input SQL that must be replaced 
   ** with the new column name, or with single-quoted versions of themselves.
   ** All that remains is to construct and return the edited SQL string. */
-  if( zOut ){
-    int nOut = nSql;
-    memcpy(zOut, zSql, nSql);
-    while( pRename->pList ){
-      int iOff;                   /* Offset of token to replace in zOut */
+  if( zOut ){ 
+    int nOut = nSql; 
+    memcpy(zOut, zSql, nSql); 
+    while( pRename->pList ){ 
+      int iOff;                   /* Offset of token to replace in zOut */ 
       u32 nReplace;
       const char *zReplace;
-      RenameToken *pBest = renameColumnTokenNext(pRename);
-
+      RenameToken *pBest = renameColumnTokenNext(pRename); 
+ 
       if( zNew ){
         if( bQuote==0 && sqlite3IsIdChar(*pBest->t.z) ){
           nReplace = nNew;
@@ -109229,7 +109229,7 @@ static int renameEditSql(
           zReplace = zQuot;
           if( pBest->t.z[pBest->t.n]=='"' ) nReplace++;
         }
-      }else{
+      }else{ 
         /* Dequote the double-quoted token. Then requote it again, this time
         ** using single quotes. If the character immediately following the
         ** original token within the input SQL was a single quote ('), then
@@ -109244,67 +109244,67 @@ static int renameEditSql(
         );
         zReplace = zBuf2;
         nReplace = sqlite3Strlen30(zReplace);
-      }
-
-      iOff = pBest->t.z - zSql;
-      if( pBest->t.n!=nReplace ){
+      } 
+ 
+      iOff = pBest->t.z - zSql; 
+      if( pBest->t.n!=nReplace ){ 
         memmove(&zOut[iOff + nReplace], &zOut[iOff + pBest->t.n],
-            nOut - (iOff + pBest->t.n)
-        );
-        nOut += nReplace - pBest->t.n;
-        zOut[nOut] = '\0';
-      }
-      memcpy(&zOut[iOff], zReplace, nReplace);
-      sqlite3DbFree(db, pBest);
-    }
-
-    sqlite3_result_text(pCtx, zOut, -1, SQLITE_TRANSIENT);
-    sqlite3DbFree(db, zOut);
-  }else{
-    rc = SQLITE_NOMEM;
-  }
-
-  sqlite3_free(zQuot);
-  return rc;
-}
-
-/*
-** Resolve all symbols in the trigger at pParse->pNewTrigger, assuming
+            nOut - (iOff + pBest->t.n) 
+        ); 
+        nOut += nReplace - pBest->t.n; 
+        zOut[nOut] = '\0'; 
+      } 
+      memcpy(&zOut[iOff], zReplace, nReplace); 
+      sqlite3DbFree(db, pBest); 
+    } 
+ 
+    sqlite3_result_text(pCtx, zOut, -1, SQLITE_TRANSIENT); 
+    sqlite3DbFree(db, zOut); 
+  }else{ 
+    rc = SQLITE_NOMEM; 
+  } 
+ 
+  sqlite3_free(zQuot); 
+  return rc; 
+} 
+ 
+/* 
+** Resolve all symbols in the trigger at pParse->pNewTrigger, assuming 
 ** it was read from the schema of database zDb. Return SQLITE_OK if
-** successful. Otherwise, return an SQLite error code and leave an error
-** message in the Parse object.
-*/
+** successful. Otherwise, return an SQLite error code and leave an error 
+** message in the Parse object. 
+*/ 
 static int renameResolveTrigger(Parse *pParse){
-  sqlite3 *db = pParse->db;
-  Trigger *pNew = pParse->pNewTrigger;
-  TriggerStep *pStep;
-  NameContext sNC;
-  int rc = SQLITE_OK;
-
-  memset(&sNC, 0, sizeof(sNC));
-  sNC.pParse = pParse;
-  assert( pNew->pTabSchema );
+  sqlite3 *db = pParse->db; 
+  Trigger *pNew = pParse->pNewTrigger; 
+  TriggerStep *pStep; 
+  NameContext sNC; 
+  int rc = SQLITE_OK; 
+ 
+  memset(&sNC, 0, sizeof(sNC)); 
+  sNC.pParse = pParse; 
+  assert( pNew->pTabSchema ); 
   pParse->pTriggerTab = sqlite3FindTable(db, pNew->table,
-      db->aDb[sqlite3SchemaToIndex(db, pNew->pTabSchema)].zDbSName
-  );
-  pParse->eTriggerOp = pNew->op;
-  /* ALWAYS() because if the table of the trigger does not exist, the
-  ** error would have been hit before this point */
-  if( ALWAYS(pParse->pTriggerTab) ){
-    rc = sqlite3ViewGetColumnNames(pParse, pParse->pTriggerTab);
-  }
-
-  /* Resolve symbols in WHEN clause */
-  if( rc==SQLITE_OK && pNew->pWhen ){
-    rc = sqlite3ResolveExprNames(&sNC, pNew->pWhen);
-  }
-
-  for(pStep=pNew->step_list; rc==SQLITE_OK && pStep; pStep=pStep->pNext){
-    if( pStep->pSelect ){
-      sqlite3SelectPrep(pParse, pStep->pSelect, &sNC);
-      if( pParse->nErr ) rc = pParse->rc;
-    }
-    if( rc==SQLITE_OK && pStep->zTarget ){
+      db->aDb[sqlite3SchemaToIndex(db, pNew->pTabSchema)].zDbSName 
+  ); 
+  pParse->eTriggerOp = pNew->op; 
+  /* ALWAYS() because if the table of the trigger does not exist, the 
+  ** error would have been hit before this point */ 
+  if( ALWAYS(pParse->pTriggerTab) ){ 
+    rc = sqlite3ViewGetColumnNames(pParse, pParse->pTriggerTab); 
+  } 
+ 
+  /* Resolve symbols in WHEN clause */ 
+  if( rc==SQLITE_OK && pNew->pWhen ){ 
+    rc = sqlite3ResolveExprNames(&sNC, pNew->pWhen); 
+  } 
+ 
+  for(pStep=pNew->step_list; rc==SQLITE_OK && pStep; pStep=pStep->pNext){ 
+    if( pStep->pSelect ){ 
+      sqlite3SelectPrep(pParse, pStep->pSelect, &sNC); 
+      if( pParse->nErr ) rc = pParse->rc; 
+    } 
+    if( rc==SQLITE_OK && pStep->zTarget ){ 
       SrcList *pSrc = sqlite3TriggerStepSrc(pParse, pStep);
       if( pSrc ){
         int i;
@@ -109332,201 +109332,201 @@ static int renameResolveTrigger(Parse *pParse){
         }
         sNC.pSrcList = pSrc;
         if( rc==SQLITE_OK && pStep->pWhere ){
-          rc = sqlite3ResolveExprNames(&sNC, pStep->pWhere);
-        }
-        if( rc==SQLITE_OK ){
-          rc = sqlite3ResolveExprListNames(&sNC, pStep->pExprList);
-        }
-        assert( !pStep->pUpsert || (!pStep->pWhere && !pStep->pExprList) );
+          rc = sqlite3ResolveExprNames(&sNC, pStep->pWhere); 
+        } 
+        if( rc==SQLITE_OK ){ 
+          rc = sqlite3ResolveExprListNames(&sNC, pStep->pExprList); 
+        } 
+        assert( !pStep->pUpsert || (!pStep->pWhere && !pStep->pExprList) ); 
         if( pStep->pUpsert && rc==SQLITE_OK ){
-          Upsert *pUpsert = pStep->pUpsert;
+          Upsert *pUpsert = pStep->pUpsert; 
           pUpsert->pUpsertSrc = pSrc;
-          sNC.uNC.pUpsert = pUpsert;
-          sNC.ncFlags = NC_UUpsert;
-          rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget);
-          if( rc==SQLITE_OK ){
-            ExprList *pUpsertSet = pUpsert->pUpsertSet;
-            rc = sqlite3ResolveExprListNames(&sNC, pUpsertSet);
-          }
-          if( rc==SQLITE_OK ){
-            rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertWhere);
-          }
-          if( rc==SQLITE_OK ){
-            rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertTargetWhere);
-          }
-          sNC.ncFlags = 0;
-        }
-        sNC.pSrcList = 0;
+          sNC.uNC.pUpsert = pUpsert; 
+          sNC.ncFlags = NC_UUpsert; 
+          rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget); 
+          if( rc==SQLITE_OK ){ 
+            ExprList *pUpsertSet = pUpsert->pUpsertSet; 
+            rc = sqlite3ResolveExprListNames(&sNC, pUpsertSet); 
+          } 
+          if( rc==SQLITE_OK ){ 
+            rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertWhere); 
+          } 
+          if( rc==SQLITE_OK ){ 
+            rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertTargetWhere); 
+          } 
+          sNC.ncFlags = 0; 
+        } 
+        sNC.pSrcList = 0; 
         sqlite3SrcListDelete(db, pSrc);
       }else{
         rc = SQLITE_NOMEM;
-      }
-    }
-  }
-  return rc;
-}
-
-/*
-** Invoke sqlite3WalkExpr() or sqlite3WalkSelect() on all Select or Expr
-** objects that are part of the trigger passed as the second argument.
-*/
-static void renameWalkTrigger(Walker *pWalker, Trigger *pTrigger){
-  TriggerStep *pStep;
-
-  /* Find tokens to edit in WHEN clause */
-  sqlite3WalkExpr(pWalker, pTrigger->pWhen);
-
-  /* Find tokens to edit in trigger steps */
-  for(pStep=pTrigger->step_list; pStep; pStep=pStep->pNext){
-    sqlite3WalkSelect(pWalker, pStep->pSelect);
-    sqlite3WalkExpr(pWalker, pStep->pWhere);
-    sqlite3WalkExprList(pWalker, pStep->pExprList);
-    if( pStep->pUpsert ){
-      Upsert *pUpsert = pStep->pUpsert;
-      sqlite3WalkExprList(pWalker, pUpsert->pUpsertTarget);
-      sqlite3WalkExprList(pWalker, pUpsert->pUpsertSet);
-      sqlite3WalkExpr(pWalker, pUpsert->pUpsertWhere);
-      sqlite3WalkExpr(pWalker, pUpsert->pUpsertTargetWhere);
-    }
+      } 
+    } 
+  } 
+  return rc; 
+} 
+ 
+/* 
+** Invoke sqlite3WalkExpr() or sqlite3WalkSelect() on all Select or Expr 
+** objects that are part of the trigger passed as the second argument. 
+*/ 
+static void renameWalkTrigger(Walker *pWalker, Trigger *pTrigger){ 
+  TriggerStep *pStep; 
+ 
+  /* Find tokens to edit in WHEN clause */ 
+  sqlite3WalkExpr(pWalker, pTrigger->pWhen); 
+ 
+  /* Find tokens to edit in trigger steps */ 
+  for(pStep=pTrigger->step_list; pStep; pStep=pStep->pNext){ 
+    sqlite3WalkSelect(pWalker, pStep->pSelect); 
+    sqlite3WalkExpr(pWalker, pStep->pWhere); 
+    sqlite3WalkExprList(pWalker, pStep->pExprList); 
+    if( pStep->pUpsert ){ 
+      Upsert *pUpsert = pStep->pUpsert; 
+      sqlite3WalkExprList(pWalker, pUpsert->pUpsertTarget); 
+      sqlite3WalkExprList(pWalker, pUpsert->pUpsertSet); 
+      sqlite3WalkExpr(pWalker, pUpsert->pUpsertWhere); 
+      sqlite3WalkExpr(pWalker, pUpsert->pUpsertTargetWhere); 
+    } 
     if( pStep->pFrom ){
       int i;
       for(i=0; i<pStep->pFrom->nSrc; i++){
         sqlite3WalkSelect(pWalker, pStep->pFrom->a[i].pSelect);
       }
     }
-  }
-}
-
-/*
-** Free the contents of Parse object (*pParse). Do not free the memory
-** occupied by the Parse object itself.
-*/
-static void renameParseCleanup(Parse *pParse){
-  sqlite3 *db = pParse->db;
-  Index *pIdx;
-  if( pParse->pVdbe ){
-    sqlite3VdbeFinalize(pParse->pVdbe);
-  }
-  sqlite3DeleteTable(db, pParse->pNewTable);
-  while( (pIdx = pParse->pNewIndex)!=0 ){
-    pParse->pNewIndex = pIdx->pNext;
-    sqlite3FreeIndex(db, pIdx);
-  }
-  sqlite3DeleteTrigger(db, pParse->pNewTrigger);
-  sqlite3DbFree(db, pParse->zErrMsg);
-  renameTokenFree(db, pParse->pRename);
-  sqlite3ParserReset(pParse);
-}
-
-/*
-** SQL function:
-**
-**     sqlite_rename_column(zSql, iCol, bQuote, zNew, zTable, zOld)
-**
-**   0. zSql:     SQL statement to rewrite
-**   1. type:     Type of object ("table", "view" etc.)
-**   2. object:   Name of object
-**   3. Database: Database name (e.g. "main")
-**   4. Table:    Table name
-**   5. iCol:     Index of column to rename
-**   6. zNew:     New column name
-**   7. bQuote:   Non-zero if the new column name should be quoted.
-**   8. bTemp:    True if zSql comes from temp schema
-**
-** Do a column rename operation on the CREATE statement given in zSql.
-** The iCol-th column (left-most is 0) of table zTable is renamed from zCol
-** into zNew.  The name should be quoted if bQuote is true.
-**
-** This function is used internally by the ALTER TABLE RENAME COLUMN command.
-** It is only accessible to SQL created using sqlite3NestedParse().  It is
-** not reachable from ordinary SQL passed into sqlite3_prepare().
-*/
-static void renameColumnFunc(
-  sqlite3_context *context,
-  int NotUsed,
-  sqlite3_value **argv
-){
-  sqlite3 *db = sqlite3_context_db_handle(context);
-  RenameCtx sCtx;
-  const char *zSql = (const char*)sqlite3_value_text(argv[0]);
-  const char *zDb = (const char*)sqlite3_value_text(argv[3]);
-  const char *zTable = (const char*)sqlite3_value_text(argv[4]);
-  int iCol = sqlite3_value_int(argv[5]);
-  const char *zNew = (const char*)sqlite3_value_text(argv[6]);
-  int bQuote = sqlite3_value_int(argv[7]);
-  int bTemp = sqlite3_value_int(argv[8]);
-  const char *zOld;
-  int rc;
-  Parse sParse;
-  Walker sWalker;
-  Index *pIdx;
-  int i;
-  Table *pTab;
-#ifndef SQLITE_OMIT_AUTHORIZATION
-  sqlite3_xauth xAuth = db->xAuth;
-#endif
-
-  UNUSED_PARAMETER(NotUsed);
-  if( zSql==0 ) return;
-  if( zTable==0 ) return;
-  if( zNew==0 ) return;
-  if( iCol<0 ) return;
-  sqlite3BtreeEnterAll(db);
-  pTab = sqlite3FindTable(db, zTable, zDb);
-  if( pTab==0 || iCol>=pTab->nCol ){
-    sqlite3BtreeLeaveAll(db);
-    return;
-  }
+  } 
+} 
+ 
+/* 
+** Free the contents of Parse object (*pParse). Do not free the memory 
+** occupied by the Parse object itself. 
+*/ 
+static void renameParseCleanup(Parse *pParse){ 
+  sqlite3 *db = pParse->db; 
+  Index *pIdx; 
+  if( pParse->pVdbe ){ 
+    sqlite3VdbeFinalize(pParse->pVdbe); 
+  } 
+  sqlite3DeleteTable(db, pParse->pNewTable); 
+  while( (pIdx = pParse->pNewIndex)!=0 ){ 
+    pParse->pNewIndex = pIdx->pNext; 
+    sqlite3FreeIndex(db, pIdx); 
+  } 
+  sqlite3DeleteTrigger(db, pParse->pNewTrigger); 
+  sqlite3DbFree(db, pParse->zErrMsg); 
+  renameTokenFree(db, pParse->pRename); 
+  sqlite3ParserReset(pParse); 
+} 
+ 
+/* 
+** SQL function: 
+** 
+**     sqlite_rename_column(zSql, iCol, bQuote, zNew, zTable, zOld) 
+** 
+**   0. zSql:     SQL statement to rewrite 
+**   1. type:     Type of object ("table", "view" etc.) 
+**   2. object:   Name of object 
+**   3. Database: Database name (e.g. "main") 
+**   4. Table:    Table name 
+**   5. iCol:     Index of column to rename 
+**   6. zNew:     New column name 
+**   7. bQuote:   Non-zero if the new column name should be quoted. 
+**   8. bTemp:    True if zSql comes from temp schema 
+** 
+** Do a column rename operation on the CREATE statement given in zSql. 
+** The iCol-th column (left-most is 0) of table zTable is renamed from zCol 
+** into zNew.  The name should be quoted if bQuote is true. 
+** 
+** This function is used internally by the ALTER TABLE RENAME COLUMN command. 
+** It is only accessible to SQL created using sqlite3NestedParse().  It is 
+** not reachable from ordinary SQL passed into sqlite3_prepare(). 
+*/ 
+static void renameColumnFunc( 
+  sqlite3_context *context, 
+  int NotUsed, 
+  sqlite3_value **argv 
+){ 
+  sqlite3 *db = sqlite3_context_db_handle(context); 
+  RenameCtx sCtx; 
+  const char *zSql = (const char*)sqlite3_value_text(argv[0]); 
+  const char *zDb = (const char*)sqlite3_value_text(argv[3]); 
+  const char *zTable = (const char*)sqlite3_value_text(argv[4]); 
+  int iCol = sqlite3_value_int(argv[5]); 
+  const char *zNew = (const char*)sqlite3_value_text(argv[6]); 
+  int bQuote = sqlite3_value_int(argv[7]); 
+  int bTemp = sqlite3_value_int(argv[8]); 
+  const char *zOld; 
+  int rc; 
+  Parse sParse; 
+  Walker sWalker; 
+  Index *pIdx; 
+  int i; 
+  Table *pTab; 
+#ifndef SQLITE_OMIT_AUTHORIZATION 
+  sqlite3_xauth xAuth = db->xAuth; 
+#endif 
+ 
+  UNUSED_PARAMETER(NotUsed); 
+  if( zSql==0 ) return; 
+  if( zTable==0 ) return; 
+  if( zNew==0 ) return; 
+  if( iCol<0 ) return; 
+  sqlite3BtreeEnterAll(db); 
+  pTab = sqlite3FindTable(db, zTable, zDb); 
+  if( pTab==0 || iCol>=pTab->nCol ){ 
+    sqlite3BtreeLeaveAll(db); 
+    return; 
+  } 
   zOld = pTab->aCol[iCol].zCnName;
-  memset(&sCtx, 0, sizeof(sCtx));
-  sCtx.iCol = ((iCol==pTab->iPKey) ? -1 : iCol);
-
-#ifndef SQLITE_OMIT_AUTHORIZATION
-  db->xAuth = 0;
-#endif
+  memset(&sCtx, 0, sizeof(sCtx)); 
+  sCtx.iCol = ((iCol==pTab->iPKey) ? -1 : iCol); 
+ 
+#ifndef SQLITE_OMIT_AUTHORIZATION 
+  db->xAuth = 0; 
+#endif 
   rc = renameParseSql(&sParse, zDb, db, zSql, bTemp);
-
-  /* Find tokens that need to be replaced. */
-  memset(&sWalker, 0, sizeof(Walker));
-  sWalker.pParse = &sParse;
-  sWalker.xExprCallback = renameColumnExprCb;
-  sWalker.xSelectCallback = renameColumnSelectCb;
-  sWalker.u.pRename = &sCtx;
-
-  sCtx.pTab = pTab;
-  if( rc!=SQLITE_OK ) goto renameColumnFunc_done;
-  if( sParse.pNewTable ){
+ 
+  /* Find tokens that need to be replaced. */ 
+  memset(&sWalker, 0, sizeof(Walker)); 
+  sWalker.pParse = &sParse; 
+  sWalker.xExprCallback = renameColumnExprCb; 
+  sWalker.xSelectCallback = renameColumnSelectCb; 
+  sWalker.u.pRename = &sCtx; 
+ 
+  sCtx.pTab = pTab; 
+  if( rc!=SQLITE_OK ) goto renameColumnFunc_done; 
+  if( sParse.pNewTable ){ 
     if( IsView(sParse.pNewTable) ){
       Select *pSelect = sParse.pNewTable->u.view.pSelect;
       pSelect->selFlags &= ~SF_View;
-      sParse.rc = SQLITE_OK;
+      sParse.rc = SQLITE_OK; 
       sqlite3SelectPrep(&sParse, pSelect, 0);
-      rc = (db->mallocFailed ? SQLITE_NOMEM : sParse.rc);
-      if( rc==SQLITE_OK ){
-        sqlite3WalkSelect(&sWalker, pSelect);
-      }
-      if( rc!=SQLITE_OK ) goto renameColumnFunc_done;
+      rc = (db->mallocFailed ? SQLITE_NOMEM : sParse.rc); 
+      if( rc==SQLITE_OK ){ 
+        sqlite3WalkSelect(&sWalker, pSelect); 
+      } 
+      if( rc!=SQLITE_OK ) goto renameColumnFunc_done; 
     }else if( IsOrdinaryTable(sParse.pNewTable) ){
-      /* A regular table */
-      int bFKOnly = sqlite3_stricmp(zTable, sParse.pNewTable->zName);
-      FKey *pFKey;
-      sCtx.pTab = sParse.pNewTable;
-      if( bFKOnly==0 ){
+      /* A regular table */ 
+      int bFKOnly = sqlite3_stricmp(zTable, sParse.pNewTable->zName); 
+      FKey *pFKey; 
+      sCtx.pTab = sParse.pNewTable; 
+      if( bFKOnly==0 ){ 
         if( iCol<sParse.pNewTable->nCol ){
           renameTokenFind(
               &sParse, &sCtx, (void*)sParse.pNewTable->aCol[iCol].zCnName
           );
         }
-        if( sCtx.iCol<0 ){
-          renameTokenFind(&sParse, &sCtx, (void*)&sParse.pNewTable->iPKey);
-        }
-        sqlite3WalkExprList(&sWalker, sParse.pNewTable->pCheck);
-        for(pIdx=sParse.pNewTable->pIndex; pIdx; pIdx=pIdx->pNext){
-          sqlite3WalkExprList(&sWalker, pIdx->aColExpr);
-        }
-        for(pIdx=sParse.pNewIndex; pIdx; pIdx=pIdx->pNext){
-          sqlite3WalkExprList(&sWalker, pIdx->aColExpr);
-        }
+        if( sCtx.iCol<0 ){ 
+          renameTokenFind(&sParse, &sCtx, (void*)&sParse.pNewTable->iPKey); 
+        } 
+        sqlite3WalkExprList(&sWalker, sParse.pNewTable->pCheck); 
+        for(pIdx=sParse.pNewTable->pIndex; pIdx; pIdx=pIdx->pNext){ 
+          sqlite3WalkExprList(&sWalker, pIdx->aColExpr); 
+        } 
+        for(pIdx=sParse.pNewIndex; pIdx; pIdx=pIdx->pNext){ 
+          sqlite3WalkExprList(&sWalker, pIdx->aColExpr); 
+        } 
 #ifndef SQLITE_OMIT_GENERATED_COLUMNS
         for(i=0; i<sParse.pNewTable->nCol; i++){
           Expr *pExpr = sqlite3ColumnExpr(sParse.pNewTable,
@@ -109535,184 +109535,184 @@ static void renameColumnFunc(
         }
 #endif
       }
-
+ 
       assert( IsOrdinaryTable(sParse.pNewTable) );
       for(pFKey=sParse.pNewTable->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
-        for(i=0; i<pFKey->nCol; i++){
-          if( bFKOnly==0 && pFKey->aCol[i].iFrom==iCol ){
-            renameTokenFind(&sParse, &sCtx, (void*)&pFKey->aCol[i]);
-          }
-          if( 0==sqlite3_stricmp(pFKey->zTo, zTable)
-           && 0==sqlite3_stricmp(pFKey->aCol[i].zCol, zOld)
-          ){
-            renameTokenFind(&sParse, &sCtx, (void*)pFKey->aCol[i].zCol);
-          }
-        }
-      }
-    }
-  }else if( sParse.pNewIndex ){
-    sqlite3WalkExprList(&sWalker, sParse.pNewIndex->aColExpr);
-    sqlite3WalkExpr(&sWalker, sParse.pNewIndex->pPartIdxWhere);
-  }else{
-    /* A trigger */
-    TriggerStep *pStep;
+        for(i=0; i<pFKey->nCol; i++){ 
+          if( bFKOnly==0 && pFKey->aCol[i].iFrom==iCol ){ 
+            renameTokenFind(&sParse, &sCtx, (void*)&pFKey->aCol[i]); 
+          } 
+          if( 0==sqlite3_stricmp(pFKey->zTo, zTable) 
+           && 0==sqlite3_stricmp(pFKey->aCol[i].zCol, zOld) 
+          ){ 
+            renameTokenFind(&sParse, &sCtx, (void*)pFKey->aCol[i].zCol); 
+          } 
+        } 
+      } 
+    } 
+  }else if( sParse.pNewIndex ){ 
+    sqlite3WalkExprList(&sWalker, sParse.pNewIndex->aColExpr); 
+    sqlite3WalkExpr(&sWalker, sParse.pNewIndex->pPartIdxWhere); 
+  }else{ 
+    /* A trigger */ 
+    TriggerStep *pStep; 
     rc = renameResolveTrigger(&sParse);
-    if( rc!=SQLITE_OK ) goto renameColumnFunc_done;
-
-    for(pStep=sParse.pNewTrigger->step_list; pStep; pStep=pStep->pNext){
+    if( rc!=SQLITE_OK ) goto renameColumnFunc_done; 
+ 
+    for(pStep=sParse.pNewTrigger->step_list; pStep; pStep=pStep->pNext){ 
       if( pStep->zTarget ){
-        Table *pTarget = sqlite3LocateTable(&sParse, 0, pStep->zTarget, zDb);
-        if( pTarget==pTab ){
-          if( pStep->pUpsert ){
-            ExprList *pUpsertSet = pStep->pUpsert->pUpsertSet;
-            renameColumnElistNames(&sParse, &sCtx, pUpsertSet, zOld);
-          }
-          renameColumnIdlistNames(&sParse, &sCtx, pStep->pIdList, zOld);
-          renameColumnElistNames(&sParse, &sCtx, pStep->pExprList, zOld);
-        }
-      }
-    }
-
-
-    /* Find tokens to edit in UPDATE OF clause */
-    if( sParse.pTriggerTab==pTab ){
-      renameColumnIdlistNames(&sParse, &sCtx,sParse.pNewTrigger->pColumns,zOld);
-    }
-
-    /* Find tokens to edit in various expressions and selects */
-    renameWalkTrigger(&sWalker, sParse.pNewTrigger);
-  }
-
-  assert( rc==SQLITE_OK );
-  rc = renameEditSql(context, &sCtx, zSql, zNew, bQuote);
-
-renameColumnFunc_done:
-  if( rc!=SQLITE_OK ){
-    if( sParse.zErrMsg ){
+        Table *pTarget = sqlite3LocateTable(&sParse, 0, pStep->zTarget, zDb); 
+        if( pTarget==pTab ){ 
+          if( pStep->pUpsert ){ 
+            ExprList *pUpsertSet = pStep->pUpsert->pUpsertSet; 
+            renameColumnElistNames(&sParse, &sCtx, pUpsertSet, zOld); 
+          } 
+          renameColumnIdlistNames(&sParse, &sCtx, pStep->pIdList, zOld); 
+          renameColumnElistNames(&sParse, &sCtx, pStep->pExprList, zOld); 
+        } 
+      } 
+    } 
+ 
+ 
+    /* Find tokens to edit in UPDATE OF clause */ 
+    if( sParse.pTriggerTab==pTab ){ 
+      renameColumnIdlistNames(&sParse, &sCtx,sParse.pNewTrigger->pColumns,zOld); 
+    } 
+ 
+    /* Find tokens to edit in various expressions and selects */ 
+    renameWalkTrigger(&sWalker, sParse.pNewTrigger); 
+  } 
+ 
+  assert( rc==SQLITE_OK ); 
+  rc = renameEditSql(context, &sCtx, zSql, zNew, bQuote); 
+ 
+renameColumnFunc_done: 
+  if( rc!=SQLITE_OK ){ 
+    if( sParse.zErrMsg ){ 
       renameColumnParseError(context, "", argv[1], argv[2], &sParse);
-    }else{
-      sqlite3_result_error_code(context, rc);
-    }
-  }
-
-  renameParseCleanup(&sParse);
-  renameTokenFree(db, sCtx.pList);
-#ifndef SQLITE_OMIT_AUTHORIZATION
-  db->xAuth = xAuth;
-#endif
-  sqlite3BtreeLeaveAll(db);
-}
-
-/*
+    }else{ 
+      sqlite3_result_error_code(context, rc); 
+    } 
+  } 
+ 
+  renameParseCleanup(&sParse); 
+  renameTokenFree(db, sCtx.pList); 
+#ifndef SQLITE_OMIT_AUTHORIZATION 
+  db->xAuth = xAuth; 
+#endif 
+  sqlite3BtreeLeaveAll(db); 
+} 
+ 
+/* 
 ** Walker expression callback used by "RENAME TABLE".
-*/
-static int renameTableExprCb(Walker *pWalker, Expr *pExpr){
-  RenameCtx *p = pWalker->u.pRename;
+*/ 
+static int renameTableExprCb(Walker *pWalker, Expr *pExpr){ 
+  RenameCtx *p = pWalker->u.pRename; 
   if( pExpr->op==TK_COLUMN
    && ALWAYS(ExprUseYTab(pExpr))
    && p->pTab==pExpr->y.pTab
   ){
-    renameTokenFind(pWalker->pParse, p, (void*)&pExpr->y.pTab);
-  }
-  return WRC_Continue;
-}
-
-/*
+    renameTokenFind(pWalker->pParse, p, (void*)&pExpr->y.pTab); 
+  } 
+  return WRC_Continue; 
+} 
+ 
+/* 
 ** Walker select callback used by "RENAME TABLE".
-*/
-static int renameTableSelectCb(Walker *pWalker, Select *pSelect){
-  int i;
-  RenameCtx *p = pWalker->u.pRename;
-  SrcList *pSrc = pSelect->pSrc;
+*/ 
+static int renameTableSelectCb(Walker *pWalker, Select *pSelect){ 
+  int i; 
+  RenameCtx *p = pWalker->u.pRename; 
+  SrcList *pSrc = pSelect->pSrc; 
   if( pSelect->selFlags & (SF_View|SF_CopyCte) ){
     testcase( pSelect->selFlags & SF_View );
     testcase( pSelect->selFlags & SF_CopyCte );
     return WRC_Prune;
   }
   if( NEVER(pSrc==0) ){
-    assert( pWalker->pParse->db->mallocFailed );
-    return WRC_Abort;
-  }
-  for(i=0; i<pSrc->nSrc; i++){
+    assert( pWalker->pParse->db->mallocFailed ); 
+    return WRC_Abort; 
+  } 
+  for(i=0; i<pSrc->nSrc; i++){ 
     SrcItem *pItem = &pSrc->a[i];
-    if( pItem->pTab==p->pTab ){
-      renameTokenFind(pWalker->pParse, p, pItem->zName);
-    }
-  }
-  renameWalkWith(pWalker, pSelect);
-
-  return WRC_Continue;
-}
-
-
-/*
-** This C function implements an SQL user function that is used by SQL code
-** generated by the ALTER TABLE ... RENAME command to modify the definition
+    if( pItem->pTab==p->pTab ){ 
+      renameTokenFind(pWalker->pParse, p, pItem->zName); 
+    } 
+  } 
+  renameWalkWith(pWalker, pSelect); 
+ 
+  return WRC_Continue; 
+} 
+ 
+ 
+/* 
+** This C function implements an SQL user function that is used by SQL code 
+** generated by the ALTER TABLE ... RENAME command to modify the definition 
 ** of any foreign key constraints that use the table being renamed as the
-** parent table. It is passed three arguments:
-**
-**   0: The database containing the table being renamed.
-**   1. type:     Type of object ("table", "view" etc.)
-**   2. object:   Name of object
-**   3: The complete text of the schema statement being modified,
-**   4: The old name of the table being renamed, and
-**   5: The new name of the table being renamed.
-**   6: True if the schema statement comes from the temp db.
-**
-** It returns the new schema statement. For example:
-**
-** sqlite_rename_table('main', 'CREATE TABLE t1(a REFERENCES t2)','t2','t3',0)
-**       -> 'CREATE TABLE t1(a REFERENCES t3)'
-*/
-static void renameTableFunc(
-  sqlite3_context *context,
-  int NotUsed,
-  sqlite3_value **argv
-){
-  sqlite3 *db = sqlite3_context_db_handle(context);
-  const char *zDb = (const char*)sqlite3_value_text(argv[0]);
-  const char *zInput = (const char*)sqlite3_value_text(argv[3]);
-  const char *zOld = (const char*)sqlite3_value_text(argv[4]);
-  const char *zNew = (const char*)sqlite3_value_text(argv[5]);
-  int bTemp = sqlite3_value_int(argv[6]);
-  UNUSED_PARAMETER(NotUsed);
-
-  if( zInput && zOld && zNew ){
-    Parse sParse;
-    int rc;
-    int bQuote = 1;
-    RenameCtx sCtx;
-    Walker sWalker;
-
-#ifndef SQLITE_OMIT_AUTHORIZATION
-    sqlite3_xauth xAuth = db->xAuth;
-    db->xAuth = 0;
-#endif
-
-    sqlite3BtreeEnterAll(db);
-
-    memset(&sCtx, 0, sizeof(RenameCtx));
-    sCtx.pTab = sqlite3FindTable(db, zOld, zDb);
-    memset(&sWalker, 0, sizeof(Walker));
-    sWalker.pParse = &sParse;
-    sWalker.xExprCallback = renameTableExprCb;
-    sWalker.xSelectCallback = renameTableSelectCb;
-    sWalker.u.pRename = &sCtx;
-
+** parent table. It is passed three arguments: 
+** 
+**   0: The database containing the table being renamed. 
+**   1. type:     Type of object ("table", "view" etc.) 
+**   2. object:   Name of object 
+**   3: The complete text of the schema statement being modified, 
+**   4: The old name of the table being renamed, and 
+**   5: The new name of the table being renamed. 
+**   6: True if the schema statement comes from the temp db. 
+** 
+** It returns the new schema statement. For example: 
+** 
+** sqlite_rename_table('main', 'CREATE TABLE t1(a REFERENCES t2)','t2','t3',0) 
+**       -> 'CREATE TABLE t1(a REFERENCES t3)' 
+*/ 
+static void renameTableFunc( 
+  sqlite3_context *context, 
+  int NotUsed, 
+  sqlite3_value **argv 
+){ 
+  sqlite3 *db = sqlite3_context_db_handle(context); 
+  const char *zDb = (const char*)sqlite3_value_text(argv[0]); 
+  const char *zInput = (const char*)sqlite3_value_text(argv[3]); 
+  const char *zOld = (const char*)sqlite3_value_text(argv[4]); 
+  const char *zNew = (const char*)sqlite3_value_text(argv[5]); 
+  int bTemp = sqlite3_value_int(argv[6]); 
+  UNUSED_PARAMETER(NotUsed); 
+ 
+  if( zInput && zOld && zNew ){ 
+    Parse sParse; 
+    int rc; 
+    int bQuote = 1; 
+    RenameCtx sCtx; 
+    Walker sWalker; 
+ 
+#ifndef SQLITE_OMIT_AUTHORIZATION 
+    sqlite3_xauth xAuth = db->xAuth; 
+    db->xAuth = 0; 
+#endif 
+ 
+    sqlite3BtreeEnterAll(db); 
+ 
+    memset(&sCtx, 0, sizeof(RenameCtx)); 
+    sCtx.pTab = sqlite3FindTable(db, zOld, zDb); 
+    memset(&sWalker, 0, sizeof(Walker)); 
+    sWalker.pParse = &sParse; 
+    sWalker.xExprCallback = renameTableExprCb; 
+    sWalker.xSelectCallback = renameTableSelectCb; 
+    sWalker.u.pRename = &sCtx; 
+ 
     rc = renameParseSql(&sParse, zDb, db, zInput, bTemp);
-
-    if( rc==SQLITE_OK ){
-      int isLegacy = (db->flags & SQLITE_LegacyAlter);
-      if( sParse.pNewTable ){
-        Table *pTab = sParse.pNewTable;
-
+ 
+    if( rc==SQLITE_OK ){ 
+      int isLegacy = (db->flags & SQLITE_LegacyAlter); 
+      if( sParse.pNewTable ){ 
+        Table *pTab = sParse.pNewTable; 
+ 
         if( IsView(pTab) ){
-          if( isLegacy==0 ){
+          if( isLegacy==0 ){ 
             Select *pSelect = pTab->u.view.pSelect;
-            NameContext sNC;
-            memset(&sNC, 0, sizeof(sNC));
-            sNC.pParse = &sParse;
-
+            NameContext sNC; 
+            memset(&sNC, 0, sizeof(sNC)); 
+            sNC.pParse = &sParse; 
+ 
             assert( pSelect->selFlags & SF_View );
             pSelect->selFlags &= ~SF_View;
             sqlite3SelectPrep(&sParse, pTab->u.view.pSelect, &sNC);
@@ -109721,90 +109721,90 @@ static void renameTableFunc(
             }else{
               sqlite3WalkSelect(&sWalker, pTab->u.view.pSelect);
             }
-          }
-        }else{
-          /* Modify any FK definitions to point to the new table. */
-#ifndef SQLITE_OMIT_FOREIGN_KEY
+          } 
+        }else{ 
+          /* Modify any FK definitions to point to the new table. */ 
+#ifndef SQLITE_OMIT_FOREIGN_KEY 
           if( (isLegacy==0 || (db->flags & SQLITE_ForeignKeys))
            && !IsVirtual(pTab)
           ){
-            FKey *pFKey;
+            FKey *pFKey; 
             assert( IsOrdinaryTable(pTab) );
             for(pFKey=pTab->u.tab.pFKey; pFKey; pFKey=pFKey->pNextFrom){
-              if( sqlite3_stricmp(pFKey->zTo, zOld)==0 ){
-                renameTokenFind(&sParse, &sCtx, (void*)pFKey->zTo);
-              }
-            }
-          }
-#endif
-
-          /* If this is the table being altered, fix any table refs in CHECK
-          ** expressions. Also update the name that appears right after the
-          ** "CREATE [VIRTUAL] TABLE" bit. */
-          if( sqlite3_stricmp(zOld, pTab->zName)==0 ){
-            sCtx.pTab = pTab;
-            if( isLegacy==0 ){
-              sqlite3WalkExprList(&sWalker, pTab->pCheck);
-            }
-            renameTokenFind(&sParse, &sCtx, pTab->zName);
-          }
-        }
-      }
-
-      else if( sParse.pNewIndex ){
-        renameTokenFind(&sParse, &sCtx, sParse.pNewIndex->zName);
-        if( isLegacy==0 ){
-          sqlite3WalkExpr(&sWalker, sParse.pNewIndex->pPartIdxWhere);
-        }
-      }
-
-#ifndef SQLITE_OMIT_TRIGGER
-      else{
-        Trigger *pTrigger = sParse.pNewTrigger;
-        TriggerStep *pStep;
+              if( sqlite3_stricmp(pFKey->zTo, zOld)==0 ){ 
+                renameTokenFind(&sParse, &sCtx, (void*)pFKey->zTo); 
+              } 
+            } 
+          } 
+#endif 
+ 
+          /* If this is the table being altered, fix any table refs in CHECK 
+          ** expressions. Also update the name that appears right after the 
+          ** "CREATE [VIRTUAL] TABLE" bit. */ 
+          if( sqlite3_stricmp(zOld, pTab->zName)==0 ){ 
+            sCtx.pTab = pTab; 
+            if( isLegacy==0 ){ 
+              sqlite3WalkExprList(&sWalker, pTab->pCheck); 
+            } 
+            renameTokenFind(&sParse, &sCtx, pTab->zName); 
+          } 
+        } 
+      } 
+ 
+      else if( sParse.pNewIndex ){ 
+        renameTokenFind(&sParse, &sCtx, sParse.pNewIndex->zName); 
+        if( isLegacy==0 ){ 
+          sqlite3WalkExpr(&sWalker, sParse.pNewIndex->pPartIdxWhere); 
+        } 
+      } 
+ 
+#ifndef SQLITE_OMIT_TRIGGER 
+      else{ 
+        Trigger *pTrigger = sParse.pNewTrigger; 
+        TriggerStep *pStep; 
         if( 0==sqlite3_stricmp(sParse.pNewTrigger->table, zOld)
-            && sCtx.pTab->pSchema==pTrigger->pTabSchema
-          ){
-          renameTokenFind(&sParse, &sCtx, sParse.pNewTrigger->table);
-        }
-
-        if( isLegacy==0 ){
+            && sCtx.pTab->pSchema==pTrigger->pTabSchema 
+          ){ 
+          renameTokenFind(&sParse, &sCtx, sParse.pNewTrigger->table); 
+        } 
+ 
+        if( isLegacy==0 ){ 
           rc = renameResolveTrigger(&sParse);
-          if( rc==SQLITE_OK ){
-            renameWalkTrigger(&sWalker, pTrigger);
-            for(pStep=pTrigger->step_list; pStep; pStep=pStep->pNext){
-              if( pStep->zTarget && 0==sqlite3_stricmp(pStep->zTarget, zOld) ){
-                renameTokenFind(&sParse, &sCtx, pStep->zTarget);
-              }
-            }
-          }
-        }
-      }
-#endif
-    }
-
-    if( rc==SQLITE_OK ){
-      rc = renameEditSql(context, &sCtx, zInput, zNew, bQuote);
-    }
-    if( rc!=SQLITE_OK ){
-      if( sParse.zErrMsg ){
+          if( rc==SQLITE_OK ){ 
+            renameWalkTrigger(&sWalker, pTrigger); 
+            for(pStep=pTrigger->step_list; pStep; pStep=pStep->pNext){ 
+              if( pStep->zTarget && 0==sqlite3_stricmp(pStep->zTarget, zOld) ){ 
+                renameTokenFind(&sParse, &sCtx, pStep->zTarget); 
+              } 
+            } 
+          } 
+        } 
+      } 
+#endif 
+    } 
+ 
+    if( rc==SQLITE_OK ){ 
+      rc = renameEditSql(context, &sCtx, zInput, zNew, bQuote); 
+    } 
+    if( rc!=SQLITE_OK ){ 
+      if( sParse.zErrMsg ){ 
         renameColumnParseError(context, "", argv[1], argv[2], &sParse);
-      }else{
-        sqlite3_result_error_code(context, rc);
-      }
-    }
-
-    renameParseCleanup(&sParse);
-    renameTokenFree(db, sCtx.pList);
-    sqlite3BtreeLeaveAll(db);
-#ifndef SQLITE_OMIT_AUTHORIZATION
-    db->xAuth = xAuth;
-#endif
-  }
-
-  return;
-}
-
+      }else{ 
+        sqlite3_result_error_code(context, rc); 
+      } 
+    } 
+ 
+    renameParseCleanup(&sParse); 
+    renameTokenFree(db, sCtx.pList); 
+    sqlite3BtreeLeaveAll(db); 
+#ifndef SQLITE_OMIT_AUTHORIZATION 
+    db->xAuth = xAuth; 
+#endif 
+  } 
+ 
+  return; 
+} 
+ 
 static int renameQuotefixExprCb(Walker *pWalker, Expr *pExpr){
   if( pExpr->op==TK_STRING && (pExpr->flags & EP_DblQuoted) ){
     renameTokenFind(pWalker->pParse, pWalker->u.pRename, (const void*)pExpr);
@@ -109812,7 +109812,7 @@ static int renameQuotefixExprCb(Walker *pWalker, Expr *pExpr){
   return WRC_Continue;
 }
 
-/*
+/* 
 ** The implementation of an SQL scalar function that rewrites DDL statements
 ** so that any string literals that use double-quotes are modified so that
 ** they use single quotes.
@@ -109921,86 +109921,86 @@ static void renameQuotefixFunc(
 }
 
 /*
-** An SQL user function that checks that there are no parse or symbol
-** resolution problems in a CREATE TRIGGER|TABLE|VIEW|INDEX statement.
-** After an ALTER TABLE .. RENAME operation is performed and the schema
-** reloaded, this function is called on each SQL statement in the schema
-** to ensure that it is still usable.
-**
-**   0: Database name ("main", "temp" etc.).
-**   1: SQL statement.
-**   2: Object type ("view", "table", "trigger" or "index").
-**   3: Object name.
-**   4: True if object is from temp schema.
+** An SQL user function that checks that there are no parse or symbol 
+** resolution problems in a CREATE TRIGGER|TABLE|VIEW|INDEX statement. 
+** After an ALTER TABLE .. RENAME operation is performed and the schema 
+** reloaded, this function is called on each SQL statement in the schema 
+** to ensure that it is still usable. 
+** 
+**   0: Database name ("main", "temp" etc.). 
+**   1: SQL statement. 
+**   2: Object type ("view", "table", "trigger" or "index"). 
+**   3: Object name. 
+**   4: True if object is from temp schema. 
 **   5: "when" part of error message.
 **   6: True to disable the DQS quirk when parsing SQL.
-**
-** Unless it finds an error, this function normally returns NULL. However, it
-** returns integer value 1 if:
-**
-**   * the SQL argument creates a trigger, and
-**   * the table that the trigger is attached to is in database zDb.
-*/
-static void renameTableTest(
-  sqlite3_context *context,
-  int NotUsed,
-  sqlite3_value **argv
-){
-  sqlite3 *db = sqlite3_context_db_handle(context);
-  char const *zDb = (const char*)sqlite3_value_text(argv[0]);
-  char const *zInput = (const char*)sqlite3_value_text(argv[1]);
-  int bTemp = sqlite3_value_int(argv[4]);
-  int isLegacy = (db->flags & SQLITE_LegacyAlter);
+** 
+** Unless it finds an error, this function normally returns NULL. However, it 
+** returns integer value 1 if: 
+** 
+**   * the SQL argument creates a trigger, and 
+**   * the table that the trigger is attached to is in database zDb. 
+*/ 
+static void renameTableTest( 
+  sqlite3_context *context, 
+  int NotUsed, 
+  sqlite3_value **argv 
+){ 
+  sqlite3 *db = sqlite3_context_db_handle(context); 
+  char const *zDb = (const char*)sqlite3_value_text(argv[0]); 
+  char const *zInput = (const char*)sqlite3_value_text(argv[1]); 
+  int bTemp = sqlite3_value_int(argv[4]); 
+  int isLegacy = (db->flags & SQLITE_LegacyAlter); 
   char const *zWhen = (const char*)sqlite3_value_text(argv[5]);
   int bNoDQS = sqlite3_value_int(argv[6]);
-
-#ifndef SQLITE_OMIT_AUTHORIZATION
-  sqlite3_xauth xAuth = db->xAuth;
-  db->xAuth = 0;
-#endif
-
-  UNUSED_PARAMETER(NotUsed);
-
-  if( zDb && zInput ){
-    int rc;
-    Parse sParse;
+ 
+#ifndef SQLITE_OMIT_AUTHORIZATION 
+  sqlite3_xauth xAuth = db->xAuth; 
+  db->xAuth = 0; 
+#endif 
+ 
+  UNUSED_PARAMETER(NotUsed); 
+
+  if( zDb && zInput ){ 
+    int rc; 
+    Parse sParse; 
     int flags = db->flags;
     if( bNoDQS ) db->flags &= ~(SQLITE_DqsDML|SQLITE_DqsDDL);
     rc = renameParseSql(&sParse, zDb, db, zInput, bTemp);
     db->flags |= (flags & (SQLITE_DqsDML|SQLITE_DqsDDL));
-    if( rc==SQLITE_OK ){
+    if( rc==SQLITE_OK ){ 
       if( isLegacy==0 && sParse.pNewTable && IsView(sParse.pNewTable) ){
-        NameContext sNC;
-        memset(&sNC, 0, sizeof(sNC));
-        sNC.pParse = &sParse;
+        NameContext sNC; 
+        memset(&sNC, 0, sizeof(sNC)); 
+        sNC.pParse = &sParse; 
         sqlite3SelectPrep(&sParse, sParse.pNewTable->u.view.pSelect, &sNC);
-        if( sParse.nErr ) rc = sParse.rc;
-      }
-
-      else if( sParse.pNewTrigger ){
-        if( isLegacy==0 ){
+        if( sParse.nErr ) rc = sParse.rc; 
+      } 
+ 
+      else if( sParse.pNewTrigger ){ 
+        if( isLegacy==0 ){ 
           rc = renameResolveTrigger(&sParse);
-        }
-        if( rc==SQLITE_OK ){
-          int i1 = sqlite3SchemaToIndex(db, sParse.pNewTrigger->pTabSchema);
-          int i2 = sqlite3FindDbName(db, zDb);
-          if( i1==i2 ) sqlite3_result_int(context, 1);
-        }
-      }
-    }
-
+        } 
+        if( rc==SQLITE_OK ){ 
+          int i1 = sqlite3SchemaToIndex(db, sParse.pNewTrigger->pTabSchema); 
+          int i2 = sqlite3FindDbName(db, zDb); 
+          if( i1==i2 ) sqlite3_result_int(context, 1); 
+        } 
+      } 
+    } 
+ 
     if( rc!=SQLITE_OK && zWhen ){
       renameColumnParseError(context, zWhen, argv[2], argv[3],&sParse);
-    }
-    renameParseCleanup(&sParse);
-  }
-
-#ifndef SQLITE_OMIT_AUTHORIZATION
-  db->xAuth = xAuth;
-#endif
-}
-
-/*
+    } 
+    renameParseCleanup(&sParse); 
+  } 
+ 
+#ifndef SQLITE_OMIT_AUTHORIZATION 
+  db->xAuth = xAuth; 
+#endif 
+} 
+ 
+/* 
 ** The implementation of internal UDF sqlite_drop_column().
 **
 ** Arguments:
@@ -110211,18 +110211,18 @@ exit_drop_column:
 }
 
 /*
-** Register built-in functions used to help implement ALTER TABLE
-*/
-SQLITE_PRIVATE void sqlite3AlterFunctions(void){
-  static FuncDef aAlterTableFuncs[] = {
+** Register built-in functions used to help implement ALTER TABLE 
+*/ 
+SQLITE_PRIVATE void sqlite3AlterFunctions(void){ 
+  static FuncDef aAlterTableFuncs[] = { 
     INTERNAL_FUNCTION(sqlite_rename_column,  9, renameColumnFunc),
     INTERNAL_FUNCTION(sqlite_rename_table,   7, renameTableFunc),
     INTERNAL_FUNCTION(sqlite_rename_test,    7, renameTableTest),
     INTERNAL_FUNCTION(sqlite_drop_column,    3, dropColumnFunc),
     INTERNAL_FUNCTION(sqlite_rename_quotefix,2, renameQuotefixFunc),
-  };
-  sqlite3InsertBuiltinFuncs(aAlterTableFuncs, ArraySize(aAlterTableFuncs));
-}
+  }; 
+  sqlite3InsertBuiltinFuncs(aAlterTableFuncs, ArraySize(aAlterTableFuncs)); 
+} 
 #endif  /* SQLITE_ALTER_TABLE */
 
 /************** End of alter.c ***********************************************/
@@ -110719,7 +110719,7 @@ static const FuncDef statInitFuncdef = {
   0,               /* pNext */
   statInit,        /* xSFunc */
   0,               /* xFinalize */
-  0, 0,            /* xValue, xInverse */
+  0, 0,            /* xValue, xInverse */ 
   "stat_init",     /* zName */
   {0}
 };
@@ -111009,7 +111009,7 @@ static const FuncDef statPushFuncdef = {
   0,               /* pNext */
   statPush,        /* xSFunc */
   0,               /* xFinalize */
-  0, 0,            /* xValue, xInverse */
+  0, 0,            /* xValue, xInverse */ 
   "stat_push",     /* zName */
   {0}
 };
@@ -111143,7 +111143,7 @@ static const FuncDef statGetFuncdef = {
   0,               /* pNext */
   statGet,         /* xSFunc */
   0,               /* xFinalize */
-  0, 0,            /* xValue, xInverse */
+  0, 0,            /* xValue, xInverse */ 
   "stat_get",      /* zName */
   {0}
 };
@@ -111229,7 +111229,7 @@ static void analyzeOneTable(
     /* Do not gather statistics on views or virtual tables */
     return;
   }
-  if( sqlite3_strlike("sqlite\\_%", pTab->zName, '\\')==0 ){
+  if( sqlite3_strlike("sqlite\\_%", pTab->zName, '\\')==0 ){ 
     /* Do not gather statistics on system tables */
     return;
   }
@@ -111373,7 +111373,7 @@ static void analyzeOneTable(
     addrNextRow = sqlite3VdbeCurrentAddr(v);
 
     if( nColTest>0 ){
-      int endDistinctTest = sqlite3VdbeMakeLabel(pParse);
+      int endDistinctTest = sqlite3VdbeMakeLabel(pParse); 
       int *aGotoChng;               /* Array of jump instruction addresses */
       aGotoChng = sqlite3DbMallocRawNN(db, sizeof(int)*nColTest);
       if( aGotoChng==0 ) continue;
@@ -111508,7 +111508,7 @@ static void analyzeOneTable(
       callStatGet(pParse, regStat, STAT_GET_NLT, regLt);
       callStatGet(pParse, regStat, STAT_GET_NDLT, regDLt);
       sqlite3VdbeAddOp4Int(v, seekOp, iTabCur, addrNext, regSampleRowid, 0);
-      VdbeCoverage(v);
+      VdbeCoverage(v); 
       for(i=0; i<nCol; i++){
         sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iTabCur, i, regCol+i);
       }
@@ -112137,7 +112137,7 @@ SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
 
   /* Load the statistics from the sqlite_stat4 table. */
 #ifdef SQLITE_ENABLE_STAT4
-  if( rc==SQLITE_OK ){
+  if( rc==SQLITE_OK ){ 
     DisableLookaside;
     rc = loadStat4(db, sInfo.zDatabase);
     EnableLookaside;
@@ -112228,10 +112228,10 @@ SQLITE_PRIVATE int sqlite3DbIsNamed(sqlite3 *db, int iDb, const char *zName){
 **
 ** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the
 ** third argument.
-**
-** If the db->init.reopenMemdb flags is set, then instead of attaching a
-** new database, close the database on db->init.iDb and reopen it as an
-** empty MemDB.
+** 
+** If the db->init.reopenMemdb flags is set, then instead of attaching a 
+** new database, close the database on db->init.iDb and reopen it as an 
+** empty MemDB. 
 */
 static void attachFunc(
   sqlite3_context *context,
@@ -112258,79 +112258,79 @@ static void attachFunc(
   if( zName==0 ) zName = "";
 
 #ifndef SQLITE_OMIT_DESERIALIZE
-# define REOPEN_AS_MEMDB(db)  (db->init.reopenMemdb)
-#else
-# define REOPEN_AS_MEMDB(db)  (0)
-#endif
-
-  if( REOPEN_AS_MEMDB(db) ){
-    /* This is not a real ATTACH.  Instead, this routine is being called
-    ** from sqlite3_deserialize() to close database db->init.iDb and
-    ** reopen it as a MemDB */
-    pVfs = sqlite3_vfs_find("memdb");
-    if( pVfs==0 ) return;
-    pNew = &db->aDb[db->init.iDb];
-    if( pNew->pBt ) sqlite3BtreeClose(pNew->pBt);
-    pNew->pBt = 0;
-    pNew->pSchema = 0;
-    rc = sqlite3BtreeOpen(pVfs, "x\0", db, &pNew->pBt, 0, SQLITE_OPEN_MAIN_DB);
-  }else{
-    /* This is a real ATTACH
-    **
-    ** Check for the following errors:
-    **
-    **     * Too many attached databases,
-    **     * Transaction currently open
-    **     * Specified database name already being used.
-    */
-    if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){
+# define REOPEN_AS_MEMDB(db)  (db->init.reopenMemdb) 
+#else 
+# define REOPEN_AS_MEMDB(db)  (0) 
+#endif 
+ 
+  if( REOPEN_AS_MEMDB(db) ){ 
+    /* This is not a real ATTACH.  Instead, this routine is being called 
+    ** from sqlite3_deserialize() to close database db->init.iDb and 
+    ** reopen it as a MemDB */ 
+    pVfs = sqlite3_vfs_find("memdb"); 
+    if( pVfs==0 ) return; 
+    pNew = &db->aDb[db->init.iDb]; 
+    if( pNew->pBt ) sqlite3BtreeClose(pNew->pBt); 
+    pNew->pBt = 0; 
+    pNew->pSchema = 0; 
+    rc = sqlite3BtreeOpen(pVfs, "x\0", db, &pNew->pBt, 0, SQLITE_OPEN_MAIN_DB); 
+  }else{ 
+    /* This is a real ATTACH 
+    ** 
+    ** Check for the following errors: 
+    ** 
+    **     * Too many attached databases, 
+    **     * Transaction currently open 
+    **     * Specified database name already being used. 
+    */ 
+    if( db->nDb>=db->aLimit[SQLITE_LIMIT_ATTACHED]+2 ){ 
       zErrDyn = sqlite3MPrintf(db, "too many attached databases - max %d",
-        db->aLimit[SQLITE_LIMIT_ATTACHED]
-      );
+        db->aLimit[SQLITE_LIMIT_ATTACHED] 
+      ); 
       goto attach_error;
     }
-    for(i=0; i<db->nDb; i++){
+    for(i=0; i<db->nDb; i++){ 
       assert( zName );
       if( sqlite3DbIsNamed(db, i, zName) ){
-        zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName);
-        goto attach_error;
-      }
-    }
-
-    /* Allocate the new entry in the db->aDb[] array and initialize the schema
-    ** hash tables.
-    */
-    if( db->aDb==db->aDbStatic ){
-      aNew = sqlite3DbMallocRawNN(db, sizeof(db->aDb[0])*3 );
-      if( aNew==0 ) return;
-      memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
-    }else{
-      aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) );
-      if( aNew==0 ) return;
-    }
-    db->aDb = aNew;
-    pNew = &db->aDb[db->nDb];
-    memset(pNew, 0, sizeof(*pNew));
-
-    /* Open the database file. If the btree is successfully opened, use
-    ** it to obtain the database schema. At this point the schema may
-    ** or may not be initialized.
-    */
-    flags = db->openFlags;
-    rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
-    if( rc!=SQLITE_OK ){
-      if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
-      sqlite3_result_error(context, zErr, -1);
-      sqlite3_free(zErr);
-      return;
-    }
-    assert( pVfs );
-    flags |= SQLITE_OPEN_MAIN_DB;
-    rc = sqlite3BtreeOpen(pVfs, zPath, db, &pNew->pBt, 0, flags);
-    db->nDb++;
-    pNew->zDbSName = sqlite3DbStrDup(db, zName);
-  }
-  db->noSharedCache = 0;
+        zErrDyn = sqlite3MPrintf(db, "database %s is already in use", zName); 
+        goto attach_error; 
+      } 
+    } 
+
+    /* Allocate the new entry in the db->aDb[] array and initialize the schema 
+    ** hash tables. 
+    */ 
+    if( db->aDb==db->aDbStatic ){ 
+      aNew = sqlite3DbMallocRawNN(db, sizeof(db->aDb[0])*3 ); 
+      if( aNew==0 ) return; 
+      memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2); 
+    }else{ 
+      aNew = sqlite3DbRealloc(db, db->aDb, sizeof(db->aDb[0])*(db->nDb+1) ); 
+      if( aNew==0 ) return; 
+    } 
+    db->aDb = aNew; 
+    pNew = &db->aDb[db->nDb]; 
+    memset(pNew, 0, sizeof(*pNew)); 
+
+    /* Open the database file. If the btree is successfully opened, use 
+    ** it to obtain the database schema. At this point the schema may 
+    ** or may not be initialized. 
+    */ 
+    flags = db->openFlags; 
+    rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr); 
+    if( rc!=SQLITE_OK ){ 
+      if( rc==SQLITE_NOMEM ) sqlite3OomFault(db); 
+      sqlite3_result_error(context, zErr, -1); 
+      sqlite3_free(zErr); 
+      return; 
+    } 
+    assert( pVfs ); 
+    flags |= SQLITE_OPEN_MAIN_DB; 
+    rc = sqlite3BtreeOpen(pVfs, zPath, db, &pNew->pBt, 0, flags); 
+    db->nDb++; 
+    pNew->zDbSName = sqlite3DbStrDup(db, zName); 
+  }
+  db->noSharedCache = 0; 
   if( rc==SQLITE_CONSTRAINT ){
     rc = SQLITE_ERROR;
     zErrDyn = sqlite3MPrintf(db, "database is already attached");
@@ -112363,21 +112363,21 @@ static void attachFunc(
 
   /* If the file was opened successfully, read the schema for the new database.
   ** If this fails, or if opening the file failed, then close the file and
-  ** remove the entry from the db->aDb[] array. i.e. put everything back the
-  ** way we found it.
+  ** remove the entry from the db->aDb[] array. i.e. put everything back the 
+  ** way we found it. 
   */
   if( rc==SQLITE_OK ){
     sqlite3BtreeEnterAll(db);
-    db->init.iDb = 0;
-    db->mDbFlags &= ~(DBFLAG_SchemaKnownOk);
-    if( !REOPEN_AS_MEMDB(db) ){
-      rc = sqlite3Init(db, &zErrDyn);
-    }
+    db->init.iDb = 0; 
+    db->mDbFlags &= ~(DBFLAG_SchemaKnownOk); 
+    if( !REOPEN_AS_MEMDB(db) ){ 
+      rc = sqlite3Init(db, &zErrDyn); 
+    } 
     sqlite3BtreeLeaveAll(db);
-    assert( zErrDyn==0 || rc!=SQLITE_OK );
+    assert( zErrDyn==0 || rc!=SQLITE_OK ); 
   }
 #ifdef SQLITE_USER_AUTHENTICATION
-  if( rc==SQLITE_OK && !REOPEN_AS_MEMDB(db) ){
+  if( rc==SQLITE_OK && !REOPEN_AS_MEMDB(db) ){ 
     u8 newAuth = 0;
     rc = sqlite3UserAuthCheckLogin(db, zName, &newAuth);
     if( newAuth<db->auth.authLevel ){
@@ -112386,23 +112386,23 @@ static void attachFunc(
   }
 #endif
   if( rc ){
-    if( !REOPEN_AS_MEMDB(db) ){
-      int iDb = db->nDb - 1;
-      assert( iDb>=2 );
-      if( db->aDb[iDb].pBt ){
-        sqlite3BtreeClose(db->aDb[iDb].pBt);
-        db->aDb[iDb].pBt = 0;
-        db->aDb[iDb].pSchema = 0;
-      }
-      sqlite3ResetAllSchemasOfConnection(db);
-      db->nDb = iDb;
-      if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
-        sqlite3OomFault(db);
-        sqlite3DbFree(db, zErrDyn);
-        zErrDyn = sqlite3MPrintf(db, "out of memory");
-      }else if( zErrDyn==0 ){
-        zErrDyn = sqlite3MPrintf(db, "unable to open database: %s", zFile);
-      }
+    if( !REOPEN_AS_MEMDB(db) ){ 
+      int iDb = db->nDb - 1; 
+      assert( iDb>=2 ); 
+      if( db->aDb[iDb].pBt ){ 
+        sqlite3BtreeClose(db->aDb[iDb].pBt); 
+        db->aDb[iDb].pBt = 0; 
+        db->aDb[iDb].pSchema = 0; 
+      } 
+      sqlite3ResetAllSchemasOfConnection(db); 
+      db->nDb = iDb; 
+      if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ 
+        sqlite3OomFault(db); 
+        sqlite3DbFree(db, zErrDyn); 
+        zErrDyn = sqlite3MPrintf(db, "out of memory"); 
+      }else if( zErrDyn==0 ){ 
+        zErrDyn = sqlite3MPrintf(db, "unable to open database: %s", zFile); 
+      } 
     }
     goto attach_error;
   }
@@ -112568,7 +112568,7 @@ SQLITE_PRIVATE void sqlite3Detach(Parse *pParse, Expr *pDbname){
     0,                /* pNext */
     detachFunc,       /* xSFunc */
     0,                /* xFinalize */
-    0, 0,             /* xValue, xInverse */
+    0, 0,             /* xValue, xInverse */ 
     "sqlite_detach",  /* zName */
     {0}
   };
@@ -112588,7 +112588,7 @@ SQLITE_PRIVATE void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *p
     0,                /* pNext */
     attachFunc,       /* xSFunc */
     0,                /* xFinalize */
-    0, 0,             /* xValue, xInverse */
+    0, 0,             /* xValue, xInverse */ 
     "sqlite_attach",  /* zName */
     {0}
   };
@@ -112738,7 +112738,7 @@ SQLITE_PRIVATE int sqlite3FixTriggerStep(
     ){
       return 1;
     }
-#ifndef SQLITE_OMIT_UPSERT
+#ifndef SQLITE_OMIT_UPSERT 
     {
       Upsert *pUp;
       for(pUp=pStep->pUpsert; pUp; pUp=pUp->pNextUpsert){
@@ -112749,9 +112749,9 @@ SQLITE_PRIVATE int sqlite3FixTriggerStep(
         ){
           return 1;
         }
-      }
-    }
-#endif
+      } 
+    } 
+#endif 
     pStep = pStep->pNext;
   }
 
@@ -112912,7 +112912,7 @@ SQLITE_PRIVATE void sqlite3AuthRead(
   int iDb;              /* The index of the database the expression refers to */
   int iCol;             /* Index of column in table */
 
-  assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
+  assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER ); 
   assert( !IN_RENAME_OBJECT );
   assert( pParse->db->xAuth!=0 );
   iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
@@ -112970,7 +112970,7 @@ SQLITE_PRIVATE int sqlite3AuthCheck(
   /* Don't do any authorization checks if the database is initialising
   ** or if the parser is being invoked from within sqlite3_declare_vtab.
   */
-  assert( !IN_RENAME_OBJECT || db->xAuth==0 );
+  assert( !IN_RENAME_OBJECT || db->xAuth==0 ); 
   if( db->xAuth==0 || db->init.busy || IN_SPECIAL_PARSE ){
     return SQLITE_OK;
   }
@@ -113316,7 +113316,7 @@ SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){
   if( v && pParse->nErr==0 && !db->mallocFailed ){
     /* A minimum of one cursor is required if autoincrement is used
     *  See ticket [a696379c1f08866] */
-    assert( pParse->pAinc==0 || pParse->nTab>0 );
+    assert( pParse->pAinc==0 || pParse->nTab>0 ); 
     sqlite3VdbeMakeReady(v, pParse);
     pParse->rc = SQLITE_DONE;
   }else{
@@ -113351,12 +113351,12 @@ SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
   zSql = sqlite3VMPrintf(db, zFormat, ap);
   va_end(ap);
   if( zSql==0 ){
-    /* This can result either from an OOM or because the formatted string
-    ** exceeds SQLITE_LIMIT_LENGTH.  In the latter case, we need to set
-    ** an error */
-    if( !db->mallocFailed ) pParse->rc = SQLITE_TOOBIG;
-    pParse->nErr++;
-    return;
+    /* This can result either from an OOM or because the formatted string 
+    ** exceeds SQLITE_LIMIT_LENGTH.  In the latter case, we need to set 
+    ** an error */ 
+    if( !db->mallocFailed ) pParse->rc = SQLITE_TOOBIG; 
+    pParse->nErr++; 
+    return; 
   }
   pParse->nested++;
   memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ);
@@ -113477,26 +113477,26 @@ SQLITE_PRIVATE Table *sqlite3LocateTable(
   const char *zDbase     /* Name of the database.  Might be NULL */
 ){
   Table *p;
-  sqlite3 *db = pParse->db;
+  sqlite3 *db = pParse->db; 
 
   /* Read the database schema. If an error occurs, leave an error message
   ** and code in pParse and return NULL. */
   if( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0
-   && SQLITE_OK!=sqlite3ReadSchema(pParse)
-  ){
+   && SQLITE_OK!=sqlite3ReadSchema(pParse) 
+  ){ 
     return 0;
   }
 
-  p = sqlite3FindTable(db, zName, zDbase);
+  p = sqlite3FindTable(db, zName, zDbase); 
   if( p==0 ){
 #ifndef SQLITE_OMIT_VIRTUALTABLE
-    /* If zName is the not the name of a table in the schema created using
-    ** CREATE, then check to see if it is the name of an virtual table that
-    ** can be an eponymous virtual table. */
+    /* If zName is the not the name of a table in the schema created using 
+    ** CREATE, then check to see if it is the name of an virtual table that 
+    ** can be an eponymous virtual table. */ 
     if( pParse->disableVtab==0 && db->init.busy==0 ){
-      Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName);
+      Module *pMod = (Module*)sqlite3HashFind(&db->aModule, zName); 
       if( pMod==0 && sqlite3_strnicmp(zName, "pragma_", 7)==0 ){
-        pMod = sqlite3PragmaVtabRegister(db, zName);
+        pMod = sqlite3PragmaVtabRegister(db, zName); 
       }
       if( pMod && sqlite3VtabEponymousTableInit(pParse, pMod) ){
         testcase( pMod->pEpoTab==0 );
@@ -113504,18 +113504,18 @@ SQLITE_PRIVATE Table *sqlite3LocateTable(
       }
     }
 #endif
-    if( flags & LOCATE_NOERR ) return 0;
-    pParse->checkSchema = 1;
-  }else if( IsVirtual(p) && pParse->disableVtab ){
-    p = 0;
-  }
-
-  if( p==0 ){
-    const char *zMsg = flags & LOCATE_VIEW ? "no such view" : "no such table";
-    if( zDbase ){
-      sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
-    }else{
-      sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
+    if( flags & LOCATE_NOERR ) return 0; 
+    pParse->checkSchema = 1; 
+  }else if( IsVirtual(p) && pParse->disableVtab ){ 
+    p = 0; 
+  } 
+ 
+  if( p==0 ){ 
+    const char *zMsg = flags & LOCATE_VIEW ? "no such view" : "no such table"; 
+    if( zDbase ){ 
+      sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName); 
+    }else{ 
+      sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName); 
     }
   }else{
     assert( HasRowid(p) || p->iPKey<0 );
@@ -113597,7 +113597,7 @@ SQLITE_PRIVATE Index *sqlite3FindIndex(sqlite3 *db, const char *zName, const cha
 /*
 ** Reclaim the memory used by an index
 */
-SQLITE_PRIVATE void sqlite3FreeIndex(sqlite3 *db, Index *p){
+SQLITE_PRIVATE void sqlite3FreeIndex(sqlite3 *db, Index *p){ 
 #ifndef SQLITE_OMIT_ANALYZE
   sqlite3DeleteIndexSamples(db, p);
 #endif
@@ -113637,7 +113637,7 @@ SQLITE_PRIVATE void sqlite3UnlinkAndDeleteIndex(sqlite3 *db, int iDb, const char
         p->pNext = pIndex->pNext;
       }
     }
-    sqlite3FreeIndex(db, pIndex);
+    sqlite3FreeIndex(db, pIndex); 
   }
   db->mDbFlags |= DBFLAG_SchemaChange;
 }
@@ -113685,7 +113685,7 @@ SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3 *db, int iDb){
     assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
     DbSetProperty(db, iDb, DB_ResetWanted);
     DbSetProperty(db, 1, DB_ResetWanted);
-    db->mDbFlags &= ~DBFLAG_SchemaKnownOk;
+    db->mDbFlags &= ~DBFLAG_SchemaKnownOk; 
   }
 
   if( db->nSchemaLock==0 ){
@@ -113707,19 +113707,19 @@ SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){
   for(i=0; i<db->nDb; i++){
     Db *pDb = &db->aDb[i];
     if( pDb->pSchema ){
-      if( db->nSchemaLock==0 ){
-        sqlite3SchemaClear(pDb->pSchema);
-      }else{
-        DbSetProperty(db, i, DB_ResetWanted);
-      }
+      if( db->nSchemaLock==0 ){ 
+        sqlite3SchemaClear(pDb->pSchema); 
+      }else{ 
+        DbSetProperty(db, i, DB_ResetWanted); 
+      } 
     }
   }
-  db->mDbFlags &= ~(DBFLAG_SchemaChange|DBFLAG_SchemaKnownOk);
+  db->mDbFlags &= ~(DBFLAG_SchemaChange|DBFLAG_SchemaKnownOk); 
   sqlite3VtabUnlockList(db);
   sqlite3BtreeLeaveAll(db);
-  if( db->nSchemaLock==0 ){
-    sqlite3CollapseDatabaseArray(db);
-  }
+  if( db->nSchemaLock==0 ){ 
+    sqlite3CollapseDatabaseArray(db); 
+  } 
 }
 
 /*
@@ -113854,14 +113854,14 @@ static void SQLITE_NOINLINE deleteTable(sqlite3 *db, Table *pTable){
 
 #ifdef SQLITE_DEBUG
   /* Record the number of outstanding lookaside allocations in schema Tables
-  ** prior to doing any free() operations. Since schema Tables do not use
+  ** prior to doing any free() operations. Since schema Tables do not use 
   ** lookaside, this number should not change.
-  **
-  ** If malloc has already failed, it may be that it failed while allocating
-  ** a Table object that was going to be marked ephemeral. So do not check
-  ** that no lookaside memory is used in this case either. */
+  ** 
+  ** If malloc has already failed, it may be that it failed while allocating 
+  ** a Table object that was going to be marked ephemeral. So do not check 
+  ** that no lookaside memory is used in this case either. */ 
   int nLookaside = 0;
-  if( db && !db->mallocFailed && (pTable->tabFlags & TF_Ephemeral)==0 ){
+  if( db && !db->mallocFailed && (pTable->tabFlags & TF_Ephemeral)==0 ){ 
     nLookaside = sqlite3LookasideUsed(db, 0);
   }
 #endif
@@ -113879,7 +113879,7 @@ static void SQLITE_NOINLINE deleteTable(sqlite3 *db, Table *pTable){
       assert( db==0 || sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
       assert( pOld==pIndex || pOld==0 );
     }
-    sqlite3FreeIndex(db, pIndex);
+    sqlite3FreeIndex(db, pIndex); 
   }
 
   if( IsOrdinaryTable(pTable) ){
@@ -114052,20 +114052,20 @@ SQLITE_PRIVATE int sqlite3TwoPartName(
 }
 
 /*
-** True if PRAGMA writable_schema is ON
-*/
-SQLITE_PRIVATE int sqlite3WritableSchema(sqlite3 *db){
-  testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==0 );
-  testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
-               SQLITE_WriteSchema );
-  testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
-               SQLITE_Defensive );
-  testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==
-               (SQLITE_WriteSchema|SQLITE_Defensive) );
-  return (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==SQLITE_WriteSchema;
-}
-
-/*
+** True if PRAGMA writable_schema is ON 
+*/ 
+SQLITE_PRIVATE int sqlite3WritableSchema(sqlite3 *db){ 
+  testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==0 ); 
+  testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))== 
+               SQLITE_WriteSchema ); 
+  testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))== 
+               SQLITE_Defensive ); 
+  testcase( (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))== 
+               (SQLITE_WriteSchema|SQLITE_Defensive) ); 
+  return (db->flags&(SQLITE_WriteSchema|SQLITE_Defensive))==SQLITE_WriteSchema; 
+} 
+ 
+/* 
 ** This routine is used to check if the UTF-8 string zName is a legal
 ** unqualified name for a new schema object (table, index, view or
 ** trigger). All names are legal except those that begin with the string
@@ -114278,9 +114278,9 @@ SQLITE_PRIVATE void sqlite3StartTable(
     }
     if( !OMIT_TEMPDB && isTemp ) iDb = 1;
     zName = sqlite3NameFromToken(db, pName);
-    if( IN_RENAME_OBJECT ){
-      sqlite3RenameTokenMap(pParse, (void*)zName, pName);
-    }
+    if( IN_RENAME_OBJECT ){ 
+      sqlite3RenameTokenMap(pParse, (void*)zName, pName); 
+    } 
   }
   pParse->sNameToken = *pName;
   if( zName==0 ) return;
@@ -114316,7 +114316,7 @@ SQLITE_PRIVATE void sqlite3StartTable(
   ** and types will be used, so there is no need to test for namespace
   ** collisions.
   */
-  if( !IN_SPECIAL_PARSE ){
+  if( !IN_SPECIAL_PARSE ){ 
     char *zDb = db->aDb[iDb].zDbSName;
     if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
       goto begin_table_error;
@@ -114610,23 +114610,23 @@ SQLITE_PRIVATE void sqlite3AddColumn(Parse *pParse, Token sName, Token sType){
 
   if( sType.n==0 ){
     /* If there is no type specified, columns have the default affinity
-    ** 'BLOB' with a default size of 4 bytes. */
+    ** 'BLOB' with a default size of 4 bytes. */ 
     pCol->affinity = affinity;
     pCol->eCType = eType;
     pCol->szEst = szEst;
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
+#ifdef SQLITE_ENABLE_SORTER_REFERENCES 
     if( affinity==SQLITE_AFF_BLOB ){
       if( 4>=sqlite3GlobalConfig.szSorterRef ){
         pCol->colFlags |= COLFLAG_SORTERREF;
       }
-    }
-#endif
+    } 
+#endif 
   }else{
     zType = z + sqlite3Strlen30(z) + 1;
     memcpy(zType, sType.z, sType.n);
     zType[sType.n] = 0;
     sqlite3Dequote(zType);
-    pCol->affinity = sqlite3AffinityType(zType, pCol);
+    pCol->affinity = sqlite3AffinityType(zType, pCol); 
     pCol->colFlags |= COLFLAG_HASTYPE;
   }
   p->nCol++;
@@ -114642,24 +114642,24 @@ SQLITE_PRIVATE void sqlite3AddColumn(Parse *pParse, Token sName, Token sType){
 */
 SQLITE_PRIVATE void sqlite3AddNotNull(Parse *pParse, int onError){
   Table *p;
-  Column *pCol;
+  Column *pCol; 
   p = pParse->pNewTable;
   if( p==0 || NEVER(p->nCol<1) ) return;
-  pCol = &p->aCol[p->nCol-1];
-  pCol->notNull = (u8)onError;
+  pCol = &p->aCol[p->nCol-1]; 
+  pCol->notNull = (u8)onError; 
   p->tabFlags |= TF_HasNotNull;
-
-  /* Set the uniqNotNull flag on any UNIQUE or PK indexes already created
-  ** on this column.  */
-  if( pCol->colFlags & COLFLAG_UNIQUE ){
-    Index *pIdx;
-    for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
-      assert( pIdx->nKeyCol==1 && pIdx->onError!=OE_None );
-      if( pIdx->aiColumn[0]==p->nCol-1 ){
-        pIdx->uniqNotNull = 1;
-      }
-    }
-  }
+ 
+  /* Set the uniqNotNull flag on any UNIQUE or PK indexes already created 
+  ** on this column.  */ 
+  if( pCol->colFlags & COLFLAG_UNIQUE ){ 
+    Index *pIdx; 
+    for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){ 
+      assert( pIdx->nKeyCol==1 && pIdx->onError!=OE_None ); 
+      if( pIdx->aiColumn[0]==p->nCol-1 ){ 
+        pIdx->uniqNotNull = 1; 
+      } 
+    } 
+  } 
 }
 
 /*
@@ -114687,7 +114687,7 @@ SQLITE_PRIVATE void sqlite3AddNotNull(Parse *pParse, int onError){
 ** If none of the substrings in the above table are found,
 ** SQLITE_AFF_NUMERIC is returned.
 */
-SQLITE_PRIVATE char sqlite3AffinityType(const char *zIn, Column *pCol){
+SQLITE_PRIVATE char sqlite3AffinityType(const char *zIn, Column *pCol){ 
   u32 h = 0;
   char aff = SQLITE_AFF_NUMERIC;
   const char *zChar = 0;
@@ -114724,32 +114724,32 @@ SQLITE_PRIVATE char sqlite3AffinityType(const char *zIn, Column *pCol){
     }
   }
 
-  /* If pCol is not NULL, store an estimate of the field size.  The
+  /* If pCol is not NULL, store an estimate of the field size.  The 
   ** estimate is scaled so that the size of an integer is 1.  */
-  if( pCol ){
-    int v = 0;   /* default size is approx 4 bytes */
+  if( pCol ){ 
+    int v = 0;   /* default size is approx 4 bytes */ 
     if( aff<SQLITE_AFF_NUMERIC ){
       if( zChar ){
         while( zChar[0] ){
           if( sqlite3Isdigit(zChar[0]) ){
-            /* BLOB(k), VARCHAR(k), CHAR(k) -> r=(k/4+1) */
+            /* BLOB(k), VARCHAR(k), CHAR(k) -> r=(k/4+1) */ 
             sqlite3GetInt32(zChar, &v);
             break;
           }
           zChar++;
         }
       }else{
-        v = 16;   /* BLOB, TEXT, CLOB -> r=5  (approx 20 bytes)*/
+        v = 16;   /* BLOB, TEXT, CLOB -> r=5  (approx 20 bytes)*/ 
       }
     }
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-    if( v>=sqlite3GlobalConfig.szSorterRef ){
-      pCol->colFlags |= COLFLAG_SORTERREF;
-    }
-#endif
-    v = v/4 + 1;
-    if( v>255 ) v = 255;
-    pCol->szEst = v;
+#ifdef SQLITE_ENABLE_SORTER_REFERENCES 
+    if( v>=sqlite3GlobalConfig.szSorterRef ){ 
+      pCol->colFlags |= COLFLAG_SORTERREF; 
+    } 
+#endif 
+    v = v/4 + 1; 
+    if( v>255 ) v = 255; 
+    pCol->szEst = v; 
   }
   return aff;
 }
@@ -114788,7 +114788,7 @@ SQLITE_PRIVATE void sqlite3AddDefaultValue(
 #endif
     }else{
       /* A copy of pExpr is used instead of the original, as pExpr contains
-      ** tokens that point to volatile memory.
+      ** tokens that point to volatile memory. 
       */
       Expr x, *pDfltExpr;
       memset(&x, 0, sizeof(x));
@@ -114801,9 +114801,9 @@ SQLITE_PRIVATE void sqlite3AddDefaultValue(
       sqlite3ColumnSetExpr(pParse, p, pCol, pDfltExpr);
     }
   }
-  if( IN_RENAME_OBJECT ){
-    sqlite3RenameExprUnmap(pParse, pExpr);
-  }
+  if( IN_RENAME_OBJECT ){ 
+    sqlite3RenameExprUnmap(pParse, pExpr); 
+  } 
   sqlite3ExprDelete(db, pExpr);
 }
 
@@ -114820,7 +114820,7 @@ SQLITE_PRIVATE void sqlite3AddDefaultValue(
 ** accept it.  This routine does the necessary conversion.  It converts
 ** the expression given in its argument from a TK_STRING into a TK_ID
 ** if the expression is just a TK_STRING with an optional COLLATE clause.
-** If the expression is anything other than TK_STRING, the expression is
+** If the expression is anything other than TK_STRING, the expression is 
 ** unchanged.
 */
 static void sqlite3StringToId(Expr *p){
@@ -114912,10 +114912,10 @@ SQLITE_PRIVATE void sqlite3AddPrimaryKey(
    && pCol->eCType==COLTYPE_INTEGER
    && sortOrder!=SQLITE_SO_DESC
   ){
-    if( IN_RENAME_OBJECT && pList ){
-      Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr);
-      sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pCExpr);
-    }
+    if( IN_RENAME_OBJECT && pList ){ 
+      Expr *pCExpr = sqlite3ExprSkipCollate(pList->a[0].pExpr); 
+      sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pCExpr); 
+    } 
     pTab->iPKey = iCol;
     pTab->keyConf = (u8)onError;
     assert( autoInc==0 || autoInc==1 );
@@ -115081,7 +115081,7 @@ SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){
   Vdbe *v = pParse->pVdbe;
   assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
   sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION,
-                   (int)(1+(unsigned)db->aDb[iDb].pSchema->schema_cookie));
+                   (int)(1+(unsigned)db->aDb[iDb].pSchema->schema_cookie)); 
 }
 
 /*
@@ -115262,60 +115262,60 @@ static void estimateIndexWidth(Index *pIdx){
   pIdx->szIdxRow = sqlite3LogEst(wIndex*4);
 }
 
-/* Return true if column number x is any of the first nCol entries of aiCol[].
-** This is used to determine if the column number x appears in any of the
-** first nCol entries of an index.
+/* Return true if column number x is any of the first nCol entries of aiCol[]. 
+** This is used to determine if the column number x appears in any of the 
+** first nCol entries of an index. 
 */
 static int hasColumn(const i16 *aiCol, int nCol, int x){
-  while( nCol-- > 0 ){
-    if( x==*(aiCol++) ){
-      return 1;
-    }
-  }
+  while( nCol-- > 0 ){ 
+    if( x==*(aiCol++) ){ 
+      return 1; 
+    } 
+  } 
   return 0;
 }
 
 /*
-** Return true if any of the first nKey entries of index pIdx exactly
-** match the iCol-th entry of pPk.  pPk is always a WITHOUT ROWID
-** PRIMARY KEY index.  pIdx is an index on the same table.  pIdx may
-** or may not be the same index as pPk.
-**
-** The first nKey entries of pIdx are guaranteed to be ordinary columns,
-** not a rowid or expression.
-**
-** This routine differs from hasColumn() in that both the column and the
-** collating sequence must match for this routine, but for hasColumn() only
-** the column name must match.
-*/
-static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){
-  int i, j;
-  assert( nKey<=pIdx->nColumn );
-  assert( iCol<MAX(pPk->nColumn,pPk->nKeyCol) );
-  assert( pPk->idxType==SQLITE_IDXTYPE_PRIMARYKEY );
-  assert( pPk->pTable->tabFlags & TF_WithoutRowid );
-  assert( pPk->pTable==pIdx->pTable );
-  testcase( pPk==pIdx );
-  j = pPk->aiColumn[iCol];
-  assert( j!=XN_ROWID && j!=XN_EXPR );
-  for(i=0; i<nKey; i++){
-    assert( pIdx->aiColumn[i]>=0 || j>=0 );
+** Return true if any of the first nKey entries of index pIdx exactly 
+** match the iCol-th entry of pPk.  pPk is always a WITHOUT ROWID 
+** PRIMARY KEY index.  pIdx is an index on the same table.  pIdx may 
+** or may not be the same index as pPk. 
+** 
+** The first nKey entries of pIdx are guaranteed to be ordinary columns, 
+** not a rowid or expression. 
+** 
+** This routine differs from hasColumn() in that both the column and the 
+** collating sequence must match for this routine, but for hasColumn() only 
+** the column name must match. 
+*/ 
+static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){ 
+  int i, j; 
+  assert( nKey<=pIdx->nColumn ); 
+  assert( iCol<MAX(pPk->nColumn,pPk->nKeyCol) ); 
+  assert( pPk->idxType==SQLITE_IDXTYPE_PRIMARYKEY ); 
+  assert( pPk->pTable->tabFlags & TF_WithoutRowid ); 
+  assert( pPk->pTable==pIdx->pTable ); 
+  testcase( pPk==pIdx ); 
+  j = pPk->aiColumn[iCol]; 
+  assert( j!=XN_ROWID && j!=XN_EXPR ); 
+  for(i=0; i<nKey; i++){ 
+    assert( pIdx->aiColumn[i]>=0 || j>=0 ); 
     if( pIdx->aiColumn[i]==j
-     && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0
-    ){
-      return 1;
-    }
-  }
-  return 0;
-}
-
-/* Recompute the colNotIdxed field of the Index.
-**
-** colNotIdxed is a bitmask that has a 0 bit representing each indexed
-** columns that are within the first 63 columns of the table.  The
-** high-order bit of colNotIdxed is always 1.  All unindexed columns
-** of the table have a 1.
-**
+     && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0 
+    ){ 
+      return 1; 
+    } 
+  } 
+  return 0; 
+} 
+ 
+/* Recompute the colNotIdxed field of the Index. 
+** 
+** colNotIdxed is a bitmask that has a 0 bit representing each indexed 
+** columns that are within the first 63 columns of the table.  The 
+** high-order bit of colNotIdxed is always 1.  All unindexed columns 
+** of the table have a 1. 
+** 
 ** 2019-10-24:  For the purpose of this computation, virtual columns are
 ** not considered to be covered by the index, even if they are in the
 ** index, because we do not trust the logic in whereIndexExprTrans() to be
@@ -115324,26 +115324,26 @@ static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){
 ** the actual table at hand in order to recompute the virtual column, if
 ** necessary.
 **
-** The colNotIdxed mask is AND-ed with the SrcList.a[].colUsed mask
-** to determine if the index is covering index.
-*/
-static void recomputeColumnsNotIndexed(Index *pIdx){
-  Bitmask m = 0;
-  int j;
+** The colNotIdxed mask is AND-ed with the SrcList.a[].colUsed mask 
+** to determine if the index is covering index. 
+*/ 
+static void recomputeColumnsNotIndexed(Index *pIdx){ 
+  Bitmask m = 0; 
+  int j; 
   Table *pTab = pIdx->pTable;
-  for(j=pIdx->nColumn-1; j>=0; j--){
-    int x = pIdx->aiColumn[j];
+  for(j=pIdx->nColumn-1; j>=0; j--){ 
+    int x = pIdx->aiColumn[j]; 
     if( x>=0 && (pTab->aCol[x].colFlags & COLFLAG_VIRTUAL)==0 ){
-      testcase( x==BMS-1 );
-      testcase( x==BMS-2 );
-      if( x<BMS-1 ) m |= MASKBIT(x);
-    }
-  }
-  pIdx->colNotIdxed = ~m;
-  assert( (pIdx->colNotIdxed>>63)==1 );
-}
-
-/*
+      testcase( x==BMS-1 ); 
+      testcase( x==BMS-2 ); 
+      if( x<BMS-1 ) m |= MASKBIT(x); 
+    } 
+  } 
+  pIdx->colNotIdxed = ~m; 
+  assert( (pIdx->colNotIdxed>>63)==1 ); 
+} 
+ 
+/* 
 ** This routine runs at the end of parsing a CREATE TABLE statement that
 ** has a WITHOUT ROWID clause.  The job of this routine is to convert both
 ** internal schema data structures and the generated VDBE code so that they
@@ -115411,12 +115411,12 @@ static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
       pTab->tabFlags &= ~TF_WithoutRowid;
       return;
     }
-    if( IN_RENAME_OBJECT ){
-      sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
-    }
+    if( IN_RENAME_OBJECT ){ 
+      sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey); 
+    } 
     pList->a[0].sortFlags = pParse->iPkSortOrder;
     assert( pParse->pNewTable==pTab );
-    pTab->iPKey = -1;
+    pTab->iPKey = -1; 
     sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0,
                        SQLITE_IDXTYPE_PRIMARYKEY);
     if( db->mallocFailed || pParse->nErr ){
@@ -115427,7 +115427,7 @@ static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
     assert( pPk->nKeyCol==1 );
   }else{
     pPk = sqlite3PrimaryKeyIndex(pTab);
-    assert( pPk!=0 );
+    assert( pPk!=0 ); 
 
     /*
     ** Remove all redundant columns from the PRIMARY KEY.  For example, change
@@ -115435,10 +115435,10 @@ static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
     ** code assumes the PRIMARY KEY contains no repeated columns.
     */
     for(i=j=1; i<pPk->nKeyCol; i++){
-      if( isDupColumn(pPk, j, pPk, i) ){
+      if( isDupColumn(pPk, j, pPk, i) ){ 
         pPk->nColumn--;
       }else{
-        testcase( hasColumn(pPk->aiColumn, j, pPk->aiColumn[i]) );
+        testcase( hasColumn(pPk->aiColumn, j, pPk->aiColumn[i]) ); 
         pPk->azColl[j] = pPk->azColl[i];
         pPk->aSortOrder[j] = pPk->aSortOrder[i];
         pPk->aiColumn[j++] = pPk->aiColumn[i];
@@ -115470,10 +115470,10 @@ static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
     int n;
     if( IsPrimaryKeyIndex(pIdx) ) continue;
     for(i=n=0; i<nPk; i++){
-      if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){
-        testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
-        n++;
-      }
+      if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){ 
+        testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) ); 
+        n++; 
+      } 
     }
     if( n==0 ){
       /* This index is a superset of the primary key */
@@ -115482,14 +115482,14 @@ static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
     }
     if( resizeIndexObject(db, pIdx, pIdx->nKeyCol+n) ) return;
     for(i=0, j=pIdx->nKeyCol; i<nPk; i++){
-      if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){
-        testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
+      if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){ 
+        testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) ); 
         pIdx->aiColumn[j] = pPk->aiColumn[i];
         pIdx->azColl[j] = pPk->azColl[i];
-        if( pPk->aSortOrder[i] ){
-          /* See ticket https://www.sqlite.org/src/info/bba7b69f9849b5bf */
-          pIdx->bAscKeyBug = 1;
-        }
+        if( pPk->aSortOrder[i] ){ 
+          /* See ticket https://www.sqlite.org/src/info/bba7b69f9849b5bf */ 
+          pIdx->bAscKeyBug = 1; 
+        } 
         j++;
       }
     }
@@ -115517,11 +115517,11 @@ static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
   }
   assert( pPk->nColumn==j );
   assert( pTab->nNVCol<=j );
-  recomputeColumnsNotIndexed(pPk);
+  recomputeColumnsNotIndexed(pPk); 
 }
 
 
-#ifndef SQLITE_OMIT_VIRTUALTABLE
+#ifndef SQLITE_OMIT_VIRTUALTABLE 
 /*
 ** Return true if pTab is a virtual table and zName is a shadow table name
 ** for that virtual table.
@@ -115579,29 +115579,29 @@ SQLITE_PRIVATE void sqlite3MarkAllShadowTablesOf(sqlite3 *db, Table *pTab){
 
 #ifndef SQLITE_OMIT_VIRTUALTABLE
 /*
-** Return true if zName is a shadow table name in the current database
-** connection.
-**
-** zName is temporarily modified while this routine is running, but is
-** restored to its original value prior to this routine returning.
-*/
+** Return true if zName is a shadow table name in the current database 
+** connection. 
+** 
+** zName is temporarily modified while this routine is running, but is 
+** restored to its original value prior to this routine returning. 
+*/ 
 SQLITE_PRIVATE int sqlite3ShadowTableName(sqlite3 *db, const char *zName){
-  char *zTail;                  /* Pointer to the last "_" in zName */
-  Table *pTab;                  /* Table that zName is a shadow of */
-  zTail = strrchr(zName, '_');
-  if( zTail==0 ) return 0;
-  *zTail = 0;
-  pTab = sqlite3FindTable(db, zName, 0);
-  *zTail = '_';
-  if( pTab==0 ) return 0;
-  if( !IsVirtual(pTab) ) return 0;
+  char *zTail;                  /* Pointer to the last "_" in zName */ 
+  Table *pTab;                  /* Table that zName is a shadow of */ 
+  zTail = strrchr(zName, '_'); 
+  if( zTail==0 ) return 0; 
+  *zTail = 0; 
+  pTab = sqlite3FindTable(db, zName, 0); 
+  *zTail = '_'; 
+  if( pTab==0 ) return 0; 
+  if( !IsVirtual(pTab) ) return 0; 
   return sqlite3IsShadowTableOf(db, pTab, zName);
-}
-#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
-
+} 
+#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */ 
+ 
 
 #ifdef SQLITE_DEBUG
-/*
+/* 
 ** Mark all nodes of an expression as EP_Immutable, indicating that
 ** they should not be changed.  Expressions attached to a table or
 ** index definition are tagged this way to help ensure that we do
@@ -115665,8 +115665,8 @@ SQLITE_PRIVATE void sqlite3EndTable(
   if( p==0 ) return;
 
   if( pSelect==0 && sqlite3ShadowTableName(db, p->zName) ){
-    p->tabFlags |= TF_Shadow;
-  }
+    p->tabFlags |= TF_Shadow; 
+  } 
 
   /* If the db->init.busy is 1 it means we are reading the SQL off the
   ** "sqlite_schema" or "sqlite_temp_schema" table on the disk.
@@ -115679,9 +115679,9 @@ SQLITE_PRIVATE void sqlite3EndTable(
   */
   if( db->init.busy ){
     if( pSelect || (!IsOrdinaryTable(p) && db->init.newTnum) ){
-      sqlite3ErrorMsg(pParse, "");
-      return;
-    }
+      sqlite3ErrorMsg(pParse, ""); 
+      return; 
+    } 
     p->tnum = db->init.newTnum;
     if( p->tnum==1 ) p->tabFlags |= TF_Readonly;
   }
@@ -115724,11 +115724,11 @@ SQLITE_PRIVATE void sqlite3EndTable(
     }
   }
 
-  assert( (p->tabFlags & TF_HasPrimaryKey)==0
-       || p->iPKey>=0 || sqlite3PrimaryKeyIndex(p)!=0 );
-  assert( (p->tabFlags & TF_HasPrimaryKey)!=0
-       || (p->iPKey<0 && sqlite3PrimaryKeyIndex(p)==0) );
-
+  assert( (p->tabFlags & TF_HasPrimaryKey)==0 
+       || p->iPKey>=0 || sqlite3PrimaryKeyIndex(p)!=0 ); 
+  assert( (p->tabFlags & TF_HasPrimaryKey)!=0 
+       || (p->iPKey<0 && sqlite3PrimaryKeyIndex(p)==0) ); 
+ 
   /* Special processing for WITHOUT ROWID Tables */
   if( tabOpts & TF_WithoutRowid ){
     if( (p->tabFlags & TF_Autoincrement) ){
@@ -116030,12 +116030,12 @@ SQLITE_PRIVATE void sqlite3CreateView(
   ** they will persist after the current sqlite3_exec() call returns.
   */
   pSelect->selFlags |= SF_View;
-  if( IN_RENAME_OBJECT ){
+  if( IN_RENAME_OBJECT ){ 
     p->u.view.pSelect = pSelect;
-    pSelect = 0;
-  }else{
+    pSelect = 0; 
+  }else{ 
     p->u.view.pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
-  }
+  } 
   p->pCheck = sqlite3ExprListDup(db, pCNames, EXPRDUP_REDUCE);
   p->eTabType = TABTYP_VIEW;
   if( db->mallocFailed ) goto create_view_fail;
@@ -116061,9 +116061,9 @@ SQLITE_PRIVATE void sqlite3CreateView(
 
 create_view_fail:
   sqlite3SelectDelete(db, pSelect);
-  if( IN_RENAME_OBJECT ){
-    sqlite3RenameExprlistUnmap(pParse, pCNames);
-  }
+  if( IN_RENAME_OBJECT ){ 
+    sqlite3RenameExprlistUnmap(pParse, pCNames); 
+  } 
   sqlite3ExprListDelete(db, pCNames);
   return;
 }
@@ -116081,7 +116081,7 @@ SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
   int nErr = 0;     /* Number of errors encountered */
   int n;            /* Temporarily holds the number of cursors assigned */
   sqlite3 *db = pParse->db;  /* Database connection for malloc errors */
-#ifndef SQLITE_OMIT_VIRTUALTABLE
+#ifndef SQLITE_OMIT_VIRTUALTABLE 
   int rc;
 #endif
 #ifndef SQLITE_OMIT_AUTHORIZATION
@@ -116136,8 +116136,8 @@ SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
   assert( IsView(pTable) );
   pSel = sqlite3SelectDup(db, pTable->u.view.pSelect, 0);
   if( pSel ){
-    u8 eParseMode = pParse->eParseMode;
-    pParse->eParseMode = PARSE_MODE_NORMAL;
+    u8 eParseMode = pParse->eParseMode; 
+    pParse->eParseMode = PARSE_MODE_NORMAL; 
     n = pParse->nTab;
     sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
     pTable->nCol = -1;
@@ -116186,14 +116186,14 @@ SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
     sqlite3DeleteTable(db, pSelTab);
     sqlite3SelectDelete(db, pSel);
     EnableLookaside;
-    pParse->eParseMode = eParseMode;
+    pParse->eParseMode = eParseMode; 
   } else {
     nErr++;
   }
   pTable->pSchema->schemaFlags |= DB_UnresetViews;
-  if( db->mallocFailed ){
-    sqlite3DeleteColumnNames(db, pTable);
-  }
+  if( db->mallocFailed ){ 
+    sqlite3DeleteColumnNames(db, pTable); 
+  } 
 #endif /* SQLITE_OMIT_VIEW */
   return nErr;
 }
@@ -116270,7 +116270,7 @@ SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3 *db, int iDb, Pgno iFrom, Pgno
 static void destroyRootPage(Parse *pParse, int iTable, int iDb){
   Vdbe *v = sqlite3GetVdbe(pParse);
   int r1 = sqlite3GetTempReg(pParse);
-  if( iTable<2 ) sqlite3ErrorMsg(pParse, "corrupt schema");
+  if( iTable<2 ) sqlite3ErrorMsg(pParse, "corrupt schema"); 
   sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
   sqlite3MayAbort(pParse);
 #ifndef SQLITE_OMIT_AUTOVACUUM
@@ -116431,7 +116431,7 @@ SQLITE_PRIVATE void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, in
   */
   if( IsVirtual(pTab) ){
     sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
-    sqlite3MayAbort(pParse);
+    sqlite3MayAbort(pParse); 
   }
   sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
   sqlite3ChangeCookie(pParse, iDb);
@@ -116570,10 +116570,10 @@ SQLITE_PRIVATE void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView,
   v = sqlite3GetVdbe(pParse);
   if( v ){
     sqlite3BeginWriteOperation(pParse, 1, iDb);
-    if( !isView ){
-      sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
-      sqlite3FkDropTable(pParse, pName, pTab);
-    }
+    if( !isView ){ 
+      sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName); 
+      sqlite3FkDropTable(pParse, pName, pTab); 
+    } 
     sqlite3CodeDropTable(pParse, pTab, iDb, isView);
   }
 
@@ -116649,9 +116649,9 @@ SQLITE_PRIVATE void sqlite3CreateForeignKey(
   pFKey->pNextFrom = p->u.tab.pFKey;
   z = (char*)&pFKey->aCol[nCol];
   pFKey->zTo = z;
-  if( IN_RENAME_OBJECT ){
-    sqlite3RenameTokenMap(pParse, (void*)z, pTo);
-  }
+  if( IN_RENAME_OBJECT ){ 
+    sqlite3RenameTokenMap(pParse, (void*)z, pTo); 
+  } 
   memcpy(z, pTo->z, pTo->n);
   z[pTo->n] = 0;
   sqlite3Dequote(z);
@@ -116674,18 +116674,18 @@ SQLITE_PRIVATE void sqlite3CreateForeignKey(
           pFromCol->a[i].zEName);
         goto fk_end;
       }
-      if( IN_RENAME_OBJECT ){
+      if( IN_RENAME_OBJECT ){ 
         sqlite3RenameTokenRemap(pParse, &pFKey->aCol[i], pFromCol->a[i].zEName);
-      }
+      } 
     }
   }
   if( pToCol ){
     for(i=0; i<nCol; i++){
       int n = sqlite3Strlen30(pToCol->a[i].zEName);
       pFKey->aCol[i].zCol = z;
-      if( IN_RENAME_OBJECT ){
+      if( IN_RENAME_OBJECT ){ 
         sqlite3RenameTokenRemap(pParse, z, pToCol->a[i].zEName);
-      }
+      } 
       memcpy(z, pToCol->a[i].zEName, n);
       z[n] = 0;
       z += n+1;
@@ -116797,7 +116797,7 @@ static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
   sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
   addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0); VdbeCoverage(v);
   regRecord = sqlite3GetTempReg(pParse);
-  sqlite3MultiWrite(pParse);
+  sqlite3MultiWrite(pParse); 
 
   sqlite3GenerateIndexKey(pParse,pIndex,iTab,regRecord,0,&iPartIdxLabel,0,0);
   sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord);
@@ -116811,35 +116811,35 @@ static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
 
   addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0); VdbeCoverage(v);
   if( IsUniqueIndex(pIndex) ){
-    int j2 = sqlite3VdbeGoto(v, 1);
+    int j2 = sqlite3VdbeGoto(v, 1); 
     addr2 = sqlite3VdbeCurrentAddr(v);
-    sqlite3VdbeVerifyAbortable(v, OE_Abort);
+    sqlite3VdbeVerifyAbortable(v, OE_Abort); 
     sqlite3VdbeAddOp4Int(v, OP_SorterCompare, iSorter, j2, regRecord,
                          pIndex->nKeyCol); VdbeCoverage(v);
     sqlite3UniqueConstraint(pParse, OE_Abort, pIndex);
-    sqlite3VdbeJumpHere(v, j2);
+    sqlite3VdbeJumpHere(v, j2); 
   }else{
-    /* Most CREATE INDEX and REINDEX statements that are not UNIQUE can not
-    ** abort. The exception is if one of the indexed expressions contains a
-    ** user function that throws an exception when it is evaluated. But the
-    ** overhead of adding a statement journal to a CREATE INDEX statement is
-    ** very small (since most of the pages written do not contain content that
+    /* Most CREATE INDEX and REINDEX statements that are not UNIQUE can not 
+    ** abort. The exception is if one of the indexed expressions contains a 
+    ** user function that throws an exception when it is evaluated. But the 
+    ** overhead of adding a statement journal to a CREATE INDEX statement is 
+    ** very small (since most of the pages written do not contain content that 
     ** needs to be restored if the statement aborts), so we call
-    ** sqlite3MayAbort() for all CREATE INDEX statements.  */
-    sqlite3MayAbort(pParse);
+    ** sqlite3MayAbort() for all CREATE INDEX statements.  */ 
+    sqlite3MayAbort(pParse); 
     addr2 = sqlite3VdbeCurrentAddr(v);
   }
   sqlite3VdbeAddOp3(v, OP_SorterData, iSorter, regRecord, iIdx);
-  if( !pIndex->bAscKeyBug ){
-    /* This OP_SeekEnd opcode makes index insert for a REINDEX go much
-    ** faster by avoiding unnecessary seeks.  But the optimization does
-    ** not work for UNIQUE constraint indexes on WITHOUT ROWID tables
-    ** with DESC primary keys, since those indexes have there keys in
-    ** a different order from the main table.
-    ** See ticket: https://www.sqlite.org/src/info/bba7b69f9849b5bf
-    */
-    sqlite3VdbeAddOp1(v, OP_SeekEnd, iIdx);
-  }
+  if( !pIndex->bAscKeyBug ){ 
+    /* This OP_SeekEnd opcode makes index insert for a REINDEX go much 
+    ** faster by avoiding unnecessary seeks.  But the optimization does 
+    ** not work for UNIQUE constraint indexes on WITHOUT ROWID tables 
+    ** with DESC primary keys, since those indexes have there keys in 
+    ** a different order from the main table. 
+    ** See ticket: https://www.sqlite.org/src/info/bba7b69f9849b5bf 
+    */ 
+    sqlite3VdbeAddOp1(v, OP_SeekEnd, iIdx); 
+  } 
   sqlite3VdbeAddOp2(v, OP_IdxInsert, iIdx, regRecord);
   sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
   sqlite3ReleaseTempReg(pParse, regRecord);
@@ -117018,7 +117018,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
   assert( pParse->nErr==0 );
   if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0
        && db->init.busy==0
-       && pTblName!=0
+       && pTblName!=0 
 #if SQLITE_USER_AUTHENTICATION
        && sqlite3UserAuthTable(pTab->zName)==0
 #endif
@@ -117059,21 +117059,21 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
     if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){
       goto exit_create_index;
     }
-    if( !IN_RENAME_OBJECT ){
-      if( !db->init.busy ){
-        if( sqlite3FindTable(db, zName, 0)!=0 ){
-          sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
-          goto exit_create_index;
-        }
-      }
-      if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){
-        if( !ifNotExist ){
-          sqlite3ErrorMsg(pParse, "index %s already exists", zName);
-        }else{
-          assert( !db->init.busy );
-          sqlite3CodeVerifySchema(pParse, iDb);
+    if( !IN_RENAME_OBJECT ){ 
+      if( !db->init.busy ){ 
+        if( sqlite3FindTable(db, zName, 0)!=0 ){ 
+          sqlite3ErrorMsg(pParse, "there is already a table named %s", zName); 
+          goto exit_create_index; 
+        } 
+      } 
+      if( sqlite3FindIndex(db, zName, pDb->zDbSName)!=0 ){ 
+        if( !ifNotExist ){ 
+          sqlite3ErrorMsg(pParse, "index %s already exists", zName); 
+        }else{ 
+          assert( !db->init.busy ); 
+          sqlite3CodeVerifySchema(pParse, iDb); 
           sqlite3ForceNotReadOnly(pParse);
-        }
+        } 
         goto exit_create_index;
       }
     }
@@ -117091,13 +117091,13 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
     ** The following statement converts "sqlite3_autoindex..." into
     ** "sqlite3_butoindex..." in order to make the names distinct.
     ** The "vtab_err.test" test demonstrates the need of this statement. */
-    if( IN_SPECIAL_PARSE ) zName[7]++;
+    if( IN_SPECIAL_PARSE ) zName[7]++; 
   }
 
   /* Check for authorization to create an index.
   */
 #ifndef SQLITE_OMIT_AUTHORIZATION
-  if( !IN_RENAME_OBJECT ){
+  if( !IN_RENAME_OBJECT ){ 
     const char *zDb = pDb->zDbSName;
     if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
       goto exit_create_index;
@@ -117116,8 +117116,8 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
   */
   if( pList==0 ){
     Token prevCol;
-    Column *pCol = &pTab->aCol[pTab->nCol-1];
-    pCol->colFlags |= COLFLAG_UNIQUE;
+    Column *pCol = &pTab->aCol[pTab->nCol-1]; 
+    pCol->colFlags |= COLFLAG_UNIQUE; 
     sqlite3TokenInit(&prevCol, pCol->zCnName);
     pList = sqlite3ExprListAppend(pParse, 0,
               sqlite3ExprAlloc(db, TK_ID, &prevCol, 0));
@@ -117126,7 +117126,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
     sqlite3ExprListSetSortOrder(pList, sortOrder, SQLITE_SO_UNDEFINED);
   }else{
     sqlite3ExprListCheckLength(pParse, pList, "index");
-    if( pParse->nErr ) goto exit_create_index;
+    if( pParse->nErr ) goto exit_create_index; 
   }
 
   /* Figure out how many bytes of space are required to store explicitly
@@ -117146,7 +117146,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
   */
   nName = sqlite3Strlen30(zName);
   nExtraCol = pPk ? pPk->nKeyCol : 1;
-  assert( pList->nExpr + nExtraCol <= 32767 /* Fits in i16 */ );
+  assert( pList->nExpr + nExtraCol <= 32767 /* Fits in i16 */ ); 
   pIndex = sqlite3AllocateIndexObject(db, pList->nExpr + nExtraCol,
                                       nName + nExtra + 1, &zExtra);
   if( db->mallocFailed ){
@@ -117187,12 +117187,12 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
   ** TODO: Issue a warning if the table primary key is used as part of the
   ** index key.
   */
-  pListItem = pList->a;
-  if( IN_RENAME_OBJECT ){
-    pIndex->aColExpr = pList;
-    pList = 0;
-  }
-  for(i=0; i<pIndex->nKeyCol; i++, pListItem++){
+  pListItem = pList->a; 
+  if( IN_RENAME_OBJECT ){ 
+    pIndex->aColExpr = pList; 
+    pList = 0; 
+  } 
+  for(i=0; i<pIndex->nKeyCol; i++, pListItem++){ 
     Expr *pCExpr;                  /* The i-th index expression */
     int requestedSortOrder;        /* ASC or DESC on the i-th expression */
     const char *zColl;             /* Collation sequence name */
@@ -117208,8 +117208,8 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
         goto exit_create_index;
       }
       if( pIndex->aColExpr==0 ){
-        pIndex->aColExpr = pList;
-        pList = 0;
+        pIndex->aColExpr = pList; 
+        pList = 0; 
       }
       j = XN_EXPR;
       pIndex->aiColumn[i] = XN_EXPR;
@@ -117260,10 +117260,10 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
     for(j=0; j<pPk->nKeyCol; j++){
       int x = pPk->aiColumn[j];
       assert( x>=0 );
-      if( isDupColumn(pIndex, pIndex->nKeyCol, pPk, j) ){
+      if( isDupColumn(pIndex, pIndex->nKeyCol, pPk, j) ){ 
         pIndex->nColumn--;
       }else{
-        testcase( hasColumn(pIndex->aiColumn,pIndex->nKeyCol,x) );
+        testcase( hasColumn(pIndex->aiColumn,pIndex->nKeyCol,x) ); 
         pIndex->aiColumn[i] = x;
         pIndex->azColl[i] = pPk->azColl[j];
         pIndex->aSortOrder[i] = pPk->aSortOrder[j];
@@ -117282,7 +117282,7 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
   ** it as a covering index */
   assert( HasRowid(pTab)
       || pTab->iPKey<0 || sqlite3TableColumnToIndex(pIndex, pTab->iPKey)>=0 );
-  recomputeColumnsNotIndexed(pIndex);
+  recomputeColumnsNotIndexed(pIndex); 
   if( pTblName!=0 && pIndex->nColumn>=pTab->nCol ){
     pIndex->isCovering = 1;
     for(j=0; j<pTab->nCol; j++){
@@ -117350,115 +117350,115 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
           }
         }
         if( idxType==SQLITE_IDXTYPE_PRIMARYKEY ) pIdx->idxType = idxType;
-        if( IN_RENAME_OBJECT ){
-          pIndex->pNext = pParse->pNewIndex;
-          pParse->pNewIndex = pIndex;
-          pIndex = 0;
-        }
+        if( IN_RENAME_OBJECT ){ 
+          pIndex->pNext = pParse->pNewIndex; 
+          pParse->pNewIndex = pIndex; 
+          pIndex = 0; 
+        } 
         goto exit_create_index;
       }
     }
   }
 
-  if( !IN_RENAME_OBJECT ){
-
-    /* Link the new Index structure to its table and to the other
+  if( !IN_RENAME_OBJECT ){ 
+ 
+    /* Link the new Index structure to its table and to the other 
     ** in-memory database structures.
-    */
-    assert( pParse->nErr==0 );
-    if( db->init.busy ){
-      Index *p;
-      assert( !IN_SPECIAL_PARSE );
-      assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) );
-      if( pTblName!=0 ){
-        pIndex->tnum = db->init.newTnum;
-        if( sqlite3IndexHasDuplicateRootPage(pIndex) ){
-          sqlite3ErrorMsg(pParse, "invalid rootpage");
-          pParse->rc = SQLITE_CORRUPT_BKPT;
-          goto exit_create_index;
-        }
-      }
+    */ 
+    assert( pParse->nErr==0 ); 
+    if( db->init.busy ){ 
+      Index *p; 
+      assert( !IN_SPECIAL_PARSE ); 
+      assert( sqlite3SchemaMutexHeld(db, 0, pIndex->pSchema) ); 
+      if( pTblName!=0 ){ 
+        pIndex->tnum = db->init.newTnum; 
+        if( sqlite3IndexHasDuplicateRootPage(pIndex) ){ 
+          sqlite3ErrorMsg(pParse, "invalid rootpage"); 
+          pParse->rc = SQLITE_CORRUPT_BKPT; 
+          goto exit_create_index; 
+        } 
+      } 
       p = sqlite3HashInsert(&pIndex->pSchema->idxHash,
-          pIndex->zName, pIndex);
-      if( p ){
-        assert( p==pIndex );  /* Malloc must have failed */
-        sqlite3OomFault(db);
-        goto exit_create_index;
-      }
-      db->mDbFlags |= DBFLAG_SchemaChange;
-    }
-
-    /* If this is the initial CREATE INDEX statement (or CREATE TABLE if the
-    ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then
-    ** emit code to allocate the index rootpage on disk and make an entry for
+          pIndex->zName, pIndex); 
+      if( p ){ 
+        assert( p==pIndex );  /* Malloc must have failed */ 
+        sqlite3OomFault(db); 
+        goto exit_create_index; 
+      } 
+      db->mDbFlags |= DBFLAG_SchemaChange; 
+    }
+
+    /* If this is the initial CREATE INDEX statement (or CREATE TABLE if the 
+    ** index is an implied index for a UNIQUE or PRIMARY KEY constraint) then 
+    ** emit code to allocate the index rootpage on disk and make an entry for 
     ** the index in the sqlite_schema table and populate the index with
     ** content.  But, do not do this if we are simply reading the sqlite_schema
-    ** table to parse the schema, or if this index is the PRIMARY KEY index
-    ** of a WITHOUT ROWID table.
-    **
-    ** If pTblName==0 it means this index is generated as an implied PRIMARY KEY
-    ** or UNIQUE index in a CREATE TABLE statement.  Since the table
-    ** has just been created, it contains no data and the index initialization
-    ** step can be skipped.
-    */
-    else if( HasRowid(pTab) || pTblName!=0 ){
-      Vdbe *v;
-      char *zStmt;
-      int iMem = ++pParse->nMem;
-
-      v = sqlite3GetVdbe(pParse);
-      if( v==0 ) goto exit_create_index;
-
-      sqlite3BeginWriteOperation(pParse, 1, iDb);
-
-      /* Create the rootpage for the index using CreateIndex. But before
+    ** table to parse the schema, or if this index is the PRIMARY KEY index 
+    ** of a WITHOUT ROWID table. 
+    ** 
+    ** If pTblName==0 it means this index is generated as an implied PRIMARY KEY 
+    ** or UNIQUE index in a CREATE TABLE statement.  Since the table 
+    ** has just been created, it contains no data and the index initialization 
+    ** step can be skipped. 
+    */ 
+    else if( HasRowid(pTab) || pTblName!=0 ){ 
+      Vdbe *v; 
+      char *zStmt; 
+      int iMem = ++pParse->nMem; 
+
+      v = sqlite3GetVdbe(pParse); 
+      if( v==0 ) goto exit_create_index; 
+
+      sqlite3BeginWriteOperation(pParse, 1, iDb); 
+
+      /* Create the rootpage for the index using CreateIndex. But before 
       ** doing so, code a Noop instruction and store its address in
       ** Index.tnum. This is required in case this index is actually a
       ** PRIMARY KEY and the table is actually a WITHOUT ROWID table. In
-      ** that case the convertToWithoutRowidTable() routine will replace
-      ** the Noop with a Goto to jump over the VDBE code generated below. */
+      ** that case the convertToWithoutRowidTable() routine will replace 
+      ** the Noop with a Goto to jump over the VDBE code generated below. */ 
       pIndex->tnum = (Pgno)sqlite3VdbeAddOp0(v, OP_Noop);
-      sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, iMem, BTREE_BLOBKEY);
+      sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, iMem, BTREE_BLOBKEY); 
 
-      /* Gather the complete text of the CREATE INDEX statement into
-      ** the zStmt variable
-      */
+      /* Gather the complete text of the CREATE INDEX statement into 
+      ** the zStmt variable 
+      */ 
       assert( pName!=0 || pStart==0 );
-      if( pStart ){
-        int n = (int)(pParse->sLastToken.z - pName->z) + pParse->sLastToken.n;
-        if( pName->z[n-1]==';' ) n--;
-        /* A named index with an explicit CREATE INDEX statement */
-        zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s",
-            onError==OE_None ? "" : " UNIQUE", n, pName->z);
-      }else{
-        /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */
-        /* zStmt = sqlite3MPrintf(""); */
-        zStmt = 0;
-      }
+      if( pStart ){ 
+        int n = (int)(pParse->sLastToken.z - pName->z) + pParse->sLastToken.n; 
+        if( pName->z[n-1]==';' ) n--; 
+        /* A named index with an explicit CREATE INDEX statement */ 
+        zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s", 
+            onError==OE_None ? "" : " UNIQUE", n, pName->z); 
+      }else{ 
+        /* An automatic index created by a PRIMARY KEY or UNIQUE constraint */ 
+        /* zStmt = sqlite3MPrintf(""); */ 
+        zStmt = 0; 
+      } 
 
       /* Add an entry in sqlite_schema for this index
-      */
+      */ 
       sqlite3NestedParse(pParse,
           "INSERT INTO %Q." LEGACY_SCHEMA_TABLE " VALUES('index',%Q,%Q,#%d,%Q);",
           db->aDb[iDb].zDbSName,
-          pIndex->zName,
-          pTab->zName,
-          iMem,
-          zStmt
-          );
-      sqlite3DbFree(db, zStmt);
-
-      /* Fill the index with data and reparse the schema. Code an OP_Expire
-      ** to invalidate all pre-compiled statements.
-      */
-      if( pTblName ){
-        sqlite3RefillIndex(pParse, pIndex, iMem);
-        sqlite3ChangeCookie(pParse, iDb);
-        sqlite3VdbeAddParseSchemaOp(v, iDb,
+          pIndex->zName, 
+          pTab->zName, 
+          iMem, 
+          zStmt 
+          ); 
+      sqlite3DbFree(db, zStmt); 
+
+      /* Fill the index with data and reparse the schema. Code an OP_Expire 
+      ** to invalidate all pre-compiled statements. 
+      */ 
+      if( pTblName ){ 
+        sqlite3RefillIndex(pParse, pIndex, iMem); 
+        sqlite3ChangeCookie(pParse, iDb); 
+        sqlite3VdbeAddParseSchemaOp(v, iDb, 
             sqlite3MPrintf(db, "name='%q' AND type='index'", pIndex->zName), 0);
-        sqlite3VdbeAddOp2(v, OP_Expire, 0, 1);
-      }
-
+        sqlite3VdbeAddOp2(v, OP_Expire, 0, 1); 
+      } 
+ 
       sqlite3VdbeJumpHere(v, (int)pIndex->tnum);
     }
   }
@@ -117467,15 +117467,15 @@ SQLITE_PRIVATE void sqlite3CreateIndex(
     pTab->pIndex = pIndex;
     pIndex = 0;
   }
-  else if( IN_RENAME_OBJECT ){
-    assert( pParse->pNewIndex==0 );
-    pParse->pNewIndex = pIndex;
-    pIndex = 0;
-  }
+  else if( IN_RENAME_OBJECT ){ 
+    assert( pParse->pNewIndex==0 ); 
+    pParse->pNewIndex = pIndex; 
+    pIndex = 0; 
+  } 
 
   /* Clean up before exiting */
 exit_create_index:
-  if( pIndex ) sqlite3FreeIndex(db, pIndex);
+  if( pIndex ) sqlite3FreeIndex(db, pIndex); 
   if( pTab ){
     /* Ensure all REPLACE indexes on pTab are at the end of the pIndex list.
     ** The list was already ordered when this routine was entered, so at this
@@ -117663,9 +117663,9 @@ SQLITE_PRIVATE void *sqlite3ArrayAllocate(
   int *pIdx         /* Write the index of a new slot here */
 ){
   char *z;
-  sqlite3_int64 n = *pIdx = *pnEntry;
+  sqlite3_int64 n = *pIdx = *pnEntry; 
   if( (n & (n-1))==0 ){
-    sqlite3_int64 sz = (n==0) ? 1 : 2*n;
+    sqlite3_int64 sz = (n==0) ? 1 : 2*n; 
     void *pNew = sqlite3DbRealloc(db, pArray, sz*szEntry);
     if( pNew==0 ){
       *pIdx = -1;
@@ -117685,8 +117685,8 @@ SQLITE_PRIVATE void *sqlite3ArrayAllocate(
 **
 ** A new IdList is returned, or NULL if malloc() fails.
 */
-SQLITE_PRIVATE IdList *sqlite3IdListAppend(Parse *pParse, IdList *pList, Token *pToken){
-  sqlite3 *db = pParse->db;
+SQLITE_PRIVATE IdList *sqlite3IdListAppend(Parse *pParse, IdList *pList, Token *pToken){ 
+  sqlite3 *db = pParse->db; 
   int i;
   if( pList==0 ){
     pList = sqlite3DbMallocZero(db, sizeof(IdList) );
@@ -117704,9 +117704,9 @@ SQLITE_PRIVATE IdList *sqlite3IdListAppend(Parse *pParse, IdList *pList, Token *
     return 0;
   }
   pList->a[i].zName = sqlite3NameFromToken(db, pToken);
-  if( IN_RENAME_OBJECT && pList->a[i].zName ){
-    sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken);
-  }
+  if( IN_RENAME_OBJECT && pList->a[i].zName ){ 
+    sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken); 
+  } 
   return pList;
 }
 
@@ -117737,18 +117737,18 @@ SQLITE_PRIVATE int sqlite3IdListIndex(IdList *pList, const char *zName){
 }
 
 /*
-** Maximum size of a SrcList object.
-** The SrcList object is used to represent the FROM clause of a
-** SELECT statement, and the query planner cannot deal with more
-** than 64 tables in a join.  So any value larger than 64 here
-** is sufficient for most uses.  Smaller values, like say 10, are
-** appropriate for small and memory-limited applications.
-*/
-#ifndef SQLITE_MAX_SRCLIST
-# define SQLITE_MAX_SRCLIST 200
-#endif
-
-/*
+** Maximum size of a SrcList object. 
+** The SrcList object is used to represent the FROM clause of a 
+** SELECT statement, and the query planner cannot deal with more 
+** than 64 tables in a join.  So any value larger than 64 here 
+** is sufficient for most uses.  Smaller values, like say 10, are 
+** appropriate for small and memory-limited applications. 
+*/ 
+#ifndef SQLITE_MAX_SRCLIST 
+# define SQLITE_MAX_SRCLIST 200 
+#endif 
+ 
+/* 
 ** Expand the space allocated for the given SrcList object by
 ** creating nExtra new slots beginning at iStart.  iStart is zero based.
 ** New slots are zeroed.
@@ -117764,12 +117764,12 @@ SQLITE_PRIVATE int sqlite3IdListIndex(IdList *pList, const char *zName){
 ** the iStart value would be 0.  The result then would
 ** be: nil, nil, nil, A, B.
 **
-** If a memory allocation fails or the SrcList becomes too large, leave
-** the original SrcList unchanged, return NULL, and leave an error message
-** in pParse.
+** If a memory allocation fails or the SrcList becomes too large, leave 
+** the original SrcList unchanged, return NULL, and leave an error message 
+** in pParse. 
 */
 SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(
-  Parse *pParse,     /* Parsing context into which errors are reported */
+  Parse *pParse,     /* Parsing context into which errors are reported */ 
   SrcList *pSrc,     /* The SrcList to be enlarged */
   int nExtra,        /* Number of new slots to add to pSrc->a[] */
   int iStart         /* Index in pSrc->a[] of first new slot */
@@ -117785,23 +117785,23 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(
   /* Allocate additional space if needed */
   if( (u32)pSrc->nSrc+nExtra>pSrc->nAlloc ){
     SrcList *pNew;
-    sqlite3_int64 nAlloc = 2*(sqlite3_int64)pSrc->nSrc+nExtra;
-    sqlite3 *db = pParse->db;
-
-    if( pSrc->nSrc+nExtra>=SQLITE_MAX_SRCLIST ){
-      sqlite3ErrorMsg(pParse, "too many FROM clause terms, max: %d",
-                      SQLITE_MAX_SRCLIST);
-      return 0;
-    }
-    if( nAlloc>SQLITE_MAX_SRCLIST ) nAlloc = SQLITE_MAX_SRCLIST;
+    sqlite3_int64 nAlloc = 2*(sqlite3_int64)pSrc->nSrc+nExtra; 
+    sqlite3 *db = pParse->db; 
+ 
+    if( pSrc->nSrc+nExtra>=SQLITE_MAX_SRCLIST ){ 
+      sqlite3ErrorMsg(pParse, "too many FROM clause terms, max: %d", 
+                      SQLITE_MAX_SRCLIST); 
+      return 0; 
+    } 
+    if( nAlloc>SQLITE_MAX_SRCLIST ) nAlloc = SQLITE_MAX_SRCLIST; 
     pNew = sqlite3DbRealloc(db, pSrc,
                sizeof(*pSrc) + (nAlloc-1)*sizeof(pSrc->a[0]) );
     if( pNew==0 ){
       assert( db->mallocFailed );
-      return 0;
+      return 0; 
     }
     pSrc = pNew;
-    pSrc->nAlloc = nAlloc;
+    pSrc->nAlloc = nAlloc; 
   }
 
   /* Move existing slots that come after the newly inserted slots
@@ -117826,8 +117826,8 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(
 ** Append a new table name to the given SrcList.  Create a new SrcList if
 ** need be.  A new entry is created in the SrcList even if pTable is NULL.
 **
-** A SrcList is returned, or NULL if there is an OOM error or if the
-** SrcList grows to large.  The returned
+** A SrcList is returned, or NULL if there is an OOM error or if the 
+** SrcList grows to large.  The returned 
 ** SrcList might be the same as the SrcList that was input or it might be
 ** a new one.  If an OOM error does occurs, then the prior value of pList
 ** that is input to this routine is automatically freed.
@@ -117858,32 +117858,32 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(
 ** before being added to the SrcList.
 */
 SQLITE_PRIVATE SrcList *sqlite3SrcListAppend(
-  Parse *pParse,      /* Parsing context, in which errors are reported */
+  Parse *pParse,      /* Parsing context, in which errors are reported */ 
   SrcList *pList,     /* Append to this SrcList. NULL creates a new SrcList */
   Token *pTable,      /* Table to append */
   Token *pDatabase    /* Database of the table */
 ){
   SrcItem *pItem;
-  sqlite3 *db;
+  sqlite3 *db; 
   assert( pDatabase==0 || pTable!=0 );  /* Cannot have C without B */
-  assert( pParse!=0 );
-  assert( pParse->db!=0 );
-  db = pParse->db;
+  assert( pParse!=0 ); 
+  assert( pParse->db!=0 ); 
+  db = pParse->db; 
   if( pList==0 ){
-    pList = sqlite3DbMallocRawNN(pParse->db, sizeof(SrcList) );
+    pList = sqlite3DbMallocRawNN(pParse->db, sizeof(SrcList) ); 
     if( pList==0 ) return 0;
     pList->nAlloc = 1;
     pList->nSrc = 1;
     memset(&pList->a[0], 0, sizeof(pList->a[0]));
     pList->a[0].iCursor = -1;
   }else{
-    SrcList *pNew = sqlite3SrcListEnlarge(pParse, pList, 1, pList->nSrc);
-    if( pNew==0 ){
-      sqlite3SrcListDelete(db, pList);
-      return 0;
-    }else{
-      pList = pNew;
-    }
+    SrcList *pNew = sqlite3SrcListEnlarge(pParse, pList, 1, pList->nSrc); 
+    if( pNew==0 ){ 
+      sqlite3SrcListDelete(db, pList); 
+      return 0; 
+    }else{ 
+      pList = pNew; 
+    } 
   }
   pItem = &pList->a[pList->nSrc-1];
   if( pDatabase && pDatabase->z==0 ){
@@ -117972,18 +117972,18 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm(
     );
     goto append_from_error;
   }
-  p = sqlite3SrcListAppend(pParse, p, pTable, pDatabase);
+  p = sqlite3SrcListAppend(pParse, p, pTable, pDatabase); 
   if( p==0 ){
     goto append_from_error;
   }
   assert( p->nSrc>0 );
   pItem = &p->a[p->nSrc-1];
-  assert( (pTable==0)==(pDatabase==0) );
-  assert( pItem->zName==0 || pDatabase!=0 );
-  if( IN_RENAME_OBJECT && pItem->zName ){
-    Token *pToken = (ALWAYS(pDatabase) && pDatabase->z) ? pDatabase : pTable;
-    sqlite3RenameTokenMap(pParse, pItem->zName, pToken);
-  }
+  assert( (pTable==0)==(pDatabase==0) ); 
+  assert( pItem->zName==0 || pDatabase!=0 ); 
+  if( IN_RENAME_OBJECT && pItem->zName ){ 
+    Token *pToken = (ALWAYS(pDatabase) && pDatabase->z) ? pDatabase : pTable; 
+    sqlite3RenameTokenMap(pParse, pItem->zName, pToken); 
+  } 
   assert( pAlias!=0 );
   if( pAlias->n ){
     pItem->zAlias = sqlite3NameFromToken(db, pAlias);
@@ -118327,18 +118327,18 @@ SQLITE_PRIVATE void sqlite3UniqueConstraint(
   Table *pTab = pIdx->pTable;
 
   sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0,
-                      pParse->db->aLimit[SQLITE_LIMIT_LENGTH]);
+                      pParse->db->aLimit[SQLITE_LIMIT_LENGTH]); 
   if( pIdx->aColExpr ){
-    sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName);
+    sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName); 
   }else{
     for(j=0; j<pIdx->nKeyCol; j++){
       char *zCol;
       assert( pIdx->aiColumn[j]>=0 );
       zCol = pTab->aCol[pIdx->aiColumn[j]].zCnName;
-      if( j ) sqlite3_str_append(&errMsg, ", ", 2);
-      sqlite3_str_appendall(&errMsg, pTab->zName);
-      sqlite3_str_append(&errMsg, ".", 1);
-      sqlite3_str_appendall(&errMsg, zCol);
+      if( j ) sqlite3_str_append(&errMsg, ", ", 2); 
+      sqlite3_str_appendall(&errMsg, pTab->zName); 
+      sqlite3_str_append(&errMsg, ".", 1); 
+      sqlite3_str_appendall(&errMsg, zCol); 
     }
   }
   zErr = sqlite3StrAccumFinish(&errMsg);
@@ -118396,15 +118396,15 @@ static int collationMatch(const char *zColl, Index *pIndex){
 */
 #ifndef SQLITE_OMIT_REINDEX
 static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
-  if( !IsVirtual(pTab) ){
-    Index *pIndex;              /* An index associated with pTab */
+  if( !IsVirtual(pTab) ){ 
+    Index *pIndex;              /* An index associated with pTab */ 
 
-    for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
-      if( zColl==0 || collationMatch(zColl, pIndex) ){
-        int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
-        sqlite3BeginWriteOperation(pParse, 0, iDb);
-        sqlite3RefillIndex(pParse, pIndex, -1);
-      }
+    for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){ 
+      if( zColl==0 || collationMatch(zColl, pIndex) ){ 
+        int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); 
+        sqlite3BeginWriteOperation(pParse, 0, iDb); 
+        sqlite3RefillIndex(pParse, pIndex, -1); 
+      } 
     }
   }
 }
@@ -118629,7 +118629,7 @@ SQLITE_PRIVATE With *sqlite3WithAdd(
   }
 
   if( pWith ){
-    sqlite3_int64 nByte = sizeof(*pWith) + (sizeof(pWith->a[1]) * pWith->nCte);
+    sqlite3_int64 nByte = sizeof(*pWith) + (sizeof(pWith->a[1]) * pWith->nCte); 
     pNew = sqlite3DbRealloc(db, pWith, nByte);
   }else{
     pNew = sqlite3DbMallocZero(db, sizeof(*pWith));
@@ -118996,7 +118996,7 @@ static int matchQuality(
 ** Search a FuncDefHash for a function with the given name.  Return
 ** a pointer to the matching FuncDef if found, or 0 if there is no match.
 */
-SQLITE_PRIVATE FuncDef *sqlite3FunctionSearch(
+SQLITE_PRIVATE FuncDef *sqlite3FunctionSearch( 
   int h,               /* Hash of the name */
   const char *zFunc    /* Name of function */
 ){
@@ -119022,10 +119022,10 @@ SQLITE_PRIVATE void sqlite3InsertBuiltinFuncs(
     FuncDef *pOther;
     const char *zName = aDef[i].zName;
     int nName = sqlite3Strlen30(zName);
-    int h = SQLITE_FUNC_HASH(zName[0], nName);
+    int h = SQLITE_FUNC_HASH(zName[0], nName); 
     assert( zName[0]>='a' && zName[0]<='z' );
     assert( aDef[i].funcFlags & SQLITE_FUNC_BUILTIN );
-    pOther = sqlite3FunctionSearch(h, zName);
+    pOther = sqlite3FunctionSearch(h, zName); 
     if( pOther ){
       assert( pOther!=&aDef[i] && pOther->pNext!=&aDef[i] );
       aDef[i].pNext = pOther->pNext;
@@ -119102,8 +119102,8 @@ SQLITE_PRIVATE FuncDef *sqlite3FindFunction(
   */
   if( !createFlag && (pBest==0 || (db->mDbFlags & DBFLAG_PreferBuiltin)!=0) ){
     bestScore = 0;
-    h = SQLITE_FUNC_HASH(sqlite3UpperToLower[(u8)zName[0]], nName);
-    p = sqlite3FunctionSearch(h, zName);
+    h = SQLITE_FUNC_HASH(sqlite3UpperToLower[(u8)zName[0]], nName); 
+    p = sqlite3FunctionSearch(h, zName); 
     while( p ){
       int score = matchQuality(p, nArg, enc);
       if( score>bestScore ){
@@ -119121,12 +119121,12 @@ SQLITE_PRIVATE FuncDef *sqlite3FindFunction(
   if( createFlag && bestScore<FUNC_PERFECT_MATCH &&
       (pBest = sqlite3DbMallocZero(db, sizeof(*pBest)+nName+1))!=0 ){
     FuncDef *pOther;
-    u8 *z;
+    u8 *z; 
     pBest->zName = (const char*)&pBest[1];
     pBest->nArg = (u16)nArg;
     pBest->funcFlags = enc;
     memcpy((char*)&pBest[1], zName, nName+1);
-    for(z=(u8*)pBest->zName; *z; z++) *z = sqlite3UpperToLower[*z];
+    for(z=(u8*)pBest->zName; *z; z++) *z = sqlite3UpperToLower[*z]; 
     pOther = (FuncDef*)sqlite3HashInsert(&db->aFunc, pBest->zName, pBest);
     if( pOther==pBest ){
       sqlite3DbFree(db, pBest);
@@ -119250,42 +119250,42 @@ SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){
   return pTab;
 }
 
-/* Return true if table pTab is read-only.
-**
-** A table is read-only if any of the following are true:
-**
-**   1) It is a virtual table and no implementation of the xUpdate method
-**      has been provided
-**
+/* Return true if table pTab is read-only. 
+** 
+** A table is read-only if any of the following are true: 
+** 
+**   1) It is a virtual table and no implementation of the xUpdate method 
+**      has been provided 
+** 
 **   2) It is a system table (i.e. sqlite_schema), this call is not
 **      part of a nested parse and writable_schema pragma has not
-**      been specified
-**
-**   3) The table is a shadow table, the database connection is in
-**      defensive mode, and the current sqlite3_prepare()
-**      is for a top-level SQL statement.
-*/
-static int tabIsReadOnly(Parse *pParse, Table *pTab){
-  sqlite3 *db;
-  if( IsVirtual(pTab) ){
-    return sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0;
-  }
-  if( (pTab->tabFlags & (TF_Readonly|TF_Shadow))==0 ) return 0;
-  db = pParse->db;
-  if( (pTab->tabFlags & TF_Readonly)!=0 ){
-    return sqlite3WritableSchema(db)==0 && pParse->nested==0;
-  }
-  assert( pTab->tabFlags & TF_Shadow );
+**      been specified 
+** 
+**   3) The table is a shadow table, the database connection is in 
+**      defensive mode, and the current sqlite3_prepare() 
+**      is for a top-level SQL statement. 
+*/ 
+static int tabIsReadOnly(Parse *pParse, Table *pTab){ 
+  sqlite3 *db; 
+  if( IsVirtual(pTab) ){ 
+    return sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0; 
+  } 
+  if( (pTab->tabFlags & (TF_Readonly|TF_Shadow))==0 ) return 0; 
+  db = pParse->db; 
+  if( (pTab->tabFlags & TF_Readonly)!=0 ){ 
+    return sqlite3WritableSchema(db)==0 && pParse->nested==0; 
+  } 
+  assert( pTab->tabFlags & TF_Shadow ); 
   return sqlite3ReadOnlyShadowTables(db);
-}
-
+} 
+ 
 /*
 ** Check to make sure the given table is writable.  If it is not
 ** writable, generate an error message and return 1.  If it is
 ** writable return 0;
 */
 SQLITE_PRIVATE int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){
-  if( tabIsReadOnly(pParse, pTab) ){
+  if( tabIsReadOnly(pParse, pTab) ){ 
     sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
     return 1;
   }
@@ -119319,7 +119319,7 @@ SQLITE_PRIVATE void sqlite3MaterializeView(
   sqlite3 *db = pParse->db;
   int iDb = sqlite3SchemaToIndex(db, pView->pSchema);
   pWhere = sqlite3ExprDup(db, pWhere, 0);
-  pFrom = sqlite3SrcListAppend(pParse, 0, 0, 0);
+  pFrom = sqlite3SrcListAppend(pParse, 0, 0, 0); 
   if( pFrom ){
     assert( pFrom->nSrc==1 );
     pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);
@@ -119464,7 +119464,7 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(
   AuthContext sContext;  /* Authorization context */
   NameContext sNC;       /* Name context to resolve expressions in */
   int iDb;               /* Database number */
-  int memCnt = 0;        /* Memory cell used for change counting */
+  int memCnt = 0;        /* Memory cell used for change counting */ 
   int rcauth;            /* Value returned by authorization callback */
   int eOnePass;          /* ONEPASS_OFF or _SINGLE or _MULTI */
   int aiCurOnePass[2];   /* The write cursors opened by WHERE_ONEPASS */
@@ -119569,7 +119569,7 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(
     goto delete_from_cleanup;
   }
   if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
-  sqlite3BeginWriteOperation(pParse, bComplex, iDb);
+  sqlite3BeginWriteOperation(pParse, bComplex, iDb); 
 
   /* If we are trying to delete from a view, realize that view into
   ** an ephemeral table.
@@ -119597,11 +119597,11 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(
   /* Initialize the counter of the number of rows deleted, if
   ** we are counting rows.
   */
-  if( (db->flags & SQLITE_CountRows)!=0
-   && !pParse->nested
-   && !pParse->pTriggerTab
+  if( (db->flags & SQLITE_CountRows)!=0 
+   && !pParse->nested 
+   && !pParse->pTriggerTab 
    && !pParse->bReturning
-  ){
+  ){ 
     memCnt = ++pParse->nMem;
     sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt);
   }
@@ -119629,7 +119629,7 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(
     assert( !isView );
     sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
     if( HasRowid(pTab) ){
-      sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt ? memCnt : -1,
+      sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt ? memCnt : -1, 
                         pTab->zName, P4_STATIC);
     }
     for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
@@ -119677,13 +119677,13 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(
     eOnePass = sqlite3WhereOkOnePass(pWInfo, aiCurOnePass);
     assert( IsVirtual(pTab)==0 || eOnePass!=ONEPASS_MULTI );
     assert( IsVirtual(pTab) || bComplex || eOnePass!=ONEPASS_OFF );
-    if( eOnePass!=ONEPASS_SINGLE ) sqlite3MultiWrite(pParse);
+    if( eOnePass!=ONEPASS_SINGLE ) sqlite3MultiWrite(pParse); 
     if( sqlite3WhereUsesDeferredSeek(pWInfo) ){
       sqlite3VdbeAddOp1(v, OP_FinishSeek, iTabCur);
     }
 
     /* Keep track of the number of rows to be deleted */
-    if( memCnt ){
+    if( memCnt ){ 
       sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1);
     }
 
@@ -119696,8 +119696,8 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(
       }
       iKey = iPk;
     }else{
-      iKey = ++pParse->nMem;
-      sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur, -1, iKey);
+      iKey = ++pParse->nMem; 
+      sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur, -1, iKey); 
     }
 
     if( eOnePass!=ONEPASS_OFF ){
@@ -119783,14 +119783,14 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(
       sqlite3VtabMakeWritable(pParse, pTab);
       assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE );
       sqlite3MayAbort(pParse);
-      if( eOnePass==ONEPASS_SINGLE ){
-        sqlite3VdbeAddOp1(v, OP_Close, iTabCur);
-        if( sqlite3IsToplevel(pParse) ){
-          pParse->isMultiWrite = 0;
-        }
-      }
-      sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iKey, pVTab, P4_VTAB);
-      sqlite3VdbeChangeP5(v, OE_Abort);
+      if( eOnePass==ONEPASS_SINGLE ){ 
+        sqlite3VdbeAddOp1(v, OP_Close, iTabCur); 
+        if( sqlite3IsToplevel(pParse) ){ 
+          pParse->isMultiWrite = 0; 
+        } 
+      }
+      sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iKey, pVTab, P4_VTAB); 
+      sqlite3VdbeChangeP5(v, OE_Abort); 
     }else
 #endif
     {
@@ -119824,7 +119824,7 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(
   ** generating code because of a call to sqlite3NestedParse(), do not
   ** invoke the callback function.
   */
-  if( memCnt ){
+  if( memCnt ){ 
     sqlite3VdbeAddOp2(v, OP_ChngCntRow, memCnt, 1);
     sqlite3VdbeSetNumCols(v, 1);
     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows deleted", SQLITE_STATIC);
@@ -119918,7 +119918,7 @@ SQLITE_PRIVATE void sqlite3GenerateRowDelete(
   /* Seek cursor iCur to the row to delete. If this row no longer exists
   ** (this can happen if a trigger program has already deleted it), do
   ** not attempt to delete it or fire any DELETE triggers.  */
-  iLabel = sqlite3VdbeMakeLabel(pParse);
+  iLabel = sqlite3VdbeMakeLabel(pParse); 
   opSeek = HasRowid(pTab) ? OP_NotExists : OP_NotFound;
   if( eMode==ONEPASS_OFF ){
     sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk);
@@ -120126,7 +120126,7 @@ SQLITE_PRIVATE int sqlite3GenerateIndexKey(
 
   if( piPartIdxLabel ){
     if( pIdx->pPartIdxWhere ){
-      *piPartIdxLabel = sqlite3VdbeMakeLabel(pParse);
+      *piPartIdxLabel = sqlite3VdbeMakeLabel(pParse); 
       pParse->iSelfTab = iDataCur + 1;
       sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, *piPartIdxLabel,
                             SQLITE_JUMPIFNULL);
@@ -120198,7 +120198,7 @@ SQLITE_PRIVATE void sqlite3ResolvePartIdxLabel(Parse *pParse, int iLabel){
 /* #include <stdlib.h> */
 /* #include <assert.h> */
 #ifndef SQLITE_OMIT_FLOATING_POINT
-/* #include <math.h> */
+/* #include <math.h> */ 
 #endif
 /* #include "vdbeInt.h" */
 
@@ -120219,8 +120219,8 @@ static CollSeq *sqlite3GetFuncCollSeq(sqlite3_context *context){
 ** iteration of the aggregate loop.
 */
 static void sqlite3SkipAccumulatorLoad(sqlite3_context *context){
-  assert( context->isError<=0 );
-  context->isError = -1;
+  assert( context->isError<=0 ); 
+  context->isError = -1; 
   context->skipFlag = 1;
 }
 
@@ -120298,17 +120298,17 @@ static void lengthFunc(
     }
     case SQLITE_TEXT: {
       const unsigned char *z = sqlite3_value_text(argv[0]);
-      const unsigned char *z0;
-      unsigned char c;
+      const unsigned char *z0; 
+      unsigned char c; 
       if( z==0 ) return;
-      z0 = z;
-      while( (c = *z)!=0 ){
-        z++;
-        if( c>=0xc0 ){
-          while( (*z & 0xc0)==0x80 ){ z++; z0++; }
-        }
+      z0 = z; 
+      while( (c = *z)!=0 ){ 
+        z++; 
+        if( c>=0xc0 ){ 
+          while( (*z & 0xc0)==0x80 ){ z++; z0++; } 
+        } 
       }
-      sqlite3_result_int(context, (int)(z-z0));
+      sqlite3_result_int(context, (int)(z-z0)); 
       break;
     }
     default: {
@@ -120385,7 +120385,7 @@ static void instrFunc(
   int typeHaystack, typeNeedle;
   int N = 1;
   int isText;
-  unsigned char firstChar;
+  unsigned char firstChar; 
   sqlite3_value *pC1 = 0;
   sqlite3_value *pC2 = 0;
 
@@ -120416,10 +120416,10 @@ static void instrFunc(
       isText = 1;
     }
     if( zNeedle==0 || (nHaystack && zHaystack==0) ) goto endInstrOOM;
-    firstChar = zNeedle[0];
-    while( nNeedle<=nHaystack
-       && (zHaystack[0]!=firstChar || memcmp(zHaystack, zNeedle, nNeedle)!=0)
-    ){
+    firstChar = zNeedle[0]; 
+    while( nNeedle<=nHaystack 
+       && (zHaystack[0]!=firstChar || memcmp(zHaystack, zNeedle, nNeedle)!=0) 
+    ){ 
       N++;
       do{
         nHaystack--;
@@ -120458,7 +120458,7 @@ static void printfFunc(
     x.apArg = argv+1;
     sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
     str.printfFlags = SQLITE_PRINTF_SQLFUNC;
-    sqlite3_str_appendf(&str, zFormat, &x);
+    sqlite3_str_appendf(&str, zFormat, &x); 
     n = str.nChar;
     sqlite3_result_text(context, sqlite3StrAccumFinish(&str), n,
                         SQLITE_DYNAMIC);
@@ -120589,10 +120589,10 @@ static void roundFunc(sqlite3_context *context, int argc, sqlite3_value **argv){
   ** handle the rounding directly,
   ** otherwise use printf.
   */
-  if( r<-4503599627370496.0 || r>+4503599627370496.0 ){
-    /* The value has no fractional part so there is nothing to round */
+  if( r<-4503599627370496.0 || r>+4503599627370496.0 ){ 
+    /* The value has no fractional part so there is nothing to round */ 
   }else if( n==0 ){
-    r = (double)((sqlite_int64)(r+(r<0?-0.5:+0.5)));
+    r = (double)((sqlite_int64)(r+(r<0?-0.5:+0.5))); 
   }else{
     zBuf = sqlite3_mprintf("%.*f",n,r);
     if( zBuf==0 ){
@@ -120717,11 +120717,11 @@ static void randomBlob(
   int argc,
   sqlite3_value **argv
 ){
-  sqlite3_int64 n;
+  sqlite3_int64 n; 
   unsigned char *p;
   assert( argc==1 );
   UNUSED_PARAMETER(argc);
-  n = sqlite3_value_int64(argv[0]);
+  n = sqlite3_value_int64(argv[0]); 
   if( n<1 ){
     n = 1;
   }
@@ -121080,8 +121080,8 @@ static void likeFunc(
   }else{
     escape = pInfo->matchSet;
   }
-  zB = sqlite3_value_text(argv[0]);
-  zA = sqlite3_value_text(argv[1]);
+  zB = sqlite3_value_text(argv[0]); 
+  zA = sqlite3_value_text(argv[1]); 
   if( zA && zB ){
 #ifdef SQLITE_TEST
     sqlite3_like_count++;
@@ -121412,8 +121412,8 @@ static void replaceFunc(
   i64 nOut;                /* Maximum size of zOut */
   int loopLimit;           /* Last zStr[] that might match zPattern[] */
   int i, j;                /* Loop counters */
-  unsigned cntExpand;      /* Number zOut expansions */
-  sqlite3 *db = sqlite3_context_db_handle(context);
+  unsigned cntExpand;      /* Number zOut expansions */ 
+  sqlite3 *db = sqlite3_context_db_handle(context); 
 
   assert( argc==3 );
   UNUSED_PARAMETER(argc);
@@ -121445,40 +121445,40 @@ static void replaceFunc(
     return;
   }
   loopLimit = nStr - nPattern;
-  cntExpand = 0;
+  cntExpand = 0; 
   for(i=j=0; i<=loopLimit; i++){
     if( zStr[i]!=zPattern[0] || memcmp(&zStr[i], zPattern, nPattern) ){
       zOut[j++] = zStr[i];
     }else{
-      if( nRep>nPattern ){
-        nOut += nRep - nPattern;
-        testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] );
-        testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );
-        if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
-          sqlite3_result_error_toobig(context);
-          sqlite3_free(zOut);
-          return;
-        }
-        cntExpand++;
-        if( (cntExpand&(cntExpand-1))==0 ){
-          /* Grow the size of the output buffer only on substitutions
-          ** whose index is a power of two: 1, 2, 4, 8, 16, 32, ... */
-          u8 *zOld;
-          zOld = zOut;
+      if( nRep>nPattern ){ 
+        nOut += nRep - nPattern; 
+        testcase( nOut-1==db->aLimit[SQLITE_LIMIT_LENGTH] ); 
+        testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] ); 
+        if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){ 
+          sqlite3_result_error_toobig(context); 
+          sqlite3_free(zOut); 
+          return; 
+        } 
+        cntExpand++; 
+        if( (cntExpand&(cntExpand-1))==0 ){ 
+          /* Grow the size of the output buffer only on substitutions 
+          ** whose index is a power of two: 1, 2, 4, 8, 16, 32, ... */ 
+          u8 *zOld; 
+          zOld = zOut; 
           zOut = sqlite3Realloc(zOut, (int)nOut + (nOut - nStr - 1));
-          if( zOut==0 ){
-            sqlite3_result_error_nomem(context);
-            sqlite3_free(zOld);
-            return;
-          }
-        }
+          if( zOut==0 ){ 
+            sqlite3_result_error_nomem(context); 
+            sqlite3_free(zOld); 
+            return; 
+          } 
+        } 
       }
       memcpy(&zOut[j], zRep, nRep);
       j += nRep;
       i += nPattern-1;
     }
   }
-  assert( j+nStr-i+1<=nOut );
+  assert( j+nStr-i+1<=nOut ); 
   memcpy(&zOut[j], &zStr[i], nStr-i);
   j += nStr - i;
   assert( j<=nOut );
@@ -121719,7 +121719,7 @@ static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){
       i64 v = sqlite3_value_int64(argv[0]);
       p->rSum += v;
       if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){
-        p->approx = p->overflow = 1;
+        p->approx = p->overflow = 1; 
       }
     }else{
       p->rSum += sqlite3_value_double(argv[0]);
@@ -121727,32 +121727,32 @@ static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){
     }
   }
 }
-#ifndef SQLITE_OMIT_WINDOWFUNC
-static void sumInverse(sqlite3_context *context, int argc, sqlite3_value**argv){
-  SumCtx *p;
-  int type;
-  assert( argc==1 );
-  UNUSED_PARAMETER(argc);
-  p = sqlite3_aggregate_context(context, sizeof(*p));
-  type = sqlite3_value_numeric_type(argv[0]);
-  /* p is always non-NULL because sumStep() will have been called first
-  ** to initialize it */
-  if( ALWAYS(p) && type!=SQLITE_NULL ){
-    assert( p->cnt>0 );
-    p->cnt--;
-    assert( type==SQLITE_INTEGER || p->approx );
-    if( type==SQLITE_INTEGER && p->approx==0 ){
-      i64 v = sqlite3_value_int64(argv[0]);
-      p->rSum -= v;
-      p->iSum -= v;
-    }else{
-      p->rSum -= sqlite3_value_double(argv[0]);
-    }
-  }
-}
-#else
-# define sumInverse 0
-#endif /* SQLITE_OMIT_WINDOWFUNC */
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+static void sumInverse(sqlite3_context *context, int argc, sqlite3_value**argv){ 
+  SumCtx *p; 
+  int type; 
+  assert( argc==1 ); 
+  UNUSED_PARAMETER(argc); 
+  p = sqlite3_aggregate_context(context, sizeof(*p)); 
+  type = sqlite3_value_numeric_type(argv[0]); 
+  /* p is always non-NULL because sumStep() will have been called first 
+  ** to initialize it */ 
+  if( ALWAYS(p) && type!=SQLITE_NULL ){ 
+    assert( p->cnt>0 ); 
+    p->cnt--; 
+    assert( type==SQLITE_INTEGER || p->approx ); 
+    if( type==SQLITE_INTEGER && p->approx==0 ){ 
+      i64 v = sqlite3_value_int64(argv[0]); 
+      p->rSum -= v; 
+      p->iSum -= v; 
+    }else{ 
+      p->rSum -= sqlite3_value_double(argv[0]); 
+    } 
+  } 
+} 
+#else 
+# define sumInverse 0 
+#endif /* SQLITE_OMIT_WINDOWFUNC */ 
 static void sumFinalize(sqlite3_context *context){
   SumCtx *p;
   p = sqlite3_aggregate_context(context, 0);
@@ -121787,9 +121787,9 @@ static void totalFinalize(sqlite3_context *context){
 typedef struct CountCtx CountCtx;
 struct CountCtx {
   i64 n;
-#ifdef SQLITE_DEBUG
-  int bInverse;                   /* True if xInverse() ever called */
-#endif
+#ifdef SQLITE_DEBUG 
+  int bInverse;                   /* True if xInverse() ever called */ 
+#endif 
 };
 
 /*
@@ -121807,7 +121807,7 @@ static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){
   ** sure it still operates correctly, verify that its count agrees with our
   ** internal count when using count(*) and when the total count can be
   ** expressed as a 32-bit integer. */
-  assert( argc==1 || p==0 || p->n>0x7fffffff || p->bInverse
+  assert( argc==1 || p==0 || p->n>0x7fffffff || p->bInverse 
           || p->n==sqlite3_aggregate_count(context) );
 #endif
 }
@@ -121816,21 +121816,21 @@ static void countFinalize(sqlite3_context *context){
   p = sqlite3_aggregate_context(context, 0);
   sqlite3_result_int64(context, p ? p->n : 0);
 }
-#ifndef SQLITE_OMIT_WINDOWFUNC
-static void countInverse(sqlite3_context *ctx, int argc, sqlite3_value **argv){
-  CountCtx *p;
-  p = sqlite3_aggregate_context(ctx, sizeof(*p));
-  /* p is always non-NULL since countStep() will have been called first */
-  if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && ALWAYS(p) ){
-    p->n--;
-#ifdef SQLITE_DEBUG
-    p->bInverse = 1;
-#endif
-  }
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+static void countInverse(sqlite3_context *ctx, int argc, sqlite3_value **argv){ 
+  CountCtx *p; 
+  p = sqlite3_aggregate_context(ctx, sizeof(*p)); 
+  /* p is always non-NULL since countStep() will have been called first */ 
+  if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && ALWAYS(p) ){ 
+    p->n--; 
+#ifdef SQLITE_DEBUG 
+    p->bInverse = 1; 
+#endif 
+  } 
 }
-#else
-# define countInverse 0
-#endif /* SQLITE_OMIT_WINDOWFUNC */
+#else 
+# define countInverse 0 
+#endif /* SQLITE_OMIT_WINDOWFUNC */ 
 
 /*
 ** Routines to implement min() and max() aggregate functions.
@@ -121847,7 +121847,7 @@ static void minmaxStep(
   pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest));
   if( !pBest ) return;
 
-  if( sqlite3_value_type(pArg)==SQLITE_NULL ){
+  if( sqlite3_value_type(pArg)==SQLITE_NULL ){ 
     if( pBest->flags ) sqlite3SkipAccumulatorLoad(context);
   }else if( pBest->flags ){
     int max;
@@ -121873,26 +121873,26 @@ static void minmaxStep(
     sqlite3VdbeMemCopy(pBest, pArg);
   }
 }
-static void minMaxValueFinalize(sqlite3_context *context, int bValue){
+static void minMaxValueFinalize(sqlite3_context *context, int bValue){ 
   sqlite3_value *pRes;
   pRes = (sqlite3_value *)sqlite3_aggregate_context(context, 0);
   if( pRes ){
     if( pRes->flags ){
       sqlite3_result_value(context, pRes);
     }
-    if( bValue==0 ) sqlite3VdbeMemRelease(pRes);
+    if( bValue==0 ) sqlite3VdbeMemRelease(pRes); 
   }
 }
-#ifndef SQLITE_OMIT_WINDOWFUNC
-static void minMaxValue(sqlite3_context *context){
-  minMaxValueFinalize(context, 1);
-}
-#else
-# define minMaxValue 0
-#endif /* SQLITE_OMIT_WINDOWFUNC */
-static void minMaxFinalize(sqlite3_context *context){
-  minMaxValueFinalize(context, 0);
-}
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+static void minMaxValue(sqlite3_context *context){ 
+  minMaxValueFinalize(context, 1); 
+} 
+#else 
+# define minMaxValue 0 
+#endif /* SQLITE_OMIT_WINDOWFUNC */ 
+static void minMaxFinalize(sqlite3_context *context){ 
+  minMaxValueFinalize(context, 0); 
+} 
 
 /*
 ** group_concat(EXPR, ?SEPARATOR?)
@@ -121987,19 +121987,19 @@ static void groupConcatStep(
   }
 }
 
-#ifndef SQLITE_OMIT_WINDOWFUNC
-static void groupConcatInverse(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+static void groupConcatInverse( 
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
   GroupConcatCtx *pGCC;
-  assert( argc==1 || argc==2 );
+  assert( argc==1 || argc==2 ); 
   (void)argc;  /* Suppress unused parameter warning */
-  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
+  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 
   pGCC = (GroupConcatCtx*)sqlite3_aggregate_context(context, sizeof(*pGCC));
   /* pGCC is always non-NULL since groupConcatStep() will have always
-  ** run frist to initialize it */
+  ** run frist to initialize it */ 
   if( ALWAYS(pGCC) ){
     int nVS;
     /* Must call sqlite3_value_text() to convert the argument into text prior
@@ -122014,26 +122014,26 @@ static void groupConcatInverse(
         memmove(pGCC->pnSepLengths, pGCC->pnSepLengths+1,
                (pGCC->nAccum-1)*sizeof(int));
       }
-    }else{
+    }else{ 
       /* If removing single accumulated string, harmlessly over-do. */
       nVS += pGCC->nFirstSepLength;
-    }
+    } 
     if( nVS>=(int)pGCC->str.nChar ){
       pGCC->str.nChar = 0;
-    }else{
+    }else{ 
       pGCC->str.nChar -= nVS;
       memmove(pGCC->str.zText, &pGCC->str.zText[nVS], pGCC->str.nChar);
-    }
+    } 
     if( pGCC->str.nChar==0 ){
       pGCC->str.mxAlloc = 0;
       sqlite3_free(pGCC->pnSepLengths);
       pGCC->pnSepLengths = 0;
     }
-  }
-}
-#else
-# define groupConcatInverse 0
-#endif /* SQLITE_OMIT_WINDOWFUNC */
+  } 
+} 
+#else 
+# define groupConcatInverse 0 
+#endif /* SQLITE_OMIT_WINDOWFUNC */ 
 static void groupConcatFinalize(sqlite3_context *context){
   GroupConcatCtx *pGCC
     = (GroupConcatCtx*)sqlite3_aggregate_context(context, 0);
@@ -122044,25 +122044,25 @@ static void groupConcatFinalize(sqlite3_context *context){
 #endif
   }
 }
-#ifndef SQLITE_OMIT_WINDOWFUNC
-static void groupConcatValue(sqlite3_context *context){
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+static void groupConcatValue(sqlite3_context *context){ 
   GroupConcatCtx *pGCC
     = (GroupConcatCtx*)sqlite3_aggregate_context(context, 0);
   if( pGCC ){
     StrAccum *pAccum = &pGCC->str;
-    if( pAccum->accError==SQLITE_TOOBIG ){
-      sqlite3_result_error_toobig(context);
-    }else if( pAccum->accError==SQLITE_NOMEM ){
-      sqlite3_result_error_nomem(context);
+    if( pAccum->accError==SQLITE_TOOBIG ){ 
+      sqlite3_result_error_toobig(context); 
+    }else if( pAccum->accError==SQLITE_NOMEM ){ 
+      sqlite3_result_error_nomem(context); 
     }else{
-      const char *zText = sqlite3_str_value(pAccum);
+      const char *zText = sqlite3_str_value(pAccum); 
       sqlite3_result_text(context, zText, pAccum->nChar, SQLITE_TRANSIENT);
-    }
-  }
-}
-#else
-# define groupConcatValue 0
-#endif /* SQLITE_OMIT_WINDOWFUNC */
+    } 
+  } 
+} 
+#else 
+# define groupConcatValue 0 
+#endif /* SQLITE_OMIT_WINDOWFUNC */ 
 
 /*
 ** This routine does per-connection function registration.  Most
@@ -122078,24 +122078,24 @@ SQLITE_PRIVATE void sqlite3RegisterPerConnectionBuiltinFunctions(sqlite3 *db){
 }
 
 /*
-** Re-register the built-in LIKE functions.  The caseSensitive
+** Re-register the built-in LIKE functions.  The caseSensitive 
 ** parameter determines whether or not the LIKE operator is case
-** sensitive.
+** sensitive. 
 */
 SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3 *db, int caseSensitive){
   struct compareInfo *pInfo;
-  int flags;
+  int flags; 
   if( caseSensitive ){
     pInfo = (struct compareInfo*)&likeInfoAlt;
-    flags = SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE;
+    flags = SQLITE_FUNC_LIKE | SQLITE_FUNC_CASE; 
   }else{
     pInfo = (struct compareInfo*)&likeInfoNorm;
-    flags = SQLITE_FUNC_LIKE;
+    flags = SQLITE_FUNC_LIKE; 
   }
-  sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0);
-  sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0);
-  sqlite3FindFunction(db, "like", 2, SQLITE_UTF8, 0)->funcFlags |= flags;
-  sqlite3FindFunction(db, "like", 3, SQLITE_UTF8, 0)->funcFlags |= flags;
+  sqlite3CreateFunc(db, "like", 2, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0); 
+  sqlite3CreateFunc(db, "like", 3, SQLITE_UTF8, pInfo, likeFunc, 0, 0, 0, 0, 0); 
+  sqlite3FindFunction(db, "like", 2, SQLITE_UTF8, 0)->funcFlags |= flags; 
+  sqlite3FindFunction(db, "like", 3, SQLITE_UTF8, 0)->funcFlags |= flags; 
 }
 
 /*
@@ -122412,11 +122412,11 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){
     FUNCTION(trim,               2, 3, 0, trimFunc         ),
     FUNCTION(min,               -1, 0, 1, minmaxFunc       ),
     FUNCTION(min,                0, 0, 1, 0                ),
-    WAGGREGATE(min, 1, 0, 1, minmaxStep, minMaxFinalize, minMaxValue, 0,
+    WAGGREGATE(min, 1, 0, 1, minmaxStep, minMaxFinalize, minMaxValue, 0, 
                                  SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ),
     FUNCTION(max,               -1, 1, 1, minmaxFunc       ),
     FUNCTION(max,                0, 1, 1, 0                ),
-    WAGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize, minMaxValue, 0,
+    WAGGREGATE(max, 1, 1, 1, minmaxStep, minMaxFinalize, minMaxValue, 0, 
                                  SQLITE_FUNC_MINMAX|SQLITE_FUNC_ANYORDER ),
     FUNCTION2(typeof,            1, 0, 0, typeofFunc,  SQLITE_FUNC_TYPEOF),
     FUNCTION2(length,            1, 0, 0, lengthFunc,  SQLITE_FUNC_LENGTH),
@@ -122449,18 +122449,18 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){
     FUNCTION(substr,             3, 0, 0, substrFunc       ),
     FUNCTION(substring,          2, 0, 0, substrFunc       ),
     FUNCTION(substring,          3, 0, 0, substrFunc       ),
-    WAGGREGATE(sum,   1,0,0, sumStep, sumFinalize, sumFinalize, sumInverse, 0),
-    WAGGREGATE(total, 1,0,0, sumStep,totalFinalize,totalFinalize,sumInverse, 0),
-    WAGGREGATE(avg,   1,0,0, sumStep, avgFinalize, avgFinalize, sumInverse, 0),
+    WAGGREGATE(sum,   1,0,0, sumStep, sumFinalize, sumFinalize, sumInverse, 0), 
+    WAGGREGATE(total, 1,0,0, sumStep,totalFinalize,totalFinalize,sumInverse, 0), 
+    WAGGREGATE(avg,   1,0,0, sumStep, avgFinalize, avgFinalize, sumInverse, 0), 
     WAGGREGATE(count, 0,0,0, countStep,
         countFinalize, countFinalize, countInverse,
         SQLITE_FUNC_COUNT|SQLITE_FUNC_ANYORDER  ),
     WAGGREGATE(count, 1,0,0, countStep,
         countFinalize, countFinalize, countInverse, SQLITE_FUNC_ANYORDER ),
     WAGGREGATE(group_concat, 1, 0, 0, groupConcatStep,
-        groupConcatFinalize, groupConcatValue, groupConcatInverse, 0),
+        groupConcatFinalize, groupConcatValue, groupConcatInverse, 0), 
     WAGGREGATE(group_concat, 2, 0, 0, groupConcatStep,
-        groupConcatFinalize, groupConcatValue, groupConcatInverse, 0),
+        groupConcatFinalize, groupConcatValue, groupConcatInverse, 0), 
 
     LIKEFUNC(glob, 2, &globInfo, SQLITE_FUNC_LIKE|SQLITE_FUNC_CASE),
 #ifdef SQLITE_CASE_SENSITIVE_LIKE
@@ -122518,7 +122518,7 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(void){
 #ifndef SQLITE_OMIT_ALTERTABLE
   sqlite3AlterFunctions();
 #endif
-  sqlite3WindowFunctions();
+  sqlite3WindowFunctions(); 
   sqlite3RegisterDateTimeFunctions();
   sqlite3InsertBuiltinFuncs(aBuiltinFunc, ArraySize(aBuiltinFunc));
 
@@ -122875,14 +122875,14 @@ static void fkLookupParent(
   int i;                                    /* Iterator variable */
   Vdbe *v = sqlite3GetVdbe(pParse);         /* Vdbe to add code to */
   int iCur = pParse->nTab - 1;              /* Cursor number to use */
-  int iOk = sqlite3VdbeMakeLabel(pParse);   /* jump here if parent key found */
+  int iOk = sqlite3VdbeMakeLabel(pParse);   /* jump here if parent key found */ 
 
-  sqlite3VdbeVerifyAbortable(v,
-    (!pFKey->isDeferred
-      && !(pParse->db->flags & SQLITE_DeferFKs)
+  sqlite3VdbeVerifyAbortable(v, 
+    (!pFKey->isDeferred 
+      && !(pParse->db->flags & SQLITE_DeferFKs) 
       && !pParse->pToplevel
-      && !pParse->isMultiWrite) ? OE_Abort : OE_Ignore);
-
+      && !pParse->isMultiWrite) ? OE_Abort : OE_Ignore); 
+ 
   /* If nIncr is less than zero, then check at runtime if there are any
   ** outstanding constraints to resolve. If there are not, there is no need
   ** to check if deleting this row resolves any outstanding violations.
@@ -123055,7 +123055,7 @@ static Expr *exprTableColumn(
   Expr *pExpr = sqlite3Expr(db, TK_COLUMN, 0);
   if( pExpr ){
     assert( ExprUseYTab(pExpr) );
-    pExpr->y.pTab = pTab;
+    pExpr->y.pTab = pTab; 
     pExpr->iTable = iCursor;
     pExpr->iColumn = iCol;
   }
@@ -123144,7 +123144,7 @@ static void fkScanChildren(
     zCol = pFKey->pFrom->aCol[iCol].zCnName;
     pRight = sqlite3Expr(db, TK_ID, zCol);
     pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight);
-    pWhere = sqlite3ExprAnd(pParse, pWhere, pEq);
+    pWhere = sqlite3ExprAnd(pParse, pWhere, pEq); 
   }
 
   /* If the child table is the same as the parent table, then add terms
@@ -123155,11 +123155,11 @@ static void fkScanChildren(
   **     NOT( $current_a==a AND $current_b==b AND ... )
   **
   ** The first form is used for rowid tables.  The second form is used
-  ** for WITHOUT ROWID tables. In the second form, the *parent* key is
+  ** for WITHOUT ROWID tables. In the second form, the *parent* key is 
   ** (a,b,...). Either the parent or primary key could be used to
-  ** uniquely identify the current row, but the parent key is more convenient
-  ** as the required values have already been loaded into registers
-  ** by the caller.
+  ** uniquely identify the current row, but the parent key is more convenient 
+  ** as the required values have already been loaded into registers 
+  ** by the caller. 
   */
   if( pTab==pFKey->pFrom && nIncr>0 ){
     Expr *pNe;                    /* Expression (pLeft != pRight) */
@@ -123172,17 +123172,17 @@ static void fkScanChildren(
     }else{
       Expr *pEq, *pAll = 0;
       assert( pIdx!=0 );
-      for(i=0; i<pIdx->nKeyCol; i++){
+      for(i=0; i<pIdx->nKeyCol; i++){ 
         i16 iCol = pIdx->aiColumn[i];
         assert( iCol>=0 );
         pLeft = exprTableRegister(pParse, pTab, regData, iCol);
         pRight = sqlite3Expr(db, TK_ID, pTab->aCol[iCol].zCnName);
-        pEq = sqlite3PExpr(pParse, TK_IS, pLeft, pRight);
-        pAll = sqlite3ExprAnd(pParse, pAll, pEq);
+        pEq = sqlite3PExpr(pParse, TK_IS, pLeft, pRight); 
+        pAll = sqlite3ExprAnd(pParse, pAll, pEq); 
       }
       pNe = sqlite3PExpr(pParse, TK_NOT, pAll, 0);
     }
-    pWhere = sqlite3ExprAnd(pParse, pWhere, pNe);
+    pWhere = sqlite3ExprAnd(pParse, pWhere, pNe); 
   }
 
   /* Resolve the references in the WHERE clause. */
@@ -123301,7 +123301,7 @@ SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTa
         if( p->isDeferred || (db->flags & SQLITE_DeferFKs) ) break;
       }
       if( !p ) return;
-      iSkip = sqlite3VdbeMakeLabel(pParse);
+      iSkip = sqlite3VdbeMakeLabel(pParse); 
       sqlite3VdbeAddOp2(v, OP_FkIfZero, 1, iSkip); VdbeCoverage(v);
     }
 
@@ -123319,7 +123319,7 @@ SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTa
     ** constraints are violated.
     */
     if( (db->flags & SQLITE_DeferFKs)==0 ){
-      sqlite3VdbeVerifyAbortable(v, OE_Abort);
+      sqlite3VdbeVerifyAbortable(v, OE_Abort); 
       sqlite3VdbeAddOp2(v, OP_FkIfZero, 0, sqlite3VdbeCurrentAddr(v)+2);
       VdbeCoverage(v);
       sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY,
@@ -123589,7 +123589,7 @@ SQLITE_PRIVATE void sqlite3FkCheck(
 
     /* Create a SrcList structure containing the child table.  We need the
     ** child table as a SrcList for sqlite3WhereBegin() */
-    pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
+    pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); 
     if( pSrc ){
       SrcItem *pItem = pSrc->a;
       pItem->pTab = pFKey->pFrom;
@@ -123813,7 +123813,7 @@ static Trigger *fkActionTrigger(
             sqlite3ExprAlloc(db, TK_ID, &tToCol, 0)),
           sqlite3ExprAlloc(db, TK_ID, &tFromCol, 0)
       );
-      pWhere = sqlite3ExprAnd(pParse, pWhere, pEq);
+      pWhere = sqlite3ExprAnd(pParse, pWhere, pEq); 
 
       /* For ON UPDATE, construct the next term of the WHEN clause.
       ** The final WHEN clause will be like this:
@@ -123829,7 +123829,7 @@ static Trigger *fkActionTrigger(
               sqlite3ExprAlloc(db, TK_ID, &tNew, 0),
               sqlite3ExprAlloc(db, TK_ID, &tToCol, 0))
             );
-        pWhen = sqlite3ExprAnd(pParse, pWhen, pEq);
+        pWhen = sqlite3ExprAnd(pParse, pWhen, pEq); 
       }
 
       if( action!=OE_Restrict && (action!=OE_Cascade || pChanges) ){
@@ -123877,7 +123877,7 @@ static Trigger *fkActionTrigger(
       }
       pSelect = sqlite3SelectNew(pParse,
           sqlite3ExprListAppend(pParse, 0, pRaise),
-          sqlite3SrcListAppend(pParse, 0, &tFrom, 0),
+          sqlite3SrcListAppend(pParse, 0, &tFrom, 0), 
           pWhere,
           0, 0, 0, 0, 0
       );
@@ -124213,8 +124213,8 @@ SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){
     }while( j>=0 && zColAff[j]<=SQLITE_AFF_BLOB );
     pTab->zColAff = zColAff;
   }
-  assert( zColAff!=0 );
-  i = sqlite3Strlen30NN(zColAff);
+  assert( zColAff!=0 ); 
+  i = sqlite3Strlen30NN(zColAff); 
   if( i ){
     if( iReg ){
       sqlite3VdbeAddOp4(v, OP_Affinity, iReg, i, 0, zColAff, i);
@@ -124399,12 +124399,12 @@ SQLITE_PRIVATE void sqlite3ComputeGeneratedColumns(
 ** first use of table pTab.  On 2nd and subsequent uses, the original
 ** AutoincInfo structure is used.
 **
-** Four consecutive registers are allocated:
+** Four consecutive registers are allocated: 
 **
-**   (1)  The name of the pTab table.
-**   (2)  The maximum ROWID of pTab.
-**   (3)  The rowid in sqlite_sequence of pTab
-**   (4)  The original value of the max ROWID in pTab, or NULL if none
+**   (1)  The name of the pTab table. 
+**   (2)  The maximum ROWID of pTab. 
+**   (3)  The rowid in sqlite_sequence of pTab 
+**   (4)  The original value of the max ROWID in pTab, or NULL if none 
 **
 ** The 2nd register is the one that is returned.  That is all the
 ** insert routine needs to know about.
@@ -124415,27 +124415,27 @@ static int autoIncBegin(
   Table *pTab         /* The table we are writing to */
 ){
   int memId = 0;      /* Register holding maximum rowid */
-  assert( pParse->db->aDb[iDb].pSchema!=0 );
+  assert( pParse->db->aDb[iDb].pSchema!=0 ); 
   if( (pTab->tabFlags & TF_Autoincrement)!=0
    && (pParse->db->mDbFlags & DBFLAG_Vacuum)==0
   ){
     Parse *pToplevel = sqlite3ParseToplevel(pParse);
     AutoincInfo *pInfo;
-    Table *pSeqTab = pParse->db->aDb[iDb].pSchema->pSeqTab;
+    Table *pSeqTab = pParse->db->aDb[iDb].pSchema->pSeqTab; 
 
-    /* Verify that the sqlite_sequence table exists and is an ordinary
-    ** rowid table with exactly two columns.
-    ** Ticket d8dc2b3a58cd5dc2918a1d4acb 2018-05-23 */
-    if( pSeqTab==0
-     || !HasRowid(pSeqTab)
+    /* Verify that the sqlite_sequence table exists and is an ordinary 
+    ** rowid table with exactly two columns. 
+    ** Ticket d8dc2b3a58cd5dc2918a1d4acb 2018-05-23 */ 
+    if( pSeqTab==0 
+     || !HasRowid(pSeqTab) 
      || NEVER(IsVirtual(pSeqTab))
-     || pSeqTab->nCol!=2
-    ){
-      pParse->nErr++;
-      pParse->rc = SQLITE_CORRUPT_SEQUENCE;
-      return 0;
-    }
-
+     || pSeqTab->nCol!=2 
+    ){ 
+      pParse->nErr++; 
+      pParse->rc = SQLITE_CORRUPT_SEQUENCE; 
+      return 0; 
+    } 
+ 
     pInfo = pToplevel->pAinc;
     while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
     if( pInfo==0 ){
@@ -124449,7 +124449,7 @@ static int autoIncBegin(
       pInfo->iDb = iDb;
       pToplevel->nMem++;                  /* Register to hold name of table */
       pInfo->regCtr = ++pToplevel->nMem;  /* Max rowid register */
-      pToplevel->nMem +=2;       /* Rowid in sqlite_sequence + orig max val */
+      pToplevel->nMem +=2;       /* Rowid in sqlite_sequence + orig max val */ 
     }
     memId = pInfo->regCtr;
   }
@@ -124477,16 +124477,16 @@ SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse){
     static const int iLn = VDBE_OFFSET_LINENO(2);
     static const VdbeOpList autoInc[] = {
       /* 0  */ {OP_Null,    0,  0, 0},
-      /* 1  */ {OP_Rewind,  0, 10, 0},
+      /* 1  */ {OP_Rewind,  0, 10, 0}, 
       /* 2  */ {OP_Column,  0,  0, 0},
-      /* 3  */ {OP_Ne,      0,  9, 0},
+      /* 3  */ {OP_Ne,      0,  9, 0}, 
       /* 4  */ {OP_Rowid,   0,  0, 0},
       /* 5  */ {OP_Column,  0,  1, 0},
-      /* 6  */ {OP_AddImm,  0,  0, 0},
-      /* 7  */ {OP_Copy,    0,  0, 0},
-      /* 8  */ {OP_Goto,    0, 11, 0},
-      /* 9  */ {OP_Next,    0,  2, 0},
-      /* 10 */ {OP_Integer, 0,  0, 0},
+      /* 6  */ {OP_AddImm,  0,  0, 0}, 
+      /* 7  */ {OP_Copy,    0,  0, 0}, 
+      /* 8  */ {OP_Goto,    0, 11, 0}, 
+      /* 9  */ {OP_Next,    0,  2, 0}, 
+      /* 10 */ {OP_Integer, 0,  0, 0}, 
       /* 11 */ {OP_Close,   0,  0, 0}
     };
     VdbeOp *aOp;
@@ -124498,18 +124498,18 @@ SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse){
     aOp = sqlite3VdbeAddOpList(v, ArraySize(autoInc), autoInc, iLn);
     if( aOp==0 ) break;
     aOp[0].p2 = memId;
-    aOp[0].p3 = memId+2;
+    aOp[0].p3 = memId+2; 
     aOp[2].p3 = memId;
     aOp[3].p1 = memId-1;
     aOp[3].p3 = memId;
     aOp[3].p5 = SQLITE_JUMPIFNULL;
     aOp[4].p2 = memId+1;
     aOp[5].p3 = memId;
-    aOp[6].p1 = memId;
-    aOp[7].p2 = memId+2;
-    aOp[7].p1 = memId;
-    aOp[10].p2 = memId;
-    if( pParse->nTab==0 ) pParse->nTab = 1;
+    aOp[6].p1 = memId; 
+    aOp[7].p2 = memId+2; 
+    aOp[7].p1 = memId; 
+    aOp[10].p2 = memId; 
+    if( pParse->nTab==0 ) pParse->nTab = 1; 
   }
 }
 
@@ -124556,8 +124556,8 @@ static SQLITE_NOINLINE void autoIncrementEnd(Parse *pParse){
 
     iRec = sqlite3GetTempReg(pParse);
     assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
-    sqlite3VdbeAddOp3(v, OP_Le, memId+2, sqlite3VdbeCurrentAddr(v)+7, memId);
-    VdbeCoverage(v);
+    sqlite3VdbeAddOp3(v, OP_Le, memId+2, sqlite3VdbeCurrentAddr(v)+7, memId); 
+    VdbeCoverage(v); 
     sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
     aOp = sqlite3VdbeAddOpList(v, ArraySize(autoIncEnd), autoIncEnd, iLn);
     if( aOp==0 ) break;
@@ -124695,8 +124695,8 @@ SQLITE_PRIVATE void sqlite3Insert(
   SrcList *pTabList,    /* Name of table into which we are inserting */
   Select *pSelect,      /* A SELECT statement to use as the data source */
   IdList *pColumn,      /* Column names corresponding to IDLIST, or NULL. */
-  int onError,          /* How to handle constraint errors */
-  Upsert *pUpsert       /* ON CONFLICT clauses for upsert, or NULL */
+  int onError,          /* How to handle constraint errors */ 
+  Upsert *pUpsert       /* ON CONFLICT clauses for upsert, or NULL */ 
 ){
   sqlite3 *db;          /* The main database structure */
   Table *pTab;          /* The table to insert into.  aka TABLE */
@@ -125026,11 +125026,11 @@ SQLITE_PRIVATE void sqlite3Insert(
 
   /* Initialize the count of rows to be inserted
   */
-  if( (db->flags & SQLITE_CountRows)!=0
-   && !pParse->nested
-   && !pParse->pTriggerTab
+  if( (db->flags & SQLITE_CountRows)!=0 
+   && !pParse->nested 
+   && !pParse->pTriggerTab 
    && !pParse->bReturning
-  ){
+  ){ 
     regRowCount = ++pParse->nMem;
     sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
   }
@@ -125040,7 +125040,7 @@ SQLITE_PRIVATE void sqlite3Insert(
     int nIdx;
     nIdx = sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, -1, 0,
                                       &iDataCur, &iIdxCur);
-    aRegIdx = sqlite3DbMallocRawNN(db, sizeof(int)*(nIdx+2));
+    aRegIdx = sqlite3DbMallocRawNN(db, sizeof(int)*(nIdx+2)); 
     if( aRegIdx==0 ){
       goto insert_cleanup;
     }
@@ -125049,16 +125049,16 @@ SQLITE_PRIVATE void sqlite3Insert(
       aRegIdx[i] = ++pParse->nMem;
       pParse->nMem += pIdx->nColumn;
     }
-    aRegIdx[i] = ++pParse->nMem;  /* Register to store the table record */
+    aRegIdx[i] = ++pParse->nMem;  /* Register to store the table record */ 
   }
-#ifndef SQLITE_OMIT_UPSERT
-  if( pUpsert ){
+#ifndef SQLITE_OMIT_UPSERT 
+  if( pUpsert ){ 
     Upsert *pNx;
-    if( IsVirtual(pTab) ){
-      sqlite3ErrorMsg(pParse, "UPSERT not implemented for virtual table \"%s\"",
-              pTab->zName);
-      goto insert_cleanup;
-    }
+    if( IsVirtual(pTab) ){ 
+      sqlite3ErrorMsg(pParse, "UPSERT not implemented for virtual table \"%s\"", 
+              pTab->zName); 
+      goto insert_cleanup; 
+    } 
     if( IsView(pTab) ){
       sqlite3ErrorMsg(pParse, "cannot UPSERT a view");
       goto insert_cleanup;
@@ -125066,7 +125066,7 @@ SQLITE_PRIVATE void sqlite3Insert(
     if( sqlite3HasExplicitNulls(pParse, pUpsert->pUpsertTarget) ){
       goto insert_cleanup;
     }
-    pTabList->a[0].iCursor = iDataCur;
+    pTabList->a[0].iCursor = iDataCur; 
     pNx = pUpsert;
     do{
       pNx->pUpsertSrc = pTabList;
@@ -125080,10 +125080,10 @@ SQLITE_PRIVATE void sqlite3Insert(
       }
       pNx = pNx->pNextUpsert;
     }while( pNx!=0 );
-  }
-#endif
-
+  } 
+#endif 
 
+ 
   /* This is the top of the main insertion loop */
   if( useTempTable ){
     /* This block codes the top of loop only.  The complete loop is the
@@ -125199,7 +125199,7 @@ SQLITE_PRIVATE void sqlite3Insert(
 
   /* Run the BEFORE and INSTEAD OF triggers, if there are any
   */
-  endOfLoop = sqlite3VdbeMakeLabel(pParse);
+  endOfLoop = sqlite3VdbeMakeLabel(pParse); 
   if( tmask & TRIGGER_BEFORE ){
     int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
 
@@ -125270,12 +125270,12 @@ SQLITE_PRIVATE void sqlite3Insert(
       }else if( pSelect ){
         /* Rowid already initialized at tag-20191021-001 */
       }else{
-        Expr *pIpk = pList->a[ipkColumn].pExpr;
-        if( pIpk->op==TK_NULL && !IsVirtual(pTab) ){
-          sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
+        Expr *pIpk = pList->a[ipkColumn].pExpr; 
+        if( pIpk->op==TK_NULL && !IsVirtual(pTab) ){ 
+          sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc); 
           appendFlag = 1;
-        }else{
-          sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid);
+        }else{ 
+          sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid); 
         }
       }
       /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid
@@ -125327,7 +125327,7 @@ SQLITE_PRIVATE void sqlite3Insert(
       int isReplace = 0;/* Set to true if constraints may cause a replace */
       int bUseSeek;     /* True to use OPFLAG_SEEKRESULT */
       sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
-          regIns, 0, ipkColumn>=0, onError, endOfLoop, &isReplace, 0, pUpsert
+          regIns, 0, ipkColumn>=0, onError, endOfLoop, &isReplace, 0, pUpsert 
       );
       sqlite3FkCheck(pParse, pTab, 0, regIns, 0, 0);
 
@@ -125355,7 +125355,7 @@ SQLITE_PRIVATE void sqlite3Insert(
 
   /* Update the count of rows that are inserted
   */
-  if( regRowCount ){
+  if( regRowCount ){ 
     sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
   }
 
@@ -125403,7 +125403,7 @@ insert_end:
   ** generating code because of a call to sqlite3NestedParse(), do not
   ** invoke the callback function.
   */
-  if( regRowCount ){
+  if( regRowCount ){ 
     sqlite3VdbeAddOp2(v, OP_ChngCntRow, regRowCount, 1);
     sqlite3VdbeSetNumCols(v, 1);
     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows inserted", SQLITE_STATIC);
@@ -125412,7 +125412,7 @@ insert_end:
 insert_cleanup:
   sqlite3SrcListDelete(db, pTabList);
   sqlite3ExprListDelete(db, pList);
-  sqlite3UpsertDelete(db, pUpsert);
+  sqlite3UpsertDelete(db, pUpsert); 
   sqlite3SelectDelete(db, pSelect);
   sqlite3IdListDelete(db, pColumn);
   sqlite3DbFree(db, aRegIdx);
@@ -125433,14 +125433,14 @@ insert_cleanup:
 
 /*
 ** Meanings of bits in of pWalker->eCode for
-** sqlite3ExprReferencesUpdatedColumn()
+** sqlite3ExprReferencesUpdatedColumn() 
 */
 #define CKCNSTRNT_COLUMN   0x01    /* CHECK constraint uses a changing column */
 #define CKCNSTRNT_ROWID    0x02    /* CHECK constraint references the ROWID */
 
-/* This is the Walker callback from sqlite3ExprReferencesUpdatedColumn().
-*  Set bit 0x01 of pWalker->eCode if pWalker->eCode to 0 and if this
-** expression node references any of the
+/* This is the Walker callback from sqlite3ExprReferencesUpdatedColumn(). 
+*  Set bit 0x01 of pWalker->eCode if pWalker->eCode to 0 and if this 
+** expression node references any of the 
 ** columns that are being modifed by an UPDATE statement.
 */
 static int checkConstraintExprNode(Walker *pWalker, Expr *pExpr){
@@ -125462,21 +125462,21 @@ static int checkConstraintExprNode(Walker *pWalker, Expr *pExpr){
 ** only columns that are modified by the UPDATE are those for which
 ** aiChng[i]>=0, and also the ROWID is modified if chngRowid is true.
 **
-** Return true if CHECK constraint pExpr uses any of the
+** Return true if CHECK constraint pExpr uses any of the 
 ** changing columns (or the rowid if it is changing).  In other words,
-** return true if this CHECK constraint must be validated for
+** return true if this CHECK constraint must be validated for 
 ** the new row in the UPDATE statement.
-**
-** 2018-09-15: pExpr might also be an expression for an index-on-expressions.
-** The operation of this routine is the same - return true if an only if
-** the expression uses one or more of columns identified by the second and
-** third arguments.
-*/
-SQLITE_PRIVATE int sqlite3ExprReferencesUpdatedColumn(
-  Expr *pExpr,    /* The expression to be checked */
-  int *aiChng,    /* aiChng[x]>=0 if column x changed by the UPDATE */
-  int chngRowid   /* True if UPDATE changes the rowid */
-){
+** 
+** 2018-09-15: pExpr might also be an expression for an index-on-expressions. 
+** The operation of this routine is the same - return true if an only if 
+** the expression uses one or more of columns identified by the second and 
+** third arguments. 
+*/
+SQLITE_PRIVATE int sqlite3ExprReferencesUpdatedColumn( 
+  Expr *pExpr,    /* The expression to be checked */ 
+  int *aiChng,    /* aiChng[x]>=0 if column x changed by the UPDATE */ 
+  int chngRowid   /* True if UPDATE changes the rowid */ 
+){ 
   Walker w;
   memset(&w, 0, sizeof(w));
   w.eCode = 0;
@@ -125491,7 +125491,7 @@ SQLITE_PRIVATE int sqlite3ExprReferencesUpdatedColumn(
   testcase( w.eCode==CKCNSTRNT_COLUMN );
   testcase( w.eCode==CKCNSTRNT_ROWID );
   testcase( w.eCode==(CKCNSTRNT_ROWID|CKCNSTRNT_COLUMN) );
-  return w.eCode!=0;
+  return w.eCode!=0; 
 }
 
 /*
@@ -125593,14 +125593,14 @@ static Index *indexIteratorNext(IndexIterator *pIter, int *pIx){
 ** the same as the order of indices on the linked list of indices
 ** at pTab->pIndex.
 **
-** (2019-05-07) The generated code also creates a new record for the
-** main table, if pTab is a rowid table, and stores that record in the
-** register identified by aRegIdx[nIdx] - in other words in the first
-** entry of aRegIdx[] past the last index.  It is important that the
-** record be generated during constraint checks to avoid affinity changes
-** to the register content that occur after constraint checks but before
-** the new record is inserted.
-**
+** (2019-05-07) The generated code also creates a new record for the 
+** main table, if pTab is a rowid table, and stores that record in the 
+** register identified by aRegIdx[nIdx] - in other words in the first 
+** entry of aRegIdx[] past the last index.  It is important that the 
+** record be generated during constraint checks to avoid affinity changes 
+** to the register content that occur after constraint checks but before 
+** the new record is inserted. 
+** 
 ** The caller must have already opened writeable cursors on the main
 ** table and all applicable indices (that is to say, all indices for which
 ** aRegIdx[] is not zero).  iDataCur is the cursor for the main table when
@@ -125661,8 +125661,8 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
   u8 overrideError,    /* Override onError to this if not OE_Default */
   int ignoreDest,      /* Jump to this label on an OE_Ignore resolution */
   int *pbMayReplace,   /* OUT: Set to true if constraint may cause a replace */
-  int *aiChng,         /* column i is unchanged if aiChng[i]<0 */
-  Upsert *pUpsert      /* ON CONFLICT clauses, if any.  NULL otherwise */
+  int *aiChng,         /* column i is unchanged if aiChng[i]<0 */ 
+  Upsert *pUpsert      /* ON CONFLICT clauses, if any.  NULL otherwise */ 
 ){
   Vdbe *v;             /* VDBE under constrution */
   Index *pIdx;         /* Pointer to one of the indices */
@@ -125679,8 +125679,8 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
   u8 bAffinityDone = 0;  /* True if the OP_Affinity operation has been run */
   int upsertIpkReturn = 0; /* Address of Goto at end of IPK uniqueness check */
   int upsertIpkDelay = 0;  /* Address of Goto to bypass initial IPK check */
-  int ipkTop = 0;        /* Top of the IPK uniqueness check */
-  int ipkBottom = 0;     /* OP_Goto at the end of the IPK uniqueness check */
+  int ipkTop = 0;        /* Top of the IPK uniqueness check */ 
+  int ipkBottom = 0;     /* OP_Goto at the end of the IPK uniqueness check */ 
   /* Variables associated with retesting uniqueness constraints after
   ** replace triggers fire have run */
   int regTrigCnt;       /* Register used to count replace trigger invocations */
@@ -125825,19 +125825,19 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
       int allOk;
       Expr *pCopy;
       Expr *pExpr = pCheck->a[i].pExpr;
-      if( aiChng
-       && !sqlite3ExprReferencesUpdatedColumn(pExpr, aiChng, pkChng)
-      ){
-        /* The check constraints do not reference any of the columns being
-        ** updated so there is no point it verifying the check constraint */
-        continue;
-      }
+      if( aiChng 
+       && !sqlite3ExprReferencesUpdatedColumn(pExpr, aiChng, pkChng) 
+      ){ 
+        /* The check constraints do not reference any of the columns being 
+        ** updated so there is no point it verifying the check constraint */ 
+        continue; 
+      } 
       if( bAffinityDone==0 ){
         sqlite3TableAffinity(v, pTab, regNewData+1);
         bAffinityDone = 1;
       }
-      allOk = sqlite3VdbeMakeLabel(pParse);
-      sqlite3VdbeVerifyAbortable(v, onError);
+      allOk = sqlite3VdbeMakeLabel(pParse); 
+      sqlite3VdbeVerifyAbortable(v, onError); 
       pCopy = sqlite3ExprDup(db, pExpr, 0);
       if( !db->mallocFailed ){
         sqlite3ExprIfTrue(pParse, pCopy, allOk, SQLITE_JUMPIFNULL);
@@ -125848,7 +125848,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
       }else{
         char *zName = pCheck->a[i].zEName;
         assert( zName!=0 || pParse->db->mallocFailed );
-        if( onError==OE_Replace ) onError = OE_Abort; /* IMP: R-26383-51744 */
+        if( onError==OE_Replace ) onError = OE_Abort; /* IMP: R-26383-51744 */ 
         sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_CHECK,
                               onError, zName, P4_TRANSIENT,
                               P5_ConstraintCheck);
@@ -125859,40 +125859,40 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
   }
 #endif /* !defined(SQLITE_OMIT_CHECK) */
 
-  /* UNIQUE and PRIMARY KEY constraints should be handled in the following
-  ** order:
-  **
-  **   (1)  OE_Update
-  **   (2)  OE_Abort, OE_Fail, OE_Rollback, OE_Ignore
-  **   (3)  OE_Replace
-  **
-  ** OE_Fail and OE_Ignore must happen before any changes are made.
-  ** OE_Update guarantees that only a single row will change, so it
-  ** must happen before OE_Replace.  Technically, OE_Abort and OE_Rollback
-  ** could happen in any order, but they are grouped up front for
-  ** convenience.
-  **
-  ** 2018-08-14: Ticket https://www.sqlite.org/src/info/908f001483982c43
-  ** The order of constraints used to have OE_Update as (2) and OE_Abort
-  ** and so forth as (1). But apparently PostgreSQL checks the OE_Update
-  ** constraint before any others, so it had to be moved.
-  **
-  ** Constraint checking code is generated in this order:
-  **   (A)  The rowid constraint
-  **   (B)  Unique index constraints that do not have OE_Replace as their
-  **        default conflict resolution strategy
-  **   (C)  Unique index that do use OE_Replace by default.
-  **
-  ** The ordering of (2) and (3) is accomplished by making sure the linked
-  ** list of indexes attached to a table puts all OE_Replace indexes last
-  ** in the list.  See sqlite3CreateIndex() for where that happens.
-  */
+  /* UNIQUE and PRIMARY KEY constraints should be handled in the following 
+  ** order: 
+  ** 
+  **   (1)  OE_Update 
+  **   (2)  OE_Abort, OE_Fail, OE_Rollback, OE_Ignore 
+  **   (3)  OE_Replace 
+  ** 
+  ** OE_Fail and OE_Ignore must happen before any changes are made. 
+  ** OE_Update guarantees that only a single row will change, so it 
+  ** must happen before OE_Replace.  Technically, OE_Abort and OE_Rollback 
+  ** could happen in any order, but they are grouped up front for 
+  ** convenience. 
+  ** 
+  ** 2018-08-14: Ticket https://www.sqlite.org/src/info/908f001483982c43 
+  ** The order of constraints used to have OE_Update as (2) and OE_Abort 
+  ** and so forth as (1). But apparently PostgreSQL checks the OE_Update 
+  ** constraint before any others, so it had to be moved. 
+  ** 
+  ** Constraint checking code is generated in this order: 
+  **   (A)  The rowid constraint 
+  **   (B)  Unique index constraints that do not have OE_Replace as their 
+  **        default conflict resolution strategy 
+  **   (C)  Unique index that do use OE_Replace by default. 
+  ** 
+  ** The ordering of (2) and (3) is accomplished by making sure the linked 
+  ** list of indexes attached to a table puts all OE_Replace indexes last 
+  ** in the list.  See sqlite3CreateIndex() for where that happens. 
+  */ 
   sIdxIter.eType = 0;
   sIdxIter.i = 0;
   sIdxIter.u.ax.aIdx = 0;  /* Silence harmless compiler warning */
   sIdxIter.u.lx.pIdx = pTab->pIndex;
-  if( pUpsert ){
-    if( pUpsert->pUpsertTarget==0 ){
+  if( pUpsert ){ 
+    if( pUpsert->pUpsertTarget==0 ){ 
       /* There is just on ON CONFLICT clause and it has no constraint-target */
       assert( pUpsert->pNextUpsert==0 );
       if( pUpsert->isDoUpdate==0 ){
@@ -125944,9 +125944,9 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
         i++;
       }
       assert( i==nIdx );
-    }
-  }
-
+    } 
+  } 
+ 
   /* Determine if it is possible that triggers (either explicitly coded
   ** triggers or FK resolution actions) might run as a result of deletes
   ** that happen when OE_Replace conflict resolution occurs. (Call these
@@ -125995,7 +125995,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
   ** exist in the table.
   */
   if( pkChng && pPk==0 ){
-    int addrRowidOk = sqlite3VdbeMakeLabel(pParse);
+    int addrRowidOk = sqlite3VdbeMakeLabel(pParse); 
 
     /* Figure out what action to take in case of a rowid collision */
     onError = pTab->keyConf;
@@ -126005,7 +126005,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
       onError = OE_Abort;
     }
 
-    /* figure out whether or not upsert applies in this case */
+    /* figure out whether or not upsert applies in this case */ 
     if( pUpsert ){
       pUpsertClause = sqlite3UpsertOfIndex(pUpsert,0);
       if( pUpsertClause!=0 ){
@@ -126014,29 +126014,29 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
         }else{
           onError = OE_Update;  /* DO UPDATE */
         }
-      }
+      } 
       if( pUpsertClause!=pUpsert ){
         /* The first ON CONFLICT clause has a conflict target other than
         ** the IPK.  We have to jump ahead to that first ON CONFLICT clause
         ** and then come back here and deal with the IPK afterwards */
         upsertIpkDelay = sqlite3VdbeAddOp0(v, OP_Goto);
       }
-    }
-
-    /* If the response to a rowid conflict is REPLACE but the response
-    ** to some other UNIQUE constraint is FAIL or IGNORE, then we need
-    ** to defer the running of the rowid conflict checking until after
-    ** the UNIQUE constraints have run.
-    */
-    if( onError==OE_Replace      /* IPK rule is REPLACE */
+    } 
+ 
+    /* If the response to a rowid conflict is REPLACE but the response 
+    ** to some other UNIQUE constraint is FAIL or IGNORE, then we need 
+    ** to defer the running of the rowid conflict checking until after 
+    ** the UNIQUE constraints have run. 
+    */ 
+    if( onError==OE_Replace      /* IPK rule is REPLACE */ 
      && onError!=overrideError   /* Rules for other constraints are different */
-     && pTab->pIndex             /* There exist other constraints */
+     && pTab->pIndex             /* There exist other constraints */ 
      && !upsertIpkDelay          /* IPK check already deferred by UPSERT */
-    ){
-      ipkTop = sqlite3VdbeAddOp0(v, OP_Goto)+1;
-      VdbeComment((v, "defer IPK REPLACE until last"));
-    }
-
+    ){ 
+      ipkTop = sqlite3VdbeAddOp0(v, OP_Goto)+1; 
+      VdbeComment((v, "defer IPK REPLACE until last")); 
+    } 
+ 
     if( isUpdate ){
       /* pkChng!=0 does not mean that the rowid has changed, only that
       ** it might have changed.  Skip the conflict logic below if the rowid
@@ -126048,8 +126048,8 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
 
     /* Check to see if the new rowid already exists in the table.  Skip
     ** the following conflict logic if it does not. */
-    VdbeNoopComment((v, "uniqueness check for ROWID"));
-    sqlite3VdbeVerifyAbortable(v, onError);
+    VdbeNoopComment((v, "uniqueness check for ROWID")); 
+    sqlite3VdbeVerifyAbortable(v, onError); 
     sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRowidOk, regNewData);
     VdbeCoverage(v);
 
@@ -126061,9 +126061,9 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
       case OE_Rollback:
       case OE_Abort:
       case OE_Fail: {
-        testcase( onError==OE_Rollback );
-        testcase( onError==OE_Abort );
-        testcase( onError==OE_Fail );
+        testcase( onError==OE_Rollback ); 
+        testcase( onError==OE_Abort ); 
+        testcase( onError==OE_Fail ); 
         sqlite3RowidConstraint(pParse, onError, pTab);
         break;
       }
@@ -126098,13 +126098,13 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
           nReplaceTrig++;
         }else{
 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
-          assert( HasRowid(pTab) );
-          /* This OP_Delete opcode fires the pre-update-hook only. It does
-          ** not modify the b-tree. It is more efficient to let the coming
-          ** OP_Insert replace the existing entry than it is to delete the
-          ** existing entry and then insert a new one. */
-          sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, OPFLAG_ISNOOP);
-          sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
+          assert( HasRowid(pTab) ); 
+          /* This OP_Delete opcode fires the pre-update-hook only. It does 
+          ** not modify the b-tree. It is more efficient to let the coming 
+          ** OP_Insert replace the existing entry than it is to delete the 
+          ** existing entry and then insert a new one. */ 
+          sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, OPFLAG_ISNOOP); 
+          sqlite3VdbeAppendP4(v, pTab, P4_TABLE); 
 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
           if( pTab->pIndex ){
             sqlite3MultiWrite(pParse);
@@ -126114,14 +126114,14 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
         seenReplace = 1;
         break;
       }
-#ifndef SQLITE_OMIT_UPSERT
-      case OE_Update: {
-        sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, 0, iDataCur);
+#ifndef SQLITE_OMIT_UPSERT 
+      case OE_Update: { 
+        sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, 0, iDataCur); 
         /* no break */ deliberate_fall_through
-      }
-#endif
+      } 
+#endif 
       case OE_Ignore: {
-        testcase( onError==OE_Ignore );
+        testcase( onError==OE_Ignore ); 
         sqlite3VdbeGoto(v, ignoreDest);
         break;
       }
@@ -126131,7 +126131,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
       upsertIpkReturn = sqlite3VdbeAddOp0(v, OP_Goto);
     }else if( ipkTop ){
       ipkBottom = sqlite3VdbeAddOp0(v, OP_Goto);
-      sqlite3VdbeJumpHere(v, ipkTop-1);
+      sqlite3VdbeJumpHere(v, ipkTop-1); 
     }
   }
 
@@ -126158,7 +126158,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
       if( upsertIpkDelay && pUpsertClause==pUpsert ){
         sqlite3VdbeJumpHere(v, upsertIpkDelay);
       }
-    }
+    } 
     addrUniqueOk = sqlite3VdbeMakeLabel(pParse);
     if( bAffinityDone==0 ){
       sqlite3TableAffinity(v, pTab, regNewData+1);
@@ -126167,7 +126167,7 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
     VdbeNoopComment((v, "prep index %s", pIdx->zName));
     iThisCur = iIdxCur+ix;
 
-
+ 
     /* Skip partial indices for which the WHERE clause is not true */
     if( pIdx->pPartIdxWhere ){
       sqlite3VdbeAddOp2(v, OP_Null, 0, aRegIdx[ix]);
@@ -126203,9 +126203,9 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
     sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]);
     VdbeComment((v, "for %s", pIdx->zName));
 #ifdef SQLITE_ENABLE_NULL_TRIM
-    if( pIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){
-      sqlite3SetMakeRecordP5(v, pIdx->pTable);
-    }
+    if( pIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){ 
+      sqlite3SetMakeRecordP5(v, pIdx->pTable); 
+    } 
 #endif
     sqlite3VdbeReleaseRegisters(pParse, regIdx, pIdx->nColumn, 0, 0);
 
@@ -126230,27 +126230,27 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
       onError = OE_Abort;
     }
 
-    /* Figure out if the upsert clause applies to this index */
+    /* Figure out if the upsert clause applies to this index */ 
     if( pUpsertClause ){
       if( pUpsertClause->isDoUpdate==0 ){
-        onError = OE_Ignore;  /* DO NOTHING is the same as INSERT OR IGNORE */
-      }else{
-        onError = OE_Update;  /* DO UPDATE */
-      }
-    }
-
+        onError = OE_Ignore;  /* DO NOTHING is the same as INSERT OR IGNORE */ 
+      }else{ 
+        onError = OE_Update;  /* DO UPDATE */ 
+      } 
+    } 
+ 
     /* Collision detection may be omitted if all of the following are true:
     **   (1) The conflict resolution algorithm is REPLACE
     **   (2) The table is a WITHOUT ROWID table
     **   (3) There are no secondary indexes on the table
     **   (4) No delete triggers need to be fired if there is a conflict
     **   (5) No FK constraint counters need to be updated if a conflict occurs.
-    **
-    ** This is not possible for ENABLE_PREUPDATE_HOOK builds, as the row
-    ** must be explicitly deleted in order to ensure any pre-update hook
+    ** 
+    ** This is not possible for ENABLE_PREUPDATE_HOOK builds, as the row 
+    ** must be explicitly deleted in order to ensure any pre-update hook 
     ** is invoked.  */
     assert( IsOrdinaryTable(pTab) );
-#ifndef SQLITE_ENABLE_PREUPDATE_HOOK
+#ifndef SQLITE_ENABLE_PREUPDATE_HOOK 
     if( (ix==0 && pIdx->pNext==0)                   /* Condition 3 */
      && pPk==pIdx                                   /* Condition 2 */
      && onError==OE_Replace                         /* Condition 1 */
@@ -126262,10 +126262,10 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
       sqlite3VdbeResolveLabel(v, addrUniqueOk);
       continue;
     }
-#endif /* ifndef SQLITE_ENABLE_PREUPDATE_HOOK */
+#endif /* ifndef SQLITE_ENABLE_PREUPDATE_HOOK */ 
 
     /* Check to see if the new index entry will be unique */
-    sqlite3VdbeVerifyAbortable(v, onError);
+    sqlite3VdbeVerifyAbortable(v, onError); 
     addrConflictCk =
       sqlite3VdbeAddOp4Int(v, OP_NoConflict, iThisCur, addrUniqueOk,
                            regIdx, pIdx->nKeyCol); VdbeCoverage(v);
@@ -126329,25 +126329,25 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
 
     /* Generate code that executes if the new index entry is not unique */
     assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
-        || onError==OE_Ignore || onError==OE_Replace || onError==OE_Update );
+        || onError==OE_Ignore || onError==OE_Replace || onError==OE_Update ); 
     switch( onError ){
       case OE_Rollback:
       case OE_Abort:
       case OE_Fail: {
-        testcase( onError==OE_Rollback );
-        testcase( onError==OE_Abort );
-        testcase( onError==OE_Fail );
+        testcase( onError==OE_Rollback ); 
+        testcase( onError==OE_Abort ); 
+        testcase( onError==OE_Fail ); 
         sqlite3UniqueConstraint(pParse, onError, pIdx);
         break;
       }
-#ifndef SQLITE_OMIT_UPSERT
-      case OE_Update: {
-        sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, pIdx, iIdxCur+ix);
+#ifndef SQLITE_OMIT_UPSERT 
+      case OE_Update: { 
+        sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, pIdx, iIdxCur+ix); 
         /* no break */ deliberate_fall_through
-      }
-#endif
+      } 
+#endif 
       case OE_Ignore: {
-        testcase( onError==OE_Ignore );
+        testcase( onError==OE_Ignore ); 
         sqlite3VdbeGoto(v, ignoreDest);
         break;
       }
@@ -126360,9 +126360,9 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
         testcase( nConflictCk<=0 );
         testcase( nConflictCk>1 );
         if( regTrigCnt ){
-          sqlite3MultiWrite(pParse);
+          sqlite3MultiWrite(pParse); 
           nReplaceTrig++;
-        }
+        } 
         if( pTrigger && isUpdate ){
           sqlite3VdbeAddOp1(v, OP_CursorLock, iDataCur);
         }
@@ -126433,17 +126433,17 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
       sqlite3VdbeGoto(v, upsertIpkDelay+1);
       sqlite3VdbeJumpHere(v, upsertIpkReturn);
       upsertIpkReturn = 0;
-    }
+    } 
   }
-
-  /* If the IPK constraint is a REPLACE, run it last */
+ 
+  /* If the IPK constraint is a REPLACE, run it last */ 
   if( ipkTop ){
-    sqlite3VdbeGoto(v, ipkTop);
-    VdbeComment((v, "Do IPK REPLACE"));
+    sqlite3VdbeGoto(v, ipkTop); 
+    VdbeComment((v, "Do IPK REPLACE")); 
     assert( ipkBottom>0 );
     sqlite3VdbeJumpHere(v, ipkBottom);
   }
-
+ 
   /* Recheck all uniqueness constraints after replace triggers have run */
   testcase( regTrigCnt!=0 && nReplaceTrig==0 );
   assert( regTrigCnt!=0 || nReplaceTrig==0 );
@@ -126464,16 +126464,16 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
     sqlite3VdbeResolveLabel(v, lblRecheckOk);
   }
 
-  /* Generate the table record */
-  if( HasRowid(pTab) ){
-    int regRec = aRegIdx[ix];
+  /* Generate the table record */ 
+  if( HasRowid(pTab) ){ 
+    int regRec = aRegIdx[ix]; 
     sqlite3VdbeAddOp3(v, OP_MakeRecord, regNewData+1, pTab->nNVCol, regRec);
-    sqlite3SetMakeRecordP5(v, pTab);
-    if( !bAffinityDone ){
-      sqlite3TableAffinity(v, pTab, 0);
-    }
-  }
-
+    sqlite3SetMakeRecordP5(v, pTab); 
+    if( !bAffinityDone ){ 
+      sqlite3TableAffinity(v, pTab, 0); 
+    } 
+  } 
+ 
   *pbMayReplace = seenReplace;
   VdbeModuleComment((v, "END: GenCnstCks(%d)", seenReplace));
 }
@@ -126595,7 +126595,7 @@ SQLITE_PRIVATE void sqlite3CompleteInsertion(
   if( useSeekResult ){
     pik_flags |= OPFLAG_USESEEKRESULT;
   }
-  sqlite3VdbeAddOp3(v, OP_Insert, iDataCur, aRegIdx[i], regNewData);
+  sqlite3VdbeAddOp3(v, OP_Insert, iDataCur, aRegIdx[i], regNewData); 
   if( !pParse->nested ){
     sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
   }
@@ -126853,7 +126853,7 @@ static int xferOptimization(
   if( pSrc==0 ){
     return 0;   /* FROM clause does not contain a real table */
   }
-  if( pSrc->tnum==pDest->tnum && pSrc->pSchema==pDest->pSchema ){
+  if( pSrc->tnum==pDest->tnum && pSrc->pSchema==pDest->pSchema ){ 
     testcase( pSrc!=pDest ); /* Possible due to bad sqlite_schema.rootpage */
     return 0;   /* tab1 and tab2 may not be the same table */
   }
@@ -126953,13 +126953,13 @@ static int xferOptimization(
     if( pSrcIdx==0 ){
       return 0;    /* pDestIdx has no corresponding index in pSrc */
     }
-    if( pSrcIdx->tnum==pDestIdx->tnum && pSrc->pSchema==pDest->pSchema
-         && sqlite3FaultSim(411)==SQLITE_OK ){
-      /* The sqlite3FaultSim() call allows this corruption test to be
-      ** bypassed during testing, in order to exercise other corruption tests
-      ** further downstream. */
-      return 0;   /* Corrupt schema - two indexes on the same btree */
-    }
+    if( pSrcIdx->tnum==pDestIdx->tnum && pSrc->pSchema==pDest->pSchema 
+         && sqlite3FaultSim(411)==SQLITE_OK ){ 
+      /* The sqlite3FaultSim() call allows this corruption test to be 
+      ** bypassed during testing, in order to exercise other corruption tests 
+      ** further downstream. */ 
+      return 0;   /* Corrupt schema - two indexes on the same btree */ 
+    } 
   }
 #ifndef SQLITE_OMIT_CHECK
   if( pDest->pCheck && sqlite3ExprListCompare(pSrc->pCheck,pDest->pCheck,-1) ){
@@ -127041,7 +127041,7 @@ static int xferOptimization(
         sqlite3VdbeJumpHere(v, addr2);
       }
       autoIncStep(pParse, regAutoinc, regRowid);
-    }else if( pDest->pIndex==0 && !(db->mDbFlags & DBFLAG_VacuumInto) ){
+    }else if( pDest->pIndex==0 && !(db->mDbFlags & DBFLAG_VacuumInto) ){ 
       addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid);
     }else{
       addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
@@ -127198,7 +127198,7 @@ SQLITE_API int sqlite3_exec(
   sqlite3_mutex_enter(db->mutex);
   sqlite3Error(db, SQLITE_OK);
   while( rc==SQLITE_OK && zSql[0] ){
-    int nCol = 0;
+    int nCol = 0; 
     char **azVals = 0;
 
     pStmt = 0;
@@ -127223,7 +127223,7 @@ SQLITE_API int sqlite3_exec(
           (SQLITE_DONE==rc && !callbackIsInit
                            && db->flags&SQLITE_NullCallback)) ){
         if( !callbackIsInit ){
-          nCol = sqlite3_column_count(pStmt);
+          nCol = sqlite3_column_count(pStmt); 
           azCols = sqlite3DbMallocRaw(db, (2*nCol+1)*sizeof(const char*));
           if( azCols==0 ){
             goto exec_out;
@@ -127611,33 +127611,33 @@ struct sqlite3_api_routines {
   int (*vtab_nochange)(sqlite3_context*);
   int (*value_nochange)(sqlite3_value*);
   const char *(*vtab_collation)(sqlite3_index_info*,int);
-  /* Version 3.24.0 and later */
-  int (*keyword_count)(void);
-  int (*keyword_name)(int,const char**,int*);
-  int (*keyword_check)(const char*,int);
-  sqlite3_str *(*str_new)(sqlite3*);
-  char *(*str_finish)(sqlite3_str*);
-  void (*str_appendf)(sqlite3_str*, const char *zFormat, ...);
-  void (*str_vappendf)(sqlite3_str*, const char *zFormat, va_list);
-  void (*str_append)(sqlite3_str*, const char *zIn, int N);
-  void (*str_appendall)(sqlite3_str*, const char *zIn);
-  void (*str_appendchar)(sqlite3_str*, int N, char C);
-  void (*str_reset)(sqlite3_str*);
-  int (*str_errcode)(sqlite3_str*);
-  int (*str_length)(sqlite3_str*);
-  char *(*str_value)(sqlite3_str*);
-  /* Version 3.25.0 and later */
-  int (*create_window_function)(sqlite3*,const char*,int,int,void*,
-                            void (*xStep)(sqlite3_context*,int,sqlite3_value**),
-                            void (*xFinal)(sqlite3_context*),
-                            void (*xValue)(sqlite3_context*),
-                            void (*xInv)(sqlite3_context*,int,sqlite3_value**),
-                            void(*xDestroy)(void*));
-  /* Version 3.26.0 and later */
-  const char *(*normalized_sql)(sqlite3_stmt*);
-  /* Version 3.28.0 and later */
-  int (*stmt_isexplain)(sqlite3_stmt*);
-  int (*value_frombind)(sqlite3_value*);
+  /* Version 3.24.0 and later */ 
+  int (*keyword_count)(void); 
+  int (*keyword_name)(int,const char**,int*); 
+  int (*keyword_check)(const char*,int); 
+  sqlite3_str *(*str_new)(sqlite3*); 
+  char *(*str_finish)(sqlite3_str*); 
+  void (*str_appendf)(sqlite3_str*, const char *zFormat, ...); 
+  void (*str_vappendf)(sqlite3_str*, const char *zFormat, va_list); 
+  void (*str_append)(sqlite3_str*, const char *zIn, int N); 
+  void (*str_appendall)(sqlite3_str*, const char *zIn); 
+  void (*str_appendchar)(sqlite3_str*, int N, char C); 
+  void (*str_reset)(sqlite3_str*); 
+  int (*str_errcode)(sqlite3_str*); 
+  int (*str_length)(sqlite3_str*); 
+  char *(*str_value)(sqlite3_str*); 
+  /* Version 3.25.0 and later */ 
+  int (*create_window_function)(sqlite3*,const char*,int,int,void*, 
+                            void (*xStep)(sqlite3_context*,int,sqlite3_value**), 
+                            void (*xFinal)(sqlite3_context*), 
+                            void (*xValue)(sqlite3_context*), 
+                            void (*xInv)(sqlite3_context*,int,sqlite3_value**), 
+                            void(*xDestroy)(void*)); 
+  /* Version 3.26.0 and later */ 
+  const char *(*normalized_sql)(sqlite3_stmt*); 
+  /* Version 3.28.0 and later */ 
+  int (*stmt_isexplain)(sqlite3_stmt*); 
+  int (*value_frombind)(sqlite3_value*); 
   /* Version 3.30.0 and later */
   int (*drop_modules)(sqlite3*,const char**);
   /* Version 3.31.0 and later */
@@ -127928,28 +127928,28 @@ typedef int (*sqlite3_loadext_entry)(
 #define sqlite3_value_pointer          sqlite3_api->value_pointer
 /* Version 3.22.0 and later */
 #define sqlite3_vtab_nochange          sqlite3_api->vtab_nochange
-#define sqlite3_value_nochange         sqlite3_api->value_nochange
-#define sqlite3_vtab_collation         sqlite3_api->vtab_collation
-/* Version 3.24.0 and later */
-#define sqlite3_keyword_count          sqlite3_api->keyword_count
-#define sqlite3_keyword_name           sqlite3_api->keyword_name
-#define sqlite3_keyword_check          sqlite3_api->keyword_check
-#define sqlite3_str_new                sqlite3_api->str_new
-#define sqlite3_str_finish             sqlite3_api->str_finish
-#define sqlite3_str_appendf            sqlite3_api->str_appendf
-#define sqlite3_str_vappendf           sqlite3_api->str_vappendf
-#define sqlite3_str_append             sqlite3_api->str_append
-#define sqlite3_str_appendall          sqlite3_api->str_appendall
-#define sqlite3_str_appendchar         sqlite3_api->str_appendchar
-#define sqlite3_str_reset              sqlite3_api->str_reset
-#define sqlite3_str_errcode            sqlite3_api->str_errcode
-#define sqlite3_str_length             sqlite3_api->str_length
-#define sqlite3_str_value              sqlite3_api->str_value
-/* Version 3.25.0 and later */
-#define sqlite3_create_window_function sqlite3_api->create_window_function
-/* Version 3.26.0 and later */
-#define sqlite3_normalized_sql         sqlite3_api->normalized_sql
-/* Version 3.28.0 and later */
+#define sqlite3_value_nochange         sqlite3_api->value_nochange 
+#define sqlite3_vtab_collation         sqlite3_api->vtab_collation 
+/* Version 3.24.0 and later */ 
+#define sqlite3_keyword_count          sqlite3_api->keyword_count 
+#define sqlite3_keyword_name           sqlite3_api->keyword_name 
+#define sqlite3_keyword_check          sqlite3_api->keyword_check 
+#define sqlite3_str_new                sqlite3_api->str_new 
+#define sqlite3_str_finish             sqlite3_api->str_finish 
+#define sqlite3_str_appendf            sqlite3_api->str_appendf 
+#define sqlite3_str_vappendf           sqlite3_api->str_vappendf 
+#define sqlite3_str_append             sqlite3_api->str_append 
+#define sqlite3_str_appendall          sqlite3_api->str_appendall 
+#define sqlite3_str_appendchar         sqlite3_api->str_appendchar 
+#define sqlite3_str_reset              sqlite3_api->str_reset 
+#define sqlite3_str_errcode            sqlite3_api->str_errcode 
+#define sqlite3_str_length             sqlite3_api->str_length 
+#define sqlite3_str_value              sqlite3_api->str_value 
+/* Version 3.25.0 and later */ 
+#define sqlite3_create_window_function sqlite3_api->create_window_function 
+/* Version 3.26.0 and later */ 
+#define sqlite3_normalized_sql         sqlite3_api->normalized_sql 
+/* Version 3.28.0 and later */ 
 #define sqlite3_stmt_isexplain         sqlite3_api->stmt_isexplain
 #define sqlite3_value_frombind         sqlite3_api->value_frombind
 /* Version 3.30.0 and later */
@@ -128059,7 +128059,7 @@ typedef int (*sqlite3_loadext_entry)(
 # define sqlite3_declare_vtab 0
 # define sqlite3_vtab_config 0
 # define sqlite3_vtab_on_conflict 0
-# define sqlite3_vtab_collation 0
+# define sqlite3_vtab_collation 0 
 #endif
 
 #ifdef SQLITE_OMIT_SHARED_CACHE
@@ -128410,32 +128410,32 @@ static const sqlite3_api_routines sqlite3Apis = {
   /* Version 3.22.0 and later */
   sqlite3_vtab_nochange,
   sqlite3_value_nochange,
-  sqlite3_vtab_collation,
-  /* Version 3.24.0 and later */
-  sqlite3_keyword_count,
-  sqlite3_keyword_name,
-  sqlite3_keyword_check,
-  sqlite3_str_new,
-  sqlite3_str_finish,
-  sqlite3_str_appendf,
-  sqlite3_str_vappendf,
-  sqlite3_str_append,
-  sqlite3_str_appendall,
-  sqlite3_str_appendchar,
-  sqlite3_str_reset,
-  sqlite3_str_errcode,
-  sqlite3_str_length,
-  sqlite3_str_value,
-  /* Version 3.25.0 and later */
-  sqlite3_create_window_function,
-  /* Version 3.26.0 and later */
-#ifdef SQLITE_ENABLE_NORMALIZE
-  sqlite3_normalized_sql,
-#else
-  0,
-#endif
-  /* Version 3.28.0 and later */
-  sqlite3_stmt_isexplain,
+  sqlite3_vtab_collation, 
+  /* Version 3.24.0 and later */ 
+  sqlite3_keyword_count, 
+  sqlite3_keyword_name, 
+  sqlite3_keyword_check, 
+  sqlite3_str_new, 
+  sqlite3_str_finish, 
+  sqlite3_str_appendf, 
+  sqlite3_str_vappendf, 
+  sqlite3_str_append, 
+  sqlite3_str_appendall, 
+  sqlite3_str_appendchar, 
+  sqlite3_str_reset, 
+  sqlite3_str_errcode, 
+  sqlite3_str_length, 
+  sqlite3_str_value, 
+  /* Version 3.25.0 and later */ 
+  sqlite3_create_window_function, 
+  /* Version 3.26.0 and later */ 
+#ifdef SQLITE_ENABLE_NORMALIZE 
+  sqlite3_normalized_sql, 
+#else 
+  0, 
+#endif 
+  /* Version 3.28.0 and later */ 
+  sqlite3_stmt_isexplain, 
   sqlite3_value_frombind,
   /* Version 3.30.0 and later */
 #ifndef SQLITE_OMIT_VIRTUALTABLE
@@ -128540,7 +128540,7 @@ static int sqlite3LoadExtension(
   for(ii=0; ii<ArraySize(azEndings) && handle==0; ii++){
     char *zAltFile = sqlite3_mprintf("%s.%s", zFile, azEndings[ii]);
     if( zAltFile==0 ) return SQLITE_NOMEM_BKPT;
-    handle = sqlite3OsDlOpen(pVfs, zAltFile);
+    handle = sqlite3OsDlOpen(pVfs, zAltFile); 
     sqlite3_free(zAltFile);
   }
 #endif
@@ -128669,7 +128669,7 @@ SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff){
   if( onoff ){
     db->flags |= SQLITE_LoadExtension|SQLITE_LoadExtFunc;
   }else{
-    db->flags &= ~(u64)(SQLITE_LoadExtension|SQLITE_LoadExtFunc);
+    db->flags &= ~(u64)(SQLITE_LoadExtension|SQLITE_LoadExtFunc); 
   }
   sqlite3_mutex_leave(db->mutex);
   return SQLITE_OK;
@@ -128946,7 +128946,7 @@ SQLITE_PRIVATE void sqlite3AutoLoadExtensions(sqlite3 *db){
 ** result column is different from the name of the pragma
 */
 static const char *const pragCName[] = {
-  /*   0 */ "id",          /* Used by: foreign_key_list */
+  /*   0 */ "id",          /* Used by: foreign_key_list */ 
   /*   1 */ "seq",
   /*   2 */ "table",
   /*   3 */ "from",
@@ -128954,14 +128954,14 @@ static const char *const pragCName[] = {
   /*   5 */ "on_update",
   /*   6 */ "on_delete",
   /*   7 */ "match",
-  /*   8 */ "cid",         /* Used by: table_xinfo */
+  /*   8 */ "cid",         /* Used by: table_xinfo */ 
   /*   9 */ "name",
   /*  10 */ "type",
   /*  11 */ "notnull",
   /*  12 */ "dflt_value",
   /*  13 */ "pk",
   /*  14 */ "hidden",
-                           /* table_info reuses 8 */
+                           /* table_info reuses 8 */ 
   /*  15 */ "schema",      /* Used by: table_list */
   /*  16 */ "name",
   /*  17 */ "type",
@@ -129005,7 +129005,7 @@ static const char *const pragCName[] = {
   /*  53 */ "database",    /* Used by: lock_status */
   /*  54 */ "status",
   /*  55 */ "cache_size",  /* Used by: default_cache_size */
-                           /* module_list pragma_list reuses 9 */
+                           /* module_list pragma_list reuses 9 */ 
   /*  56 */ "timeout",     /* Used by: busy_timeout */
 };
 
@@ -129016,7 +129016,7 @@ typedef struct PragmaName {
   u8 mPragFlg;             /* Zero or more PragFlg_XXX values */
   u8 iPragCName;           /* Start of column names in pragCName[] */
   u8 nPragCName;           /* Num of col names. 0 means use pragma name */
-  u64 iArg;                /* Extra argument */
+  u64 iArg;                /* Extra argument */ 
 } PragmaName;
 static const PragmaName aPragmaName[] = {
 #if defined(SQLITE_ENABLE_CEROD)
@@ -129073,13 +129073,13 @@ static const PragmaName aPragmaName[] = {
   /* ColNames:  */ 0, 0,
   /* iArg:      */ 0 },
 #endif
-#if !defined(SQLITE_OMIT_CASE_SENSITIVE_LIKE_PRAGMA)
+#if !defined(SQLITE_OMIT_CASE_SENSITIVE_LIKE_PRAGMA) 
  {/* zName:     */ "case_sensitive_like",
   /* ePragTyp:  */ PragTyp_CASE_SENSITIVE_LIKE,
   /* ePragFlg:  */ PragFlg_NoColumns,
   /* ColNames:  */ 0, 0,
   /* iArg:      */ 0 },
-#endif
+#endif 
  {/* zName:     */ "cell_size_check",
   /* ePragTyp:  */ PragTyp_FLAG,
   /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
@@ -129175,7 +129175,7 @@ static const PragmaName aPragmaName[] = {
  {/* zName:     */ "foreign_key_list",
   /* ePragTyp:  */ PragTyp_FOREIGN_KEY_LIST,
   /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt,
-  /* ColNames:  */ 0, 8,
+  /* ColNames:  */ 0, 8, 
   /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
@@ -129273,11 +129273,11 @@ static const PragmaName aPragmaName[] = {
   /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
- {/* zName:     */ "legacy_alter_table",
-  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
-  /* ColNames:  */ 0, 0,
-  /* iArg:      */ SQLITE_LegacyAlter },
+ {/* zName:     */ "legacy_alter_table", 
+  /* ePragTyp:  */ PragTyp_FLAG, 
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1, 
+  /* ColNames:  */ 0, 0, 
+  /* iArg:      */ SQLITE_LegacyAlter }, 
 #endif
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS) && SQLITE_ENABLE_LOCKING_STYLE
  {/* zName:     */ "lock_proxy_file",
@@ -129316,7 +129316,7 @@ static const PragmaName aPragmaName[] = {
  {/* zName:     */ "module_list",
   /* ePragTyp:  */ PragTyp_MODULE_LIST,
   /* ePragFlg:  */ PragFlg_Result0,
-  /* ColNames:  */ 9, 1,
+  /* ColNames:  */ 9, 1, 
   /* iArg:      */ 0 },
 #endif
 #endif
@@ -129338,20 +129338,20 @@ static const PragmaName aPragmaName[] = {
   /* ColNames:  */ 0, 0,
   /* iArg:      */ 0 },
 #endif
-#if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
-#if defined(SQLITE_DEBUG)
+#if !defined(SQLITE_OMIT_FLAG_PRAGMAS) 
+#if defined(SQLITE_DEBUG) 
  {/* zName:     */ "parser_trace",
-  /* ePragTyp:  */ PragTyp_FLAG,
-  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
+  /* ePragTyp:  */ PragTyp_FLAG, 
+  /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1, 
   /* ColNames:  */ 0, 0,
-  /* iArg:      */ SQLITE_ParserTrace },
-#endif
+  /* iArg:      */ SQLITE_ParserTrace }, 
 #endif
+#endif 
 #if !defined(SQLITE_OMIT_INTROSPECTION_PRAGMAS)
  {/* zName:     */ "pragma_list",
   /* ePragTyp:  */ PragTyp_PRAGMA_LIST,
   /* ePragFlg:  */ PragFlg_Result0,
-  /* ColNames:  */ 9, 1,
+  /* ColNames:  */ 9, 1, 
   /* iArg:      */ 0 },
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
@@ -129443,18 +129443,18 @@ static const PragmaName aPragmaName[] = {
  {/* zName:     */ "table_info",
   /* ePragTyp:  */ PragTyp_TABLE_INFO,
   /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt,
-  /* ColNames:  */ 8, 6,
+  /* ColNames:  */ 8, 6, 
   /* iArg:      */ 0 },
  {/* zName:     */ "table_list",
   /* ePragTyp:  */ PragTyp_TABLE_LIST,
   /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1,
   /* ColNames:  */ 15, 6,
   /* iArg:      */ 0 },
- {/* zName:     */ "table_xinfo",
-  /* ePragTyp:  */ PragTyp_TABLE_INFO,
-  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt,
-  /* ColNames:  */ 8, 7,
-  /* iArg:      */ 1 },
+ {/* zName:     */ "table_xinfo", 
+  /* ePragTyp:  */ PragTyp_TABLE_INFO, 
+  /* ePragFlg:  */ PragFlg_NeedSchema|PragFlg_Result1|PragFlg_SchemaOpt, 
+  /* ColNames:  */ 8, 7, 
+  /* iArg:      */ 1 }, 
 #endif
 #if !defined(SQLITE_OMIT_PAGER_PRAGMAS)
  {/* zName:     */ "temp_store",
@@ -129533,7 +129533,7 @@ static const PragmaName aPragmaName[] = {
   /* ePragTyp:  */ PragTyp_FLAG,
   /* ePragFlg:  */ PragFlg_Result0|PragFlg_NoColumns1,
   /* ColNames:  */ 0, 0,
-  /* iArg:      */ SQLITE_WriteSchema|SQLITE_NoSchemaError },
+  /* iArg:      */ SQLITE_WriteSchema|SQLITE_NoSchemaError }, 
 #endif
 };
 /* Number of pragmas: 68 on by default, 78 total. */
@@ -130216,11 +130216,11 @@ SQLITE_PRIVATE void sqlite3Pragma(
         ** then do a query */
         eMode = PAGER_JOURNALMODE_QUERY;
       }
-      if( eMode==PAGER_JOURNALMODE_OFF && (db->flags & SQLITE_Defensive)!=0 ){
-        /* Do not allow journal-mode "OFF" in defensive since the database
-        ** can become corrupted using ordinary SQL when the journal is off */
-        eMode = PAGER_JOURNALMODE_QUERY;
-      }
+      if( eMode==PAGER_JOURNALMODE_OFF && (db->flags & SQLITE_Defensive)!=0 ){ 
+        /* Do not allow journal-mode "OFF" in defensive since the database 
+        ** can become corrupted using ordinary SQL when the journal is off */ 
+        eMode = PAGER_JOURNALMODE_QUERY; 
+      } 
     }
     if( eMode==PAGER_JOURNALMODE_QUERY && pId2->n==0 ){
       /* Convert "PRAGMA journal_mode" into "PRAGMA main.journal_mode" */
@@ -130393,7 +130393,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
       if( sqlite3GetBoolean(zRight, size!=0) ){
         db->flags |= SQLITE_CacheSpill;
       }else{
-        db->flags &= ~(u64)SQLITE_CacheSpill;
+        db->flags &= ~(u64)SQLITE_CacheSpill; 
       }
       setAllPagerFlags(db);
     }
@@ -130614,7 +130614,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
       setPragmaResultColumnNames(v, pPragma);
       returnSingleInt(v, (db->flags & pPragma->iArg)!=0 );
     }else{
-      u64 mask = pPragma->iArg;    /* Mask of bits to set or clear. */
+      u64 mask = pPragma->iArg;    /* Mask of bits to set or clear. */ 
       if( db->autoCommit==0 ){
         /* Foreign key support may not be enabled or disabled while not
         ** in auto-commit mode.  */
@@ -130676,7 +130676,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
       int nHidden = 0;
       Column *pCol;
       Index *pPk = sqlite3PrimaryKeyIndex(pTab);
-      pParse->nMem = 7;
+      pParse->nMem = 7; 
       sqlite3ViewGetColumnNames(pParse, pTab);
       for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
         int isHidden = 0;
@@ -130705,14 +130705,14 @@ SQLITE_PRIVATE void sqlite3Pragma(
         assert( pColExpr==0 || pColExpr->op==TK_SPAN || isHidden>=2 );
         assert( pColExpr==0 || !ExprHasProperty(pColExpr, EP_IntValue)
                   || isHidden>=2 );
-        sqlite3VdbeMultiLoad(v, 1, pPragma->iArg ? "issisii" : "issisi",
+        sqlite3VdbeMultiLoad(v, 1, pPragma->iArg ? "issisii" : "issisi", 
                i-nHidden,
                pCol->zCnName,
                sqlite3ColumnType(pCol,""),
                pCol->notNull ? 1 : 0,
                (isHidden>=2 || pColExpr==0) ? 0 : pColExpr->u.zToken,
-               k,
-               isHidden);
+               k, 
+               isHidden); 
       }
     }
   }
@@ -130834,7 +130834,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
       }
     }
     if( pIdx ){
-      int iIdxDb = sqlite3SchemaToIndex(db, pIdx->pSchema);
+      int iIdxDb = sqlite3SchemaToIndex(db, pIdx->pSchema); 
       int i;
       int mx;
       if( pPragma->iArg ){
@@ -130847,7 +130847,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
         pParse->nMem = 3;
       }
       pTab = pIdx->pTable;
-      sqlite3CodeVerifySchema(pParse, iIdxDb);
+      sqlite3CodeVerifySchema(pParse, iIdxDb); 
       assert( pParse->nMem<=pPragma->nPragCName );
       for(i=0; i<mx; i++){
         i16 cnum = pIdx->aiColumn[i];
@@ -130871,9 +130871,9 @@ SQLITE_PRIVATE void sqlite3Pragma(
     int i;
     pTab = sqlite3FindTable(db, zRight, zDb);
     if( pTab ){
-      int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
+      int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema); 
       pParse->nMem = 5;
-      sqlite3CodeVerifySchema(pParse, iTabDb);
+      sqlite3CodeVerifySchema(pParse, iTabDb); 
       for(pIdx=pTab->pIndex, i=0; pIdx; pIdx=pIdx->pNext, i++){
         const char *azOrigin[] = { "c", "u", "pk" };
         sqlite3VdbeMultiLoad(v, 1, "isisi",
@@ -130964,10 +130964,10 @@ SQLITE_PRIVATE void sqlite3Pragma(
     if( pTab && IsOrdinaryTable(pTab) ){
       pFK = pTab->u.tab.pFKey;
       if( pFK ){
-        int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
+        int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema); 
         int i = 0;
         pParse->nMem = 8;
-        sqlite3CodeVerifySchema(pParse, iTabDb);
+        sqlite3CodeVerifySchema(pParse, iTabDb); 
         while(pFK){
           int j;
           for(j=0; j<pFK->nCol; j++){
@@ -131061,7 +131061,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
           x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, &aiCols);
           assert( x==0 || db->mallocFailed );
         }
-        addrOk = sqlite3VdbeMakeLabel(pParse);
+        addrOk = sqlite3VdbeMakeLabel(pParse); 
 
         /* Generate code to read the child key values into registers
         ** regRow..regRow+n. If any of the child key values are NULL, this
@@ -131107,7 +131107,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
 #endif /* !defined(SQLITE_OMIT_TRIGGER) */
 #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
 
-#ifndef SQLITE_OMIT_CASE_SENSITIVE_LIKE_PRAGMA
+#ifndef SQLITE_OMIT_CASE_SENSITIVE_LIKE_PRAGMA 
   /* Reinstall the LIKE and GLOB functions.  The variant of LIKE
   ** used will be case sensitive or not depending on the RHS.
   */
@@ -131117,7 +131117,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
     }
   }
   break;
-#endif /* SQLITE_OMIT_CASE_SENSITIVE_LIKE_PRAGMA */
+#endif /* SQLITE_OMIT_CASE_SENSITIVE_LIKE_PRAGMA */ 
 
 #ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX
 # define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100
@@ -131272,12 +131272,12 @@ SQLITE_PRIVATE void sqlite3Pragma(
         assert( sqlite3NoTempsInRange(pParse,1,7+j) );
         sqlite3VdbeAddOp2(v, OP_Rewind, iDataCur, 0); VdbeCoverage(v);
         loopTop = sqlite3VdbeAddOp2(v, OP_AddImm, 7, 1);
-        if( !isQuick ){
-          /* Sanity check on record header decoding */
+        if( !isQuick ){ 
+          /* Sanity check on record header decoding */ 
           sqlite3VdbeAddOp3(v, OP_Column, iDataCur, pTab->nNVCol-1,3);
-          sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG);
+          sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG); 
           VdbeComment((v, "(right-most column)"));
-        }
+        } 
         /* Verify that all NOT NULL columns really are NOT NULL.  At the
         ** same time verify the type of the content of STRICT tables */
         bStrict = (pTab->tabFlags & TF_Strict)!=0;
@@ -131323,8 +131323,8 @@ SQLITE_PRIVATE void sqlite3Pragma(
         if( pTab->pCheck && (db->flags & SQLITE_IgnoreChecks)==0 ){
           ExprList *pCheck = sqlite3ExprListDup(db, pTab->pCheck, 0);
           if( db->mallocFailed==0 ){
-            int addrCkFault = sqlite3VdbeMakeLabel(pParse);
-            int addrCkOk = sqlite3VdbeMakeLabel(pParse);
+            int addrCkFault = sqlite3VdbeMakeLabel(pParse); 
+            int addrCkOk = sqlite3VdbeMakeLabel(pParse); 
             char *zErr;
             int k;
             pParse->iSelfTab = iDataCur + 1;
@@ -131347,7 +131347,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
           /* Validate index entries for the current row */
           for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
             int jmp2, jmp3, jmp4, jmp5;
-            int ckUniq = sqlite3VdbeMakeLabel(pParse);
+            int ckUniq = sqlite3VdbeMakeLabel(pParse); 
             if( pPk==pIdx ) continue;
             r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 0, &jmp3,
                                          pPrior, r1);
@@ -131368,7 +131368,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
             ** current key.  The entry is unique if (1) any column is NULL
             ** or (2) the next entry has a different key */
             if( IsUniqueIndex(pIdx) ){
-              int uniqOk = sqlite3VdbeMakeLabel(pParse);
+              int uniqOk = sqlite3VdbeMakeLabel(pParse); 
               int jmp6;
               int kk;
               for(kk=0; kk<pIdx->nKeyCol; kk++){
@@ -131954,25 +131954,25 @@ static int pragmaVtabConnect(
   UNUSED_PARAMETER(argc);
   UNUSED_PARAMETER(argv);
   sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0);
-  sqlite3_str_appendall(&acc, "CREATE TABLE x");
+  sqlite3_str_appendall(&acc, "CREATE TABLE x"); 
   for(i=0, j=pPragma->iPragCName; i<pPragma->nPragCName; i++, j++){
-    sqlite3_str_appendf(&acc, "%c\"%s\"", cSep, pragCName[j]);
+    sqlite3_str_appendf(&acc, "%c\"%s\"", cSep, pragCName[j]); 
     cSep = ',';
   }
   if( i==0 ){
-    sqlite3_str_appendf(&acc, "(\"%s\"", pPragma->zName);
+    sqlite3_str_appendf(&acc, "(\"%s\"", pPragma->zName); 
     i++;
   }
   j = 0;
   if( pPragma->mPragFlg & PragFlg_Result1 ){
-    sqlite3_str_appendall(&acc, ",arg HIDDEN");
+    sqlite3_str_appendall(&acc, ",arg HIDDEN"); 
     j++;
   }
   if( pPragma->mPragFlg & (PragFlg_SchemaOpt|PragFlg_SchemaReq) ){
-    sqlite3_str_appendall(&acc, ",schema HIDDEN");
+    sqlite3_str_appendall(&acc, ",schema HIDDEN"); 
     j++;
   }
-  sqlite3_str_append(&acc, ")", 1);
+  sqlite3_str_append(&acc, ")", 1); 
   sqlite3StrAccumFinish(&acc);
   assert( strlen(zBuf) < sizeof(zBuf)-1 );
   rc = sqlite3_declare_vtab(db, zBuf);
@@ -132124,13 +132124,13 @@ static int pragmaVtabFilter(
     }
   }
   sqlite3StrAccumInit(&acc, 0, 0, 0, pTab->db->aLimit[SQLITE_LIMIT_SQL_LENGTH]);
-  sqlite3_str_appendall(&acc, "PRAGMA ");
+  sqlite3_str_appendall(&acc, "PRAGMA "); 
   if( pCsr->azArg[1] ){
-    sqlite3_str_appendf(&acc, "%Q.", pCsr->azArg[1]);
+    sqlite3_str_appendf(&acc, "%Q.", pCsr->azArg[1]); 
   }
-  sqlite3_str_appendall(&acc, pTab->pName->zName);
+  sqlite3_str_appendall(&acc, pTab->pName->zName); 
   if( pCsr->azArg[0] ){
-    sqlite3_str_appendf(&acc, "=%Q", pCsr->azArg[0]);
+    sqlite3_str_appendf(&acc, "=%Q", pCsr->azArg[0]); 
   }
   zSql = sqlite3StrAccumFinish(&acc);
   if( zSql==0 ) return SQLITE_NOMEM;
@@ -132202,8 +132202,8 @@ static const sqlite3_module pragmaVtabModule = {
   0,                           /* xRename - rename the table */
   0,                           /* xSavepoint */
   0,                           /* xRelease */
-  0,                           /* xRollbackTo */
-  0                            /* xShadowName */
+  0,                           /* xRollbackTo */ 
+  0                            /* xShadowName */ 
 };
 
 /*
@@ -132254,10 +132254,10 @@ static void corruptSchema(
   const char *zExtra   /* Error information */
 ){
   sqlite3 *db = pData->db;
-  if( db->mallocFailed ){
-    pData->rc = SQLITE_NOMEM_BKPT;
-  }else if( pData->pzErrMsg[0]!=0 ){
-    /* A error message has already been generated.  Do not overwrite it */
+  if( db->mallocFailed ){ 
+    pData->rc = SQLITE_NOMEM_BKPT; 
+  }else if( pData->pzErrMsg[0]!=0 ){ 
+    /* A error message has already been generated.  Do not overwrite it */ 
   }else if( pData->mInitFlags & (INITFLAG_AlterMask) ){
     static const char *azAlterType[] = {
        "rename",
@@ -132269,32 +132269,32 @@ static void corruptSchema(
         azAlterType[(pData->mInitFlags&INITFLAG_AlterMask)-1],
         zExtra
     );
-    pData->rc = SQLITE_ERROR;
-  }else if( db->flags & SQLITE_WriteSchema ){
-    pData->rc = SQLITE_CORRUPT_BKPT;
-  }else{
+    pData->rc = SQLITE_ERROR; 
+  }else if( db->flags & SQLITE_WriteSchema ){ 
+    pData->rc = SQLITE_CORRUPT_BKPT; 
+  }else{ 
     char *z;
     const char *zObj = azObj[1] ? azObj[1] : "?";
     z = sqlite3MPrintf(db, "malformed database schema (%s)", zObj);
-    if( zExtra && zExtra[0] ) z = sqlite3MPrintf(db, "%z - %s", z, zExtra);
+    if( zExtra && zExtra[0] ) z = sqlite3MPrintf(db, "%z - %s", z, zExtra); 
     *pData->pzErrMsg = z;
-    pData->rc = SQLITE_CORRUPT_BKPT;
+    pData->rc = SQLITE_CORRUPT_BKPT; 
   }
 }
 
 /*
-** Check to see if any sibling index (another index on the same table)
-** of pIndex has the same root page number, and if it does, return true.
-** This would indicate a corrupt schema.
-*/
-SQLITE_PRIVATE int sqlite3IndexHasDuplicateRootPage(Index *pIndex){
-  Index *p;
-  for(p=pIndex->pTable->pIndex; p; p=p->pNext){
-    if( p->tnum==pIndex->tnum && p!=pIndex ) return 1;
-  }
-  return 0;
-}
-
+** Check to see if any sibling index (another index on the same table) 
+** of pIndex has the same root page number, and if it does, return true. 
+** This would indicate a corrupt schema. 
+*/ 
+SQLITE_PRIVATE int sqlite3IndexHasDuplicateRootPage(Index *pIndex){ 
+  Index *p; 
+  for(p=pIndex->pTable->pIndex; p; p=p->pNext){ 
+    if( p->tnum==pIndex->tnum && p!=pIndex ) return 1; 
+  } 
+  return 0; 
+} 
+ 
 /* forward declaration */
 static int sqlite3Prepare(
   sqlite3 *db,              /* Database handle. */
@@ -132307,7 +132307,7 @@ static int sqlite3Prepare(
 );
 
 
-/*
+/* 
 ** This is the callback routine for the code that initializes the
 ** database.  See sqlite3Init() below for additional information.
 ** This routine is also called from the OP_ParseSchema opcode of the VDBE.
@@ -132331,7 +132331,7 @@ SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char
   assert( sqlite3_mutex_held(db->mutex) );
   db->mDbFlags |= DBFLAG_EncodingFixed;
   if( argv==0 ) return 0;   /* Might happen if EMPTY_RESULT_CALLBACKS are on */
-  pData->nInitRow++;
+  pData->nInitRow++; 
   if( db->mallocFailed ){
     corruptSchema(pData, argv, 0);
     return 1;
@@ -132374,7 +132374,7 @@ SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char
     rc = db->errCode;
     assert( (rc&0xFF)==(rcp&0xFF) );
     db->init.iDb = saved_iDb;
-    /* assert( saved_iDb==0 || (db->mDbFlags & DBFLAG_Vacuum)!=0 ); */
+    /* assert( saved_iDb==0 || (db->mDbFlags & DBFLAG_Vacuum)!=0 ); */ 
     if( SQLITE_OK!=rc ){
       if( db->init.orphanTrigger ){
         assert( iDb==1 );
@@ -132404,10 +132404,10 @@ SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char
       corruptSchema(pData, argv, "orphan index");
     }else
     if( sqlite3GetUInt32(argv[3],&pIndex->tnum)==0
-     || pIndex->tnum<2
+     || pIndex->tnum<2 
      || pIndex->tnum>pData->mxPage
-     || sqlite3IndexHasDuplicateRootPage(pIndex)
-    ){
+     || sqlite3IndexHasDuplicateRootPage(pIndex) 
+    ){ 
       if( sqlite3Config.bExtraSchemaChecks ){
         corruptSchema(pData, argv, "invalid rootpage");
       }
@@ -132424,7 +132424,7 @@ SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char
 ** auxiliary databases.  Return one of the SQLITE_ error codes to
 ** indicate success or failure.
 */
-SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFlags){
+SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFlags){ 
   int rc;
   int i;
 #ifndef SQLITE_OMIT_DEPRECATED
@@ -132438,7 +132438,7 @@ SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFl
   int openedTransaction = 0;
   int mask = ((db->mDbFlags & DBFLAG_EncodingFixed) | ~DBFLAG_EncodingFixed);
 
-  assert( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0 );
+  assert( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0 ); 
   assert( iDb>=0 && iDb<db->nDb );
   assert( db->aDb[iDb].pSchema );
   assert( sqlite3_mutex_held(db->mutex) );
@@ -132462,8 +132462,8 @@ SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFl
   initData.iDb = iDb;
   initData.rc = SQLITE_OK;
   initData.pzErrMsg = pzErrMsg;
-  initData.mInitFlags = mFlags;
-  initData.nInitRow = 0;
+  initData.mInitFlags = mFlags; 
+  initData.nInitRow = 0; 
   initData.mxPage = 0;
   sqlite3InitCallback(&initData, 5, (char **)azArg, 0);
   db->mDbFlags &= mask;
@@ -132487,7 +132487,7 @@ SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFl
   ** will be closed before this function returns.  */
   sqlite3BtreeEnter(pDb->pBt);
   if( sqlite3BtreeTxnState(pDb->pBt)==SQLITE_TXN_NONE ){
-    rc = sqlite3BtreeBeginTrans(pDb->pBt, 0, 0);
+    rc = sqlite3BtreeBeginTrans(pDb->pBt, 0, 0); 
     if( rc!=SQLITE_OK ){
       sqlite3SetString(pzErrMsg, db, sqlite3ErrStr(rc));
       goto initone_error_out;
@@ -132515,9 +132515,9 @@ SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFl
   for(i=0; i<ArraySize(meta); i++){
     sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
   }
-  if( (db->flags & SQLITE_ResetDatabase)!=0 ){
-    memset(meta, 0, sizeof(meta));
-  }
+  if( (db->flags & SQLITE_ResetDatabase)!=0 ){ 
+    memset(meta, 0, sizeof(meta)); 
+  } 
   pDb->pSchema->schema_cookie = meta[BTREE_SCHEMA_VERSION-1];
 
   /* If opening a non-empty database, check the text encoding. For the
@@ -132581,7 +132581,7 @@ SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFl
   ** indices that the user might have created.
   */
   if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){
-    db->flags &= ~(u64)SQLITE_LegacyFileFmt;
+    db->flags &= ~(u64)SQLITE_LegacyFileFmt; 
   }
 
   /* Read the schema information out of the schema tables
@@ -132618,7 +132618,7 @@ SQLITE_PRIVATE int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFl
     sqlite3ResetAllSchemasOfConnection(db);
     pDb = &db->aDb[iDb];
   }else
-  if( rc==SQLITE_OK || (db->flags&SQLITE_NoSchemaError)){
+  if( rc==SQLITE_OK || (db->flags&SQLITE_NoSchemaError)){ 
     /* Hack: If the SQLITE_NoSchemaError flag is set, then consider
     ** the schema loaded, even if errors (other than OOM) occurred. In
     ** this situation the current sqlite3_prepare() operation will fail,
@@ -132674,14 +132674,14 @@ SQLITE_PRIVATE int sqlite3Init(sqlite3 *db, char **pzErrMsg){
   assert( db->nDb>0 );
   /* Do the main schema first */
   if( !DbHasProperty(db, 0, DB_SchemaLoaded) ){
-    rc = sqlite3InitOne(db, 0, pzErrMsg, 0);
+    rc = sqlite3InitOne(db, 0, pzErrMsg, 0); 
     if( rc ) return rc;
   }
   /* All other schemas after the main schema. The "temp" schema must be last */
   for(i=db->nDb-1; i>0; i--){
-    assert( i==1 || sqlite3BtreeHoldsMutex(db->aDb[i].pBt) );
+    assert( i==1 || sqlite3BtreeHoldsMutex(db->aDb[i].pBt) ); 
     if( !DbHasProperty(db, i, DB_SchemaLoaded) ){
-      rc = sqlite3InitOne(db, i, pzErrMsg, 0);
+      rc = sqlite3InitOne(db, i, pzErrMsg, 0); 
       if( rc ) return rc;
     }
   }
@@ -132701,12 +132701,12 @@ SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse){
   assert( sqlite3_mutex_held(db->mutex) );
   if( !db->init.busy ){
     rc = sqlite3Init(db, &pParse->zErrMsg);
-    if( rc!=SQLITE_OK ){
-      pParse->rc = rc;
-      pParse->nErr++;
-    }else if( db->noSharedCache ){
-      db->mDbFlags |= DBFLAG_SchemaKnownOk;
-    }
+    if( rc!=SQLITE_OK ){ 
+      pParse->rc = rc; 
+      pParse->nErr++; 
+    }else if( db->noSharedCache ){ 
+      db->mDbFlags |= DBFLAG_SchemaKnownOk; 
+    } 
   }
   return rc;
 }
@@ -132734,7 +132734,7 @@ static void schemaIsValid(Parse *pParse){
     ** on the b-tree database, open one now. If a transaction is opened, it
     ** will be closed immediately after reading the meta-value. */
     if( sqlite3BtreeTxnState(pBt)==SQLITE_TXN_NONE ){
-      rc = sqlite3BtreeBeginTrans(pBt, 0, 0);
+      rc = sqlite3BtreeBeginTrans(pBt, 0, 0); 
       if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
         sqlite3OomFault(db);
         pParse->rc = SQLITE_NOMEM;
@@ -132897,7 +132897,7 @@ static int sqlite3Prepare(
     sParse.disableLookaside++;
     DisableLookaside;
   }
-  sParse.disableVtab = (prepFlags & SQLITE_PREPARE_NO_VTAB)!=0;
+  sParse.disableVtab = (prepFlags & SQLITE_PREPARE_NO_VTAB)!=0; 
 
   /* Check to verify that it is possible to get a read lock on all
   ** database schemas.  The inability to get a read lock indicates that
@@ -133048,7 +133048,7 @@ static int sqlite3LockAndPrepare(
   return rc;
 }
 
-
+ 
 /*
 ** Rerun the compilation of a statement after a schema change.
 **
@@ -133288,20 +133288,20 @@ struct DistinctCtx {
 /*
 ** An instance of the following object is used to record information about
 ** the ORDER BY (or GROUP BY) clause of query is being coded.
-**
-** The aDefer[] array is used by the sorter-references optimization. For
-** example, assuming there is no index that can be used for the ORDER BY,
-** for the query:
-**
-**     SELECT a, bigblob FROM t1 ORDER BY a LIMIT 10;
-**
-** it may be more efficient to add just the "a" values to the sorter, and
-** retrieve the associated "bigblob" values directly from table t1 as the
-** 10 smallest "a" values are extracted from the sorter.
-**
-** When the sorter-reference optimization is used, there is one entry in the
-** aDefer[] array for each database table that may be read as values are
-** extracted from the sorter.
+** 
+** The aDefer[] array is used by the sorter-references optimization. For 
+** example, assuming there is no index that can be used for the ORDER BY, 
+** for the query: 
+** 
+**     SELECT a, bigblob FROM t1 ORDER BY a LIMIT 10; 
+** 
+** it may be more efficient to add just the "a" values to the sorter, and 
+** retrieve the associated "bigblob" values directly from table t1 as the 
+** 10 smallest "a" values are extracted from the sorter. 
+** 
+** When the sorter-reference optimization is used, there is one entry in the 
+** aDefer[] array for each database table that may be read as values are 
+** extracted from the sorter. 
 */
 typedef struct SortCtx SortCtx;
 struct SortCtx {
@@ -133312,17 +133312,17 @@ struct SortCtx {
   int labelBkOut;       /* Start label for the block-output subroutine */
   int addrSortIndex;    /* Address of the OP_SorterOpen or OP_OpenEphemeral */
   int labelDone;        /* Jump here when done, ex: LIMIT reached */
-  int labelOBLopt;      /* Jump here when sorter is full */
+  int labelOBLopt;      /* Jump here when sorter is full */ 
   u8 sortFlags;         /* Zero or more SORTFLAG_* bits */
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-  u8 nDefer;            /* Number of valid entries in aDefer[] */
-  struct DeferredCsr {
-    Table *pTab;        /* Table definition */
-    int iCsr;           /* Cursor number for table */
-    int nKey;           /* Number of PK columns for table pTab (>=1) */
-  } aDefer[4];
-#endif
-  struct RowLoadInfo *pDeferredRowLoad;  /* Deferred row loading info or NULL */
+#ifdef SQLITE_ENABLE_SORTER_REFERENCES 
+  u8 nDefer;            /* Number of valid entries in aDefer[] */ 
+  struct DeferredCsr { 
+    Table *pTab;        /* Table definition */ 
+    int iCsr;           /* Cursor number for table */ 
+    int nKey;           /* Number of PK columns for table pTab (>=1) */ 
+  } aDefer[4]; 
+#endif 
+  struct RowLoadInfo *pDeferredRowLoad;  /* Deferred row loading info or NULL */ 
 };
 #define SORTFLAG_UseSorter  0x01   /* Use SorterOpen instead of OpenEphemeral */
 
@@ -133344,15 +133344,15 @@ static void clearSelect(sqlite3 *db, Select *p, int bFree){
     sqlite3ExprListDelete(db, p->pOrderBy);
     sqlite3ExprDelete(db, p->pLimit);
     if( OK_IF_ALWAYS_TRUE(p->pWith) ) sqlite3WithDelete(db, p->pWith);
-#ifndef SQLITE_OMIT_WINDOWFUNC
-    if( OK_IF_ALWAYS_TRUE(p->pWinDefn) ){
-      sqlite3WindowListDelete(db, p->pWinDefn);
-    }
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+    if( OK_IF_ALWAYS_TRUE(p->pWinDefn) ){ 
+      sqlite3WindowListDelete(db, p->pWinDefn); 
+    } 
     while( p->pWin ){
       assert( p->pWin->ppThis==&p->pWin );
       sqlite3WindowUnlinkFromSelect(p->pWin);
     }
-#endif
+#endif 
     if( bFree ) sqlite3DbFreeNN(db, p);
     p = pPrior;
     bFree = 1;
@@ -133403,7 +133403,7 @@ SQLITE_PRIVATE Select *sqlite3SelectNew(
   pNew->selFlags = selFlags;
   pNew->iLimit = 0;
   pNew->iOffset = 0;
-  pNew->selId = ++pParse->nSelect;
+  pNew->selId = ++pParse->nSelect; 
   pNew->addrOpenEphm[0] = -1;
   pNew->addrOpenEphm[1] = -1;
   pNew->nSelectRow = 0;
@@ -133417,10 +133417,10 @@ SQLITE_PRIVATE Select *sqlite3SelectNew(
   pNew->pNext = 0;
   pNew->pLimit = pLimit;
   pNew->pWith = 0;
-#ifndef SQLITE_OMIT_WINDOWFUNC
-  pNew->pWin = 0;
-  pNew->pWinDefn = 0;
-#endif
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+  pNew->pWin = 0; 
+  pNew->pWinDefn = 0; 
+#endif 
   if( pParse->db->mallocFailed ) {
     clearSelect(pParse->db, pNew, pNew!=&standin);
     pAllocated = 0;
@@ -133614,7 +133614,7 @@ static void addWhereTerm(
     ExprSetVVAProperty(pEq, EP_NoReduce);
     pEq->iRightJoinTable = pE2->iTable;
   }
-  *ppWhere = sqlite3ExprAnd(pParse, *ppWhere, pEq);
+  *ppWhere = sqlite3ExprAnd(pParse, *ppWhere, pEq); 
 }
 
 /*
@@ -133664,17 +133664,17 @@ SQLITE_PRIVATE void sqlite3SetJoinExpr(Expr *p, int iTable){
 }
 
 /* Undo the work of sqlite3SetJoinExpr(). In the expression p, convert every
-** term that is marked with EP_FromJoin and iRightJoinTable==iTable into
-** an ordinary term that omits the EP_FromJoin mark.
-**
-** This happens when a LEFT JOIN is simplified into an ordinary JOIN.
-*/
-static void unsetJoinExpr(Expr *p, int iTable){
-  while( p ){
-    if( ExprHasProperty(p, EP_FromJoin)
-     && (iTable<0 || p->iRightJoinTable==iTable) ){
-      ExprClearProperty(p, EP_FromJoin);
-    }
+** term that is marked with EP_FromJoin and iRightJoinTable==iTable into 
+** an ordinary term that omits the EP_FromJoin mark. 
+** 
+** This happens when a LEFT JOIN is simplified into an ordinary JOIN. 
+*/ 
+static void unsetJoinExpr(Expr *p, int iTable){ 
+  while( p ){ 
+    if( ExprHasProperty(p, EP_FromJoin) 
+     && (iTable<0 || p->iRightJoinTable==iTable) ){ 
+      ExprClearProperty(p, EP_FromJoin); 
+    } 
     if( p->op==TK_COLUMN && p->iTable==iTable ){
       ExprClearProperty(p, EP_CanBeNull);
     }
@@ -133685,13 +133685,13 @@ static void unsetJoinExpr(Expr *p, int iTable){
         for(i=0; i<p->x.pList->nExpr; i++){
           unsetJoinExpr(p->x.pList->a[i].pExpr, iTable);
         }
-      }
-    }
-    unsetJoinExpr(p->pLeft, iTable);
-    p = p->pRight;
+      } 
+    } 
+    unsetJoinExpr(p->pLeft, iTable); 
+    p = p->pRight; 
   }
-}
-
+} 
+ 
 /*
 ** This routine processes the join information for a SELECT statement.
 ** ON and USING clauses are converted into extra terms of the WHERE clause.
@@ -133758,7 +133758,7 @@ static int sqliteProcessJoin(Parse *pParse, Select *p){
     */
     if( pRight->pOn ){
       if( isOuter ) sqlite3SetJoinExpr(pRight->pOn, pRight->iCursor);
-      p->pWhere = sqlite3ExprAnd(pParse, p->pWhere, pRight->pOn);
+      p->pWhere = sqlite3ExprAnd(pParse, p->pWhere, pRight->pOn); 
       pRight->pOn = 0;
     }
 
@@ -133794,63 +133794,63 @@ static int sqliteProcessJoin(Parse *pParse, Select *p){
   return 0;
 }
 
-/*
-** An instance of this object holds information (beyond pParse and pSelect)
-** needed to load the next result row that is to be added to the sorter.
-*/
-typedef struct RowLoadInfo RowLoadInfo;
-struct RowLoadInfo {
-  int regResult;               /* Store results in array of registers here */
-  u8 ecelFlags;                /* Flag argument to ExprCodeExprList() */
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-  ExprList *pExtra;            /* Extra columns needed by sorter refs */
-  int regExtraResult;          /* Where to load the extra columns */
-#endif
-};
-
-/*
-** This routine does the work of loading query data into an array of
-** registers so that it can be added to the sorter.
-*/
-static void innerLoopLoadRow(
-  Parse *pParse,             /* Statement under construction */
-  Select *pSelect,           /* The query being coded */
-  RowLoadInfo *pInfo         /* Info needed to complete the row load */
-){
-  sqlite3ExprCodeExprList(pParse, pSelect->pEList, pInfo->regResult,
-                          0, pInfo->ecelFlags);
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-  if( pInfo->pExtra ){
-    sqlite3ExprCodeExprList(pParse, pInfo->pExtra, pInfo->regExtraResult, 0, 0);
-    sqlite3ExprListDelete(pParse->db, pInfo->pExtra);
-  }
-#endif
-}
-
-/*
-** Code the OP_MakeRecord instruction that generates the entry to be
-** added into the sorter.
-**
-** Return the register in which the result is stored.
-*/
-static int makeSorterRecord(
-  Parse *pParse,
-  SortCtx *pSort,
-  Select *pSelect,
-  int regBase,
-  int nBase
-){
-  int nOBSat = pSort->nOBSat;
-  Vdbe *v = pParse->pVdbe;
-  int regOut = ++pParse->nMem;
-  if( pSort->pDeferredRowLoad ){
-    innerLoopLoadRow(pParse, pSelect, pSort->pDeferredRowLoad);
-  }
-  sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase+nOBSat, nBase-nOBSat, regOut);
-  return regOut;
-}
-
-/*
+/* 
+** An instance of this object holds information (beyond pParse and pSelect) 
+** needed to load the next result row that is to be added to the sorter. 
+*/ 
+typedef struct RowLoadInfo RowLoadInfo; 
+struct RowLoadInfo { 
+  int regResult;               /* Store results in array of registers here */ 
+  u8 ecelFlags;                /* Flag argument to ExprCodeExprList() */ 
+#ifdef SQLITE_ENABLE_SORTER_REFERENCES 
+  ExprList *pExtra;            /* Extra columns needed by sorter refs */ 
+  int regExtraResult;          /* Where to load the extra columns */ 
+#endif 
+}; 
+
+/*
+** This routine does the work of loading query data into an array of 
+** registers so that it can be added to the sorter. 
+*/ 
+static void innerLoopLoadRow( 
+  Parse *pParse,             /* Statement under construction */ 
+  Select *pSelect,           /* The query being coded */ 
+  RowLoadInfo *pInfo         /* Info needed to complete the row load */ 
+){ 
+  sqlite3ExprCodeExprList(pParse, pSelect->pEList, pInfo->regResult, 
+                          0, pInfo->ecelFlags); 
+#ifdef SQLITE_ENABLE_SORTER_REFERENCES 
+  if( pInfo->pExtra ){ 
+    sqlite3ExprCodeExprList(pParse, pInfo->pExtra, pInfo->regExtraResult, 0, 0); 
+    sqlite3ExprListDelete(pParse->db, pInfo->pExtra); 
+  } 
+#endif 
+} 
+ 
+/* 
+** Code the OP_MakeRecord instruction that generates the entry to be 
+** added into the sorter. 
+** 
+** Return the register in which the result is stored. 
+*/ 
+static int makeSorterRecord( 
+  Parse *pParse, 
+  SortCtx *pSort, 
+  Select *pSelect, 
+  int regBase, 
+  int nBase 
+){ 
+  int nOBSat = pSort->nOBSat; 
+  Vdbe *v = pParse->pVdbe; 
+  int regOut = ++pParse->nMem; 
+  if( pSort->pDeferredRowLoad ){ 
+    innerLoopLoadRow(pParse, pSelect, pSort->pDeferredRowLoad); 
+  } 
+  sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase+nOBSat, nBase-nOBSat, regOut); 
+  return regOut; 
+} 
+ 
+/* 
 ** Generate code that will push the record in registers regData
 ** through regData+nData-1 onto the sorter.
 */
@@ -133860,7 +133860,7 @@ static void pushOntoSorter(
   Select *pSelect,       /* The whole SELECT statement */
   int regData,           /* First register holding data to be sorted */
   int regOrigData,       /* First register holding data before packing */
-  int nData,             /* Number of elements in the regData data array */
+  int nData,             /* Number of elements in the regData data array */ 
   int nPrefixReg         /* No. of reg prior to regData available for use */
 ){
   Vdbe *v = pParse->pVdbe;                         /* Stmt under construction */
@@ -133868,39 +133868,39 @@ static void pushOntoSorter(
   int nExpr = pSort->pOrderBy->nExpr;              /* No. of ORDER BY terms */
   int nBase = nExpr + bSeq + nData;                /* Fields in sorter record */
   int regBase;                                     /* Regs for sorter record */
-  int regRecord = 0;                               /* Assembled sorter record */
+  int regRecord = 0;                               /* Assembled sorter record */ 
   int nOBSat = pSort->nOBSat;                      /* ORDER BY terms to skip */
   int op;                            /* Opcode to add sorter record to sorter */
   int iLimit;                        /* LIMIT counter */
-  int iSkip = 0;                     /* End of the sorter insert loop */
+  int iSkip = 0;                     /* End of the sorter insert loop */ 
 
   assert( bSeq==0 || bSeq==1 );
-
-  /* Three cases:
-  **   (1) The data to be sorted has already been packed into a Record
-  **       by a prior OP_MakeRecord.  In this case nData==1 and regData
-  **       will be completely unrelated to regOrigData.
-  **   (2) All output columns are included in the sort record.  In that
-  **       case regData==regOrigData.
-  **   (3) Some output columns are omitted from the sort record due to
-  **       the SQLITE_ENABLE_SORTER_REFERENCE optimization, or due to the
+ 
+  /* Three cases: 
+  **   (1) The data to be sorted has already been packed into a Record 
+  **       by a prior OP_MakeRecord.  In this case nData==1 and regData 
+  **       will be completely unrelated to regOrigData. 
+  **   (2) All output columns are included in the sort record.  In that 
+  **       case regData==regOrigData. 
+  **   (3) Some output columns are omitted from the sort record due to 
+  **       the SQLITE_ENABLE_SORTER_REFERENCE optimization, or due to the 
   **       SQLITE_ECEL_OMITREF optimization, or due to the
-  **       SortCtx.pDeferredRowLoad optimiation.  In any of these cases
-  **       regOrigData is 0 to prevent this routine from trying to copy
-  **       values that might not yet exist.
-  */
+  **       SortCtx.pDeferredRowLoad optimiation.  In any of these cases 
+  **       regOrigData is 0 to prevent this routine from trying to copy 
+  **       values that might not yet exist. 
+  */ 
   assert( nData==1 || regData==regOrigData || regOrigData==0 );
-
+ 
   if( nPrefixReg ){
     assert( nPrefixReg==nExpr+bSeq );
-    regBase = regData - nPrefixReg;
+    regBase = regData - nPrefixReg; 
   }else{
     regBase = pParse->nMem + 1;
     pParse->nMem += nBase;
   }
   assert( pSelect->iOffset==0 || pSelect->iLimit!=0 );
   iLimit = pSelect->iOffset ? pSelect->iOffset+1 : pSelect->iLimit;
-  pSort->labelDone = sqlite3VdbeMakeLabel(pParse);
+  pSort->labelDone = sqlite3VdbeMakeLabel(pParse); 
   sqlite3ExprCodeExprList(pParse, pSort->pOrderBy, regBase, regOrigData,
                           SQLITE_ECEL_DUP | (regOrigData? SQLITE_ECEL_REF : 0));
   if( bSeq ){
@@ -133917,7 +133917,7 @@ static void pushOntoSorter(
     int nKey;         /* Number of sorting key columns, including OP_Sequence */
     KeyInfo *pKI;     /* Original KeyInfo on the sorter table */
 
-    regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase);
+    regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase); 
     regPrevKey = pParse->nMem+1;
     pParse->nMem += pSort->nOBSat;
     nKey = nExpr - pSort->nOBSat + bSeq;
@@ -133935,12 +133935,12 @@ static void pushOntoSorter(
     memset(pKI->aSortFlags, 0, pKI->nKeyField); /* Makes OP_Jump testable */
     sqlite3VdbeChangeP4(v, -1, (char*)pKI, P4_KEYINFO);
     testcase( pKI->nAllField > pKI->nKeyField+2 );
-    pOp->p4.pKeyInfo = sqlite3KeyInfoFromExprList(pParse,pSort->pOrderBy,nOBSat,
+    pOp->p4.pKeyInfo = sqlite3KeyInfoFromExprList(pParse,pSort->pOrderBy,nOBSat, 
                                            pKI->nAllField-pKI->nKeyField-1);
     pOp = 0; /* Ensure pOp not used after sqltie3VdbeAddOp3() */
     addrJmp = sqlite3VdbeCurrentAddr(v);
     sqlite3VdbeAddOp3(v, OP_Jump, addrJmp+1, 0, addrJmp+1); VdbeCoverage(v);
-    pSort->labelBkOut = sqlite3VdbeMakeLabel(pParse);
+    pSort->labelBkOut = sqlite3VdbeMakeLabel(pParse); 
     pSort->regReturn = ++pParse->nMem;
     sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut);
     sqlite3VdbeAddOp1(v, OP_ResetSorter, pSort->iECursor);
@@ -133952,34 +133952,34 @@ static void pushOntoSorter(
     sqlite3ExprCodeMove(pParse, regBase, regPrevKey, pSort->nOBSat);
     sqlite3VdbeJumpHere(v, addrJmp);
   }
-  if( iLimit ){
-    /* At this point the values for the new sorter entry are stored
-    ** in an array of registers. They need to be composed into a record
-    ** and inserted into the sorter if either (a) there are currently
+  if( iLimit ){ 
+    /* At this point the values for the new sorter entry are stored 
+    ** in an array of registers. They need to be composed into a record 
+    ** and inserted into the sorter if either (a) there are currently 
     ** less than LIMIT+OFFSET items or (b) the new record is smaller than
-    ** the largest record currently in the sorter. If (b) is true and there
-    ** are already LIMIT+OFFSET items in the sorter, delete the largest
+    ** the largest record currently in the sorter. If (b) is true and there 
+    ** are already LIMIT+OFFSET items in the sorter, delete the largest 
     ** entry before inserting the new one. This way there are never more
-    ** than LIMIT+OFFSET items in the sorter.
-    **
-    ** If the new record does not need to be inserted into the sorter,
-    ** jump to the next iteration of the loop. If the pSort->labelOBLopt
-    ** value is not zero, then it is a label of where to jump.  Otherwise,
-    ** just bypass the row insert logic.  See the header comment on the
-    ** sqlite3WhereOrderByLimitOptLabel() function for additional info.
-    */
-    int iCsr = pSort->iECursor;
-    sqlite3VdbeAddOp2(v, OP_IfNotZero, iLimit, sqlite3VdbeCurrentAddr(v)+4);
-    VdbeCoverage(v);
-    sqlite3VdbeAddOp2(v, OP_Last, iCsr, 0);
-    iSkip = sqlite3VdbeAddOp4Int(v, OP_IdxLE,
-                                 iCsr, 0, regBase+nOBSat, nExpr-nOBSat);
-    VdbeCoverage(v);
-    sqlite3VdbeAddOp1(v, OP_Delete, iCsr);
-  }
-  if( regRecord==0 ){
-    regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase);
-  }
+    ** than LIMIT+OFFSET items in the sorter. 
+    ** 
+    ** If the new record does not need to be inserted into the sorter, 
+    ** jump to the next iteration of the loop. If the pSort->labelOBLopt 
+    ** value is not zero, then it is a label of where to jump.  Otherwise, 
+    ** just bypass the row insert logic.  See the header comment on the 
+    ** sqlite3WhereOrderByLimitOptLabel() function for additional info. 
+    */ 
+    int iCsr = pSort->iECursor; 
+    sqlite3VdbeAddOp2(v, OP_IfNotZero, iLimit, sqlite3VdbeCurrentAddr(v)+4); 
+    VdbeCoverage(v); 
+    sqlite3VdbeAddOp2(v, OP_Last, iCsr, 0); 
+    iSkip = sqlite3VdbeAddOp4Int(v, OP_IdxLE, 
+                                 iCsr, 0, regBase+nOBSat, nExpr-nOBSat); 
+    VdbeCoverage(v); 
+    sqlite3VdbeAddOp1(v, OP_Delete, iCsr); 
+  } 
+  if( regRecord==0 ){ 
+    regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase); 
+  } 
   if( pSort->sortFlags & SORTFLAG_UseSorter ){
     op = OP_SorterInsert;
   }else{
@@ -133987,9 +133987,9 @@ static void pushOntoSorter(
   }
   sqlite3VdbeAddOp4Int(v, op, pSort->iECursor, regRecord,
                        regBase+nOBSat, nBase-nOBSat);
-  if( iSkip ){
-    sqlite3VdbeChangeP2(v, iSkip,
-         pSort->labelOBLopt ? pSort->labelOBLopt : sqlite3VdbeCurrentAddr(v));
+  if( iSkip ){ 
+    sqlite3VdbeChangeP2(v, iSkip, 
+         pSort->labelOBLopt ? pSort->labelOBLopt : sqlite3VdbeCurrentAddr(v)); 
   }
 }
 
@@ -134161,44 +134161,44 @@ static void fixDistinctOpenEph(
   }
 }
 
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
+#ifdef SQLITE_ENABLE_SORTER_REFERENCES 
 /*
-** This function is called as part of inner-loop generation for a SELECT
+** This function is called as part of inner-loop generation for a SELECT 
 ** statement with an ORDER BY that is not optimized by an index. It
 ** determines the expressions, if any, that the sorter-reference
-** optimization should be used for. The sorter-reference optimization
-** is used for SELECT queries like:
-**
-**   SELECT a, bigblob FROM t1 ORDER BY a LIMIT 10
-**
-** If the optimization is used for expression "bigblob", then instead of
-** storing values read from that column in the sorter records, the PK of
-** the row from table t1 is stored instead. Then, as records are extracted from
-** the sorter to return to the user, the required value of bigblob is
+** optimization should be used for. The sorter-reference optimization 
+** is used for SELECT queries like: 
+** 
+**   SELECT a, bigblob FROM t1 ORDER BY a LIMIT 10 
+** 
+** If the optimization is used for expression "bigblob", then instead of 
+** storing values read from that column in the sorter records, the PK of 
+** the row from table t1 is stored instead. Then, as records are extracted from 
+** the sorter to return to the user, the required value of bigblob is 
 ** retrieved directly from table t1. If the values are very large, this
-** can be more efficient than storing them directly in the sorter records.
-**
+** can be more efficient than storing them directly in the sorter records. 
+** 
 ** The ExprList_item.bSorterRef flag is set for each expression in pEList
 ** for which the sorter-reference optimization should be enabled.
-** Additionally, the pSort->aDefer[] array is populated with entries
-** for all cursors required to evaluate all selected expressions. Finally.
-** output variable (*ppExtra) is set to an expression list containing
-** expressions for all extra PK values that should be stored in the
-** sorter records.
-*/
-static void selectExprDefer(
-  Parse *pParse,                  /* Leave any error here */
-  SortCtx *pSort,                 /* Sorter context */
-  ExprList *pEList,               /* Expressions destined for sorter */
-  ExprList **ppExtra              /* Expressions to append to sorter record */
-){
-  int i;
-  int nDefer = 0;
-  ExprList *pExtra = 0;
-  for(i=0; i<pEList->nExpr; i++){
-    struct ExprList_item *pItem = &pEList->a[i];
-    if( pItem->u.x.iOrderByCol==0 ){
-      Expr *pExpr = pItem->pExpr;
+** Additionally, the pSort->aDefer[] array is populated with entries 
+** for all cursors required to evaluate all selected expressions. Finally. 
+** output variable (*ppExtra) is set to an expression list containing 
+** expressions for all extra PK values that should be stored in the 
+** sorter records. 
+*/ 
+static void selectExprDefer( 
+  Parse *pParse,                  /* Leave any error here */ 
+  SortCtx *pSort,                 /* Sorter context */ 
+  ExprList *pEList,               /* Expressions destined for sorter */ 
+  ExprList **ppExtra              /* Expressions to append to sorter record */ 
+){ 
+  int i; 
+  int nDefer = 0; 
+  ExprList *pExtra = 0; 
+  for(i=0; i<pEList->nExpr; i++){ 
+    struct ExprList_item *pItem = &pEList->a[i]; 
+    if( pItem->u.x.iOrderByCol==0 ){ 
+      Expr *pExpr = pItem->pExpr; 
       Table *pTab;
       if( pExpr->op==TK_COLUMN
        && pExpr->iColumn>=0
@@ -134206,48 +134206,48 @@ static void selectExprDefer(
        && (pTab = pExpr->y.pTab)!=0
        && IsOrdinaryTable(pTab)
        && (pTab->aCol[pExpr->iColumn].colFlags & COLFLAG_SORTERREF)!=0
-      ){
-        int j;
-        for(j=0; j<nDefer; j++){
-          if( pSort->aDefer[j].iCsr==pExpr->iTable ) break;
-        }
-        if( j==nDefer ){
-          if( nDefer==ArraySize(pSort->aDefer) ){
-            continue;
-          }else{
-            int nKey = 1;
-            int k;
-            Index *pPk = 0;
-            if( !HasRowid(pTab) ){
-              pPk = sqlite3PrimaryKeyIndex(pTab);
-              nKey = pPk->nKeyCol;
-            }
-            for(k=0; k<nKey; k++){
-              Expr *pNew = sqlite3PExpr(pParse, TK_COLUMN, 0, 0);
-              if( pNew ){
-                pNew->iTable = pExpr->iTable;
+      ){ 
+        int j; 
+        for(j=0; j<nDefer; j++){ 
+          if( pSort->aDefer[j].iCsr==pExpr->iTable ) break; 
+        } 
+        if( j==nDefer ){ 
+          if( nDefer==ArraySize(pSort->aDefer) ){ 
+            continue; 
+          }else{ 
+            int nKey = 1; 
+            int k; 
+            Index *pPk = 0; 
+            if( !HasRowid(pTab) ){ 
+              pPk = sqlite3PrimaryKeyIndex(pTab); 
+              nKey = pPk->nKeyCol; 
+            } 
+            for(k=0; k<nKey; k++){ 
+              Expr *pNew = sqlite3PExpr(pParse, TK_COLUMN, 0, 0); 
+              if( pNew ){ 
+                pNew->iTable = pExpr->iTable; 
                 assert( ExprUseYTab(pNew) );
-                pNew->y.pTab = pExpr->y.pTab;
-                pNew->iColumn = pPk ? pPk->aiColumn[k] : -1;
-                pExtra = sqlite3ExprListAppend(pParse, pExtra, pNew);
-              }
-            }
-            pSort->aDefer[nDefer].pTab = pExpr->y.pTab;
-            pSort->aDefer[nDefer].iCsr = pExpr->iTable;
-            pSort->aDefer[nDefer].nKey = nKey;
-            nDefer++;
-          }
-        }
-        pItem->bSorterRef = 1;
-      }
-    }
-  }
-  pSort->nDefer = (u8)nDefer;
-  *ppExtra = pExtra;
-}
-#endif
-
-/*
+                pNew->y.pTab = pExpr->y.pTab; 
+                pNew->iColumn = pPk ? pPk->aiColumn[k] : -1; 
+                pExtra = sqlite3ExprListAppend(pParse, pExtra, pNew); 
+              } 
+            } 
+            pSort->aDefer[nDefer].pTab = pExpr->y.pTab; 
+            pSort->aDefer[nDefer].iCsr = pExpr->iTable; 
+            pSort->aDefer[nDefer].nKey = nKey; 
+            nDefer++; 
+          } 
+        } 
+        pItem->bSorterRef = 1; 
+      } 
+    } 
+  } 
+  pSort->nDefer = (u8)nDefer; 
+  *ppExtra = pExtra; 
+} 
+#endif 
+ 
+/* 
 ** This routine generates the code for the inside of the inner loop
 ** of a SELECT.
 **
@@ -134273,7 +134273,7 @@ static void selectInnerLoop(
   int iParm = pDest->iSDParm; /* First argument to disposal method */
   int nResultCol;             /* Number of result columns */
   int nPrefixReg = 0;         /* Number of extra registers before regResult */
-  RowLoadInfo sRowLoadInfo;   /* Info for deferred row loading */
+  RowLoadInfo sRowLoadInfo;   /* Info for deferred row loading */ 
 
   /* Usually, regResult is the first cell in an array of memory cells
   ** containing the current result row. In this case regOrig is set to the
@@ -134320,14 +134320,14 @@ static void selectInnerLoop(
       VdbeComment((v, "%s", p->pEList->a[i].zEName));
     }
   }else if( eDest!=SRT_Exists ){
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-    ExprList *pExtra = 0;
-#endif
+#ifdef SQLITE_ENABLE_SORTER_REFERENCES 
+    ExprList *pExtra = 0; 
+#endif 
     /* If the destination is an EXISTS(...) expression, the actual
     ** values returned by the SELECT are not required.
     */
-    u8 ecelFlags;    /* "ecel" is an abbreviation of "ExprCodeExprList" */
-    ExprList *pEList;
+    u8 ecelFlags;    /* "ecel" is an abbreviation of "ExprCodeExprList" */ 
+    ExprList *pEList; 
     if( eDest==SRT_Mem || eDest==SRT_Output || eDest==SRT_Coroutine ){
       ecelFlags = SQLITE_ECEL_DUP;
     }else{
@@ -134341,69 +134341,69 @@ static void selectInnerLoop(
       ** This allows the p->pEList field to be omitted from the sorted record,
       ** saving space and CPU cycles.  */
       ecelFlags |= (SQLITE_ECEL_OMITREF|SQLITE_ECEL_REF);
-
+ 
       for(i=pSort->nOBSat; i<pSort->pOrderBy->nExpr; i++){
         int j;
         if( (j = pSort->pOrderBy->a[i].u.x.iOrderByCol)>0 ){
           p->pEList->a[j-1].u.x.iOrderByCol = i+1-pSort->nOBSat;
         }
       }
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-      selectExprDefer(pParse, pSort, p->pEList, &pExtra);
-      if( pExtra && pParse->db->mallocFailed==0 ){
-        /* If there are any extra PK columns to add to the sorter records,
+#ifdef SQLITE_ENABLE_SORTER_REFERENCES 
+      selectExprDefer(pParse, pSort, p->pEList, &pExtra); 
+      if( pExtra && pParse->db->mallocFailed==0 ){ 
+        /* If there are any extra PK columns to add to the sorter records, 
         ** allocate extra memory cells and adjust the OpenEphemeral
-        ** instruction to account for the larger records. This is only
-        ** required if there are one or more WITHOUT ROWID tables with
-        ** composite primary keys in the SortCtx.aDefer[] array.  */
-        VdbeOp *pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);
-        pOp->p2 += (pExtra->nExpr - pSort->nDefer);
-        pOp->p4.pKeyInfo->nAllField += (pExtra->nExpr - pSort->nDefer);
-        pParse->nMem += pExtra->nExpr;
-      }
-#endif
-
-      /* Adjust nResultCol to account for columns that are omitted
-      ** from the sorter by the optimizations in this branch */
-      pEList = p->pEList;
-      for(i=0; i<pEList->nExpr; i++){
-        if( pEList->a[i].u.x.iOrderByCol>0
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-         || pEList->a[i].bSorterRef
-#endif
-        ){
-          nResultCol--;
-          regOrig = 0;
-        }
-      }
-
-      testcase( regOrig );
-      testcase( eDest==SRT_Set );
-      testcase( eDest==SRT_Mem );
-      testcase( eDest==SRT_Coroutine );
-      testcase( eDest==SRT_Output );
+        ** instruction to account for the larger records. This is only 
+        ** required if there are one or more WITHOUT ROWID tables with 
+        ** composite primary keys in the SortCtx.aDefer[] array.  */ 
+        VdbeOp *pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex); 
+        pOp->p2 += (pExtra->nExpr - pSort->nDefer); 
+        pOp->p4.pKeyInfo->nAllField += (pExtra->nExpr - pSort->nDefer); 
+        pParse->nMem += pExtra->nExpr; 
+      } 
+#endif 
+ 
+      /* Adjust nResultCol to account for columns that are omitted 
+      ** from the sorter by the optimizations in this branch */ 
+      pEList = p->pEList; 
+      for(i=0; i<pEList->nExpr; i++){ 
+        if( pEList->a[i].u.x.iOrderByCol>0 
+#ifdef SQLITE_ENABLE_SORTER_REFERENCES 
+         || pEList->a[i].bSorterRef 
+#endif 
+        ){ 
+          nResultCol--; 
+          regOrig = 0; 
+        } 
+      } 
+ 
+      testcase( regOrig ); 
+      testcase( eDest==SRT_Set ); 
+      testcase( eDest==SRT_Mem ); 
+      testcase( eDest==SRT_Coroutine ); 
+      testcase( eDest==SRT_Output ); 
       assert( eDest==SRT_Set || eDest==SRT_Mem
            || eDest==SRT_Coroutine || eDest==SRT_Output
            || eDest==SRT_Upfrom );
     }
-    sRowLoadInfo.regResult = regResult;
-    sRowLoadInfo.ecelFlags = ecelFlags;
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-    sRowLoadInfo.pExtra = pExtra;
-    sRowLoadInfo.regExtraResult = regResult + nResultCol;
-    if( pExtra ) nResultCol += pExtra->nExpr;
-#endif
-    if( p->iLimit
+    sRowLoadInfo.regResult = regResult; 
+    sRowLoadInfo.ecelFlags = ecelFlags; 
+#ifdef SQLITE_ENABLE_SORTER_REFERENCES 
+    sRowLoadInfo.pExtra = pExtra; 
+    sRowLoadInfo.regExtraResult = regResult + nResultCol; 
+    if( pExtra ) nResultCol += pExtra->nExpr; 
+#endif 
+    if( p->iLimit 
      && (ecelFlags & SQLITE_ECEL_OMITREF)!=0
-     && nPrefixReg>0
-    ){
-      assert( pSort!=0 );
-      assert( hasDistinct==0 );
-      pSort->pDeferredRowLoad = &sRowLoadInfo;
-      regOrig = 0;
-    }else{
-      innerLoopLoadRow(pParse, p, &sRowLoadInfo);
-    }
+     && nPrefixReg>0 
+    ){ 
+      assert( pSort!=0 ); 
+      assert( hasDistinct==0 ); 
+      pSort->pDeferredRowLoad = &sRowLoadInfo; 
+      regOrig = 0; 
+    }else{ 
+      innerLoopLoadRow(pParse, p, &sRowLoadInfo); 
+    } 
   }
 
   /* If the DISTINCT keyword was present on the SELECT statement
@@ -134472,8 +134472,8 @@ static void selectInnerLoop(
       }
 #endif
       if( pSort ){
-        assert( regResult==regOrig );
-        pushOntoSorter(pParse, pSort, p, r1+nPrefixReg, regOrig, 1, nPrefixReg);
+        assert( regResult==regOrig ); 
+        pushOntoSorter(pParse, pSort, p, r1+nPrefixReg, regOrig, 1, nPrefixReg); 
       }else{
         int r2 = sqlite3GetTempReg(pParse);
         sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2);
@@ -134713,7 +134713,7 @@ SQLITE_PRIVATE int sqlite3KeyInfoIsWriteable(KeyInfo *p){ return p->nRef==1; }
 ** function is responsible for seeing that this structure is eventually
 ** freed.
 */
-SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoFromExprList(
+SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoFromExprList( 
   Parse *pParse,       /* Parsing context */
   ExprList *pList,     /* Form the KeyInfo object from this ExprList */
   int iStart,          /* Begin with this column of pList */
@@ -134763,7 +134763,7 @@ SQLITE_PRIVATE const char *sqlite3SelectOpName(int id){
 ** is determined by the zUsage argument.
 */
 static void explainTempTable(Parse *pParse, const char *zUsage){
-  ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s", zUsage));
+  ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s", zUsage)); 
 }
 
 /*
@@ -134797,8 +134797,8 @@ static void generateSortTail(
 ){
   Vdbe *v = pParse->pVdbe;                     /* The prepared statement */
   int addrBreak = pSort->labelDone;            /* Jump here to exit loop */
-  int addrContinue = sqlite3VdbeMakeLabel(pParse);/* Jump here for next cycle */
-  int addr;                       /* Top of output loop. Jump for Next. */
+  int addrContinue = sqlite3VdbeMakeLabel(pParse);/* Jump here for next cycle */ 
+  int addr;                       /* Top of output loop. Jump for Next. */ 
   int addrOnce = 0;
   int iTab;
   ExprList *pOrderBy = pSort->pOrderBy;
@@ -134807,11 +134807,11 @@ static void generateSortTail(
   int regRow;
   int regRowid;
   int iCol;
-  int nKey;                       /* Number of key columns in sorter record */
+  int nKey;                       /* Number of key columns in sorter record */ 
   int iSortTab;                   /* Sorter cursor to read from */
   int i;
   int bSeq;                       /* True if sorter record includes seq. no. */
-  int nRefKey = 0;
+  int nRefKey = 0; 
   struct ExprList_item *aOutEx = p->pEList->a;
 
   assert( addrBreak<0 );
@@ -134820,29 +134820,29 @@ static void generateSortTail(
     sqlite3VdbeGoto(v, addrBreak);
     sqlite3VdbeResolveLabel(v, pSort->labelBkOut);
   }
-
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-  /* Open any cursors needed for sorter-reference expressions */
-  for(i=0; i<pSort->nDefer; i++){
-    Table *pTab = pSort->aDefer[i].pTab;
-    int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
-    sqlite3OpenTable(pParse, pSort->aDefer[i].iCsr, iDb, pTab, OP_OpenRead);
-    nRefKey = MAX(nRefKey, pSort->aDefer[i].nKey);
-  }
-#endif
-
+ 
+#ifdef SQLITE_ENABLE_SORTER_REFERENCES 
+  /* Open any cursors needed for sorter-reference expressions */ 
+  for(i=0; i<pSort->nDefer; i++){ 
+    Table *pTab = pSort->aDefer[i].pTab; 
+    int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema); 
+    sqlite3OpenTable(pParse, pSort->aDefer[i].iCsr, iDb, pTab, OP_OpenRead); 
+    nRefKey = MAX(nRefKey, pSort->aDefer[i].nKey); 
+  } 
+#endif 
+ 
   iTab = pSort->iECursor;
   if( eDest==SRT_Output || eDest==SRT_Coroutine || eDest==SRT_Mem ){
     regRowid = 0;
     regRow = pDest->iSdst;
   }else{
     regRowid = sqlite3GetTempReg(pParse);
-    if( eDest==SRT_EphemTab || eDest==SRT_Table ){
-      regRow = sqlite3GetTempReg(pParse);
-      nColumn = 0;
-    }else{
-      regRow = sqlite3GetTempRange(pParse, nColumn);
-    }
+    if( eDest==SRT_EphemTab || eDest==SRT_Table ){ 
+      regRow = sqlite3GetTempReg(pParse); 
+      nColumn = 0; 
+    }else{ 
+      regRow = sqlite3GetTempRange(pParse, nColumn); 
+    } 
   }
   nKey = pOrderBy->nExpr - pSort->nOBSat;
   if( pSort->sortFlags & SORTFLAG_UseSorter ){
@@ -134852,7 +134852,7 @@ static void generateSortTail(
       addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
     }
     sqlite3VdbeAddOp3(v, OP_OpenPseudo, iSortTab, regSortOut,
-        nKey+1+nColumn+nRefKey);
+        nKey+1+nColumn+nRefKey); 
     if( addrOnce ) sqlite3VdbeJumpHere(v, addrOnce);
     addr = 1 + sqlite3VdbeAddOp2(v, OP_SorterSort, iTab, addrBreak);
     VdbeCoverage(v);
@@ -134865,64 +134865,64 @@ static void generateSortTail(
     iSortTab = iTab;
     bSeq = 1;
   }
-  for(i=0, iCol=nKey+bSeq-1; i<nColumn; i++){
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-    if( aOutEx[i].bSorterRef ) continue;
-#endif
-    if( aOutEx[i].u.x.iOrderByCol==0 ) iCol++;
-  }
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-  if( pSort->nDefer ){
-    int iKey = iCol+1;
-    int regKey = sqlite3GetTempRange(pParse, nRefKey);
-
-    for(i=0; i<pSort->nDefer; i++){
-      int iCsr = pSort->aDefer[i].iCsr;
-      Table *pTab = pSort->aDefer[i].pTab;
-      int nKey = pSort->aDefer[i].nKey;
-
-      sqlite3VdbeAddOp1(v, OP_NullRow, iCsr);
-      if( HasRowid(pTab) ){
-        sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey);
+  for(i=0, iCol=nKey+bSeq-1; i<nColumn; i++){ 
+#ifdef SQLITE_ENABLE_SORTER_REFERENCES 
+    if( aOutEx[i].bSorterRef ) continue; 
+#endif 
+    if( aOutEx[i].u.x.iOrderByCol==0 ) iCol++; 
+  } 
+#ifdef SQLITE_ENABLE_SORTER_REFERENCES 
+  if( pSort->nDefer ){ 
+    int iKey = iCol+1; 
+    int regKey = sqlite3GetTempRange(pParse, nRefKey); 
+ 
+    for(i=0; i<pSort->nDefer; i++){ 
+      int iCsr = pSort->aDefer[i].iCsr; 
+      Table *pTab = pSort->aDefer[i].pTab; 
+      int nKey = pSort->aDefer[i].nKey; 
+ 
+      sqlite3VdbeAddOp1(v, OP_NullRow, iCsr); 
+      if( HasRowid(pTab) ){ 
+        sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey); 
         sqlite3VdbeAddOp3(v, OP_SeekRowid, iCsr,
-            sqlite3VdbeCurrentAddr(v)+1, regKey);
-      }else{
-        int k;
-        int iJmp;
-        assert( sqlite3PrimaryKeyIndex(pTab)->nKeyCol==nKey );
-        for(k=0; k<nKey; k++){
-          sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey+k);
-        }
-        iJmp = sqlite3VdbeCurrentAddr(v);
-        sqlite3VdbeAddOp4Int(v, OP_SeekGE, iCsr, iJmp+2, regKey, nKey);
-        sqlite3VdbeAddOp4Int(v, OP_IdxLE, iCsr, iJmp+3, regKey, nKey);
-        sqlite3VdbeAddOp1(v, OP_NullRow, iCsr);
-      }
-    }
-    sqlite3ReleaseTempRange(pParse, regKey, nRefKey);
-  }
-#endif
-  for(i=nColumn-1; i>=0; i--){
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-    if( aOutEx[i].bSorterRef ){
-      sqlite3ExprCode(pParse, aOutEx[i].pExpr, regRow+i);
-    }else
-#endif
-    {
-      int iRead;
-      if( aOutEx[i].u.x.iOrderByCol ){
-        iRead = aOutEx[i].u.x.iOrderByCol-1;
-      }else{
-        iRead = iCol--;
-      }
-      sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iRead, regRow+i);
+            sqlite3VdbeCurrentAddr(v)+1, regKey); 
+      }else{ 
+        int k; 
+        int iJmp; 
+        assert( sqlite3PrimaryKeyIndex(pTab)->nKeyCol==nKey ); 
+        for(k=0; k<nKey; k++){ 
+          sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey+k); 
+        } 
+        iJmp = sqlite3VdbeCurrentAddr(v); 
+        sqlite3VdbeAddOp4Int(v, OP_SeekGE, iCsr, iJmp+2, regKey, nKey); 
+        sqlite3VdbeAddOp4Int(v, OP_IdxLE, iCsr, iJmp+3, regKey, nKey); 
+        sqlite3VdbeAddOp1(v, OP_NullRow, iCsr); 
+      } 
+    }
+    sqlite3ReleaseTempRange(pParse, regKey, nRefKey); 
+  }
+#endif 
+  for(i=nColumn-1; i>=0; i--){ 
+#ifdef SQLITE_ENABLE_SORTER_REFERENCES 
+    if( aOutEx[i].bSorterRef ){ 
+      sqlite3ExprCode(pParse, aOutEx[i].pExpr, regRow+i); 
+    }else 
+#endif 
+    { 
+      int iRead; 
+      if( aOutEx[i].u.x.iOrderByCol ){ 
+        iRead = aOutEx[i].u.x.iOrderByCol-1; 
+      }else{ 
+        iRead = iCol--; 
+      } 
+      sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iRead, regRow+i); 
       VdbeComment((v, "%s", aOutEx[i].zEName));
-    }
-  }
+    } 
+  } 
   switch( eDest ){
     case SRT_Table:
     case SRT_EphemTab: {
-      sqlite3VdbeAddOp3(v, OP_Column, iSortTab, nKey+bSeq, regRow);
+      sqlite3VdbeAddOp3(v, OP_Column, iSortTab, nKey+bSeq, regRow); 
       sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, regRowid);
       sqlite3VdbeAddOp3(v, OP_Insert, iParm, regRow, regRowid);
       sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
@@ -135251,7 +135251,7 @@ SQLITE_PRIVATE void sqlite3GenerateColumnNames(
   }
 #endif
 
-  if( pParse->colNamesSet ) return;
+  if( pParse->colNamesSet ) return; 
   /* Column names are determined by the left-most term of a compound select */
   while( pSelect->pPrior ) pSelect = pSelect->pPrior;
   SELECTTRACE(1,pParse,pSelect,("generating column names\n"));
@@ -135277,7 +135277,7 @@ SQLITE_PRIVATE void sqlite3GenerateColumnNames(
     }else if( srcName && p->op==TK_COLUMN ){
       char *zCol;
       int iCol = p->iColumn;
-      pTab = p->y.pTab;
+      pTab = p->y.pTab; 
       assert( pTab!=0 );
       if( iCol<0 ) iCol = pTab->iPKey;
       assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) );
@@ -135489,13 +135489,13 @@ SQLITE_PRIVATE void sqlite3SelectAddColumnTypeAndCollation(
 SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse *pParse, Select *pSelect, char aff){
   Table *pTab;
   sqlite3 *db = pParse->db;
-  u64 savedFlags;
+  u64 savedFlags; 
 
   savedFlags = db->flags;
-  db->flags &= ~(u64)SQLITE_FullColNames;
+  db->flags &= ~(u64)SQLITE_FullColNames; 
   db->flags |= SQLITE_ShortColNames;
   sqlite3SelectPrep(pParse, pSelect, 0);
-  db->flags = savedFlags;
+  db->flags = savedFlags; 
   if( pParse->nErr ) return 0;
   while( pSelect->pPrior ) pSelect = pSelect->pPrior;
   pTab = sqlite3DbMallocZero(db, sizeof(Table) );
@@ -135728,18 +135728,18 @@ static void generateWithRecursiveQuery(
   Expr *pLimit;                 /* Saved LIMIT and OFFSET */
   int regLimit, regOffset;      /* Registers used by LIMIT and OFFSET */
 
-#ifndef SQLITE_OMIT_WINDOWFUNC
-  if( p->pWin ){
-    sqlite3ErrorMsg(pParse, "cannot use window functions in recursive queries");
-    return;
-  }
-#endif
-
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+  if( p->pWin ){ 
+    sqlite3ErrorMsg(pParse, "cannot use window functions in recursive queries"); 
+    return; 
+  } 
+#endif 
+ 
   /* Obtain authorization to do a recursive query */
   if( sqlite3AuthCheck(pParse, SQLITE_RECURSIVE, 0, 0, 0) ) return;
 
   /* Process the LIMIT and OFFSET clauses, if they exist */
-  addrBreak = sqlite3VdbeMakeLabel(pParse);
+  addrBreak = sqlite3VdbeMakeLabel(pParse); 
   p->nSelectRow = 320;  /* 4 billion rows */
   computeLimitRegisters(pParse, p, addrBreak);
   pLimit = p->pLimit;
@@ -135808,7 +135808,7 @@ static void generateWithRecursiveQuery(
   /* Store the results of the setup-query in Queue. */
   pSetup = pFirstRec->pPrior;
   pSetup->pNext = 0;
-  ExplainQueryPlan((pParse, 1, "SETUP"));
+  ExplainQueryPlan((pParse, 1, "SETUP")); 
   rc = sqlite3Select(pParse, pSetup, &destQueue);
   pSetup->pNext = p;
   if( rc ) goto end_of_recursive_query;
@@ -135826,7 +135826,7 @@ static void generateWithRecursiveQuery(
   sqlite3VdbeAddOp1(v, OP_Delete, iQueue);
 
   /* Output the single row in Current */
-  addrCont = sqlite3VdbeMakeLabel(pParse);
+  addrCont = sqlite3VdbeMakeLabel(pParse); 
   codeOffset(v, regOffset, addrCont);
   selectInnerLoop(pParse, p, iCurrent,
       0, 0, pDest, addrCont, addrBreak);
@@ -135887,7 +135887,7 @@ static int multiSelectValues(
 ){
   int nRow = 1;
   int rc = 0;
-  int bShowAll = p->pLimit==0;
+  int bShowAll = p->pLimit==0; 
   assert( p->selFlags & SF_MultiValue );
   do{
     assert( p->selFlags & SF_Values );
@@ -135899,13 +135899,13 @@ static int multiSelectValues(
     if( p->pPrior==0 ) break;
     assert( p->pPrior->pNext==p );
     p = p->pPrior;
-    nRow += bShowAll;
+    nRow += bShowAll; 
   }while(1);
-  ExplainQueryPlan((pParse, 0, "SCAN %d CONSTANT ROW%s", nRow,
-                    nRow==1 ? "" : "S"));
+  ExplainQueryPlan((pParse, 0, "SCAN %d CONSTANT ROW%s", nRow, 
+                    nRow==1 ? "" : "S")); 
   while( p ){
-    selectInnerLoop(pParse, p, -1, 0, 0, pDest, 1, 1);
-    if( !bShowAll ) break;
+    selectInnerLoop(pParse, p, -1, 0, 0, pDest, 1, 1); 
+    if( !bShowAll ) break; 
     p->nSelectRow = nRow;
     p = p->pNext;
   }
@@ -135970,7 +135970,7 @@ static int multiSelect(
   */
   assert( p && p->pPrior );  /* Calling function guarantees this much */
   assert( (p->selFlags & SF_Recursive)==0 || p->op==TK_ALL || p->op==TK_UNION );
-  assert( p->selFlags & SF_Compound );
+  assert( p->selFlags & SF_Compound ); 
   db = pParse->db;
   pPrior = p->pPrior;
   dest = *pDest;
@@ -136012,235 +136012,235 @@ static int multiSelect(
   */
   if( p->pOrderBy ){
     return multiSelectOrderBy(pParse, p, pDest);
-  }else{
-
-#ifndef SQLITE_OMIT_EXPLAIN
-    if( pPrior->pPrior==0 ){
-      ExplainQueryPlan((pParse, 1, "COMPOUND QUERY"));
-      ExplainQueryPlan((pParse, 1, "LEFT-MOST SUBQUERY"));
-    }
-#endif
-
-    /* Generate code for the left and right SELECT statements.
-    */
-    switch( p->op ){
-      case TK_ALL: {
-        int addr = 0;
+  }else{ 
+
+#ifndef SQLITE_OMIT_EXPLAIN 
+    if( pPrior->pPrior==0 ){ 
+      ExplainQueryPlan((pParse, 1, "COMPOUND QUERY")); 
+      ExplainQueryPlan((pParse, 1, "LEFT-MOST SUBQUERY")); 
+    } 
+#endif 
+ 
+    /* Generate code for the left and right SELECT statements. 
+    */ 
+    switch( p->op ){ 
+      case TK_ALL: { 
+        int addr = 0; 
         int nLimit = 0;  /* Initialize to suppress harmless compiler warning */
-        assert( !pPrior->pLimit );
-        pPrior->iLimit = p->iLimit;
-        pPrior->iOffset = p->iOffset;
-        pPrior->pLimit = p->pLimit;
+        assert( !pPrior->pLimit ); 
+        pPrior->iLimit = p->iLimit; 
+        pPrior->iOffset = p->iOffset; 
+        pPrior->pLimit = p->pLimit; 
         SELECTTRACE(1, pParse, p, ("multiSelect UNION ALL left...\n"));
-        rc = sqlite3Select(pParse, pPrior, &dest);
+        rc = sqlite3Select(pParse, pPrior, &dest); 
         pPrior->pLimit = 0;
-        if( rc ){
-          goto multi_select_end;
-        }
-        p->pPrior = 0;
-        p->iLimit = pPrior->iLimit;
-        p->iOffset = pPrior->iOffset;
-        if( p->iLimit ){
-          addr = sqlite3VdbeAddOp1(v, OP_IfNot, p->iLimit); VdbeCoverage(v);
-          VdbeComment((v, "Jump ahead if LIMIT reached"));
-          if( p->iOffset ){
-            sqlite3VdbeAddOp3(v, OP_OffsetLimit,
-                              p->iLimit, p->iOffset+1, p->iOffset);
-          }
-        }
-        ExplainQueryPlan((pParse, 1, "UNION ALL"));
+        if( rc ){ 
+          goto multi_select_end; 
+        } 
+        p->pPrior = 0; 
+        p->iLimit = pPrior->iLimit; 
+        p->iOffset = pPrior->iOffset; 
+        if( p->iLimit ){ 
+          addr = sqlite3VdbeAddOp1(v, OP_IfNot, p->iLimit); VdbeCoverage(v); 
+          VdbeComment((v, "Jump ahead if LIMIT reached")); 
+          if( p->iOffset ){ 
+            sqlite3VdbeAddOp3(v, OP_OffsetLimit, 
+                              p->iLimit, p->iOffset+1, p->iOffset); 
+          } 
+        } 
+        ExplainQueryPlan((pParse, 1, "UNION ALL")); 
         SELECTTRACE(1, pParse, p, ("multiSelect UNION ALL right...\n"));
-        rc = sqlite3Select(pParse, p, &dest);
-        testcase( rc!=SQLITE_OK );
-        pDelete = p->pPrior;
-        p->pPrior = pPrior;
-        p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
+        rc = sqlite3Select(pParse, p, &dest); 
+        testcase( rc!=SQLITE_OK ); 
+        pDelete = p->pPrior; 
+        p->pPrior = pPrior; 
+        p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow); 
         if( p->pLimit
          && sqlite3ExprIsInteger(p->pLimit->pLeft, &nLimit)
          && nLimit>0 && p->nSelectRow > sqlite3LogEst((u64)nLimit)
-        ){
-          p->nSelectRow = sqlite3LogEst((u64)nLimit);
-        }
-        if( addr ){
-          sqlite3VdbeJumpHere(v, addr);
-        }
-        break;
-      }
-      case TK_EXCEPT:
-      case TK_UNION: {
-        int unionTab;    /* Cursor number of the temp table holding result */
-        u8 op = 0;       /* One of the SRT_ operations to apply to self */
-        int priorOp;     /* The SRT_ operation to apply to prior selects */
-        Expr *pLimit;    /* Saved values of p->nLimit  */
-        int addr;
-        SelectDest uniondest;
-
-        testcase( p->op==TK_EXCEPT );
-        testcase( p->op==TK_UNION );
-        priorOp = SRT_Union;
-        if( dest.eDest==priorOp ){
-          /* We can reuse a temporary table generated by a SELECT to our
-          ** right.
-          */
-          assert( p->pLimit==0 );      /* Not allowed on leftward elements */
-          unionTab = dest.iSDParm;
-        }else{
-          /* We will need to create our own temporary table to hold the
-          ** intermediate results.
-          */
-          unionTab = pParse->nTab++;
-          assert( p->pOrderBy==0 );
-          addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0);
-          assert( p->addrOpenEphm[0] == -1 );
-          p->addrOpenEphm[0] = addr;
-          findRightmost(p)->selFlags |= SF_UsesEphemeral;
-          assert( p->pEList );
-        }
-
-
-        /* Code the SELECT statements to our left
-        */
-        assert( !pPrior->pOrderBy );
-        sqlite3SelectDestInit(&uniondest, priorOp, unionTab);
+        ){ 
+          p->nSelectRow = sqlite3LogEst((u64)nLimit); 
+        } 
+        if( addr ){ 
+          sqlite3VdbeJumpHere(v, addr); 
+        } 
+        break; 
+      }
+      case TK_EXCEPT: 
+      case TK_UNION: { 
+        int unionTab;    /* Cursor number of the temp table holding result */ 
+        u8 op = 0;       /* One of the SRT_ operations to apply to self */ 
+        int priorOp;     /* The SRT_ operation to apply to prior selects */ 
+        Expr *pLimit;    /* Saved values of p->nLimit  */ 
+        int addr; 
+        SelectDest uniondest; 
+
+        testcase( p->op==TK_EXCEPT ); 
+        testcase( p->op==TK_UNION ); 
+        priorOp = SRT_Union; 
+        if( dest.eDest==priorOp ){ 
+          /* We can reuse a temporary table generated by a SELECT to our 
+          ** right. 
+          */ 
+          assert( p->pLimit==0 );      /* Not allowed on leftward elements */ 
+          unionTab = dest.iSDParm; 
+        }else{ 
+          /* We will need to create our own temporary table to hold the 
+          ** intermediate results. 
+          */ 
+          unionTab = pParse->nTab++; 
+          assert( p->pOrderBy==0 ); 
+          addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0); 
+          assert( p->addrOpenEphm[0] == -1 ); 
+          p->addrOpenEphm[0] = addr; 
+          findRightmost(p)->selFlags |= SF_UsesEphemeral; 
+          assert( p->pEList ); 
+        }
+
+
+        /* Code the SELECT statements to our left 
+        */ 
+        assert( !pPrior->pOrderBy ); 
+        sqlite3SelectDestInit(&uniondest, priorOp, unionTab); 
         SELECTTRACE(1, pParse, p, ("multiSelect EXCEPT/UNION left...\n"));
-        rc = sqlite3Select(pParse, pPrior, &uniondest);
-        if( rc ){
-          goto multi_select_end;
-        }
-
-        /* Code the current SELECT statement
-        */
-        if( p->op==TK_EXCEPT ){
-          op = SRT_Except;
-        }else{
-          assert( p->op==TK_UNION );
-          op = SRT_Union;
-        }
-        p->pPrior = 0;
-        pLimit = p->pLimit;
-        p->pLimit = 0;
-        uniondest.eDest = op;
-        ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
+        rc = sqlite3Select(pParse, pPrior, &uniondest); 
+        if( rc ){ 
+          goto multi_select_end; 
+        } 
+
+        /* Code the current SELECT statement 
+        */ 
+        if( p->op==TK_EXCEPT ){ 
+          op = SRT_Except; 
+        }else{ 
+          assert( p->op==TK_UNION ); 
+          op = SRT_Union; 
+        } 
+        p->pPrior = 0; 
+        pLimit = p->pLimit; 
+        p->pLimit = 0; 
+        uniondest.eDest = op; 
+        ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE", 
                           sqlite3SelectOpName(p->op)));
         SELECTTRACE(1, pParse, p, ("multiSelect EXCEPT/UNION right...\n"));
-        rc = sqlite3Select(pParse, p, &uniondest);
-        testcase( rc!=SQLITE_OK );
+        rc = sqlite3Select(pParse, p, &uniondest); 
+        testcase( rc!=SQLITE_OK ); 
         assert( p->pOrderBy==0 );
-        pDelete = p->pPrior;
-        p->pPrior = pPrior;
-        p->pOrderBy = 0;
-        if( p->op==TK_UNION ){
-          p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow);
-        }
-        sqlite3ExprDelete(db, p->pLimit);
-        p->pLimit = pLimit;
-        p->iLimit = 0;
-        p->iOffset = 0;
-
-        /* Convert the data in the temporary table into whatever form
-        ** it is that we currently need.
-        */
-        assert( unionTab==dest.iSDParm || dest.eDest!=priorOp );
+        pDelete = p->pPrior; 
+        p->pPrior = pPrior; 
+        p->pOrderBy = 0; 
+        if( p->op==TK_UNION ){ 
+          p->nSelectRow = sqlite3LogEstAdd(p->nSelectRow, pPrior->nSelectRow); 
+        } 
+        sqlite3ExprDelete(db, p->pLimit); 
+        p->pLimit = pLimit; 
+        p->iLimit = 0; 
+        p->iOffset = 0; 
+
+        /* Convert the data in the temporary table into whatever form 
+        ** it is that we currently need. 
+        */ 
+        assert( unionTab==dest.iSDParm || dest.eDest!=priorOp ); 
         assert( p->pEList || db->mallocFailed );
         if( dest.eDest!=priorOp && db->mallocFailed==0 ){
-          int iCont, iBreak, iStart;
-          iBreak = sqlite3VdbeMakeLabel(pParse);
-          iCont = sqlite3VdbeMakeLabel(pParse);
-          computeLimitRegisters(pParse, p, iBreak);
-          sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak); VdbeCoverage(v);
-          iStart = sqlite3VdbeCurrentAddr(v);
-          selectInnerLoop(pParse, p, unionTab,
-                          0, 0, &dest, iCont, iBreak);
-          sqlite3VdbeResolveLabel(v, iCont);
-          sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart); VdbeCoverage(v);
-          sqlite3VdbeResolveLabel(v, iBreak);
-          sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0);
-        }
-        break;
-      }
-      default: assert( p->op==TK_INTERSECT ); {
-        int tab1, tab2;
-        int iCont, iBreak, iStart;
-        Expr *pLimit;
-        int addr;
-        SelectDest intersectdest;
-        int r1;
-
-        /* INTERSECT is different from the others since it requires
-        ** two temporary tables.  Hence it has its own case.  Begin
-        ** by allocating the tables we will need.
+          int iCont, iBreak, iStart; 
+          iBreak = sqlite3VdbeMakeLabel(pParse); 
+          iCont = sqlite3VdbeMakeLabel(pParse); 
+          computeLimitRegisters(pParse, p, iBreak); 
+          sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak); VdbeCoverage(v); 
+          iStart = sqlite3VdbeCurrentAddr(v); 
+          selectInnerLoop(pParse, p, unionTab, 
+                          0, 0, &dest, iCont, iBreak); 
+          sqlite3VdbeResolveLabel(v, iCont); 
+          sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart); VdbeCoverage(v); 
+          sqlite3VdbeResolveLabel(v, iBreak); 
+          sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0); 
+        } 
+        break; 
+      }
+      default: assert( p->op==TK_INTERSECT ); { 
+        int tab1, tab2; 
+        int iCont, iBreak, iStart; 
+        Expr *pLimit; 
+        int addr; 
+        SelectDest intersectdest; 
+        int r1; 
+
+        /* INTERSECT is different from the others since it requires 
+        ** two temporary tables.  Hence it has its own case.  Begin 
+        ** by allocating the tables we will need. 
         */
-        tab1 = pParse->nTab++;
-        tab2 = pParse->nTab++;
+        tab1 = pParse->nTab++; 
+        tab2 = pParse->nTab++; 
         assert( p->pOrderBy==0 );
 
-        addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0);
+        addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0); 
         assert( p->addrOpenEphm[0] == -1 );
         p->addrOpenEphm[0] = addr;
         findRightmost(p)->selFlags |= SF_UsesEphemeral;
         assert( p->pEList );
 
-        /* Code the SELECTs to our left into temporary table "tab1".
-        */
-        sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1);
+        /* Code the SELECTs to our left into temporary table "tab1". 
+        */ 
+        sqlite3SelectDestInit(&intersectdest, SRT_Union, tab1); 
         SELECTTRACE(1, pParse, p, ("multiSelect INTERSECT left...\n"));
-        rc = sqlite3Select(pParse, pPrior, &intersectdest);
-        if( rc ){
-          goto multi_select_end;
-        }
-
-        /* Code the current SELECT into temporary table "tab2"
-        */
-        addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0);
-        assert( p->addrOpenEphm[1] == -1 );
-        p->addrOpenEphm[1] = addr;
-        p->pPrior = 0;
-        pLimit = p->pLimit;
-        p->pLimit = 0;
-        intersectdest.iSDParm = tab2;
-        ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
+        rc = sqlite3Select(pParse, pPrior, &intersectdest); 
+        if( rc ){ 
+          goto multi_select_end; 
+        } 
+
+        /* Code the current SELECT into temporary table "tab2" 
+        */ 
+        addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0); 
+        assert( p->addrOpenEphm[1] == -1 ); 
+        p->addrOpenEphm[1] = addr; 
+        p->pPrior = 0; 
+        pLimit = p->pLimit; 
+        p->pLimit = 0; 
+        intersectdest.iSDParm = tab2; 
+        ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE", 
                           sqlite3SelectOpName(p->op)));
         SELECTTRACE(1, pParse, p, ("multiSelect INTERSECT right...\n"));
-        rc = sqlite3Select(pParse, p, &intersectdest);
-        testcase( rc!=SQLITE_OK );
-        pDelete = p->pPrior;
-        p->pPrior = pPrior;
-        if( p->nSelectRow>pPrior->nSelectRow ){
-          p->nSelectRow = pPrior->nSelectRow;
-        }
-        sqlite3ExprDelete(db, p->pLimit);
-        p->pLimit = pLimit;
-
-        /* Generate code to take the intersection of the two temporary
-        ** tables.
-        */
+        rc = sqlite3Select(pParse, p, &intersectdest); 
+        testcase( rc!=SQLITE_OK ); 
+        pDelete = p->pPrior; 
+        p->pPrior = pPrior; 
+        if( p->nSelectRow>pPrior->nSelectRow ){ 
+          p->nSelectRow = pPrior->nSelectRow; 
+        } 
+        sqlite3ExprDelete(db, p->pLimit); 
+        p->pLimit = pLimit; 
+
+        /* Generate code to take the intersection of the two temporary 
+        ** tables. 
+        */ 
         if( rc ) break;
         assert( p->pEList );
-        iBreak = sqlite3VdbeMakeLabel(pParse);
-        iCont = sqlite3VdbeMakeLabel(pParse);
+        iBreak = sqlite3VdbeMakeLabel(pParse); 
+        iCont = sqlite3VdbeMakeLabel(pParse); 
         computeLimitRegisters(pParse, p, iBreak);
-        sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak); VdbeCoverage(v);
-        r1 = sqlite3GetTempReg(pParse);
-        iStart = sqlite3VdbeAddOp2(v, OP_RowData, tab1, r1);
-        sqlite3VdbeAddOp4Int(v, OP_NotFound, tab2, iCont, r1, 0);
-        VdbeCoverage(v);
-        sqlite3ReleaseTempReg(pParse, r1);
-        selectInnerLoop(pParse, p, tab1,
+        sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak); VdbeCoverage(v); 
+        r1 = sqlite3GetTempReg(pParse); 
+        iStart = sqlite3VdbeAddOp2(v, OP_RowData, tab1, r1); 
+        sqlite3VdbeAddOp4Int(v, OP_NotFound, tab2, iCont, r1, 0); 
+        VdbeCoverage(v); 
+        sqlite3ReleaseTempReg(pParse, r1); 
+        selectInnerLoop(pParse, p, tab1, 
                         0, 0, &dest, iCont, iBreak);
         sqlite3VdbeResolveLabel(v, iCont);
-        sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart); VdbeCoverage(v);
+        sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart); VdbeCoverage(v); 
         sqlite3VdbeResolveLabel(v, iBreak);
-        sqlite3VdbeAddOp2(v, OP_Close, tab2, 0);
-        sqlite3VdbeAddOp2(v, OP_Close, tab1, 0);
-        break;
+        sqlite3VdbeAddOp2(v, OP_Close, tab2, 0); 
+        sqlite3VdbeAddOp2(v, OP_Close, tab1, 0); 
+        break; 
       }
     }
 
-  #ifndef SQLITE_OMIT_EXPLAIN
-    if( p->pNext==0 ){
-      ExplainQueryPlanPop(pParse);
+  #ifndef SQLITE_OMIT_EXPLAIN 
+    if( p->pNext==0 ){ 
+      ExplainQueryPlanPop(pParse); 
     }
-  #endif
+  #endif 
   }
   if( pParse->nErr ) goto multi_select_end;
 
@@ -136354,7 +136354,7 @@ static int generateOutputSubroutine(
   int addr;
 
   addr = sqlite3VdbeCurrentAddr(v);
-  iContinue = sqlite3VdbeMakeLabel(pParse);
+  iContinue = sqlite3VdbeMakeLabel(pParse); 
 
   /* Suppress duplicates for UNION, EXCEPT, and INTERSECT
   */
@@ -136592,8 +136592,8 @@ static int multiSelectOrderBy(
   db = pParse->db;
   v = pParse->pVdbe;
   assert( v!=0 );       /* Already thrown the error if VDBE alloc failed */
-  labelEnd = sqlite3VdbeMakeLabel(pParse);
-  labelCmpr = sqlite3VdbeMakeLabel(pParse);
+  labelEnd = sqlite3VdbeMakeLabel(pParse); 
+  labelCmpr = sqlite3VdbeMakeLabel(pParse); 
 
 
   /* Patch up the ORDER BY clause
@@ -136708,7 +136708,7 @@ static int multiSelectOrderBy(
   sqlite3SelectDestInit(&destB, SRT_Coroutine, regAddrB);
 
   ExplainQueryPlan((pParse, 1, "MERGE (%s)", sqlite3SelectOpName(p->op)));
-
+ 
   /* Generate a coroutine to evaluate the SELECT statement to the
   ** left of the compound operator - the "A" select.
   */
@@ -136716,7 +136716,7 @@ static int multiSelectOrderBy(
   addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrA, 0, addrSelectA);
   VdbeComment((v, "left SELECT"));
   pPrior->iLimit = regLimitA;
-  ExplainQueryPlan((pParse, 1, "LEFT"));
+  ExplainQueryPlan((pParse, 1, "LEFT")); 
   sqlite3Select(pParse, pPrior, &destA);
   sqlite3VdbeEndCoroutine(v, regAddrA);
   sqlite3VdbeJumpHere(v, addr1);
@@ -136731,7 +136731,7 @@ static int multiSelectOrderBy(
   savedOffset = p->iOffset;
   p->iLimit = regLimitB;
   p->iOffset = 0;
-  ExplainQueryPlan((pParse, 1, "RIGHT"));
+  ExplainQueryPlan((pParse, 1, "RIGHT")); 
   sqlite3Select(pParse, p, &destB);
   p->iLimit = savedLimit;
   p->iOffset = savedOffset;
@@ -136846,7 +136846,7 @@ static int multiSelectOrderBy(
 
   /*** TBD:  Insert subroutine calls to close cursors on incomplete
   **** subqueries ****/
-  ExplainQueryPlanPop(pParse);
+  ExplainQueryPlanPop(pParse); 
   return pParse->nErr!=0;
 }
 #endif
@@ -136908,7 +136908,7 @@ static Expr *substExpr(
       Expr *pCopy = pSubst->pEList->a[pExpr->iColumn].pExpr;
       Expr ifNullRow;
       assert( pSubst->pEList!=0 && pExpr->iColumn<pSubst->pEList->nExpr );
-      assert( pExpr->pRight==0 );
+      assert( pExpr->pRight==0 ); 
       if( sqlite3ExprIsVector(pCopy) ){
         sqlite3VectorErrorMsg(pSubst->pParse, pCopy);
       }else{
@@ -136921,7 +136921,7 @@ static Expr *substExpr(
           ifNullRow.flags = EP_IfNullRow;
           pCopy = &ifNullRow;
         }
-        testcase( ExprHasProperty(pCopy, EP_Subquery) );
+        testcase( ExprHasProperty(pCopy, EP_Subquery) ); 
         pNew = sqlite3ExprDup(db, pCopy, 0);
         if( db->mallocFailed ){
           sqlite3ExprDelete(db, pNew);
@@ -137275,11 +137275,11 @@ static void renumberCursors(
 **        "SELECT x FROM (SELECT max(y), x FROM t1)" would not necessarily
 **        return the value X for which Y was maximal.)
 **
-**  (25)  If either the subquery or the parent query contains a window
-**        function in the select list or ORDER BY clause, flattening
-**        is not attempted.
-**
+**  (25)  If either the subquery or the parent query contains a window 
+**        function in the select list or ORDER BY clause, flattening 
+**        is not attempted. 
 **
+** 
 ** In this routine, the "p" parameter is a pointer to the outer query.
 ** The subquery is p->pSrc->a[iFrom].  isAgg is true if the outer query
 ** uses aggregates.
@@ -137324,10 +137324,10 @@ static int flattenSubquery(
   pSub = pSubitem->pSelect;
   assert( pSub!=0 );
 
-#ifndef SQLITE_OMIT_WINDOWFUNC
-  if( p->pWin || pSub->pWin ) return 0;                  /* Restriction (25) */
-#endif
-
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+  if( p->pWin || pSub->pWin ) return 0;                  /* Restriction (25) */ 
+#endif 
+ 
   pSubSrc = pSub->pSrc;
   assert( pSubSrc );
   /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants,
@@ -137446,8 +137446,8 @@ static int flattenSubquery(
   }
 
   /***** If we reach this point, flattening is permitted. *****/
-  SELECTTRACE(1,pParse,p,("flatten %u.%p from term %d\n",
-                   pSub->selId, pSub, iFrom));
+  SELECTTRACE(1,pParse,p,("flatten %u.%p from term %d\n", 
+                   pSub->selId, pSub, iFrom)); 
 
   /* Authorize the subquery */
   pParse->zAuthContext = pSubitem->zName;
@@ -137525,8 +137525,8 @@ static int flattenSubquery(
       if( pPrior ) pPrior->pNext = pNew;
       pNew->pNext = p;
       p->pPrior = pNew;
-      SELECTTRACE(2,pParse,p,("compound-subquery flattener"
-                              " creates %u as peer\n",pNew->selId));
+      SELECTTRACE(2,pParse,p,("compound-subquery flattener" 
+                              " creates %u as peer\n",pNew->selId)); 
     }
     assert( pSubitem->pSelect==0 );
   }
@@ -137599,9 +137599,9 @@ static int flattenSubquery(
     ** for the two elements in the FROM clause of the subquery.
     */
     if( nSubSrc>1 ){
-      pSrc = sqlite3SrcListEnlarge(pParse, pSrc, nSubSrc-1,iFrom+1);
-      if( pSrc==0 ) break;
-      pParent->pSrc = pSrc;
+      pSrc = sqlite3SrcListEnlarge(pParse, pSrc, nSubSrc-1,iFrom+1); 
+      if( pSrc==0 ) break; 
+      pParent->pSrc = pSrc; 
     }
 
     /* Transfer the FROM clause terms from the subquery into the
@@ -137647,8 +137647,8 @@ static int flattenSubquery(
       pParent->pOrderBy = pOrderBy;
       pSub->pOrderBy = 0;
     }
-    pWhere = pSub->pWhere;
-    pSub->pWhere = 0;
+    pWhere = pSub->pWhere; 
+    pSub->pWhere = 0; 
     if( isLeftJoin>0 ){
       sqlite3SetJoinExpr(pWhere, iNewParent);
     }
@@ -137669,10 +137669,10 @@ static int flattenSubquery(
       substSelect(&x, pParent, 0);
     }
 
-    /* The flattened query is a compound if either the inner or the
-    ** outer query is a compound. */
-    pParent->selFlags |= pSub->selFlags & SF_Compound;
-    assert( (pSub->selFlags & SF_Distinct)==0 ); /* restriction (17b) */
+    /* The flattened query is a compound if either the inner or the 
+    ** outer query is a compound. */ 
+    pParent->selFlags |= pSub->selFlags & SF_Compound; 
+    assert( (pSub->selFlags & SF_Distinct)==0 ); /* restriction (17b) */ 
 
     /*
     ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y;
@@ -137710,36 +137710,36 @@ static int flattenSubquery(
 }
 #endif /* !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW) */
 
-/*
-** A structure to keep track of all of the column values that are fixed to
-** a known value due to WHERE clause constraints of the form COLUMN=VALUE.
-*/
-typedef struct WhereConst WhereConst;
-struct WhereConst {
-  Parse *pParse;   /* Parsing context */
+/* 
+** A structure to keep track of all of the column values that are fixed to 
+** a known value due to WHERE clause constraints of the form COLUMN=VALUE. 
+*/ 
+typedef struct WhereConst WhereConst; 
+struct WhereConst { 
+  Parse *pParse;   /* Parsing context */ 
   u8 *pOomFault;   /* Pointer to pParse->db->mallocFailed */
-  int nConst;      /* Number for COLUMN=CONSTANT terms */
-  int nChng;       /* Number of times a constant is propagated */
+  int nConst;      /* Number for COLUMN=CONSTANT terms */ 
+  int nChng;       /* Number of times a constant is propagated */ 
   int bHasAffBlob; /* At least one column in apExpr[] as affinity BLOB */
-  Expr **apExpr;   /* [i*2] is COLUMN and [i*2+1] is VALUE */
-};
+  Expr **apExpr;   /* [i*2] is COLUMN and [i*2+1] is VALUE */ 
+}; 
 
-/*
-** Add a new entry to the pConst object.  Except, do not add duplicate
+/* 
+** Add a new entry to the pConst object.  Except, do not add duplicate 
 ** pColumn entires.  Also, do not add if doing so would not be appropriate.
 **
 ** The caller guarantees the pColumn is a column and pValue is a constant.
 ** This routine has to do some additional checks before completing the
 ** insert.
-*/
-static void constInsert(
+*/ 
+static void constInsert( 
   WhereConst *pConst,  /* The WhereConst into which we are inserting */
   Expr *pColumn,       /* The COLUMN part of the constraint */
   Expr *pValue,        /* The VALUE part of the constraint */
   Expr *pExpr          /* Overall expression: COLUMN=VALUE or VALUE=COLUMN */
-){
-  int i;
-  assert( pColumn->op==TK_COLUMN );
+){ 
+  int i; 
+  assert( pColumn->op==TK_COLUMN ); 
   assert( sqlite3ExprIsConstant(pValue) );
 
   if( ExprHasProperty(pColumn, EP_FixedCol) ) return;
@@ -137748,61 +137748,61 @@ static void constInsert(
     return;
   }
 
-  /* 2018-10-25 ticket [cf5ed20f]
-  ** Make sure the same pColumn is not inserted more than once */
-  for(i=0; i<pConst->nConst; i++){
+  /* 2018-10-25 ticket [cf5ed20f] 
+  ** Make sure the same pColumn is not inserted more than once */ 
+  for(i=0; i<pConst->nConst; i++){ 
     const Expr *pE2 = pConst->apExpr[i*2];
     assert( pE2->op==TK_COLUMN );
     if( pE2->iTable==pColumn->iTable
      && pE2->iColumn==pColumn->iColumn
-    ){
-      return;  /* Already present.  Return without doing anything. */
-    }
-  }
+    ){ 
+      return;  /* Already present.  Return without doing anything. */ 
+    } 
+  } 
   if( sqlite3ExprAffinity(pColumn)==SQLITE_AFF_BLOB ){
     pConst->bHasAffBlob = 1;
   }
-
-  pConst->nConst++;
-  pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr,
-                         pConst->nConst*2*sizeof(Expr*));
-  if( pConst->apExpr==0 ){
-    pConst->nConst = 0;
-  }else{
-    pConst->apExpr[pConst->nConst*2-2] = pColumn;
-    pConst->apExpr[pConst->nConst*2-1] = pValue;
-  }
-}
-
-/*
-** Find all terms of COLUMN=VALUE or VALUE=COLUMN in pExpr where VALUE
-** is a constant expression and where the term must be true because it
-** is part of the AND-connected terms of the expression.  For each term
-** found, add it to the pConst structure.
-*/
-static void findConstInWhere(WhereConst *pConst, Expr *pExpr){
-  Expr *pRight, *pLeft;
+ 
+  pConst->nConst++; 
+  pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr, 
+                         pConst->nConst*2*sizeof(Expr*)); 
+  if( pConst->apExpr==0 ){ 
+    pConst->nConst = 0; 
+  }else{ 
+    pConst->apExpr[pConst->nConst*2-2] = pColumn; 
+    pConst->apExpr[pConst->nConst*2-1] = pValue; 
+  } 
+} 
+ 
+/* 
+** Find all terms of COLUMN=VALUE or VALUE=COLUMN in pExpr where VALUE 
+** is a constant expression and where the term must be true because it 
+** is part of the AND-connected terms of the expression.  For each term 
+** found, add it to the pConst structure. 
+*/ 
+static void findConstInWhere(WhereConst *pConst, Expr *pExpr){ 
+  Expr *pRight, *pLeft; 
   if( NEVER(pExpr==0) ) return;
-  if( ExprHasProperty(pExpr, EP_FromJoin) ) return;
-  if( pExpr->op==TK_AND ){
-    findConstInWhere(pConst, pExpr->pRight);
-    findConstInWhere(pConst, pExpr->pLeft);
-    return;
-  }
-  if( pExpr->op!=TK_EQ ) return;
-  pRight = pExpr->pRight;
-  pLeft = pExpr->pLeft;
-  assert( pRight!=0 );
-  assert( pLeft!=0 );
+  if( ExprHasProperty(pExpr, EP_FromJoin) ) return; 
+  if( pExpr->op==TK_AND ){ 
+    findConstInWhere(pConst, pExpr->pRight); 
+    findConstInWhere(pConst, pExpr->pLeft); 
+    return; 
+  } 
+  if( pExpr->op!=TK_EQ ) return; 
+  pRight = pExpr->pRight; 
+  pLeft = pExpr->pLeft; 
+  assert( pRight!=0 ); 
+  assert( pLeft!=0 ); 
   if( pRight->op==TK_COLUMN && sqlite3ExprIsConstant(pLeft) ){
     constInsert(pConst,pRight,pLeft,pExpr);
-  }
+  } 
   if( pLeft->op==TK_COLUMN && sqlite3ExprIsConstant(pRight) ){
     constInsert(pConst,pLeft,pRight,pExpr);
   }
-}
-
-/*
+} 
+ 
+/* 
 ** This is a helper function for Walker callback propagateConstantExprRewrite().
 **
 ** Argument pExpr is a candidate expression to be replaced by a value. If
@@ -137810,41 +137810,41 @@ static void findConstInWhere(WhereConst *pConst, Expr *pExpr){
 ** then overwrite it with the corresponding value. Except, do not do so
 ** if argument bIgnoreAffBlob is non-zero and the affinity of pExpr
 ** is SQLITE_AFF_BLOB.
-*/
+*/ 
 static int propagateConstantExprRewriteOne(
   WhereConst *pConst,
   Expr *pExpr,
   int bIgnoreAffBlob
 ){
-  int i;
+  int i; 
   if( pConst->pOomFault[0] ) return WRC_Prune;
-  if( pExpr->op!=TK_COLUMN ) return WRC_Continue;
+  if( pExpr->op!=TK_COLUMN ) return WRC_Continue; 
   if( ExprHasProperty(pExpr, EP_FixedCol|EP_FromJoin) ){
     testcase( ExprHasProperty(pExpr, EP_FixedCol) );
     testcase( ExprHasProperty(pExpr, EP_FromJoin) );
     return WRC_Continue;
   }
-  for(i=0; i<pConst->nConst; i++){
-    Expr *pColumn = pConst->apExpr[i*2];
-    if( pColumn==pExpr ) continue;
-    if( pColumn->iTable!=pExpr->iTable ) continue;
-    if( pColumn->iColumn!=pExpr->iColumn ) continue;
+  for(i=0; i<pConst->nConst; i++){ 
+    Expr *pColumn = pConst->apExpr[i*2]; 
+    if( pColumn==pExpr ) continue; 
+    if( pColumn->iTable!=pExpr->iTable ) continue; 
+    if( pColumn->iColumn!=pExpr->iColumn ) continue; 
     if( bIgnoreAffBlob && sqlite3ExprAffinity(pColumn)==SQLITE_AFF_BLOB ){
       break;
     }
-    /* A match is found.  Add the EP_FixedCol property */
-    pConst->nChng++;
-    ExprClearProperty(pExpr, EP_Leaf);
-    ExprSetProperty(pExpr, EP_FixedCol);
-    assert( pExpr->pLeft==0 );
-    pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0);
+    /* A match is found.  Add the EP_FixedCol property */ 
+    pConst->nChng++; 
+    ExprClearProperty(pExpr, EP_Leaf); 
+    ExprSetProperty(pExpr, EP_FixedCol); 
+    assert( pExpr->pLeft==0 ); 
+    pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0); 
     if( pConst->pParse->db->mallocFailed ) return WRC_Prune;
-    break;
-  }
-  return WRC_Prune;
-}
-
-/*
+    break; 
+  } 
+  return WRC_Prune; 
+} 
+ 
+/* 
 ** This is a Walker expression callback. pExpr is a node from the WHERE
 ** clause of a SELECT statement. This function examines pExpr to see if
 ** any substitutions based on the contents of pWalker->u.pConst should
@@ -137881,40 +137881,40 @@ static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){
 }
 
 /*
-** The WHERE-clause constant propagation optimization.
-**
-** If the WHERE clause contains terms of the form COLUMN=CONSTANT or
+** The WHERE-clause constant propagation optimization. 
+** 
+** If the WHERE clause contains terms of the form COLUMN=CONSTANT or 
 ** CONSTANT=COLUMN that are top-level AND-connected terms that are not
 ** part of a ON clause from a LEFT JOIN, then throughout the query
 ** replace all other occurrences of COLUMN with CONSTANT.
-**
-** For example, the query:
-**
-**      SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=t1.a AND t3.c=t2.b
-**
-** Is transformed into
-**
-**      SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=39 AND t3.c=39
-**
-** Return true if any transformations where made and false if not.
-**
-** Implementation note:  Constant propagation is tricky due to affinity
-** and collating sequence interactions.  Consider this example:
-**
-**    CREATE TABLE t1(a INT,b TEXT);
-**    INSERT INTO t1 VALUES(123,'0123');
-**    SELECT * FROM t1 WHERE a=123 AND b=a;
-**    SELECT * FROM t1 WHERE a=123 AND b=123;
-**
-** The two SELECT statements above should return different answers.  b=a
-** is alway true because the comparison uses numeric affinity, but b=123
-** is false because it uses text affinity and '0123' is not the same as '123'.
-** To work around this, the expression tree is not actually changed from
-** "b=a" to "b=123" but rather the "a" in "b=a" is tagged with EP_FixedCol
-** and the "123" value is hung off of the pLeft pointer.  Code generator
-** routines know to generate the constant "123" instead of looking up the
-** column value.  Also, to avoid collation problems, this optimization is
-** only attempted if the "a=123" term uses the default BINARY collation.
+** 
+** For example, the query: 
+** 
+**      SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=t1.a AND t3.c=t2.b 
+** 
+** Is transformed into 
+** 
+**      SELECT * FROM t1, t2, t3 WHERE t1.a=39 AND t2.b=39 AND t3.c=39 
+** 
+** Return true if any transformations where made and false if not. 
+** 
+** Implementation note:  Constant propagation is tricky due to affinity 
+** and collating sequence interactions.  Consider this example: 
+** 
+**    CREATE TABLE t1(a INT,b TEXT); 
+**    INSERT INTO t1 VALUES(123,'0123'); 
+**    SELECT * FROM t1 WHERE a=123 AND b=a; 
+**    SELECT * FROM t1 WHERE a=123 AND b=123; 
+** 
+** The two SELECT statements above should return different answers.  b=a 
+** is alway true because the comparison uses numeric affinity, but b=123 
+** is false because it uses text affinity and '0123' is not the same as '123'. 
+** To work around this, the expression tree is not actually changed from 
+** "b=a" to "b=123" but rather the "a" in "b=a" is tagged with EP_FixedCol 
+** and the "123" value is hung off of the pLeft pointer.  Code generator 
+** routines know to generate the constant "123" instead of looking up the 
+** column value.  Also, to avoid collation problems, this optimization is 
+** only attempted if the "a=123" term uses the default BINARY collation. 
 **
 ** 2021-05-25 forum post 6a06202608: Another troublesome case is...
 **
@@ -137930,38 +137930,38 @@ static int propagateConstantExprRewrite(Walker *pWalker, Expr *pExpr){
 ** operators ==, <=, <, >=, >, or IS in a way that will cause the correct
 ** type conversions to occur.  See logic associated with the bHasAffBlob flag
 ** for details.
-*/
-static int propagateConstants(
-  Parse *pParse,   /* The parsing context */
-  Select *p        /* The query in which to propagate constants */
-){
-  WhereConst x;
-  Walker w;
-  int nChng = 0;
-  x.pParse = pParse;
+*/ 
+static int propagateConstants( 
+  Parse *pParse,   /* The parsing context */ 
+  Select *p        /* The query in which to propagate constants */ 
+){ 
+  WhereConst x; 
+  Walker w; 
+  int nChng = 0; 
+  x.pParse = pParse; 
   x.pOomFault = &pParse->db->mallocFailed;
-  do{
-    x.nConst = 0;
-    x.nChng = 0;
-    x.apExpr = 0;
+  do{ 
+    x.nConst = 0; 
+    x.nChng = 0; 
+    x.apExpr = 0; 
     x.bHasAffBlob = 0;
-    findConstInWhere(&x, p->pWhere);
-    if( x.nConst ){
-      memset(&w, 0, sizeof(w));
-      w.pParse = pParse;
-      w.xExprCallback = propagateConstantExprRewrite;
-      w.xSelectCallback = sqlite3SelectWalkNoop;
-      w.xSelectCallback2 = 0;
-      w.walkerDepth = 0;
-      w.u.pConst = &x;
-      sqlite3WalkExpr(&w, p->pWhere);
-      sqlite3DbFree(x.pParse->db, x.apExpr);
-      nChng += x.nChng;
-    }
+    findConstInWhere(&x, p->pWhere); 
+    if( x.nConst ){ 
+      memset(&w, 0, sizeof(w)); 
+      w.pParse = pParse; 
+      w.xExprCallback = propagateConstantExprRewrite; 
+      w.xSelectCallback = sqlite3SelectWalkNoop; 
+      w.xSelectCallback2 = 0; 
+      w.walkerDepth = 0; 
+      w.u.pConst = &x; 
+      sqlite3WalkExpr(&w, p->pWhere); 
+      sqlite3DbFree(x.pParse->db, x.apExpr); 
+      nChng += x.nChng; 
+    } 
   }while( x.nChng );
-  return nChng;
-}
-
+  return nChng; 
+} 
+ 
 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
 # if !defined(SQLITE_OMIT_WINDOWFUNC)
 /*
@@ -138019,30 +138019,30 @@ static int pushDownWindowCheck(Parse *pParse, Select *pSubq, Expr *pExpr){
 **   (2) The inner query is the recursive part of a common table expression.
 **
 **   (3) The inner query has a LIMIT clause (since the changes to the WHERE
-**       clause would change the meaning of the LIMIT).
+**       clause would change the meaning of the LIMIT). 
 **
-**   (4) The inner query is the right operand of a LEFT JOIN and the
-**       expression to be pushed down does not come from the ON clause
-**       on that LEFT JOIN.
+**   (4) The inner query is the right operand of a LEFT JOIN and the 
+**       expression to be pushed down does not come from the ON clause 
+**       on that LEFT JOIN. 
 **
 **   (5) The WHERE clause expression originates in the ON or USING clause
-**       of a LEFT JOIN where iCursor is not the right-hand table of that
-**       left join.  An example:
-**
-**           SELECT *
-**           FROM (SELECT 1 AS a1 UNION ALL SELECT 2) AS aa
-**           JOIN (SELECT 1 AS b2 UNION ALL SELECT 2) AS bb ON (a1=b2)
-**           LEFT JOIN (SELECT 8 AS c3 UNION ALL SELECT 9) AS cc ON (b2=2);
-**
-**       The correct answer is three rows:  (1,1,NULL),(2,2,8),(2,2,9).
-**       But if the (b2=2) term were to be pushed down into the bb subquery,
-**       then the (1,1,NULL) row would be suppressed.
-**
+**       of a LEFT JOIN where iCursor is not the right-hand table of that 
+**       left join.  An example: 
+**
+**           SELECT * 
+**           FROM (SELECT 1 AS a1 UNION ALL SELECT 2) AS aa 
+**           JOIN (SELECT 1 AS b2 UNION ALL SELECT 2) AS bb ON (a1=b2) 
+**           LEFT JOIN (SELECT 8 AS c3 UNION ALL SELECT 9) AS cc ON (b2=2); 
+** 
+**       The correct answer is three rows:  (1,1,NULL),(2,2,8),(2,2,9). 
+**       But if the (b2=2) term were to be pushed down into the bb subquery, 
+**       then the (1,1,NULL) row would be suppressed. 
+** 
 **   (6) Window functions make things tricky as changes to the WHERE clause
 **       of the inner query could change the window over which window
 **       functions are calculated. Therefore, do not attempt the optimization
 **       if:
-**
+** 
 **     (6a) The inner query uses multiple incompatible window partitions.
 **
 **     (6b) The inner query is a compound and uses window-functions.
@@ -138064,15 +138064,15 @@ static int pushDownWhereTerms(
   Parse *pParse,        /* Parse context (for malloc() and error reporting) */
   Select *pSubq,        /* The subquery whose WHERE clause is to be augmented */
   Expr *pWhere,         /* The WHERE clause of the outer query */
-  int iCursor,          /* Cursor number of the subquery */
-  int isLeftJoin        /* True if pSubq is the right term of a LEFT JOIN */
+  int iCursor,          /* Cursor number of the subquery */ 
+  int isLeftJoin        /* True if pSubq is the right term of a LEFT JOIN */ 
 ){
   Expr *pNew;
   int nChng = 0;
   if( pWhere==0 ) return 0;
   if( pSubq->selFlags & (SF_Recursive|SF_MultiPart) ) return 0;
 
-#ifndef SQLITE_OMIT_WINDOWFUNC
+#ifndef SQLITE_OMIT_WINDOWFUNC 
   if( pSubq->pPrior ){
     Select *pSel;
     for(pSel=pSubq; pSel; pSel=pSel->pPrior){
@@ -138081,8 +138081,8 @@ static int pushDownWhereTerms(
   }else{
     if( pSubq->pWin && pSubq->pWin->pPartition==0 ) return 0;
   }
-#endif
-
+#endif 
+ 
 #ifdef SQLITE_DEBUG
   /* Only the first term of a compound can have a WITH clause.  But make
   ** sure no other terms are marked SF_Recursive in case something changes
@@ -138100,26 +138100,26 @@ static int pushDownWhereTerms(
     return 0; /* restriction (3) */
   }
   while( pWhere->op==TK_AND ){
-    nChng += pushDownWhereTerms(pParse, pSubq, pWhere->pRight,
-                                iCursor, isLeftJoin);
+    nChng += pushDownWhereTerms(pParse, pSubq, pWhere->pRight, 
+                                iCursor, isLeftJoin); 
     pWhere = pWhere->pLeft;
   }
-  if( isLeftJoin
-   && (ExprHasProperty(pWhere,EP_FromJoin)==0
-         || pWhere->iRightJoinTable!=iCursor)
-  ){
-    return 0; /* restriction (4) */
-  }
-  if( ExprHasProperty(pWhere,EP_FromJoin) && pWhere->iRightJoinTable!=iCursor ){
-    return 0; /* restriction (5) */
-  }
+  if( isLeftJoin 
+   && (ExprHasProperty(pWhere,EP_FromJoin)==0 
+         || pWhere->iRightJoinTable!=iCursor) 
+  ){ 
+    return 0; /* restriction (4) */ 
+  } 
+  if( ExprHasProperty(pWhere,EP_FromJoin) && pWhere->iRightJoinTable!=iCursor ){ 
+    return 0; /* restriction (5) */ 
+  } 
   if( sqlite3ExprIsTableConstant(pWhere, iCursor) ){
     nChng++;
     pSubq->selFlags |= SF_PushDown;
     while( pSubq ){
       SubstContext x;
       pNew = sqlite3ExprDup(pParse->db, pWhere, 0);
-      unsetJoinExpr(pNew, -1);
+      unsetJoinExpr(pNew, -1); 
       x.pParse = pParse;
       x.iTable = iCursor;
       x.iNewTable = iCursor;
@@ -138135,9 +138135,9 @@ static int pushDownWhereTerms(
       }
 #endif
       if( pSubq->selFlags & SF_Aggregate ){
-        pSubq->pHaving = sqlite3ExprAnd(pParse, pSubq->pHaving, pNew);
+        pSubq->pHaving = sqlite3ExprAnd(pParse, pSubq->pHaving, pNew); 
       }else{
-        pSubq->pWhere = sqlite3ExprAnd(pParse, pSubq->pWhere, pNew);
+        pSubq->pWhere = sqlite3ExprAnd(pParse, pSubq->pWhere, pNew); 
       }
       pSubq = pSubq->pPrior;
     }
@@ -138648,41 +138648,41 @@ SQLITE_PRIVATE void sqlite3SelectPopWith(Walker *pWalker, Select *p){
 #endif
 
 /*
-** The SrcList_item structure passed as the second argument represents a
-** sub-query in the FROM clause of a SELECT statement. This function
-** allocates and populates the SrcList_item.pTab object. If successful,
-** SQLITE_OK is returned. Otherwise, if an OOM error is encountered,
-** SQLITE_NOMEM.
-*/
+** The SrcList_item structure passed as the second argument represents a 
+** sub-query in the FROM clause of a SELECT statement. This function 
+** allocates and populates the SrcList_item.pTab object. If successful, 
+** SQLITE_OK is returned. Otherwise, if an OOM error is encountered, 
+** SQLITE_NOMEM. 
+*/ 
 SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse *pParse, SrcItem *pFrom){
-  Select *pSel = pFrom->pSelect;
-  Table *pTab;
-
-  assert( pSel );
-  pFrom->pTab = pTab = sqlite3DbMallocZero(pParse->db, sizeof(Table));
-  if( pTab==0 ) return SQLITE_NOMEM;
-  pTab->nTabRef = 1;
-  if( pFrom->zAlias ){
-    pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias);
-  }else{
-    pTab->zName = sqlite3MPrintf(pParse->db, "subquery_%u", pSel->selId);
-  }
-  while( pSel->pPrior ){ pSel = pSel->pPrior; }
-  sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
-  pTab->iPKey = -1;
-  pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
+  Select *pSel = pFrom->pSelect; 
+  Table *pTab; 
+ 
+  assert( pSel ); 
+  pFrom->pTab = pTab = sqlite3DbMallocZero(pParse->db, sizeof(Table)); 
+  if( pTab==0 ) return SQLITE_NOMEM; 
+  pTab->nTabRef = 1; 
+  if( pFrom->zAlias ){ 
+    pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias); 
+  }else{ 
+    pTab->zName = sqlite3MPrintf(pParse->db, "subquery_%u", pSel->selId); 
+  } 
+  while( pSel->pPrior ){ pSel = pSel->pPrior; } 
+  sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol); 
+  pTab->iPKey = -1; 
+  pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) ); 
 #ifndef SQLITE_ALLOW_ROWID_IN_VIEW
   /* The usual case - do not allow ROWID on a subquery */
   pTab->tabFlags |= TF_Ephemeral | TF_NoVisibleRowid;
 #else
   pTab->tabFlags |= TF_Ephemeral;  /* Legacy compatibility mode */
 #endif
+ 
 
-
-  return pParse->nErr ? SQLITE_ERROR : SQLITE_OK;
-}
-
-/*
+  return pParse->nErr ? SQLITE_ERROR : SQLITE_OK; 
+} 
+ 
+/* 
 ** This routine is a Walker callback for "expanding" a SELECT statement.
 ** "Expanding" means to do the following:
 **
@@ -138725,10 +138725,10 @@ static int selectExpander(Walker *pWalker, Select *p){
   if( (selFlags & SF_Expanded)!=0 ){
     return WRC_Prune;
   }
-  if( pWalker->eCode ){
-    /* Renumber selId because it has been copied from a view */
-    p->selId = ++pParse->nSelect;
-  }
+  if( pWalker->eCode ){ 
+    /* Renumber selId because it has been copied from a view */ 
+    p->selId = ++pParse->nSelect; 
+  } 
   pTabList = p->pSrc;
   pEList = p->pEList;
   if( pParse->pWith && (p->selFlags & SF_View) ){
@@ -138740,7 +138740,7 @@ static int selectExpander(Walker *pWalker, Select *p){
     }
     p->pWith->bView = 1;
   }
-  sqlite3WithPush(pParse, p->pWith, 0);
+  sqlite3WithPush(pParse, p->pWith, 0); 
 
   /* Make sure cursor numbers have been assigned to all entries in
   ** the FROM clause of the SELECT statement.
@@ -138763,7 +138763,7 @@ static int selectExpander(Walker *pWalker, Select *p){
       assert( pSel!=0 );
       assert( pFrom->pTab==0 );
       if( sqlite3WalkSelect(pWalker, pSel) ) return WRC_Abort;
-      if( sqlite3ExpandSubquery(pParse, pFrom) ) return WRC_Abort;
+      if( sqlite3ExpandSubquery(pParse, pFrom) ) return WRC_Abort; 
 #endif
 #ifndef SQLITE_OMIT_CTE
     }else if( (rc = resolveFromTermToCte(pParse, pWalker, pFrom))!=0 ){
@@ -138789,7 +138789,7 @@ static int selectExpander(Walker *pWalker, Select *p){
 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE)
       if( !IsOrdinaryTable(pTab) ){
         i16 nCol;
-        u8 eCodeOrig = pWalker->eCode;
+        u8 eCodeOrig = pWalker->eCode; 
         if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
         assert( pFrom->pSelect==0 );
         if( IsView(pTab) ){
@@ -138814,9 +138814,9 @@ static int selectExpander(Walker *pWalker, Select *p){
 #endif
         nCol = pTab->nCol;
         pTab->nCol = -1;
-        pWalker->eCode = 1;  /* Turn on Select.selId renumbering */
+        pWalker->eCode = 1;  /* Turn on Select.selId renumbering */ 
         sqlite3WalkSelect(pWalker, pFrom->pSelect);
-        pWalker->eCode = eCodeOrig;
+        pWalker->eCode = eCodeOrig; 
         pTab->nCol = nCol;
       }
 #endif
@@ -139043,7 +139043,7 @@ static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){
   }
   w.xSelectCallback = selectExpander;
   w.xSelectCallback2 = sqlite3SelectPopWith;
-  w.eCode = 0;
+  w.eCode = 0; 
   sqlite3WalkSelect(&w, pSelect);
 }
 
@@ -139069,7 +139069,7 @@ static void selectAddSubqueryTypeInfo(Walker *pWalker, Select *p){
   SrcItem *pFrom;
 
   assert( p->selFlags & SF_Resolved );
-  if( p->selFlags & SF_HasTypeInfo ) return;
+  if( p->selFlags & SF_HasTypeInfo ) return; 
   p->selFlags |= SF_HasTypeInfo;
   pParse = pWalker->pParse;
   pTabList = p->pSrc;
@@ -139174,7 +139174,7 @@ static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
            "argument");
         pFunc->iDistinct = -1;
       }else{
-        KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pE->x.pList,0,0);
+        KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pE->x.pList,0,0); 
         pFunc->iDistAddr = sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
             pFunc->iDistinct, 0, 0, (char*)pKeyInfo, P4_KEYINFO);
         ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s(DISTINCT)",
@@ -139201,15 +139201,15 @@ static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
   }
 }
 
-
+ 
 /*
 ** Update the accumulator memory cells for an aggregate based on
 ** the current cursor position.
-**
-** If regAcc is non-zero and there are no min() or max() aggregates
-** in pAggInfo, then only populate the pAggInfo->nAccumulator accumulator
-** registers if register regAcc contains 0. The caller will take care
-** of setting and clearing regAcc.
+** 
+** If regAcc is non-zero and there are no min() or max() aggregates 
+** in pAggInfo, then only populate the pAggInfo->nAccumulator accumulator 
+** registers if register regAcc contains 0. The caller will take care 
+** of setting and clearing regAcc. 
 */
 static void updateAccumulator(
   Parse *pParse,
@@ -139284,7 +139284,7 @@ static void updateAccumulator(
       if( regHit==0 && pAggInfo->nAccumulator ) regHit = ++pParse->nMem;
       sqlite3VdbeAddOp4(v, OP_CollSeq, regHit, 0, 0, (char *)pColl, P4_COLLSEQ);
     }
-    sqlite3VdbeAddOp3(v, OP_AggStep, 0, regAgg, pF->iMem);
+    sqlite3VdbeAddOp3(v, OP_AggStep, 0, regAgg, pF->iMem); 
     sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
     sqlite3VdbeChangeP5(v, (u8)nArg);
     sqlite3ReleaseTempRange(pParse, regAgg, nArg);
@@ -139292,9 +139292,9 @@ static void updateAccumulator(
       sqlite3VdbeResolveLabel(v, addrNext);
     }
   }
-  if( regHit==0 && pAggInfo->nAccumulator ){
-    regHit = regAcc;
-  }
+  if( regHit==0 && pAggInfo->nAccumulator ){ 
+    regHit = regAcc; 
+  } 
   if( regHit ){
     addrHitTest = sqlite3VdbeAddOp1(v, OP_If, regHit); VdbeCoverage(v);
   }
@@ -139344,7 +139344,7 @@ static void explainSimpleCount(
 */
 static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){
   if( pExpr->op!=TK_AND ){
-    Select *pS = pWalker->u.pSelect;
+    Select *pS = pWalker->u.pSelect; 
     /* This routine is called before the HAVING clause of the current
     ** SELECT is analyzed for aggregates. So if pExpr->pAggInfo is set
     ** here, it indicates that the expression is a correlated reference to a
@@ -139359,11 +139359,11 @@ static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){
       sqlite3 *db = pWalker->pParse->db;
       Expr *pNew = sqlite3Expr(db, TK_INTEGER, "1");
       if( pNew ){
-        Expr *pWhere = pS->pWhere;
+        Expr *pWhere = pS->pWhere; 
         SWAP(Expr, *pNew, *pExpr);
-        pNew = sqlite3ExprAnd(pWalker->pParse, pWhere, pNew);
-        pS->pWhere = pNew;
-        pWalker->eCode = 1;
+        pNew = sqlite3ExprAnd(pWalker->pParse, pWhere, pNew); 
+        pS->pWhere = pNew; 
+        pWalker->eCode = 1; 
       }
     }
     return WRC_Prune;
@@ -139386,19 +139386,19 @@ static int havingToWhereExprCb(Walker *pWalker, Expr *pExpr){
 ** entirely of constants and expressions that are also GROUP BY terms that
 ** use the "BINARY" collation sequence.
 */
-static void havingToWhere(Parse *pParse, Select *p){
+static void havingToWhere(Parse *pParse, Select *p){ 
   Walker sWalker;
   memset(&sWalker, 0, sizeof(sWalker));
   sWalker.pParse = pParse;
   sWalker.xExprCallback = havingToWhereExprCb;
-  sWalker.u.pSelect = p;
-  sqlite3WalkExpr(&sWalker, p->pHaving);
-#if SELECTTRACE_ENABLED
+  sWalker.u.pSelect = p; 
+  sqlite3WalkExpr(&sWalker, p->pHaving); 
+#if SELECTTRACE_ENABLED 
   if( sWalker.eCode && (sqlite3SelectTrace & 0x100)!=0 ){
-    SELECTTRACE(0x100,pParse,p,("Move HAVING terms into WHERE:\n"));
-    sqlite3TreeViewSelect(0, p, 0);
-  }
-#endif
+    SELECTTRACE(0x100,pParse,p,("Move HAVING terms into WHERE:\n")); 
+    sqlite3TreeViewSelect(0, p, 0); 
+  } 
+#endif 
 }
 
 /*
@@ -139414,20 +139414,20 @@ static SrcItem *isSelfJoinView(
   assert( pThis->pSelect!=0 );
   if( pThis->pSelect->selFlags & SF_PushDown ) return 0;
   for(pItem = pTabList->a; pItem<pThis; pItem++){
-    Select *pS1;
+    Select *pS1; 
     if( pItem->pSelect==0 ) continue;
     if( pItem->fg.viaCoroutine ) continue;
     if( pItem->zName==0 ) continue;
-    assert( pItem->pTab!=0 );
-    assert( pThis->pTab!=0 );
-    if( pItem->pTab->pSchema!=pThis->pTab->pSchema ) continue;
+    assert( pItem->pTab!=0 ); 
+    assert( pThis->pTab!=0 ); 
+    if( pItem->pTab->pSchema!=pThis->pTab->pSchema ) continue; 
     if( sqlite3_stricmp(pItem->zName, pThis->zName)!=0 ) continue;
-    pS1 = pItem->pSelect;
-    if( pItem->pTab->pSchema==0 && pThis->pSelect->selId!=pS1->selId ){
-      /* The query flattener left two different CTE tables with identical
-      ** names in the same FROM clause. */
-      continue;
-    }
+    pS1 = pItem->pSelect; 
+    if( pItem->pTab->pSchema==0 && pThis->pSelect->selId!=pS1->selId ){ 
+      /* The query flattener left two different CTE tables with identical 
+      ** names in the same FROM clause. */ 
+      continue; 
+    } 
     if( pItem->pSelect->selFlags & SF_PushDown ){
       /* The view was modified by some other optimization such as
       ** pushDownWhereTerms() */
@@ -139460,10 +139460,10 @@ static void agginfoFree(sqlite3 *db, AggInfo *p){
 ** The transformation only works if all of the following are true:
 **
 **   *  The subquery is a UNION ALL of two or more terms
-**   *  The subquery does not have a LIMIT clause
+**   *  The subquery does not have a LIMIT clause 
 **   *  There is no WHERE or GROUP BY or HAVING clauses on the subqueries
-**   *  The outer query is a simple count(*) with no WHERE clause or other
-**      extraneous syntax.
+**   *  The outer query is a simple count(*) with no WHERE clause or other 
+**      extraneous syntax. 
 **
 ** Return TRUE if the optimization is undertaken.
 */
@@ -139474,8 +139474,8 @@ static int countOfViewOptimization(Parse *pParse, Select *p){
   sqlite3 *db;
   if( (p->selFlags & SF_Aggregate)==0 ) return 0;   /* This is an aggregate */
   if( p->pEList->nExpr!=1 ) return 0;               /* Single result column */
-  if( p->pWhere ) return 0;
-  if( p->pGroupBy ) return 0;
+  if( p->pWhere ) return 0; 
+  if( p->pGroupBy ) return 0; 
   pExpr = p->pEList->a[0].pExpr;
   if( pExpr->op!=TK_AGG_FUNCTION ) return 0;        /* Result is an aggregate */
   assert( ExprUseUToken(pExpr) );
@@ -139489,7 +139489,7 @@ static int countOfViewOptimization(Parse *pParse, Select *p){
   do{
     if( pSub->op!=TK_ALL && pSub->pPrior ) return 0;  /* Must be UNION ALL */
     if( pSub->pWhere ) return 0;                      /* No WHERE clause */
-    if( pSub->pLimit ) return 0;                      /* No LIMIT clause */
+    if( pSub->pLimit ) return 0;                      /* No LIMIT clause */ 
     if( pSub->selFlags & SF_Aggregate ) return 0;     /* Not an aggregate */
     pSub = pSub->pPrior;                              /* Repeat over compound */
   }while( pSub );
@@ -139573,13 +139573,13 @@ SQLITE_PRIVATE int sqlite3Select(
   u8 minMaxFlag;                 /* Flag for min/max queries */
 
   db = pParse->db;
-  v = sqlite3GetVdbe(pParse);
+  v = sqlite3GetVdbe(pParse); 
   if( p==0 || db->mallocFailed || pParse->nErr ){
     return 1;
   }
   if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
 #if SELECTTRACE_ENABLED
-  SELECTTRACE(1,pParse,p, ("begin processing:\n", pParse->addrExplain));
+  SELECTTRACE(1,pParse,p, ("begin processing:\n", pParse->addrExplain)); 
   if( sqlite3SelectTrace & 0x100 ){
     sqlite3TreeViewSelect(0, p, 0);
   }
@@ -139617,7 +139617,7 @@ SQLITE_PRIVATE int sqlite3Select(
   assert( p->pEList!=0 );
 #if SELECTTRACE_ENABLED
   if( sqlite3SelectTrace & 0x104 ){
-    SELECTTRACE(0x104,pParse,p, ("after name resolution:\n"));
+    SELECTTRACE(0x104,pParse,p, ("after name resolution:\n")); 
     sqlite3TreeViewSelect(0, p, 0);
   }
 #endif
@@ -139655,51 +139655,51 @@ SQLITE_PRIVATE int sqlite3Select(
     sqlite3GenerateColumnNames(pParse, p);
   }
 
-#ifndef SQLITE_OMIT_WINDOWFUNC
+#ifndef SQLITE_OMIT_WINDOWFUNC 
   if( sqlite3WindowRewrite(pParse, p) ){
     assert( db->mallocFailed || pParse->nErr>0 );
-    goto select_end;
-  }
-#if SELECTTRACE_ENABLED
+    goto select_end; 
+  } 
+#if SELECTTRACE_ENABLED 
   if( p->pWin && (sqlite3SelectTrace & 0x108)!=0 ){
-    SELECTTRACE(0x104,pParse,p, ("after window rewrite:\n"));
-    sqlite3TreeViewSelect(0, p, 0);
-  }
-#endif
-#endif /* SQLITE_OMIT_WINDOWFUNC */
-  pTabList = p->pSrc;
-  isAgg = (p->selFlags & SF_Aggregate)!=0;
-  memset(&sSort, 0, sizeof(sSort));
-  sSort.pOrderBy = p->pOrderBy;
-
+    SELECTTRACE(0x104,pParse,p, ("after window rewrite:\n")); 
+    sqlite3TreeViewSelect(0, p, 0); 
+  } 
+#endif 
+#endif /* SQLITE_OMIT_WINDOWFUNC */ 
+  pTabList = p->pSrc; 
+  isAgg = (p->selFlags & SF_Aggregate)!=0; 
+  memset(&sSort, 0, sizeof(sSort)); 
+  sSort.pOrderBy = p->pOrderBy; 
+ 
   /* Try to do various optimizations (flattening subqueries, and strength
-  ** reduction of join operators) in the FROM clause up into the main query
+  ** reduction of join operators) in the FROM clause up into the main query 
   */
 #if !defined(SQLITE_OMIT_SUBQUERY) || !defined(SQLITE_OMIT_VIEW)
   for(i=0; !p->pPrior && i<pTabList->nSrc; i++){
     SrcItem *pItem = &pTabList->a[i];
     Select *pSub = pItem->pSelect;
     Table *pTab = pItem->pTab;
-
+ 
     /* The expander should have already created transient Table objects
     ** even for FROM clause elements such as subqueries that do not correspond
     ** to a real table */
     assert( pTab!=0 );
 
-    /* Convert LEFT JOIN into JOIN if there are terms of the right table
-    ** of the LEFT JOIN used in the WHERE clause.
-    */
-    if( (pItem->fg.jointype & JT_LEFT)!=0
-     && sqlite3ExprImpliesNonNullRow(p->pWhere, pItem->iCursor)
-     && OptimizationEnabled(db, SQLITE_SimplifyJoin)
-    ){
-      SELECTTRACE(0x100,pParse,p,
-                ("LEFT-JOIN simplifies to JOIN on term %d\n",i));
-      pItem->fg.jointype &= ~(JT_LEFT|JT_OUTER);
-      unsetJoinExpr(p->pWhere, pItem->iCursor);
-    }
-
-    /* No futher action if this term of the FROM clause is no a subquery */
+    /* Convert LEFT JOIN into JOIN if there are terms of the right table 
+    ** of the LEFT JOIN used in the WHERE clause. 
+    */ 
+    if( (pItem->fg.jointype & JT_LEFT)!=0 
+     && sqlite3ExprImpliesNonNullRow(p->pWhere, pItem->iCursor) 
+     && OptimizationEnabled(db, SQLITE_SimplifyJoin) 
+    ){ 
+      SELECTTRACE(0x100,pParse,p, 
+                ("LEFT-JOIN simplifies to JOIN on term %d\n",i)); 
+      pItem->fg.jointype &= ~(JT_LEFT|JT_OUTER); 
+      unsetJoinExpr(p->pWhere, pItem->iCursor); 
+    } 
+ 
+    /* No futher action if this term of the FROM clause is no a subquery */ 
     if( pSub==0 ) continue;
 
     /* Catch mismatch in the declared columns of a view and the number of
@@ -139781,7 +139781,7 @@ SQLITE_PRIVATE int sqlite3Select(
     }
 
     if( flattenSubquery(pParse, p, i, isAgg) ){
-      if( pParse->nErr ) goto select_end;
+      if( pParse->nErr ) goto select_end; 
       /* This subquery can be absorbed into its parent. */
       i = -1;
     }
@@ -139800,46 +139800,46 @@ SQLITE_PRIVATE int sqlite3Select(
   if( p->pPrior ){
     rc = multiSelect(pParse, p, pDest);
 #if SELECTTRACE_ENABLED
-    SELECTTRACE(0x1,pParse,p,("end compound-select processing\n"));
+    SELECTTRACE(0x1,pParse,p,("end compound-select processing\n")); 
     if( (sqlite3SelectTrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){
-      sqlite3TreeViewSelect(0, p, 0);
-    }
+      sqlite3TreeViewSelect(0, p, 0); 
+    } 
 #endif
-    if( p->pNext==0 ) ExplainQueryPlanPop(pParse);
+    if( p->pNext==0 ) ExplainQueryPlanPop(pParse); 
     return rc;
   }
 #endif
 
-  /* Do the WHERE-clause constant propagation optimization if this is
-  ** a join.  No need to speed time on this operation for non-join queries
-  ** as the equivalent optimization will be handled by query planner in
-  ** sqlite3WhereBegin().
-  */
+  /* Do the WHERE-clause constant propagation optimization if this is 
+  ** a join.  No need to speed time on this operation for non-join queries 
+  ** as the equivalent optimization will be handled by query planner in 
+  ** sqlite3WhereBegin(). 
+  */ 
   if( p->pWhere!=0
    && p->pWhere->op==TK_AND
-   && OptimizationEnabled(db, SQLITE_PropagateConst)
-   && propagateConstants(pParse, p)
-  ){
-#if SELECTTRACE_ENABLED
+   && OptimizationEnabled(db, SQLITE_PropagateConst) 
+   && propagateConstants(pParse, p) 
+  ){ 
+#if SELECTTRACE_ENABLED 
     if( sqlite3SelectTrace & 0x100 ){
-      SELECTTRACE(0x100,pParse,p,("After constant propagation:\n"));
-      sqlite3TreeViewSelect(0, p, 0);
-    }
-#endif
-  }else{
-    SELECTTRACE(0x100,pParse,p,("Constant propagation not helpful\n"));
-  }
-
-#ifdef SQLITE_COUNTOFVIEW_OPTIMIZATION
-  if( OptimizationEnabled(db, SQLITE_QueryFlattener|SQLITE_CountOfView)
-   && countOfViewOptimization(pParse, p)
-  ){
-    if( db->mallocFailed ) goto select_end;
-    pEList = p->pEList;
-    pTabList = p->pSrc;
-  }
-#endif
-
+      SELECTTRACE(0x100,pParse,p,("After constant propagation:\n")); 
+      sqlite3TreeViewSelect(0, p, 0); 
+    } 
+#endif 
+  }else{ 
+    SELECTTRACE(0x100,pParse,p,("Constant propagation not helpful\n")); 
+  } 
+ 
+#ifdef SQLITE_COUNTOFVIEW_OPTIMIZATION 
+  if( OptimizationEnabled(db, SQLITE_QueryFlattener|SQLITE_CountOfView) 
+   && countOfViewOptimization(pParse, p) 
+  ){ 
+    if( db->mallocFailed ) goto select_end; 
+    pEList = p->pEList; 
+    pTabList = p->pSrc; 
+  } 
+#endif 
+ 
   /* For each term in the FROM clause, do two things:
   ** (1) Authorized unreferenced tables
   ** (2) Generate code for all sub-queries
@@ -139894,22 +139894,22 @@ SQLITE_PRIVATE int sqlite3Select(
     /* Make copies of constant WHERE-clause terms in the outer query down
     ** inside the subquery.  This can help the subquery to run more efficiently.
     */
-    if( OptimizationEnabled(db, SQLITE_PushDown)
+    if( OptimizationEnabled(db, SQLITE_PushDown) 
      && (pItem->fg.isCte==0
          || (pItem->u2.pCteUse->eM10d!=M10d_Yes && pItem->u2.pCteUse->nUse<2))
-     && pushDownWhereTerms(pParse, pSub, p->pWhere, pItem->iCursor,
-                           (pItem->fg.jointype & JT_OUTER)!=0)
+     && pushDownWhereTerms(pParse, pSub, p->pWhere, pItem->iCursor, 
+                           (pItem->fg.jointype & JT_OUTER)!=0) 
     ){
 #if SELECTTRACE_ENABLED
       if( sqlite3SelectTrace & 0x100 ){
-        SELECTTRACE(0x100,pParse,p,
-            ("After WHERE-clause push-down into subquery %d:\n", pSub->selId));
+        SELECTTRACE(0x100,pParse,p, 
+            ("After WHERE-clause push-down into subquery %d:\n", pSub->selId)); 
         sqlite3TreeViewSelect(0, p, 0);
       }
 #endif
       assert( pItem->pSelect && (pItem->pSelect->selFlags & SF_PushDown)!=0 );
-    }else{
-      SELECTTRACE(0x100,pParse,p,("Push-down not possible\n"));
+    }else{ 
+      SELECTTRACE(0x100,pParse,p,("Push-down not possible\n")); 
     }
 
     zSavedAuthContext = pParse->zAuthContext;
@@ -140073,8 +140073,8 @@ SQLITE_PRIVATE int sqlite3Select(
   */
   if( sSort.pOrderBy ){
     KeyInfo *pKeyInfo;
-    pKeyInfo = sqlite3KeyInfoFromExprList(
-        pParse, sSort.pOrderBy, 0, pEList->nExpr);
+    pKeyInfo = sqlite3KeyInfoFromExprList( 
+        pParse, sSort.pOrderBy, 0, pEList->nExpr); 
     sSort.iECursor = pParse->nTab++;
     sSort.addrSortIndex =
       sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
@@ -140093,7 +140093,7 @@ SQLITE_PRIVATE int sqlite3Select(
 
   /* Set the limiter.
   */
-  iEnd = sqlite3VdbeMakeLabel(pParse);
+  iEnd = sqlite3VdbeMakeLabel(pParse); 
   if( (p->selFlags & SF_FixedLimit)==0 ){
     p->nSelectRow = 320;  /* 4 billion rows */
   }
@@ -140108,9 +140108,9 @@ SQLITE_PRIVATE int sqlite3Select(
   if( p->selFlags & SF_Distinct ){
     sDistinct.tabTnct = pParse->nTab++;
     sDistinct.addrTnct = sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
-                       sDistinct.tabTnct, 0, 0,
-                       (char*)sqlite3KeyInfoFromExprList(pParse, p->pEList,0,0),
-                       P4_KEYINFO);
+                       sDistinct.tabTnct, 0, 0, 
+                       (char*)sqlite3KeyInfoFromExprList(pParse, p->pEList,0,0), 
+                       P4_KEYINFO); 
     sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
     sDistinct.eTnctType = WHERE_DISTINCT_UNORDERED;
   }else{
@@ -140119,19 +140119,19 @@ SQLITE_PRIVATE int sqlite3Select(
 
   if( !isAgg && pGroupBy==0 ){
     /* No aggregate functions and no GROUP BY clause */
-    u16 wctrlFlags = (sDistinct.isTnct ? WHERE_WANT_DISTINCT : 0)
-                   | (p->selFlags & SF_FixedLimit);
-#ifndef SQLITE_OMIT_WINDOWFUNC
+    u16 wctrlFlags = (sDistinct.isTnct ? WHERE_WANT_DISTINCT : 0) 
+                   | (p->selFlags & SF_FixedLimit); 
+#ifndef SQLITE_OMIT_WINDOWFUNC 
     Window *pWin = p->pWin;      /* Main window object (or NULL) */
-    if( pWin ){
+    if( pWin ){ 
       sqlite3WindowCodeInit(pParse, p);
-    }
-#endif
+    } 
+#endif 
     assert( WHERE_USE_LIMIT==SF_FixedLimit );
 
-
+ 
     /* Begin the database scan. */
-    SELECTTRACE(1,pParse,p,("WhereBegin\n"));
+    SELECTTRACE(1,pParse,p,("WhereBegin\n")); 
     pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, sSort.pOrderBy,
                                p->pEList, wctrlFlags, p->nSelectRow);
     if( pWInfo==0 ) goto select_end;
@@ -140143,7 +140143,7 @@ SQLITE_PRIVATE int sqlite3Select(
     }
     if( sSort.pOrderBy ){
       sSort.nOBSat = sqlite3WhereIsOrdered(pWInfo);
-      sSort.labelOBLopt = sqlite3WhereOrderByLimitOptLabel(pWInfo);
+      sSort.labelOBLopt = sqlite3WhereOrderByLimitOptLabel(pWInfo); 
       if( sSort.nOBSat==sSort.pOrderBy->nExpr ){
         sSort.pOrderBy = 0;
       }
@@ -140159,37 +140159,37 @@ SQLITE_PRIVATE int sqlite3Select(
     }
 
     assert( p->pEList==pEList );
-#ifndef SQLITE_OMIT_WINDOWFUNC
-    if( pWin ){
-      int addrGosub = sqlite3VdbeMakeLabel(pParse);
-      int iCont = sqlite3VdbeMakeLabel(pParse);
-      int iBreak = sqlite3VdbeMakeLabel(pParse);
-      int regGosub = ++pParse->nMem;
-
-      sqlite3WindowCodeStep(pParse, p, pWInfo, regGosub, addrGosub);
-
-      sqlite3VdbeAddOp2(v, OP_Goto, 0, iBreak);
-      sqlite3VdbeResolveLabel(v, addrGosub);
-      VdbeNoopComment((v, "inner-loop subroutine"));
-      sSort.labelOBLopt = 0;
-      selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest, iCont, iBreak);
-      sqlite3VdbeResolveLabel(v, iCont);
-      sqlite3VdbeAddOp1(v, OP_Return, regGosub);
-      VdbeComment((v, "end inner-loop subroutine"));
-      sqlite3VdbeResolveLabel(v, iBreak);
-    }else
-#endif /* SQLITE_OMIT_WINDOWFUNC */
-    {
-      /* Use the standard inner loop. */
-      selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest,
-          sqlite3WhereContinueLabel(pWInfo),
-          sqlite3WhereBreakLabel(pWInfo));
-
-      /* End the database scan loop.
-      */
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+    if( pWin ){ 
+      int addrGosub = sqlite3VdbeMakeLabel(pParse); 
+      int iCont = sqlite3VdbeMakeLabel(pParse); 
+      int iBreak = sqlite3VdbeMakeLabel(pParse); 
+      int regGosub = ++pParse->nMem; 
+
+      sqlite3WindowCodeStep(pParse, p, pWInfo, regGosub, addrGosub); 
+ 
+      sqlite3VdbeAddOp2(v, OP_Goto, 0, iBreak); 
+      sqlite3VdbeResolveLabel(v, addrGosub); 
+      VdbeNoopComment((v, "inner-loop subroutine")); 
+      sSort.labelOBLopt = 0; 
+      selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest, iCont, iBreak); 
+      sqlite3VdbeResolveLabel(v, iCont); 
+      sqlite3VdbeAddOp1(v, OP_Return, regGosub); 
+      VdbeComment((v, "end inner-loop subroutine")); 
+      sqlite3VdbeResolveLabel(v, iBreak); 
+    }else 
+#endif /* SQLITE_OMIT_WINDOWFUNC */ 
+    { 
+      /* Use the standard inner loop. */ 
+      selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest, 
+          sqlite3WhereContinueLabel(pWInfo), 
+          sqlite3WhereBreakLabel(pWInfo)); 
+ 
+      /* End the database scan loop. 
+      */ 
       SELECTTRACE(1,pParse,p,("WhereEnd\n"));
-      sqlite3WhereEnd(pWInfo);
-    }
+      sqlite3WhereEnd(pWInfo); 
+    } 
   }else{
     /* This case when there exist aggregate functions or a GROUP BY clause
     ** or both */
@@ -140251,7 +140251,7 @@ SQLITE_PRIVATE int sqlite3Select(
     }
 
     /* Create a label to jump to when we want to abort the query */
-    addrEnd = sqlite3VdbeMakeLabel(pParse);
+    addrEnd = sqlite3VdbeMakeLabel(pParse); 
 
     /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in
     ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
@@ -140271,7 +140271,7 @@ SQLITE_PRIVATE int sqlite3Select(
     sNC.pParse = pParse;
     sNC.pSrcList = pTabList;
     sNC.uNC.pAggInfo = pAggInfo;
-    VVA_ONLY( sNC.ncFlags = NC_UAggInfo; )
+    VVA_ONLY( sNC.ncFlags = NC_UAggInfo; ) 
     pAggInfo->mnReg = pParse->nMem+1;
     pAggInfo->nSortingColumn = pGroupBy ? pGroupBy->nExpr : 0;
     pAggInfo->pGroupBy = pGroupBy;
@@ -140280,9 +140280,9 @@ SQLITE_PRIVATE int sqlite3Select(
     if( pHaving ){
       if( pGroupBy ){
         assert( pWhere==p->pWhere );
-        assert( pHaving==p->pHaving );
-        assert( pGroupBy==p->pGroupBy );
-        havingToWhere(pParse, p);
+        assert( pHaving==p->pHaving ); 
+        assert( pGroupBy==p->pGroupBy ); 
+        havingToWhere(pParse, p); 
         pWhere = p->pWhere;
       }
       sqlite3ExprAnalyzeAggregates(&sNC, pHaving);
@@ -140378,9 +140378,9 @@ SQLITE_PRIVATE int sqlite3Select(
       iUseFlag = ++pParse->nMem;
       iAbortFlag = ++pParse->nMem;
       regOutputRow = ++pParse->nMem;
-      addrOutputRow = sqlite3VdbeMakeLabel(pParse);
+      addrOutputRow = sqlite3VdbeMakeLabel(pParse); 
       regReset = ++pParse->nMem;
-      addrReset = sqlite3VdbeMakeLabel(pParse);
+      addrReset = sqlite3VdbeMakeLabel(pParse); 
       iAMem = pParse->nMem + 1;
       pParse->nMem += pGroupBy->nExpr;
       iBMem = pParse->nMem + 1;
@@ -140395,7 +140395,7 @@ SQLITE_PRIVATE int sqlite3Select(
       ** in the right order to begin with.
       */
       sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
-      SELECTTRACE(1,pParse,p,("WhereBegin\n"));
+      SELECTTRACE(1,pParse,p,("WhereBegin\n")); 
       pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, pDistinct,
           WHERE_GROUPBY | (orderByGrp ? WHERE_SORTBYGROUP : 0) | distFlag, 0
       );
@@ -140443,8 +140443,8 @@ SQLITE_PRIVATE int sqlite3Select(
           struct AggInfo_col *pCol = &pAggInfo->aCol[i];
           if( pCol->iSorterColumn>=j ){
             int r1 = j + regBase;
-            sqlite3ExprCodeGetColumnOfTable(v,
-                               pCol->pTab, pCol->iTable, pCol->iColumn, r1);
+            sqlite3ExprCodeGetColumnOfTable(v, 
+                               pCol->pTab, pCol->iTable, pCol->iColumn, r1); 
             j++;
           }
         }
@@ -140575,8 +140575,8 @@ SQLITE_PRIVATE int sqlite3Select(
       */
       sqlite3VdbeResolveLabel(v, addrReset);
       resetAccumulator(pParse, pAggInfo);
-      sqlite3VdbeAddOp2(v, OP_Integer, 0, iUseFlag);
-      VdbeComment((v, "indicate accumulator empty"));
+      sqlite3VdbeAddOp2(v, OP_Integer, 0, iUseFlag); 
+      VdbeComment((v, "indicate accumulator empty")); 
       sqlite3VdbeAddOp1(v, OP_Return, regReset);
 
       if( eDist!=WHERE_DISTINCT_NOOP ){
@@ -140645,11 +140645,11 @@ SQLITE_PRIVATE int sqlite3Select(
         sqlite3VdbeAddOp1(v, OP_Close, iCsr);
         explainSimpleCount(pParse, pTab, pBest);
       }else{
-        int regAcc = 0;           /* "populate accumulators" flag */
+        int regAcc = 0;           /* "populate accumulators" flag */ 
         ExprList *pDistinct = 0;
         u16 distFlag = 0;
         int eDist;
-
+ 
         /* If there are accumulator registers but no min() or max() functions
         ** without FILTER clauses, allocate register regAcc. Register regAcc
         ** will contain 0 the first time the inner loop runs, and 1 thereafter.
@@ -140667,17 +140667,17 @@ SQLITE_PRIVATE int sqlite3Select(
             if( pAggInfo->aFunc[i].pFunc->funcFlags&SQLITE_FUNC_NEEDCOLL ){
               break;
             }
-          }
+          } 
           if( i==pAggInfo->nFunc ){
-            regAcc = ++pParse->nMem;
-            sqlite3VdbeAddOp2(v, OP_Integer, 0, regAcc);
-          }
+            regAcc = ++pParse->nMem; 
+            sqlite3VdbeAddOp2(v, OP_Integer, 0, regAcc); 
+          } 
         }else if( pAggInfo->nFunc==1 && pAggInfo->aFunc[0].iDistinct>=0 ){
           assert( ExprUseXList(pAggInfo->aFunc[0].pFExpr) );
           pDistinct = pAggInfo->aFunc[0].pFExpr->x.pList;
           distFlag = pDistinct ? (WHERE_WANT_DISTINCT|WHERE_AGG_DISTINCT) : 0;
-        }
-
+        } 
+ 
         /* This case runs if the aggregate has no GROUP BY clause.  The
         ** processing is much simpler since there is only a single row
         ** of output.
@@ -140693,7 +140693,7 @@ SQLITE_PRIVATE int sqlite3Select(
         assert( minMaxFlag==WHERE_ORDERBY_NORMAL || pMinMaxOrderBy!=0 );
         assert( pMinMaxOrderBy==0 || pMinMaxOrderBy->nExpr==1 );
 
-        SELECTTRACE(1,pParse,p,("WhereBegin\n"));
+        SELECTTRACE(1,pParse,p,("WhereBegin\n")); 
         pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMaxOrderBy,
                                    pDistinct, minMaxFlag|distFlag, 0);
         if( pWInfo==0 ){
@@ -140707,7 +140707,7 @@ SQLITE_PRIVATE int sqlite3Select(
           fixDistinctOpenEph(pParse, eDist, pF->iDistinct, pF->iDistAddr);
         }
 
-        if( regAcc ) sqlite3VdbeAddOp2(v, OP_Integer, 1, regAcc);
+        if( regAcc ) sqlite3VdbeAddOp2(v, OP_Integer, 1, regAcc); 
         if( minMaxFlag ){
           sqlite3WhereMinMaxOptEarlyOut(v, pWInfo);
         }
@@ -140735,7 +140735,7 @@ SQLITE_PRIVATE int sqlite3Select(
   if( sSort.pOrderBy ){
     explainTempTable(pParse,
                      sSort.nOBSat>0 ? "RIGHT PART OF ORDER BY":"ORDER BY");
-    assert( p->pEList==pEList );
+    assert( p->pEList==pEList ); 
     generateSortTail(pParse, p, &sSort, pEList->nExpr, pDest);
   }
 
@@ -140772,12 +140772,12 @@ select_end:
 #endif
 
 #if SELECTTRACE_ENABLED
-  SELECTTRACE(0x1,pParse,p,("end processing\n"));
+  SELECTTRACE(0x1,pParse,p,("end processing\n")); 
   if( (sqlite3SelectTrace & 0x2000)!=0 && ExplainQueryPlanParent(pParse)==0 ){
-    sqlite3TreeViewSelect(0, p, 0);
-  }
+    sqlite3TreeViewSelect(0, p, 0); 
+  } 
 #endif
-  ExplainQueryPlanPop(pParse);
+  ExplainQueryPlanPop(pParse); 
   return rc;
 }
 
@@ -141011,7 +141011,7 @@ SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3 *db, TriggerStep *pTriggerS
     sqlite3ExprListDelete(db, pTmp->pExprList);
     sqlite3SelectDelete(db, pTmp->pSelect);
     sqlite3IdListDelete(db, pTmp->pIdList);
-    sqlite3UpsertDelete(db, pTmp->pUpsert);
+    sqlite3UpsertDelete(db, pTmp->pUpsert); 
     sqlite3SrcListDelete(db, pTmp->pFrom);
     sqlite3DbFree(db, pTmp->zSpan);
 
@@ -141184,15 +141184,15 @@ SQLITE_PRIVATE void sqlite3BeginTrigger(
     goto trigger_cleanup;
   }
   assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
-  if( !IN_RENAME_OBJECT ){
-    if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){
-      if( !noErr ){
-        sqlite3ErrorMsg(pParse, "trigger %T already exists", pName);
-      }else{
-        assert( !db->init.busy );
-        sqlite3CodeVerifySchema(pParse, iDb);
-      }
-      goto trigger_cleanup;
+  if( !IN_RENAME_OBJECT ){ 
+    if( sqlite3HashFind(&(db->aDb[iDb].pSchema->trigHash),zName) ){ 
+      if( !noErr ){ 
+        sqlite3ErrorMsg(pParse, "trigger %T already exists", pName); 
+      }else{ 
+        assert( !db->init.busy ); 
+        sqlite3CodeVerifySchema(pParse, iDb); 
+      } 
+      goto trigger_cleanup; 
     }
   }
 
@@ -141217,7 +141217,7 @@ SQLITE_PRIVATE void sqlite3BeginTrigger(
   }
 
 #ifndef SQLITE_OMIT_AUTHORIZATION
-  if( !IN_RENAME_OBJECT ){
+  if( !IN_RENAME_OBJECT ){ 
     int iTabDb = sqlite3SchemaToIndex(db, pTab->pSchema);
     int code = SQLITE_CREATE_TRIGGER;
     const char *zDb = db->aDb[iTabDb].zDbSName;
@@ -141251,15 +141251,15 @@ SQLITE_PRIVATE void sqlite3BeginTrigger(
   pTrigger->pTabSchema = pTab->pSchema;
   pTrigger->op = (u8)op;
   pTrigger->tr_tm = tr_tm==TK_BEFORE ? TRIGGER_BEFORE : TRIGGER_AFTER;
-  if( IN_RENAME_OBJECT ){
-    sqlite3RenameTokenRemap(pParse, pTrigger->table, pTableName->a[0].zName);
-    pTrigger->pWhen = pWhen;
-    pWhen = 0;
-  }else{
-    pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE);
-  }
-  pTrigger->pColumns = pColumns;
-  pColumns = 0;
+  if( IN_RENAME_OBJECT ){ 
+    sqlite3RenameTokenRemap(pParse, pTrigger->table, pTableName->a[0].zName); 
+    pTrigger->pWhen = pWhen; 
+    pWhen = 0; 
+  }else{ 
+    pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE); 
+  } 
+  pTrigger->pColumns = pColumns; 
+  pColumns = 0; 
   assert( pParse->pNewTrigger==0 );
   pParse->pNewTrigger = pTrigger;
 
@@ -141325,14 +141325,14 @@ SQLITE_PRIVATE void sqlite3FinishTrigger(
     goto triggerfinish_cleanup;
   }
 
-#ifndef SQLITE_OMIT_ALTERTABLE
-  if( IN_RENAME_OBJECT ){
-    assert( !db->init.busy );
-    pParse->pNewTrigger = pTrig;
-    pTrig = 0;
-  }else
-#endif
-
+#ifndef SQLITE_OMIT_ALTERTABLE 
+  if( IN_RENAME_OBJECT ){ 
+    assert( !db->init.busy ); 
+    pParse->pNewTrigger = pTrig; 
+    pTrig = 0; 
+  }else 
+#endif 
+ 
   /* if we are not initializing,
   ** build the sqlite_schema entry
   */
@@ -141376,7 +141376,7 @@ SQLITE_PRIVATE void sqlite3FinishTrigger(
 
 triggerfinish_cleanup:
   sqlite3DeleteTrigger(db, pTrig);
-  assert( IN_RENAME_OBJECT || !pParse->pNewTrigger );
+  assert( IN_RENAME_OBJECT || !pParse->pNewTrigger ); 
   sqlite3DeleteTriggerStep(db, pStepList);
 }
 
@@ -141423,13 +141423,13 @@ SQLITE_PRIVATE TriggerStep *sqlite3TriggerSelectStep(
 ** If an OOM error occurs, NULL is returned and db->mallocFailed is set.
 */
 static TriggerStep *triggerStepAllocate(
-  Parse *pParse,              /* Parser context */
+  Parse *pParse,              /* Parser context */ 
   u8 op,                      /* Trigger opcode */
   Token *pName,               /* The target name */
   const char *zStart,         /* Start of SQL text */
   const char *zEnd            /* End of SQL text */
 ){
-  sqlite3 *db = pParse->db;
+  sqlite3 *db = pParse->db; 
   TriggerStep *pTriggerStep;
 
   pTriggerStep = sqlite3DbMallocZero(db, sizeof(TriggerStep) + pName->n + 1);
@@ -141440,9 +141440,9 @@ static TriggerStep *triggerStepAllocate(
     pTriggerStep->zTarget = z;
     pTriggerStep->op = op;
     pTriggerStep->zSpan = triggerSpanDup(db, zStart, zEnd);
-    if( IN_RENAME_OBJECT ){
-      sqlite3RenameTokenMap(pParse, pTriggerStep->zTarget, pName);
-    }
+    if( IN_RENAME_OBJECT ){ 
+      sqlite3RenameTokenMap(pParse, pTriggerStep->zTarget, pName); 
+    } 
   }
   return pTriggerStep;
 }
@@ -141455,39 +141455,39 @@ static TriggerStep *triggerStepAllocate(
 ** body of a trigger.
 */
 SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep(
-  Parse *pParse,      /* Parser */
+  Parse *pParse,      /* Parser */ 
   Token *pTableName,  /* Name of the table into which we insert */
   IdList *pColumn,    /* List of columns in pTableName to insert into */
   Select *pSelect,    /* A SELECT statement that supplies values */
   u8 orconf,          /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */
-  Upsert *pUpsert,    /* ON CONFLICT clauses for upsert */
+  Upsert *pUpsert,    /* ON CONFLICT clauses for upsert */ 
   const char *zStart, /* Start of SQL text */
   const char *zEnd    /* End of SQL text */
 ){
-  sqlite3 *db = pParse->db;
+  sqlite3 *db = pParse->db; 
   TriggerStep *pTriggerStep;
 
   assert(pSelect != 0 || db->mallocFailed);
 
-  pTriggerStep = triggerStepAllocate(pParse, TK_INSERT, pTableName,zStart,zEnd);
+  pTriggerStep = triggerStepAllocate(pParse, TK_INSERT, pTableName,zStart,zEnd); 
   if( pTriggerStep ){
-    if( IN_RENAME_OBJECT ){
-      pTriggerStep->pSelect = pSelect;
-      pSelect = 0;
-    }else{
-      pTriggerStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
-    }
+    if( IN_RENAME_OBJECT ){ 
+      pTriggerStep->pSelect = pSelect; 
+      pSelect = 0; 
+    }else{ 
+      pTriggerStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); 
+    } 
     pTriggerStep->pIdList = pColumn;
-    pTriggerStep->pUpsert = pUpsert;
+    pTriggerStep->pUpsert = pUpsert; 
     pTriggerStep->orconf = orconf;
     if( pUpsert ){
       sqlite3HasExplicitNulls(pParse, pUpsert->pUpsertTarget);
     }
   }else{
-    testcase( pColumn );
+    testcase( pColumn ); 
     sqlite3IdListDelete(db, pColumn);
-    testcase( pUpsert );
-    sqlite3UpsertDelete(db, pUpsert);
+    testcase( pUpsert ); 
+    sqlite3UpsertDelete(db, pUpsert); 
   }
   sqlite3SelectDelete(db, pSelect);
 
@@ -141500,7 +141500,7 @@ SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep(
 ** sees an UPDATE statement inside the body of a CREATE TRIGGER.
 */
 SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep(
-  Parse *pParse,          /* Parser */
+  Parse *pParse,          /* Parser */ 
   Token *pTableName,   /* Name of the table to be updated */
   SrcList *pFrom,
   ExprList *pEList,    /* The SET clause: list of column and new values */
@@ -141509,23 +141509,23 @@ SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep(
   const char *zStart,  /* Start of SQL text */
   const char *zEnd     /* End of SQL text */
 ){
-  sqlite3 *db = pParse->db;
+  sqlite3 *db = pParse->db; 
   TriggerStep *pTriggerStep;
 
-  pTriggerStep = triggerStepAllocate(pParse, TK_UPDATE, pTableName,zStart,zEnd);
+  pTriggerStep = triggerStepAllocate(pParse, TK_UPDATE, pTableName,zStart,zEnd); 
   if( pTriggerStep ){
-    if( IN_RENAME_OBJECT ){
-      pTriggerStep->pExprList = pEList;
-      pTriggerStep->pWhere = pWhere;
+    if( IN_RENAME_OBJECT ){ 
+      pTriggerStep->pExprList = pEList; 
+      pTriggerStep->pWhere = pWhere; 
       pTriggerStep->pFrom = pFrom;
-      pEList = 0;
-      pWhere = 0;
+      pEList = 0; 
+      pWhere = 0; 
       pFrom = 0;
-    }else{
-      pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE);
-      pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
+    }else{ 
+      pTriggerStep->pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE); 
+      pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); 
       pTriggerStep->pFrom = sqlite3SrcListDup(db, pFrom, EXPRDUP_REDUCE);
-    }
+    } 
     pTriggerStep->orconf = orconf;
   }
   sqlite3ExprListDelete(db, pEList);
@@ -141540,23 +141540,23 @@ SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep(
 ** sees a DELETE statement inside the body of a CREATE TRIGGER.
 */
 SQLITE_PRIVATE TriggerStep *sqlite3TriggerDeleteStep(
-  Parse *pParse,          /* Parser */
+  Parse *pParse,          /* Parser */ 
   Token *pTableName,      /* The table from which rows are deleted */
   Expr *pWhere,           /* The WHERE clause */
   const char *zStart,     /* Start of SQL text */
   const char *zEnd        /* End of SQL text */
 ){
-  sqlite3 *db = pParse->db;
+  sqlite3 *db = pParse->db; 
   TriggerStep *pTriggerStep;
 
-  pTriggerStep = triggerStepAllocate(pParse, TK_DELETE, pTableName,zStart,zEnd);
+  pTriggerStep = triggerStepAllocate(pParse, TK_DELETE, pTableName,zStart,zEnd); 
   if( pTriggerStep ){
-    if( IN_RENAME_OBJECT ){
-      pTriggerStep->pWhere = pWhere;
-      pWhere = 0;
-    }else{
-      pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
-    }
+    if( IN_RENAME_OBJECT ){ 
+      pTriggerStep->pWhere = pWhere; 
+      pWhere = 0; 
+    }else{ 
+      pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); 
+    } 
     pTriggerStep->orconf = OE_Default;
   }
   sqlite3ExprDelete(db, pWhere);
@@ -141802,7 +141802,7 @@ SQLITE_PRIVATE SrcList *sqlite3TriggerStepSrc(
   sqlite3 *db = pParse->db;
   SrcList *pSrc;                  /* SrcList to be returned */
   char *zName = sqlite3DbStrDup(db, pStep->zTarget);
-  pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
+  pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); 
   assert( pSrc==0 || pSrc->nSrc==1 );
   assert( zName || pSrc==0 );
   if( pSrc ){
@@ -142003,7 +142003,7 @@ static int codeTriggerProgram(
           sqlite3TriggerStepSrc(pParse, pStep),
           sqlite3ExprListDup(db, pStep->pExprList, 0),
           sqlite3ExprDup(db, pStep->pWhere, 0),
-          pParse->eOrconf, 0, 0, 0
+          pParse->eOrconf, 0, 0, 0 
         );
         sqlite3VdbeAddOp0(v, OP_ResetCount);
         break;
@@ -142013,8 +142013,8 @@ static int codeTriggerProgram(
           sqlite3TriggerStepSrc(pParse, pStep),
           sqlite3SelectDup(db, pStep->pSelect, 0),
           sqlite3IdListDup(db, pStep->pIdList),
-          pParse->eOrconf,
-          sqlite3UpsertDup(db, pStep->pUpsert)
+          pParse->eOrconf, 
+          sqlite3UpsertDup(db, pStep->pUpsert) 
         );
         sqlite3VdbeAddOp0(v, OP_ResetCount);
         break;
@@ -142126,7 +142126,7 @@ static TriggerPrg *codeRowTrigger(
   pSubParse->zAuthContext = pTrigger->zName;
   pSubParse->eTriggerOp = pTrigger->op;
   pSubParse->nQueryLoop = pParse->nQueryLoop;
-  pSubParse->disableVtab = pParse->disableVtab;
+  pSubParse->disableVtab = pParse->disableVtab; 
 
   v = sqlite3GetVdbe(pSubParse);
   if( v ){
@@ -142154,7 +142154,7 @@ static TriggerPrg *codeRowTrigger(
       if( db->mallocFailed==0
        && SQLITE_OK==sqlite3ResolveExprNames(&sNC, pWhen)
       ){
-        iEndTrigger = sqlite3VdbeMakeLabel(pSubParse);
+        iEndTrigger = sqlite3VdbeMakeLabel(pSubParse); 
         sqlite3ExprIfFalse(pSubParse, pWhen, iEndTrigger, SQLITE_JUMPIFNULL);
       }
       sqlite3ExprDelete(db, pWhen);
@@ -142492,57 +142492,57 @@ SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
 }
 
 /*
-** Check to see if column iCol of index pIdx references any of the
-** columns defined by aXRef and chngRowid.  Return true if it does
-** and false if not.  This is an optimization.  False-positives are a
-** performance degradation, but false-negatives can result in a corrupt
-** index and incorrect answers.
-**
-** aXRef[j] will be non-negative if column j of the original table is
-** being updated.  chngRowid will be true if the rowid of the table is
-** being updated.
-*/
-static int indexColumnIsBeingUpdated(
-  Index *pIdx,      /* The index to check */
-  int iCol,         /* Which column of the index to check */
-  int *aXRef,       /* aXRef[j]>=0 if column j is being updated */
-  int chngRowid     /* true if the rowid is being updated */
-){
-  i16 iIdxCol = pIdx->aiColumn[iCol];
-  assert( iIdxCol!=XN_ROWID ); /* Cannot index rowid */
-  if( iIdxCol>=0 ){
-    return aXRef[iIdxCol]>=0;
-  }
-  assert( iIdxCol==XN_EXPR );
-  assert( pIdx->aColExpr!=0 );
-  assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
-  return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr,
-                                            aXRef,chngRowid);
-}
-
-/*
-** Check to see if index pIdx is a partial index whose conditional
-** expression might change values due to an UPDATE.  Return true if
-** the index is subject to change and false if the index is guaranteed
-** to be unchanged.  This is an optimization.  False-positives are a
-** performance degradation, but false-negatives can result in a corrupt
-** index and incorrect answers.
-**
-** aXRef[j] will be non-negative if column j of the original table is
-** being updated.  chngRowid will be true if the rowid of the table is
-** being updated.
-*/
-static int indexWhereClauseMightChange(
-  Index *pIdx,      /* The index to check */
-  int *aXRef,       /* aXRef[j]>=0 if column j is being updated */
-  int chngRowid     /* true if the rowid is being updated */
-){
-  if( pIdx->pPartIdxWhere==0 ) return 0;
-  return sqlite3ExprReferencesUpdatedColumn(pIdx->pPartIdxWhere,
-                                            aXRef, chngRowid);
-}
-
-/*
+** Check to see if column iCol of index pIdx references any of the 
+** columns defined by aXRef and chngRowid.  Return true if it does 
+** and false if not.  This is an optimization.  False-positives are a 
+** performance degradation, but false-negatives can result in a corrupt 
+** index and incorrect answers. 
+** 
+** aXRef[j] will be non-negative if column j of the original table is 
+** being updated.  chngRowid will be true if the rowid of the table is 
+** being updated. 
+*/ 
+static int indexColumnIsBeingUpdated( 
+  Index *pIdx,      /* The index to check */ 
+  int iCol,         /* Which column of the index to check */ 
+  int *aXRef,       /* aXRef[j]>=0 if column j is being updated */ 
+  int chngRowid     /* true if the rowid is being updated */ 
+){ 
+  i16 iIdxCol = pIdx->aiColumn[iCol]; 
+  assert( iIdxCol!=XN_ROWID ); /* Cannot index rowid */ 
+  if( iIdxCol>=0 ){ 
+    return aXRef[iIdxCol]>=0; 
+  } 
+  assert( iIdxCol==XN_EXPR ); 
+  assert( pIdx->aColExpr!=0 ); 
+  assert( pIdx->aColExpr->a[iCol].pExpr!=0 ); 
+  return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr, 
+                                            aXRef,chngRowid); 
+} 
+ 
+/* 
+** Check to see if index pIdx is a partial index whose conditional 
+** expression might change values due to an UPDATE.  Return true if 
+** the index is subject to change and false if the index is guaranteed 
+** to be unchanged.  This is an optimization.  False-positives are a 
+** performance degradation, but false-negatives can result in a corrupt 
+** index and incorrect answers. 
+** 
+** aXRef[j] will be non-negative if column j of the original table is 
+** being updated.  chngRowid will be true if the rowid of the table is 
+** being updated. 
+*/ 
+static int indexWhereClauseMightChange( 
+  Index *pIdx,      /* The index to check */ 
+  int *aXRef,       /* aXRef[j]>=0 if column j is being updated */ 
+  int chngRowid     /* true if the rowid is being updated */ 
+){ 
+  if( pIdx->pPartIdxWhere==0 ) return 0; 
+  return sqlite3ExprReferencesUpdatedColumn(pIdx->pPartIdxWhere, 
+                                            aXRef, chngRowid); 
+} 
+ 
+/* 
 ** Allocate and return a pointer to an expression of type TK_ROW with
 ** Expr.iColumn set to value (iCol+1). The resolver will modify the
 ** expression to be a TK_COLUMN reading column iCol of the first
@@ -142696,8 +142696,8 @@ SQLITE_PRIVATE void sqlite3Update(
   Expr *pWhere,          /* The WHERE clause.  May be null */
   int onError,           /* How to handle constraint errors */
   ExprList *pOrderBy,    /* ORDER BY clause. May be null */
-  Expr *pLimit,          /* LIMIT clause. May be null */
-  Upsert *pUpsert        /* ON CONFLICT clause, or null */
+  Expr *pLimit,          /* LIMIT clause. May be null */ 
+  Upsert *pUpsert        /* ON CONFLICT clause, or null */ 
 ){
   int i, j, k;           /* Loop counters */
   Table *pTab;           /* The table to be updated */
@@ -142707,12 +142707,12 @@ SQLITE_PRIVATE void sqlite3Update(
   Index *pIdx;           /* For looping over indices */
   Index *pPk;            /* The PRIMARY KEY index for WITHOUT ROWID tables */
   int nIdx;              /* Number of indices that need updating */
-  int nAllIdx;           /* Total number of indexes */
+  int nAllIdx;           /* Total number of indexes */ 
   int iBaseCur;          /* Base cursor number */
   int iDataCur;          /* Cursor for the canonical data btree */
   int iIdxCur;           /* Cursor for the first index */
   sqlite3 *db;           /* The database structure */
-  int *aRegIdx = 0;      /* Registers for to each index and the main table */
+  int *aRegIdx = 0;      /* Registers for to each index and the main table */ 
   int *aXRef = 0;        /* aXRef[i] is the index in pChanges->a[] of the
                          ** an expression for the i-th column of the table.
                          ** aXRef[i]==-1 if the i-th column is not changed. */
@@ -142814,31 +142814,31 @@ SQLITE_PRIVATE void sqlite3Update(
   ** need to occur right after the database cursor.  So go ahead and
   ** allocate enough space, just in case.
   */
-  iBaseCur = iDataCur = pParse->nTab++;
+  iBaseCur = iDataCur = pParse->nTab++; 
   iIdxCur = iDataCur+1;
   pPk = HasRowid(pTab) ? 0 : sqlite3PrimaryKeyIndex(pTab);
-  testcase( pPk!=0 && pPk!=pTab->pIndex );
+  testcase( pPk!=0 && pPk!=pTab->pIndex ); 
   for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
-    if( pPk==pIdx ){
+    if( pPk==pIdx ){ 
       iDataCur = pParse->nTab;
     }
     pParse->nTab++;
   }
-  if( pUpsert ){
-    /* On an UPSERT, reuse the same cursors already opened by INSERT */
-    iDataCur = pUpsert->iDataCur;
-    iIdxCur = pUpsert->iIdxCur;
-    pParse->nTab = iBaseCur;
-  }
-  pTabList->a[0].iCursor = iDataCur;
+  if( pUpsert ){ 
+    /* On an UPSERT, reuse the same cursors already opened by INSERT */ 
+    iDataCur = pUpsert->iDataCur; 
+    iIdxCur = pUpsert->iIdxCur; 
+    pParse->nTab = iBaseCur; 
+  } 
+  pTabList->a[0].iCursor = iDataCur; 
 
   /* Allocate space for aXRef[], aRegIdx[], and aToOpen[].
   ** Initialize aXRef[] and aToOpen[] to their default values.
   */
-  aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx+1) + nIdx+2 );
+  aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx+1) + nIdx+2 ); 
   if( aXRef==0 ) goto update_cleanup;
   aRegIdx = aXRef+pTab->nCol;
-  aToOpen = (u8*)(aRegIdx+nIdx+1);
+  aToOpen = (u8*)(aRegIdx+nIdx+1); 
   memset(aToOpen, 1, nIdx+1);
   aToOpen[nIdx+1] = 0;
   for(i=0; i<pTab->nCol; i++) aXRef[i] = -1;
@@ -142847,8 +142847,8 @@ SQLITE_PRIVATE void sqlite3Update(
   memset(&sNC, 0, sizeof(sNC));
   sNC.pParse = pParse;
   sNC.pSrcList = pTabList;
-  sNC.uNC.pUpsert = pUpsert;
-  sNC.ncFlags = NC_UUpsert;
+  sNC.uNC.pUpsert = pUpsert; 
+  sNC.ncFlags = NC_UUpsert; 
 
   /* Begin generating code. */
   v = sqlite3GetVdbe(pParse);
@@ -142966,31 +142966,31 @@ SQLITE_PRIVATE void sqlite3Update(
   ** being updated.  Fill in aRegIdx[] with a register number that will hold
   ** the key for accessing each index.
   */
-  if( onError==OE_Replace ) bReplace = 1;
-  for(nAllIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nAllIdx++){
+  if( onError==OE_Replace ) bReplace = 1; 
+  for(nAllIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nAllIdx++){ 
     int reg;
-    if( chngKey || hasFK>1 || pIdx==pPk
-     || indexWhereClauseMightChange(pIdx,aXRef,chngRowid)
-    ){
+    if( chngKey || hasFK>1 || pIdx==pPk 
+     || indexWhereClauseMightChange(pIdx,aXRef,chngRowid) 
+    ){ 
       reg = ++pParse->nMem;
       pParse->nMem += pIdx->nColumn;
     }else{
       reg = 0;
       for(i=0; i<pIdx->nKeyCol; i++){
-        if( indexColumnIsBeingUpdated(pIdx, i, aXRef, chngRowid) ){
+        if( indexColumnIsBeingUpdated(pIdx, i, aXRef, chngRowid) ){ 
           reg = ++pParse->nMem;
           pParse->nMem += pIdx->nColumn;
-          if( onError==OE_Default && pIdx->onError==OE_Replace ){
+          if( onError==OE_Default && pIdx->onError==OE_Replace ){ 
             bReplace = 1;
           }
           break;
         }
       }
     }
-    if( reg==0 ) aToOpen[nAllIdx+1] = 0;
-    aRegIdx[nAllIdx] = reg;
+    if( reg==0 ) aToOpen[nAllIdx+1] = 0; 
+    aRegIdx[nAllIdx] = reg; 
   }
-  aRegIdx[nAllIdx] = ++pParse->nMem;  /* Register storing the table record */
+  aRegIdx[nAllIdx] = ++pParse->nMem;  /* Register storing the table record */ 
   if( bReplace ){
     /* If REPLACE conflict resolution might be invoked, open cursors on all
     ** indexes in case they are needed to delete records.  */
@@ -142998,17 +142998,17 @@ SQLITE_PRIVATE void sqlite3Update(
   }
 
   if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
-  sqlite3BeginWriteOperation(pParse, pTrigger || hasFK, iDb);
+  sqlite3BeginWriteOperation(pParse, pTrigger || hasFK, iDb); 
 
   /* Allocate required registers. */
   if( !IsVirtual(pTab) ){
-    /* For now, regRowSet and aRegIdx[nAllIdx] share the same register.
-    ** If regRowSet turns out to be needed, then aRegIdx[nAllIdx] will be
-    ** reallocated.  aRegIdx[nAllIdx] is the register in which the main
-    ** table record is written.  regRowSet holds the RowSet for the
-    ** two-pass update algorithm. */
-    assert( aRegIdx[nAllIdx]==pParse->nMem );
-    regRowSet = aRegIdx[nAllIdx];
+    /* For now, regRowSet and aRegIdx[nAllIdx] share the same register. 
+    ** If regRowSet turns out to be needed, then aRegIdx[nAllIdx] will be 
+    ** reallocated.  aRegIdx[nAllIdx] is the register in which the main 
+    ** table record is written.  regRowSet holds the RowSet for the 
+    ** two-pass update algorithm. */ 
+    assert( aRegIdx[nAllIdx]==pParse->nMem ); 
+    regRowSet = aRegIdx[nAllIdx]; 
     regOldRowid = regNewRowid = ++pParse->nMem;
     if( chngPk || pTrigger || hasFK ){
       regOld = pParse->nMem + 1;
@@ -143055,17 +143055,17 @@ SQLITE_PRIVATE void sqlite3Update(
   }
 #endif
 
-  /* Jump to labelBreak to abandon further processing of this UPDATE */
-  labelContinue = labelBreak = sqlite3VdbeMakeLabel(pParse);
-
-  /* Not an UPSERT.  Normal processing.  Begin by
-  ** initialize the count of updated rows */
-  if( (db->flags&SQLITE_CountRows)!=0
-   && !pParse->pTriggerTab
-   && !pParse->nested
+  /* Jump to labelBreak to abandon further processing of this UPDATE */ 
+  labelContinue = labelBreak = sqlite3VdbeMakeLabel(pParse); 
+ 
+  /* Not an UPSERT.  Normal processing.  Begin by 
+  ** initialize the count of updated rows */ 
+  if( (db->flags&SQLITE_CountRows)!=0 
+   && !pParse->pTriggerTab 
+   && !pParse->nested 
    && !pParse->bReturning
-   && pUpsert==0
-  ){
+   && pUpsert==0 
+  ){ 
     regRowCount = ++pParse->nMem;
     sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
   }
@@ -143081,9 +143081,9 @@ SQLITE_PRIVATE void sqlite3Update(
     pParse->nMem += nPk;
     pParse->nMem += nChangeFrom;
     regKey = ++pParse->nMem;
-    if( pUpsert==0 ){
+    if( pUpsert==0 ){ 
       int nEphCol = nPk + nChangeFrom + (isView ? pTab->nCol : 0);
-      iEph = pParse->nTab++;
+      iEph = pParse->nTab++; 
       if( pPk ) sqlite3VdbeAddOp3(v, OP_Null, 0, iPk, iPk+nPk-1);
       addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nEphCol);
       if( pPk ){
@@ -143101,7 +143101,7 @@ SQLITE_PRIVATE void sqlite3Update(
         if( isView ) iDataCur = iEph;
 #endif
       }
-    }
+    } 
   }
 
   if( nChangeFrom ){
@@ -143109,7 +143109,7 @@ SQLITE_PRIVATE void sqlite3Update(
     eOnePass = ONEPASS_OFF;
     nKey = nPk;
     regKey = iPk;
-  }else{
+  }else{ 
     if( pUpsert ){
       /* If this is an UPSERT, then all cursors have already been opened by
       ** the outer INSERT and the data cursor should be pointing at the row
@@ -143155,9 +143155,9 @@ SQLITE_PRIVATE void sqlite3Update(
             eOnePass = ONEPASS_OFF;
           }
           assert( iCur!=iDataCur || !HasRowid(pTab) );
-        }
-      }
-    }
+        } 
+      } 
+    } 
 
     if( HasRowid(pTab) ){
       /* Read the rowid of the current row of the WHERE scan. In ONEPASS_OFF
@@ -143193,51 +143193,51 @@ SQLITE_PRIVATE void sqlite3Update(
     }
   }
 
-  if( pUpsert==0 ){
+  if( pUpsert==0 ){ 
     if( nChangeFrom==0 && eOnePass!=ONEPASS_MULTI ){
-      sqlite3WhereEnd(pWInfo);
+      sqlite3WhereEnd(pWInfo); 
     }
 
-    if( !isView ){
-      int addrOnce = 0;
+    if( !isView ){ 
+      int addrOnce = 0; 
 
-      /* Open every index that needs updating. */
-      if( eOnePass!=ONEPASS_OFF ){
-        if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0;
-        if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0;
-      }
+      /* Open every index that needs updating. */ 
+      if( eOnePass!=ONEPASS_OFF ){ 
+        if( aiCurOnePass[0]>=0 ) aToOpen[aiCurOnePass[0]-iBaseCur] = 0; 
+        if( aiCurOnePass[1]>=0 ) aToOpen[aiCurOnePass[1]-iBaseCur] = 0; 
+      } 
 
-      if( eOnePass==ONEPASS_MULTI && (nIdx-(aiCurOnePass[1]>=0))>0 ){
-        addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
-      }
-      sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, iBaseCur,
-                                 aToOpen, 0, 0);
+      if( eOnePass==ONEPASS_MULTI && (nIdx-(aiCurOnePass[1]>=0))>0 ){ 
+        addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v); 
+      } 
+      sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, iBaseCur, 
+                                 aToOpen, 0, 0); 
       if( addrOnce ){
         sqlite3VdbeJumpHereOrPopInst(v, addrOnce);
       }
     }
 
-    /* Top of the update loop */
-    if( eOnePass!=ONEPASS_OFF ){
+    /* Top of the update loop */ 
+    if( eOnePass!=ONEPASS_OFF ){ 
       if( aiCurOnePass[0]!=iDataCur
        && aiCurOnePass[1]!=iDataCur
 #ifdef SQLITE_ALLOW_ROWID_IN_VIEW
        && !isView
 #endif
       ){
-        assert( pPk );
-        sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey,nKey);
-        VdbeCoverage(v);
-      }
-      if( eOnePass!=ONEPASS_SINGLE ){
-        labelContinue = sqlite3VdbeMakeLabel(pParse);
-      }
-      sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak);
-      VdbeCoverageIf(v, pPk==0);
-      VdbeCoverageIf(v, pPk!=0);
+        assert( pPk ); 
+        sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey,nKey); 
+        VdbeCoverage(v); 
+      } 
+      if( eOnePass!=ONEPASS_SINGLE ){ 
+        labelContinue = sqlite3VdbeMakeLabel(pParse); 
+      } 
+      sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak); 
+      VdbeCoverageIf(v, pPk==0); 
+      VdbeCoverageIf(v, pPk!=0); 
     }else if( pPk || nChangeFrom ){
-      labelContinue = sqlite3VdbeMakeLabel(pParse);
-      sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v);
+      labelContinue = sqlite3VdbeMakeLabel(pParse); 
+      sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v); 
       addrTop = sqlite3VdbeCurrentAddr(v);
       if( nChangeFrom ){
         if( !isView ){
@@ -143264,14 +143264,14 @@ SQLITE_PRIVATE void sqlite3Update(
       sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v);
       labelContinue = sqlite3VdbeMakeLabel(pParse);
       addrTop = sqlite3VdbeAddOp2(v, OP_Rowid, iEph, regOldRowid);
-      VdbeCoverage(v);
-      sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid);
-      VdbeCoverage(v);
+      VdbeCoverage(v); 
+      sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid); 
+      VdbeCoverage(v); 
     }
   }
 
-  /* If the rowid value will change, set register regNewRowid to
-  ** contain the new value. If the rowid is not being modified,
+  /* If the rowid value will change, set register regNewRowid to 
+  ** contain the new value. If the rowid is not being modified, 
   ** then regNewRowid is the same register as regOldRowid, which is
   ** already populated.  */
   assert( chngKey || pTrigger || hasFK || regOldRowid==regNewRowid );
@@ -143418,7 +143418,7 @@ SQLITE_PRIVATE void sqlite3Update(
     assert( regOldRowid>0 );
     sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
         regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace,
-        aXRef, 0);
+        aXRef, 0); 
 
     /* If REPLACE conflict handling may have been used, or if the PK of the
     ** row is changing, then the GenerateConstraintChecks() above may have
@@ -143498,7 +143498,7 @@ SQLITE_PRIVATE void sqlite3Update(
 
   /* Increment the row counter
   */
-  if( regRowCount ){
+  if( regRowCount ){ 
     sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
   }
 
@@ -143523,15 +143523,15 @@ SQLITE_PRIVATE void sqlite3Update(
   ** maximum rowid counter values recorded while inserting into
   ** autoincrement tables.
   */
-  if( pParse->nested==0 && pParse->pTriggerTab==0 && pUpsert==0 ){
+  if( pParse->nested==0 && pParse->pTriggerTab==0 && pUpsert==0 ){ 
     sqlite3AutoincrementEnd(pParse);
   }
 
   /*
-  ** Return the number of rows that were changed, if we are tracking
-  ** that information.
+  ** Return the number of rows that were changed, if we are tracking 
+  ** that information. 
   */
-  if( regRowCount ){
+  if( regRowCount ){ 
     sqlite3VdbeAddOp2(v, OP_ChngCntRow, regRowCount, 1);
     sqlite3VdbeSetNumCols(v, 1);
     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC);
@@ -143603,7 +143603,7 @@ static void updateVirtualTable(
   int regRowid;                   /* Register for ephem table rowid */
   int iCsr = pSrc->a[0].iCursor;  /* Cursor used for virtual table scan */
   int aDummy[2];                  /* Unused arg for sqlite3WhereOkOnePass() */
-  int eOnePass;                   /* True to use onepass strategy */
+  int eOnePass;                   /* True to use onepass strategy */ 
   int addr;                       /* Address of OP_OpenEphemeral */
 
   /* Allocate nArg registers in which to gather the arguments for VUpdate. Then
@@ -143691,7 +143691,7 @@ static void updateVirtualTable(
 
     /* There is no ONEPASS_MULTI on virtual tables */
     assert( eOnePass==ONEPASS_OFF || eOnePass==ONEPASS_SINGLE );
-
+ 
     if( eOnePass ){
       /* If using the onepass strategy, no-op out the OP_OpenEphemeral coded
       ** above. */
@@ -143713,7 +143713,7 @@ static void updateVirtualTable(
   }
 
 
-  if( eOnePass==ONEPASS_OFF ){
+  if( eOnePass==ONEPASS_OFF ){ 
     /* End the virtual table scan */
     if( pSrc->nSrc==1 ){
       sqlite3WhereEnd(pWInfo);
@@ -143735,7 +143735,7 @@ static void updateVirtualTable(
 
   /* End of the ephemeral table scan. Or, if using the onepass strategy,
   ** jump to here if the scan visited zero rows. */
-  if( eOnePass==ONEPASS_OFF ){
+  if( eOnePass==ONEPASS_OFF ){ 
     sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1); VdbeCoverage(v);
     sqlite3VdbeJumpHere(v, addr);
     sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0);
@@ -143746,130 +143746,130 @@ static void updateVirtualTable(
 #endif /* SQLITE_OMIT_VIRTUALTABLE */
 
 /************** End of update.c **********************************************/
-/************** Begin file upsert.c ******************************************/
-/*
-** 2018-04-12
-**
-** 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 code to implement various aspects of UPSERT
-** processing and handling of the Upsert object.
-*/
-/* #include "sqliteInt.h" */
-
-#ifndef SQLITE_OMIT_UPSERT
-/*
-** Free a list of Upsert objects
-*/
+/************** Begin file upsert.c ******************************************/ 
+/* 
+** 2018-04-12 
+** 
+** 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 code to implement various aspects of UPSERT 
+** processing and handling of the Upsert object. 
+*/ 
+/* #include "sqliteInt.h" */ 
+ 
+#ifndef SQLITE_OMIT_UPSERT 
+/* 
+** Free a list of Upsert objects 
+*/ 
 static void SQLITE_NOINLINE upsertDelete(sqlite3 *db, Upsert *p){
   do{
     Upsert *pNext = p->pNextUpsert;
-    sqlite3ExprListDelete(db, p->pUpsertTarget);
-    sqlite3ExprDelete(db, p->pUpsertTargetWhere);
-    sqlite3ExprListDelete(db, p->pUpsertSet);
-    sqlite3ExprDelete(db, p->pUpsertWhere);
+    sqlite3ExprListDelete(db, p->pUpsertTarget); 
+    sqlite3ExprDelete(db, p->pUpsertTargetWhere); 
+    sqlite3ExprListDelete(db, p->pUpsertSet); 
+    sqlite3ExprDelete(db, p->pUpsertWhere); 
     sqlite3DbFree(db, p->pToFree);
-    sqlite3DbFree(db, p);
+    sqlite3DbFree(db, p); 
     p = pNext;
   }while( p );
-}
+} 
 SQLITE_PRIVATE void sqlite3UpsertDelete(sqlite3 *db, Upsert *p){
   if( p ) upsertDelete(db, p);
 }
-
-
-/*
-** Duplicate an Upsert object.
-*/
-SQLITE_PRIVATE Upsert *sqlite3UpsertDup(sqlite3 *db, Upsert *p){
-  if( p==0 ) return 0;
-  return sqlite3UpsertNew(db,
-           sqlite3ExprListDup(db, p->pUpsertTarget, 0),
-           sqlite3ExprDup(db, p->pUpsertTargetWhere, 0),
-           sqlite3ExprListDup(db, p->pUpsertSet, 0),
+ 
+
+/* 
+** Duplicate an Upsert object. 
+*/ 
+SQLITE_PRIVATE Upsert *sqlite3UpsertDup(sqlite3 *db, Upsert *p){ 
+  if( p==0 ) return 0; 
+  return sqlite3UpsertNew(db, 
+           sqlite3ExprListDup(db, p->pUpsertTarget, 0), 
+           sqlite3ExprDup(db, p->pUpsertTargetWhere, 0), 
+           sqlite3ExprListDup(db, p->pUpsertSet, 0), 
            sqlite3ExprDup(db, p->pUpsertWhere, 0),
            sqlite3UpsertDup(db, p->pNextUpsert)
-         );
-}
-
-/*
-** Create a new Upsert object.
-*/
-SQLITE_PRIVATE Upsert *sqlite3UpsertNew(
-  sqlite3 *db,           /* Determines which memory allocator to use */
-  ExprList *pTarget,     /* Target argument to ON CONFLICT, or NULL */
-  Expr *pTargetWhere,    /* Optional WHERE clause on the target */
-  ExprList *pSet,        /* UPDATE columns, or NULL for a DO NOTHING */
+         ); 
+} 
+ 
+/* 
+** Create a new Upsert object. 
+*/ 
+SQLITE_PRIVATE Upsert *sqlite3UpsertNew( 
+  sqlite3 *db,           /* Determines which memory allocator to use */ 
+  ExprList *pTarget,     /* Target argument to ON CONFLICT, or NULL */ 
+  Expr *pTargetWhere,    /* Optional WHERE clause on the target */ 
+  ExprList *pSet,        /* UPDATE columns, or NULL for a DO NOTHING */ 
   Expr *pWhere,          /* WHERE clause for the ON CONFLICT UPDATE */
   Upsert *pNext          /* Next ON CONFLICT clause in the list */
-){
-  Upsert *pNew;
+){ 
+  Upsert *pNew; 
   pNew = sqlite3DbMallocZero(db, sizeof(Upsert));
-  if( pNew==0 ){
-    sqlite3ExprListDelete(db, pTarget);
-    sqlite3ExprDelete(db, pTargetWhere);
-    sqlite3ExprListDelete(db, pSet);
-    sqlite3ExprDelete(db, pWhere);
+  if( pNew==0 ){ 
+    sqlite3ExprListDelete(db, pTarget); 
+    sqlite3ExprDelete(db, pTargetWhere); 
+    sqlite3ExprListDelete(db, pSet); 
+    sqlite3ExprDelete(db, pWhere); 
     sqlite3UpsertDelete(db, pNext);
-    return 0;
-  }else{
-    pNew->pUpsertTarget = pTarget;
-    pNew->pUpsertTargetWhere = pTargetWhere;
-    pNew->pUpsertSet = pSet;
-    pNew->pUpsertWhere = pWhere;
+    return 0; 
+  }else{ 
+    pNew->pUpsertTarget = pTarget; 
+    pNew->pUpsertTargetWhere = pTargetWhere; 
+    pNew->pUpsertSet = pSet; 
+    pNew->pUpsertWhere = pWhere; 
     pNew->isDoUpdate = pSet!=0;
     pNew->pNextUpsert = pNext;
-  }
-  return pNew;
-}
-
-/*
-** Analyze the ON CONFLICT clause described by pUpsert.  Resolve all
-** symbols in the conflict-target.
-**
-** Return SQLITE_OK if everything works, or an error code is something
-** is wrong.
-*/
-SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget(
-  Parse *pParse,     /* The parsing context */
-  SrcList *pTabList, /* Table into which we are inserting */
-  Upsert *pUpsert    /* The ON CONFLICT clauses */
-){
-  Table *pTab;            /* That table into which we are inserting */
-  int rc;                 /* Result code */
-  int iCursor;            /* Cursor used by pTab */
-  Index *pIdx;            /* One of the indexes of pTab */
-  ExprList *pTarget;      /* The conflict-target clause */
-  Expr *pTerm;            /* One term of the conflict-target clause */
-  NameContext sNC;        /* Context for resolving symbolic names */
-  Expr sCol[2];           /* Index column converted into an Expr */
+  } 
+  return pNew; 
+} 
+ 
+/* 
+** Analyze the ON CONFLICT clause described by pUpsert.  Resolve all 
+** symbols in the conflict-target. 
+** 
+** Return SQLITE_OK if everything works, or an error code is something 
+** is wrong. 
+*/ 
+SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget( 
+  Parse *pParse,     /* The parsing context */ 
+  SrcList *pTabList, /* Table into which we are inserting */ 
+  Upsert *pUpsert    /* The ON CONFLICT clauses */ 
+){ 
+  Table *pTab;            /* That table into which we are inserting */ 
+  int rc;                 /* Result code */ 
+  int iCursor;            /* Cursor used by pTab */ 
+  Index *pIdx;            /* One of the indexes of pTab */ 
+  ExprList *pTarget;      /* The conflict-target clause */ 
+  Expr *pTerm;            /* One term of the conflict-target clause */ 
+  NameContext sNC;        /* Context for resolving symbolic names */ 
+  Expr sCol[2];           /* Index column converted into an Expr */ 
   int nClause = 0;        /* Counter of ON CONFLICT clauses */
-
-  assert( pTabList->nSrc==1 );
-  assert( pTabList->a[0].pTab!=0 );
-  assert( pUpsert!=0 );
-  assert( pUpsert->pUpsertTarget!=0 );
-
-  /* Resolve all symbolic names in the conflict-target clause, which
-  ** includes both the list of columns and the optional partial-index
-  ** WHERE clause.
-  */
-  memset(&sNC, 0, sizeof(sNC));
-  sNC.pParse = pParse;
-  sNC.pSrcList = pTabList;
+ 
+  assert( pTabList->nSrc==1 ); 
+  assert( pTabList->a[0].pTab!=0 ); 
+  assert( pUpsert!=0 ); 
+  assert( pUpsert->pUpsertTarget!=0 ); 
+ 
+  /* Resolve all symbolic names in the conflict-target clause, which 
+  ** includes both the list of columns and the optional partial-index 
+  ** WHERE clause. 
+  */ 
+  memset(&sNC, 0, sizeof(sNC)); 
+  sNC.pParse = pParse; 
+  sNC.pSrcList = pTabList; 
   for(; pUpsert && pUpsert->pUpsertTarget;
         pUpsert=pUpsert->pNextUpsert, nClause++){
     rc = sqlite3ResolveExprListNames(&sNC, pUpsert->pUpsertTarget);
     if( rc ) return rc;
     rc = sqlite3ResolveExprNames(&sNC, pUpsert->pUpsertTargetWhere);
     if( rc ) return rc;
-
+ 
     /* Check to see if the conflict target matches the rowid. */
     pTab = pTabList->a[0].pTab;
     pTarget = pUpsert->pUpsertTarget;
@@ -143883,7 +143883,7 @@ SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget(
       assert( pUpsert->pUpsertIdx==0 );
       continue;
     }
-
+ 
     /* Initialize sCol[0..1] to be an expression parse tree for a
     ** single column of an index.  The sCol[0] node will be the TK_COLLATE
     ** operator and sCol[1] will be the TK_COLUMN operator.  Code below
@@ -143895,7 +143895,7 @@ SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget(
     sCol[0].pLeft = &sCol[1];
     sCol[1].op = TK_COLUMN;
     sCol[1].iTable = pTabList->a[0].iCursor;
-
+ 
     /* Check for matches against other indexes */
     for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
       int ii, jj, nn;
@@ -143907,7 +143907,7 @@ SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget(
                                pIdx->pPartIdxWhere, iCursor)!=0 ){
           continue;
         }
-      }
+      } 
       nn = pIdx->nKeyCol;
       for(ii=0; ii<nn; ii++){
         Expr *pExpr;
@@ -143923,26 +143923,26 @@ SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget(
         }else{
           sCol[0].pLeft = &sCol[1];
           sCol[1].iColumn = pIdx->aiColumn[ii];
-          pExpr = &sCol[0];
-        }
+          pExpr = &sCol[0]; 
+        } 
         for(jj=0; jj<nn; jj++){
           if( sqlite3ExprCompare(pParse,pTarget->a[jj].pExpr,pExpr,iCursor)<2 ){
             break;  /* Column ii of the index matches column jj of target */
           }
-        }
+        } 
         if( jj>=nn ){
           /* The target contains no match for column jj of the index */
           break;
         }
-      }
+      } 
       if( ii<nn ){
         /* Column ii of the index did not match any term of the conflict target.
         ** Continue the search with the next index. */
         continue;
-      }
+      } 
       pUpsert->pUpsertIdx = pIdx;
       break;
-    }
+    } 
     if( pUpsert->pUpsertIdx==0 ){
       char zWhich[16];
       if( nClause==0 && pUpsert->pNextUpsert==0 ){
@@ -143953,12 +143953,12 @@ SQLITE_PRIVATE int sqlite3UpsertAnalyzeTarget(
       sqlite3ErrorMsg(pParse, "%sON CONFLICT clause does not match any "
                               "PRIMARY KEY or UNIQUE constraint", zWhich);
       return SQLITE_ERROR;
-    }
-  }
+    } 
+  } 
   return SQLITE_OK;
-}
-
-/*
+} 
+ 
+/* 
 ** Return true if pUpsert is the last ON CONFLICT clause with a
 ** conflict target, or if pUpsert is followed by another ON CONFLICT
 ** clause that targets the INTEGER PRIMARY KEY.
@@ -143991,62 +143991,62 @@ SQLITE_PRIVATE Upsert *sqlite3UpsertOfIndex(Upsert *pUpsert, Index *pIdx){
 }
 
 /*
-** Generate bytecode that does an UPDATE as part of an upsert.
-**
-** If pIdx is NULL, then the UNIQUE constraint that failed was the IPK.
-** In this case parameter iCur is a cursor open on the table b-tree that
-** currently points to the conflicting table row. Otherwise, if pIdx
-** is not NULL, then pIdx is the constraint that failed and iCur is a
-** cursor points to the conflicting row.
-*/
-SQLITE_PRIVATE void sqlite3UpsertDoUpdate(
-  Parse *pParse,        /* The parsing and code-generating context */
-  Upsert *pUpsert,      /* The ON CONFLICT clause for the upsert */
-  Table *pTab,          /* The table being updated */
-  Index *pIdx,          /* The UNIQUE constraint that failed */
-  int iCur              /* Cursor for pIdx (or pTab if pIdx==NULL) */
-){
-  Vdbe *v = pParse->pVdbe;
-  sqlite3 *db = pParse->db;
-  SrcList *pSrc;            /* FROM clause for the UPDATE */
-  int iDataCur;
+** Generate bytecode that does an UPDATE as part of an upsert. 
+** 
+** If pIdx is NULL, then the UNIQUE constraint that failed was the IPK. 
+** In this case parameter iCur is a cursor open on the table b-tree that 
+** currently points to the conflicting table row. Otherwise, if pIdx 
+** is not NULL, then pIdx is the constraint that failed and iCur is a 
+** cursor points to the conflicting row. 
+*/ 
+SQLITE_PRIVATE void sqlite3UpsertDoUpdate( 
+  Parse *pParse,        /* The parsing and code-generating context */ 
+  Upsert *pUpsert,      /* The ON CONFLICT clause for the upsert */ 
+  Table *pTab,          /* The table being updated */ 
+  Index *pIdx,          /* The UNIQUE constraint that failed */ 
+  int iCur              /* Cursor for pIdx (or pTab if pIdx==NULL) */ 
+){ 
+  Vdbe *v = pParse->pVdbe; 
+  sqlite3 *db = pParse->db; 
+  SrcList *pSrc;            /* FROM clause for the UPDATE */ 
+  int iDataCur; 
   int i;
   Upsert *pTop = pUpsert;
-
-  assert( v!=0 );
-  assert( pUpsert!=0 );
+ 
+  assert( v!=0 ); 
+  assert( pUpsert!=0 ); 
   iDataCur = pUpsert->iDataCur;
   pUpsert = sqlite3UpsertOfIndex(pTop, pIdx);
-  VdbeNoopComment((v, "Begin DO UPDATE of UPSERT"));
-  if( pIdx && iCur!=iDataCur ){
-    if( HasRowid(pTab) ){
-      int regRowid = sqlite3GetTempReg(pParse);
-      sqlite3VdbeAddOp2(v, OP_IdxRowid, iCur, regRowid);
-      sqlite3VdbeAddOp3(v, OP_SeekRowid, iDataCur, 0, regRowid);
-      VdbeCoverage(v);
-      sqlite3ReleaseTempReg(pParse, regRowid);
-    }else{
-      Index *pPk = sqlite3PrimaryKeyIndex(pTab);
-      int nPk = pPk->nKeyCol;
-      int iPk = pParse->nMem+1;
-      pParse->nMem += nPk;
-      for(i=0; i<nPk; i++){
-        int k;
-        assert( pPk->aiColumn[i]>=0 );
+  VdbeNoopComment((v, "Begin DO UPDATE of UPSERT")); 
+  if( pIdx && iCur!=iDataCur ){ 
+    if( HasRowid(pTab) ){ 
+      int regRowid = sqlite3GetTempReg(pParse); 
+      sqlite3VdbeAddOp2(v, OP_IdxRowid, iCur, regRowid); 
+      sqlite3VdbeAddOp3(v, OP_SeekRowid, iDataCur, 0, regRowid); 
+      VdbeCoverage(v); 
+      sqlite3ReleaseTempReg(pParse, regRowid); 
+    }else{ 
+      Index *pPk = sqlite3PrimaryKeyIndex(pTab); 
+      int nPk = pPk->nKeyCol; 
+      int iPk = pParse->nMem+1; 
+      pParse->nMem += nPk; 
+      for(i=0; i<nPk; i++){ 
+        int k; 
+        assert( pPk->aiColumn[i]>=0 ); 
         k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[i]);
-        sqlite3VdbeAddOp3(v, OP_Column, iCur, k, iPk+i);
-        VdbeComment((v, "%s.%s", pIdx->zName,
+        sqlite3VdbeAddOp3(v, OP_Column, iCur, k, iPk+i); 
+        VdbeComment((v, "%s.%s", pIdx->zName, 
                     pTab->aCol[pPk->aiColumn[i]].zCnName));
-      }
-      sqlite3VdbeVerifyAbortable(v, OE_Abort);
-      i = sqlite3VdbeAddOp4Int(v, OP_Found, iDataCur, 0, iPk, nPk);
-      VdbeCoverage(v);
+      } 
+      sqlite3VdbeVerifyAbortable(v, OE_Abort); 
+      i = sqlite3VdbeAddOp4Int(v, OP_Found, iDataCur, 0, iPk, nPk); 
+      VdbeCoverage(v); 
       sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CORRUPT, OE_Abort, 0,
-            "corrupt database", P4_STATIC);
+            "corrupt database", P4_STATIC); 
       sqlite3MayAbort(pParse);
-      sqlite3VdbeJumpHere(v, i);
-    }
-  }
+      sqlite3VdbeJumpHere(v, i); 
+    } 
+  } 
   /* pUpsert does not own pTop->pUpsertSrc - the outer INSERT statement does.
   ** So we have to make a copy before passing it down into sqlite3Update() */
   pSrc = sqlite3SrcListDup(db, pTop->pUpsertSrc, 0);
@@ -144058,12 +144058,12 @@ SQLITE_PRIVATE void sqlite3UpsertDoUpdate(
   }
   sqlite3Update(pParse, pSrc, sqlite3ExprListDup(db,pUpsert->pUpsertSet,0),
       sqlite3ExprDup(db,pUpsert->pUpsertWhere,0), OE_Abort, 0, 0, pUpsert);
-  VdbeNoopComment((v, "End DO UPDATE of UPSERT"));
-}
-
-#endif /* SQLITE_OMIT_UPSERT */
-
-/************** End of upsert.c **********************************************/
+  VdbeNoopComment((v, "End DO UPDATE of UPSERT")); 
+} 
+ 
+#endif /* SQLITE_OMIT_UPSERT */ 
+ 
+/************** End of upsert.c **********************************************/ 
 /************** Begin file vacuum.c ******************************************/
 /*
 ** 2003 April 6
@@ -144106,14 +144106,14 @@ static int execSql(sqlite3 *db, char **pzErrMsg, const char *zSql){
   while( SQLITE_ROW==(rc = sqlite3_step(pStmt)) ){
     const char *zSubSql = (const char*)sqlite3_column_text(pStmt,0);
     assert( sqlite3_strnicmp(zSql,"SELECT",6)==0 );
-    /* The secondary SQL must be one of CREATE TABLE, CREATE INDEX,
-    ** or INSERT.  Historically there have been attacks that first
+    /* The secondary SQL must be one of CREATE TABLE, CREATE INDEX, 
+    ** or INSERT.  Historically there have been attacks that first 
     ** corrupt the sqlite_schema.sql field with other kinds of statements
-    ** then run VACUUM to get those statements to execute at inappropriate
-    ** times. */
-    if( zSubSql
-     && (strncmp(zSubSql,"CRE",3)==0 || strncmp(zSubSql,"INS",3)==0)
-    ){
+    ** then run VACUUM to get those statements to execute at inappropriate 
+    ** times. */ 
+    if( zSubSql 
+     && (strncmp(zSubSql,"CRE",3)==0 || strncmp(zSubSql,"INS",3)==0) 
+    ){ 
       rc = execSql(db, pzErrMsg, zSubSql);
       if( rc!=SQLITE_OK ) break;
     }
@@ -144169,17 +144169,17 @@ static int execSqlF(sqlite3 *db, char **pzErrMsg, const char *zSql, ...){
 ** transient would cause the database file to appear to be deleted
 ** following reboot.
 */
-SQLITE_PRIVATE void sqlite3Vacuum(Parse *pParse, Token *pNm, Expr *pInto){
+SQLITE_PRIVATE void sqlite3Vacuum(Parse *pParse, Token *pNm, Expr *pInto){ 
   Vdbe *v = sqlite3GetVdbe(pParse);
   int iDb = 0;
-  if( v==0 ) goto build_vacuum_end;
-  if( pParse->nErr ) goto build_vacuum_end;
+  if( v==0 ) goto build_vacuum_end; 
+  if( pParse->nErr ) goto build_vacuum_end; 
   if( pNm ){
 #ifndef SQLITE_BUG_COMPATIBLE_20160819
     /* Default behavior:  Report an error if the argument to VACUUM is
     ** not recognized */
     iDb = sqlite3TwoPartName(pParse, pNm, pNm, &pNm);
-    if( iDb<0 ) goto build_vacuum_end;
+    if( iDb<0 ) goto build_vacuum_end; 
 #else
     /* When SQLITE_BUG_COMPATIBLE_20160819 is defined, unrecognized arguments
     ** to VACUUM are silently ignored.  This is a back-out of a bug fix that
@@ -144191,64 +144191,64 @@ SQLITE_PRIVATE void sqlite3Vacuum(Parse *pParse, Token *pNm, Expr *pInto){
 #endif
   }
   if( iDb!=1 ){
-    int iIntoReg = 0;
-    if( pInto && sqlite3ResolveSelfReference(pParse,0,0,pInto,0)==0 ){
-      iIntoReg = ++pParse->nMem;
-      sqlite3ExprCode(pParse, pInto, iIntoReg);
-    }
-    sqlite3VdbeAddOp2(v, OP_Vacuum, iDb, iIntoReg);
+    int iIntoReg = 0; 
+    if( pInto && sqlite3ResolveSelfReference(pParse,0,0,pInto,0)==0 ){ 
+      iIntoReg = ++pParse->nMem; 
+      sqlite3ExprCode(pParse, pInto, iIntoReg); 
+    } 
+    sqlite3VdbeAddOp2(v, OP_Vacuum, iDb, iIntoReg); 
     sqlite3VdbeUsesBtree(v, iDb);
   }
-build_vacuum_end:
-  sqlite3ExprDelete(pParse->db, pInto);
+build_vacuum_end: 
+  sqlite3ExprDelete(pParse->db, pInto); 
   return;
 }
 
 /*
 ** This routine implements the OP_Vacuum opcode of the VDBE.
 */
-SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum(
-  char **pzErrMsg,        /* Write error message here */
-  sqlite3 *db,            /* Database connection */
-  int iDb,                /* Which attached DB to vacuum */
-  sqlite3_value *pOut     /* Write results here, if not NULL. VACUUM INTO */
-){
+SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum( 
+  char **pzErrMsg,        /* Write error message here */ 
+  sqlite3 *db,            /* Database connection */ 
+  int iDb,                /* Which attached DB to vacuum */ 
+  sqlite3_value *pOut     /* Write results here, if not NULL. VACUUM INTO */ 
+){ 
   int rc = SQLITE_OK;     /* Return code from service routines */
   Btree *pMain;           /* The database being vacuumed */
   Btree *pTemp;           /* The temporary database we vacuum into */
-  u32 saved_mDbFlags;     /* Saved value of db->mDbFlags */
-  u64 saved_flags;        /* Saved value of db->flags */
+  u32 saved_mDbFlags;     /* Saved value of db->mDbFlags */ 
+  u64 saved_flags;        /* Saved value of db->flags */ 
   i64 saved_nChange;      /* Saved value of db->nChange */
   i64 saved_nTotalChange; /* Saved value of db->nTotalChange */
-  u32 saved_openFlags;    /* Saved value of db->openFlags */
+  u32 saved_openFlags;    /* Saved value of db->openFlags */ 
   u8 saved_mTrace;        /* Saved trace settings */
   Db *pDb = 0;            /* Database to detach at end of vacuum */
   int isMemDb;            /* True if vacuuming a :memory: database */
   int nRes;               /* Bytes of reserved space at the end of each page */
   int nDb;                /* Number of attached databases */
   const char *zDbMain;    /* Schema name of database to vacuum */
-  const char *zOut;       /* Name of output file */
+  const char *zOut;       /* Name of output file */ 
 
   if( !db->autoCommit ){
     sqlite3SetString(pzErrMsg, db, "cannot VACUUM from within a transaction");
-    return SQLITE_ERROR; /* IMP: R-12218-18073 */
+    return SQLITE_ERROR; /* IMP: R-12218-18073 */ 
   }
   if( db->nVdbeActive>1 ){
     sqlite3SetString(pzErrMsg, db,"cannot VACUUM - SQL statements in progress");
-    return SQLITE_ERROR; /* IMP: R-15610-35227 */
-  }
-  saved_openFlags = db->openFlags;
-  if( pOut ){
-    if( sqlite3_value_type(pOut)!=SQLITE_TEXT ){
-      sqlite3SetString(pzErrMsg, db, "non-text filename");
-      return SQLITE_ERROR;
-    }
-    zOut = (const char*)sqlite3_value_text(pOut);
-    db->openFlags &= ~SQLITE_OPEN_READONLY;
-    db->openFlags |= SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE;
-  }else{
-    zOut = "";
-  }
+    return SQLITE_ERROR; /* IMP: R-15610-35227 */ 
+  }
+  saved_openFlags = db->openFlags; 
+  if( pOut ){ 
+    if( sqlite3_value_type(pOut)!=SQLITE_TEXT ){ 
+      sqlite3SetString(pzErrMsg, db, "non-text filename"); 
+      return SQLITE_ERROR; 
+    } 
+    zOut = (const char*)sqlite3_value_text(pOut); 
+    db->openFlags &= ~SQLITE_OPEN_READONLY; 
+    db->openFlags |= SQLITE_OPEN_CREATE|SQLITE_OPEN_READWRITE; 
+  }else{ 
+    zOut = ""; 
+  } 
 
   /* Save the current value of the database flags so that it can be
   ** restored before returning. Then set the writable-schema flag, and
@@ -144260,8 +144260,8 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum(
   saved_mTrace = db->mTrace;
   db->flags |= SQLITE_WriteSchema | SQLITE_IgnoreChecks;
   db->mDbFlags |= DBFLAG_PreferBuiltin | DBFLAG_Vacuum;
-  db->flags &= ~(u64)(SQLITE_ForeignKeys | SQLITE_ReverseOrder
-                   | SQLITE_Defensive | SQLITE_CountRows);
+  db->flags &= ~(u64)(SQLITE_ForeignKeys | SQLITE_ReverseOrder 
+                   | SQLITE_Defensive | SQLITE_CountRows); 
   db->mTrace = 0;
 
   zDbMain = db->aDb[iDb].zDbSName;
@@ -144283,23 +144283,23 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum(
   ** to write the journal header file.
   */
   nDb = db->nDb;
-  rc = execSqlF(db, pzErrMsg, "ATTACH %Q AS vacuum_db", zOut);
-  db->openFlags = saved_openFlags;
+  rc = execSqlF(db, pzErrMsg, "ATTACH %Q AS vacuum_db", zOut); 
+  db->openFlags = saved_openFlags; 
   if( rc!=SQLITE_OK ) goto end_of_vacuum;
   assert( (db->nDb-1)==nDb );
   pDb = &db->aDb[nDb];
   assert( strcmp(pDb->zDbSName,"vacuum_db")==0 );
   pTemp = pDb->pBt;
-  if( pOut ){
-    sqlite3_file *id = sqlite3PagerFile(sqlite3BtreePager(pTemp));
-    i64 sz = 0;
-    if( id->pMethods!=0 && (sqlite3OsFileSize(id, &sz)!=SQLITE_OK || sz>0) ){
-      rc = SQLITE_ERROR;
-      sqlite3SetString(pzErrMsg, db, "output file already exists");
-      goto end_of_vacuum;
-    }
-    db->mDbFlags |= DBFLAG_VacuumInto;
-  }
+  if( pOut ){ 
+    sqlite3_file *id = sqlite3PagerFile(sqlite3BtreePager(pTemp)); 
+    i64 sz = 0; 
+    if( id->pMethods!=0 && (sqlite3OsFileSize(id, &sz)!=SQLITE_OK || sz>0) ){ 
+      rc = SQLITE_ERROR; 
+      sqlite3SetString(pzErrMsg, db, "output file already exists"); 
+      goto end_of_vacuum; 
+    } 
+    db->mDbFlags |= DBFLAG_VacuumInto; 
+  } 
   nRes = sqlite3BtreeGetRequestedReserve(pMain);
 
   sqlite3BtreeSetCacheSize(pTemp, db->aDb[iDb].pSchema->cache_size);
@@ -144312,7 +144312,7 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum(
   */
   rc = execSql(db, pzErrMsg, "BEGIN");
   if( rc!=SQLITE_OK ) goto end_of_vacuum;
-  rc = sqlite3BtreeBeginTrans(pMain, pOut==0 ? 2 : 0, 0);
+  rc = sqlite3BtreeBeginTrans(pMain, pOut==0 ? 2 : 0, 0); 
   if( rc!=SQLITE_OK ) goto end_of_vacuum;
 
   /* Do not attempt to change the page size for a WAL database */
@@ -144349,7 +144349,7 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum(
   if( rc!=SQLITE_OK ) goto end_of_vacuum;
   rc = execSqlF(db, pzErrMsg,
       "SELECT sql FROM \"%w\".sqlite_schema"
-      " WHERE type='index'",
+      " WHERE type='index'", 
       zDbMain
   );
   if( rc!=SQLITE_OK ) goto end_of_vacuum;
@@ -144420,23 +144420,23 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3RunVacuum(
       if( NEVER(rc!=SQLITE_OK) ) goto end_of_vacuum;
     }
 
-    if( pOut==0 ){
-      rc = sqlite3BtreeCopyFile(pMain, pTemp);
-    }
+    if( pOut==0 ){ 
+      rc = sqlite3BtreeCopyFile(pMain, pTemp); 
+    } 
     if( rc!=SQLITE_OK ) goto end_of_vacuum;
     rc = sqlite3BtreeCommit(pTemp);
     if( rc!=SQLITE_OK ) goto end_of_vacuum;
 #ifndef SQLITE_OMIT_AUTOVACUUM
-    if( pOut==0 ){
-      sqlite3BtreeSetAutoVacuum(pMain, sqlite3BtreeGetAutoVacuum(pTemp));
-    }
+    if( pOut==0 ){ 
+      sqlite3BtreeSetAutoVacuum(pMain, sqlite3BtreeGetAutoVacuum(pTemp)); 
+    } 
 #endif
   }
 
   assert( rc==SQLITE_OK );
-  if( pOut==0 ){
-    rc = sqlite3BtreeSetPageSize(pMain, sqlite3BtreeGetPageSize(pTemp), nRes,1);
-  }
+  if( pOut==0 ){ 
+    rc = sqlite3BtreeSetPageSize(pMain, sqlite3BtreeGetPageSize(pTemp), nRes,1); 
+  } 
 
 end_of_vacuum:
   /* Restore the original value of db->flags */
@@ -144791,7 +144791,7 @@ SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3 *db){
 
   if( p ){
     db->pDisconnect = 0;
-    sqlite3ExpirePreparedStatements(db, 0);
+    sqlite3ExpirePreparedStatements(db, 0); 
     do {
       VTable *pNext = p->pNext;
       sqlite3VtabUnlock(p);
@@ -144832,16 +144832,16 @@ SQLITE_PRIVATE void sqlite3VtabClear(sqlite3 *db, Table *p){
 ** string will be freed automatically when the table is
 ** deleted.
 */
-static void addModuleArgument(Parse *pParse, Table *pTable, char *zArg){
+static void addModuleArgument(Parse *pParse, Table *pTable, char *zArg){ 
   sqlite3_int64 nBytes;
   char **azModuleArg;
-  sqlite3 *db = pParse->db;
+  sqlite3 *db = pParse->db; 
 
   assert( IsVirtual(pTable) );
   nBytes = sizeof(char *)*(2+pTable->u.vtab.nArg);
   if( pTable->u.vtab.nArg+3>=db->aLimit[SQLITE_LIMIT_COLUMN] ){
-    sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName);
-  }
+    sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName); 
+  } 
   azModuleArg = sqlite3DbRealloc(db, pTable->u.vtab.azArg, nBytes);
   if( azModuleArg==0 ){
     sqlite3DbFree(db, zArg);
@@ -144877,9 +144877,9 @@ SQLITE_PRIVATE void sqlite3VtabBeginParse(
   db = pParse->db;
 
   assert( pTable->u.vtab.nArg==0 );
-  addModuleArgument(pParse, pTable, sqlite3NameFromToken(db, pModuleName));
-  addModuleArgument(pParse, pTable, 0);
-  addModuleArgument(pParse, pTable, sqlite3DbStrDup(db, pTable->zName));
+  addModuleArgument(pParse, pTable, sqlite3NameFromToken(db, pModuleName)); 
+  addModuleArgument(pParse, pTable, 0); 
+  addModuleArgument(pParse, pTable, sqlite3DbStrDup(db, pTable->zName)); 
   assert( (pParse->sNameToken.z==pName2->z && pName2->z!=0)
        || (pParse->sNameToken.z==pName1->z && pName2->z==0)
   );
@@ -144894,8 +144894,8 @@ SQLITE_PRIVATE void sqlite3VtabBeginParse(
   ** The second call, to obtain permission to create the table, is made now.
   */
   if( pTable->u.vtab.azArg ){
-    int iDb = sqlite3SchemaToIndex(db, pTable->pSchema);
-    assert( iDb>=0 ); /* The database the table is being created in */
+    int iDb = sqlite3SchemaToIndex(db, pTable->pSchema); 
+    assert( iDb>=0 ); /* The database the table is being created in */ 
     sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
             pTable->u.vtab.azArg[0], pParse->db->aDb[iDb].zDbSName);
   }
@@ -144912,7 +144912,7 @@ static void addArgumentToVtab(Parse *pParse){
     const char *z = (const char*)pParse->sArg.z;
     int n = pParse->sArg.n;
     sqlite3 *db = pParse->db;
-    addModuleArgument(pParse, pParse->pNewTable, sqlite3DbStrNDup(db, z, n));
+    addModuleArgument(pParse, pParse->pNewTable, sqlite3DbStrNDup(db, z, n)); 
   }
 }
 
@@ -145207,8 +145207,8 @@ static int growVTrans(sqlite3 *db){
   /* Grow the sqlite3.aVTrans array if required */
   if( (db->nVTrans%ARRAY_INCR)==0 ){
     VTable **aVTrans;
-    sqlite3_int64 nBytes = sizeof(sqlite3_vtab*)*
-                                 ((sqlite3_int64)db->nVTrans + ARRAY_INCR);
+    sqlite3_int64 nBytes = sizeof(sqlite3_vtab*)* 
+                                 ((sqlite3_int64)db->nVTrans + ARRAY_INCR); 
     aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);
     if( !aVTrans ){
       return SQLITE_NOMEM_BKPT;
@@ -145303,7 +145303,7 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
   assert( IsVirtual(pTab) );
 
   memset(&sParse, 0, sizeof(sParse));
-  sParse.eParseMode = PARSE_MODE_DECLARE_VTAB;
+  sParse.eParseMode = PARSE_MODE_DECLARE_VTAB; 
   sParse.db = db;
   /* We should never be able to reach this point while loading the
   ** schema.  Nevertheless, defend against that (turn off db->init.busy)
@@ -145350,7 +145350,7 @@ SQLITE_API int sqlite3_declare_vtab(sqlite3 *db, const char *zCreateTable){
     sqlite3DbFree(db, zErr);
     rc = SQLITE_ERROR;
   }
-  sParse.eParseMode = PARSE_MODE_NORMAL;
+  sParse.eParseMode = PARSE_MODE_NORMAL; 
 
   if( sParse.pVdbe ){
     sqlite3VdbeFinalize(sParse.pVdbe);
@@ -145393,7 +145393,7 @@ SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab
     xDestroy = p->pMod->pModule->xDestroy;
     if( xDestroy==0 ) xDestroy = p->pMod->pModule->xDisconnect;
     assert( xDestroy!=0 );
-    pTab->nTabRef++;
+    pTab->nTabRef++; 
     rc = xDestroy(p->pVtab);
     /* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */
     if( rc==SQLITE_OK ){
@@ -145402,7 +145402,7 @@ SQLITE_PRIVATE int sqlite3VtabCallDestroy(sqlite3 *db, int iDb, const char *zTab
       pTab->u.vtab.p = 0;
       sqlite3VtabUnlock(p);
     }
-    sqlite3DeleteTable(db, pTab);
+    sqlite3DeleteTable(db, pTab); 
   }
 
   return rc;
@@ -145560,7 +145560,7 @@ SQLITE_PRIVATE int sqlite3VtabSavepoint(sqlite3 *db, int op, int iSavepoint){
       const sqlite3_module *pMod = pVTab->pMod->pModule;
       if( pVTab->pVtab && pMod->iVersion>=2 ){
         int (*xMethod)(sqlite3_vtab *, int);
-        sqlite3VtabLock(pVTab);
+        sqlite3VtabLock(pVTab); 
         switch( op ){
           case SAVEPOINT_BEGIN:
             xMethod = pMod->xSavepoint;
@@ -145576,7 +145576,7 @@ SQLITE_PRIVATE int sqlite3VtabSavepoint(sqlite3 *db, int op, int iSavepoint){
         if( xMethod && pVTab->iSavepoint>iSavepoint ){
           rc = xMethod(pVTab->pVtab, iSavepoint);
         }
-        sqlite3VtabUnlock(pVTab);
+        sqlite3VtabUnlock(pVTab); 
       }
     }
   }
@@ -145614,7 +145614,7 @@ SQLITE_PRIVATE FuncDef *sqlite3VtabOverloadFunction(
   if( NEVER(pExpr==0) ) return pDef;
   if( pExpr->op!=TK_COLUMN ) return pDef;
   assert( ExprUseYTab(pExpr) );
-  pTab = pExpr->y.pTab;
+  pTab = pExpr->y.pTab; 
   if( pTab==0 ) return pDef;
   if( !IsVirtual(pTab) ) return pDef;
   pVtab = sqlite3GetVTable(db, pTab)->pVtab;
@@ -145624,22 +145624,22 @@ SQLITE_PRIVATE FuncDef *sqlite3VtabOverloadFunction(
   if( pMod->xFindFunction==0 ) return pDef;
 
   /* Call the xFindFunction method on the virtual table implementation
-  ** to see if the implementation wants to overload this function.
-  **
-  ** Though undocumented, we have historically always invoked xFindFunction
-  ** with an all lower-case function name.  Continue in this tradition to
-  ** avoid any chance of an incompatibility.
-  */
-#ifdef SQLITE_DEBUG
-  {
-    int i;
-    for(i=0; pDef->zName[i]; i++){
-      unsigned char x = (unsigned char)pDef->zName[i];
-      assert( x==sqlite3UpperToLower[x] );
-    }
-  }
-#endif
-  rc = pMod->xFindFunction(pVtab, nArg, pDef->zName, &xSFunc, &pArg);
+  ** to see if the implementation wants to overload this function. 
+  ** 
+  ** Though undocumented, we have historically always invoked xFindFunction 
+  ** with an all lower-case function name.  Continue in this tradition to 
+  ** avoid any chance of an incompatibility. 
+  */
+#ifdef SQLITE_DEBUG 
+  { 
+    int i; 
+    for(i=0; pDef->zName[i]; i++){ 
+      unsigned char x = (unsigned char)pDef->zName[i]; 
+      assert( x==sqlite3UpperToLower[x] ); 
+    }
+  }
+#endif 
+  rc = pMod->xFindFunction(pVtab, nArg, pDef->zName, &xSFunc, &pArg); 
   if( rc==0 ){
     return pDef;
   }
@@ -145722,9 +145722,9 @@ SQLITE_PRIVATE int sqlite3VtabEponymousTableInit(Parse *pParse, Module *pMod){
   assert( pTab->u.vtab.nArg==0 );
   pTab->iPKey = -1;
   pTab->tabFlags |= TF_Eponymous;
-  addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
-  addModuleArgument(pParse, pTab, 0);
-  addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
+  addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName)); 
+  addModuleArgument(pParse, pTab, 0); 
+  addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName)); 
   rc = vtabCallConstructor(db, pTab, pMod, pModule->xConnect, &zErr);
   if( rc ){
     sqlite3ErrorMsg(pParse, "%s", zErr);
@@ -145858,8 +145858,8 @@ SQLITE_API int sqlite3_vtab_config(sqlite3 *db, int op, ...){
 ** planner logic in "where.c".  These definitions are broken out into
 ** a separate source file for easier editing.
 */
-#ifndef SQLITE_WHEREINT_H
-#define SQLITE_WHEREINT_H
+#ifndef SQLITE_WHEREINT_H 
+#define SQLITE_WHEREINT_H 
 
 
 /* Forward references
@@ -145917,8 +145917,8 @@ struct WhereLevel {
       struct InLoop {
         int iCur;              /* The VDBE cursor used by this IN operator */
         int addrInTop;         /* Top of the IN loop */
-        int iBase;             /* Base register of multi-key index record */
-        int nPrefix;           /* Number of prior entires in the key */
+        int iBase;             /* Base register of multi-key index record */ 
+        int nPrefix;           /* Number of prior entires in the key */ 
         u8 eEndLoopOp;         /* IN Loop terminator. OP_Next or OP_Prev */
       } *aInLoop;           /* Information about each nested IN operator */
     } in;                 /* Used when pWLoop->wsFlags&WHERE_IN_ABLE */
@@ -146161,7 +146161,7 @@ struct WhereClause {
   WhereInfo *pWInfo;       /* WHERE clause processing context */
   WhereClause *pOuter;     /* Outer conjunction */
   u8 op;                   /* Split operator.  TK_AND or TK_OR */
-  u8 hasOr;                /* True if any a[].eOperator is WO_OR */
+  u8 hasOr;                /* True if any a[].eOperator is WO_OR */ 
   int nTerm;               /* Number of terms */
   int nSlot;               /* Number of entries in a[] */
   WhereTerm *a;            /* Each a[] describes a term of the WHERE cluase */
@@ -146242,7 +146242,7 @@ struct WhereLoopBuilder {
 #endif
   unsigned char bldFlags1;  /* First set of SQLITE_BLDF_* flags */
   unsigned char bldFlags2;  /* Second set of SQLITE_BLDF_* flags */
-  unsigned int iPlanLimit;  /* Search limiter */
+  unsigned int iPlanLimit;  /* Search limiter */ 
 };
 
 /* Allowed values for WhereLoopBuider.bldFlags */
@@ -146251,26 +146251,26 @@ struct WhereLoopBuilder {
 
 #define SQLITE_BLDF2_2NDPASS  0x0004   /* Second builder pass needed */
 
-/* The WhereLoopBuilder.iPlanLimit is used to limit the number of
-** index+constraint combinations the query planner will consider for a
-** particular query.  If this parameter is unlimited, then certain
-** pathological queries can spend excess time in the sqlite3WhereBegin()
-** routine.  The limit is high enough that is should not impact real-world
-** queries.
-**
-** SQLITE_QUERY_PLANNER_LIMIT is the baseline limit.  The limit is
-** increased by SQLITE_QUERY_PLANNER_LIMIT_INCR before each term of the FROM
-** clause is processed, so that every table in a join is guaranteed to be
-** able to propose a some index+constraint combinations even if the initial
-** baseline limit was exhausted by prior tables of the join.
-*/
-#ifndef SQLITE_QUERY_PLANNER_LIMIT
-# define SQLITE_QUERY_PLANNER_LIMIT 20000
-#endif
-#ifndef SQLITE_QUERY_PLANNER_LIMIT_INCR
-# define SQLITE_QUERY_PLANNER_LIMIT_INCR 1000
-#endif
-
+/* The WhereLoopBuilder.iPlanLimit is used to limit the number of 
+** index+constraint combinations the query planner will consider for a 
+** particular query.  If this parameter is unlimited, then certain 
+** pathological queries can spend excess time in the sqlite3WhereBegin() 
+** routine.  The limit is high enough that is should not impact real-world 
+** queries. 
+** 
+** SQLITE_QUERY_PLANNER_LIMIT is the baseline limit.  The limit is 
+** increased by SQLITE_QUERY_PLANNER_LIMIT_INCR before each term of the FROM 
+** clause is processed, so that every table in a join is guaranteed to be 
+** able to propose a some index+constraint combinations even if the initial 
+** baseline limit was exhausted by prior tables of the join. 
+*/ 
+#ifndef SQLITE_QUERY_PLANNER_LIMIT 
+# define SQLITE_QUERY_PLANNER_LIMIT 20000 
+#endif 
+#ifndef SQLITE_QUERY_PLANNER_LIMIT_INCR 
+# define SQLITE_QUERY_PLANNER_LIMIT_INCR 1000 
+#endif 
+ 
 /*
 ** Each instance of this object records a change to a single node
 ** in an expression tree to cause that node to point to a column
@@ -146355,7 +146355,7 @@ SQLITE_PRIVATE int sqlite3WhereExplainOneScan(
   u16 wctrlFlags                  /* Flags passed to sqlite3WhereBegin() */
 );
 #else
-# define sqlite3WhereExplainOneScan(u,v,w,x) 0
+# define sqlite3WhereExplainOneScan(u,v,w,x) 0 
 #endif /* SQLITE_OMIT_EXPLAIN */
 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
 SQLITE_PRIVATE void sqlite3WhereAddScanStatus(
@@ -146368,11 +146368,11 @@ SQLITE_PRIVATE void sqlite3WhereAddScanStatus(
 # define sqlite3WhereAddScanStatus(a, b, c, d) ((void)d)
 #endif
 SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
-  Parse *pParse,       /* Parsing context */
-  Vdbe *v,             /* Prepared statement under construction */
+  Parse *pParse,       /* Parsing context */ 
+  Vdbe *v,             /* Prepared statement under construction */ 
   WhereInfo *pWInfo,   /* Complete information about the WHERE clause */
   int iLevel,          /* Which level of pWInfo->a[] should be coded */
-  WhereLevel *pLevel,  /* The current level pointer */
+  WhereLevel *pLevel,  /* The current level pointer */ 
   Bitmask notReady     /* Which tables are currently available */
 );
 
@@ -146381,7 +146381,7 @@ SQLITE_PRIVATE void sqlite3WhereClauseInit(WhereClause*,WhereInfo*);
 SQLITE_PRIVATE void sqlite3WhereClauseClear(WhereClause*);
 SQLITE_PRIVATE void sqlite3WhereSplit(WhereClause*,Expr*,u8);
 SQLITE_PRIVATE Bitmask sqlite3WhereExprUsage(WhereMaskSet*, Expr*);
-SQLITE_PRIVATE Bitmask sqlite3WhereExprUsageNN(WhereMaskSet*, Expr*);
+SQLITE_PRIVATE Bitmask sqlite3WhereExprUsageNN(WhereMaskSet*, Expr*); 
 SQLITE_PRIVATE Bitmask sqlite3WhereExprListUsage(WhereMaskSet*, ExprList*);
 SQLITE_PRIVATE void sqlite3WhereExprAnalyze(SrcList*, WhereClause*);
 SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(Parse*, SrcItem*, WhereClause*);
@@ -146444,13 +146444,13 @@ SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(Parse*, SrcItem*, WhereClause*);
 #define WHERE_SKIPSCAN     0x00008000  /* Uses the skip-scan algorithm */
 #define WHERE_UNQ_WANTED   0x00010000  /* WHERE_ONEROW would have been helpful*/
 #define WHERE_PARTIALIDX   0x00020000  /* The automatic index is partial */
-#define WHERE_IN_EARLYOUT  0x00040000  /* Perhaps quit IN loops early */
+#define WHERE_IN_EARLYOUT  0x00040000  /* Perhaps quit IN loops early */ 
 #define WHERE_BIGNULL_SORT 0x00080000  /* Column nEq of index is BIGNULL */
 #define WHERE_IN_SEEKSCAN  0x00100000  /* Seek-scan optimization for IN */
 #define WHERE_TRANSCONS    0x00200000  /* Uses a transitive constraint */
 
-#endif /* !defined(SQLITE_WHEREINT_H) */
-
+#endif /* !defined(SQLITE_WHEREINT_H) */ 
+ 
 /************** End of whereInt.h ********************************************/
 /************** Continuing where we left off in wherecode.c ******************/
 
@@ -146485,23 +146485,23 @@ static void explainAppendTerm(
   int i;
 
   assert( nTerm>=1 );
-  if( bAnd ) sqlite3_str_append(pStr, " AND ", 5);
+  if( bAnd ) sqlite3_str_append(pStr, " AND ", 5); 
 
-  if( nTerm>1 ) sqlite3_str_append(pStr, "(", 1);
+  if( nTerm>1 ) sqlite3_str_append(pStr, "(", 1); 
   for(i=0; i<nTerm; i++){
-    if( i ) sqlite3_str_append(pStr, ",", 1);
-    sqlite3_str_appendall(pStr, explainIndexColumnName(pIdx, iTerm+i));
+    if( i ) sqlite3_str_append(pStr, ",", 1); 
+    sqlite3_str_appendall(pStr, explainIndexColumnName(pIdx, iTerm+i)); 
   }
-  if( nTerm>1 ) sqlite3_str_append(pStr, ")", 1);
+  if( nTerm>1 ) sqlite3_str_append(pStr, ")", 1); 
 
-  sqlite3_str_append(pStr, zOp, 1);
+  sqlite3_str_append(pStr, zOp, 1); 
 
-  if( nTerm>1 ) sqlite3_str_append(pStr, "(", 1);
+  if( nTerm>1 ) sqlite3_str_append(pStr, "(", 1); 
   for(i=0; i<nTerm; i++){
-    if( i ) sqlite3_str_append(pStr, ",", 1);
-    sqlite3_str_append(pStr, "?", 1);
+    if( i ) sqlite3_str_append(pStr, ",", 1); 
+    sqlite3_str_append(pStr, "?", 1); 
   }
-  if( nTerm>1 ) sqlite3_str_append(pStr, ")", 1);
+  if( nTerm>1 ) sqlite3_str_append(pStr, ")", 1); 
 }
 
 /*
@@ -146525,11 +146525,11 @@ static void explainIndexRange(StrAccum *pStr, WhereLoop *pLoop){
   int i, j;
 
   if( nEq==0 && (pLoop->wsFlags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))==0 ) return;
-  sqlite3_str_append(pStr, " (", 2);
+  sqlite3_str_append(pStr, " (", 2); 
   for(i=0; i<nEq; i++){
     const char *z = explainIndexColumnName(pIndex, i);
-    if( i ) sqlite3_str_append(pStr, " AND ", 5);
-    sqlite3_str_appendf(pStr, i>=nSkip ? "%s=?" : "ANY(%s)", z);
+    if( i ) sqlite3_str_append(pStr, " AND ", 5); 
+    sqlite3_str_appendf(pStr, i>=nSkip ? "%s=?" : "ANY(%s)", z); 
   }
 
   j = i;
@@ -146540,7 +146540,7 @@ static void explainIndexRange(StrAccum *pStr, WhereLoop *pLoop){
   if( pLoop->wsFlags&WHERE_TOP_LIMIT ){
     explainAppendTerm(pStr, pIndex, pLoop->u.btree.nTop, j, i, "<");
   }
-  sqlite3_str_append(pStr, ")", 1);
+  sqlite3_str_append(pStr, ")", 1); 
 }
 
 /*
@@ -146605,8 +146605,8 @@ SQLITE_PRIVATE int sqlite3WhereExplainOneScan(
         zFmt = "INDEX %s";
       }
       if( zFmt ){
-        sqlite3_str_append(&str, " USING ", 7);
-        sqlite3_str_appendf(&str, zFmt, pIdx->zName);
+        sqlite3_str_append(&str, " USING ", 7); 
+        sqlite3_str_appendf(&str, zFmt, pIdx->zName); 
         explainIndexRange(&str, pLoop);
       }
     }else if( (flags & WHERE_IPK)!=0 && (flags & WHERE_CONSTRAINT)!=0 ){
@@ -146622,26 +146622,26 @@ SQLITE_PRIVATE int sqlite3WhereExplainOneScan(
         zRangeOp = "<";
       }
       sqlite3_str_appendf(&str,
-          " USING INTEGER PRIMARY KEY (rowid%s?)",zRangeOp);
+          " USING INTEGER PRIMARY KEY (rowid%s?)",zRangeOp); 
     }
 #ifndef SQLITE_OMIT_VIRTUALTABLE
     else if( (flags & WHERE_VIRTUALTABLE)!=0 ){
-      sqlite3_str_appendf(&str, " VIRTUAL TABLE INDEX %d:%s",
+      sqlite3_str_appendf(&str, " VIRTUAL TABLE INDEX %d:%s", 
                   pLoop->u.vtab.idxNum, pLoop->u.vtab.idxStr);
     }
 #endif
 #ifdef SQLITE_EXPLAIN_ESTIMATED_ROWS
     if( pLoop->nOut>=10 ){
-      sqlite3_str_appendf(&str, " (~%llu rows)",
-             sqlite3LogEstToInt(pLoop->nOut));
+      sqlite3_str_appendf(&str, " (~%llu rows)", 
+             sqlite3LogEstToInt(pLoop->nOut)); 
     }else{
-      sqlite3_str_append(&str, " (~1 row)", 9);
+      sqlite3_str_append(&str, " (~1 row)", 9); 
     }
 #endif
     zMsg = sqlite3StrAccumFinish(&str);
-    sqlite3ExplainBreakpoint("",zMsg);
-    ret = sqlite3VdbeAddOp4(v, OP_Explain, sqlite3VdbeCurrentAddr(v),
-                            pParse->addrExplain, 0, zMsg,P4_DYNAMIC);
+    sqlite3ExplainBreakpoint("",zMsg); 
+    ret = sqlite3VdbeAddOp4(v, OP_Explain, sqlite3VdbeCurrentAddr(v), 
+                            pParse->addrExplain, 0, zMsg,P4_DYNAMIC); 
   }
   return ret;
 }
@@ -146867,7 +146867,7 @@ static Expr *removeUnindexableInClauseTerms(
         int iField;
         assert( (pLoop->aLTerm[i]->eOperator & (WO_OR|WO_AND))==0 );
         iField = pLoop->aLTerm[i]->u.x.iField - 1;
-        if( pOrigRhs->a[iField].pExpr==0 ) continue; /* Duplicate PK column */
+        if( pOrigRhs->a[iField].pExpr==0 ) continue; /* Duplicate PK column */ 
         pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr);
         pOrigRhs->a[iField].pExpr = 0;
         assert( pOrigLhs->a[iField].pExpr!=0 );
@@ -146980,17 +146980,17 @@ static int codeEqualityTerm(
       if( pLoop->aLTerm[i]->pExpr==pX ) nEq++;
     }
 
-    iTab = 0;
+    iTab = 0; 
     if( !ExprUseXSelect(pX) || pX->x.pSelect->pEList->nExpr==1 ){
-      eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, 0, &iTab);
+      eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, 0, &iTab); 
     }else{
       sqlite3 *db = pParse->db;
       pX = removeUnindexableInClauseTerms(pParse, iEq, pLoop, pX);
 
       if( !db->mallocFailed ){
         aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*nEq);
-        eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap, &iTab);
-        pTerm->pExpr->iTable = iTab;
+        eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap, &iTab); 
+        pTerm->pExpr->iTable = iTab; 
       }
       sqlite3ExprDelete(db, pX);
       pX = pTerm->pExpr;
@@ -147007,7 +147007,7 @@ static int codeEqualityTerm(
     assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 );
     pLoop->wsFlags |= WHERE_IN_ABLE;
     if( pLevel->u.in.nIn==0 ){
-      pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse);
+      pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse); 
     }
     if( iEq>0 && (pLoop->wsFlags & WHERE_IN_SEEKSCAN)==0 ){
       pLoop->wsFlags |= WHERE_IN_EARLYOUT;
@@ -147034,13 +147034,13 @@ static int codeEqualityTerm(
           sqlite3VdbeAddOp1(v, OP_IsNull, iOut); VdbeCoverage(v);
           if( i==iEq ){
             pIn->iCur = iTab;
-            pIn->eEndLoopOp = bRev ? OP_Prev : OP_Next;
+            pIn->eEndLoopOp = bRev ? OP_Prev : OP_Next; 
             if( iEq>0 ){
-              pIn->iBase = iReg - i;
-              pIn->nPrefix = i;
-            }else{
-              pIn->nPrefix = 0;
-            }
+              pIn->iBase = iReg - i; 
+              pIn->nPrefix = i; 
+            }else{ 
+              pIn->nPrefix = 0; 
+            } 
           }else{
             pIn->eEndLoopOp = OP_Noop;
           }
@@ -147352,7 +147352,7 @@ static int codeCursorHintFixExpr(Walker *pWalker, Expr *pExpr){
   if( pExpr->op==TK_COLUMN ){
     if( pExpr->iTable!=pHint->iTabCur ){
       int reg = ++pWalker->pParse->nMem;   /* Register for column value */
-      sqlite3ExprCode(pWalker->pParse, pExpr, reg);
+      sqlite3ExprCode(pWalker->pParse, pExpr, reg); 
       pExpr->op = TK_REGISTER;
       pExpr->iTable = reg;
     }else if( pHint->pIdx!=0 ){
@@ -147466,7 +147466,7 @@ static void codeCursorHint(
     }
 
     /* If we survive all prior tests, that means this term is worth hinting */
-    pExpr = sqlite3ExprAnd(pParse, pExpr, sqlite3ExprDup(db, pTerm->pExpr, 0));
+    pExpr = sqlite3ExprAnd(pParse, pExpr, sqlite3ExprDup(db, pTerm->pExpr, 0)); 
   }
   if( pExpr!=0 ){
     sWalker.xExprCallback = codeCursorHintFixExpr;
@@ -147548,9 +147548,9 @@ static void codeExprOrVector(Parse *pParse, Expr *p, int iReg, int nReg){
 #ifndef SQLITE_OMIT_SUBQUERY
     if( ExprUseXSelect(p) ){
       Vdbe *v = pParse->pVdbe;
-      int iSelect;
-      assert( p->op==TK_SELECT );
-      iSelect = sqlite3CodeSubselect(pParse, p);
+      int iSelect; 
+      assert( p->op==TK_SELECT ); 
+      iSelect = sqlite3CodeSubselect(pParse, p); 
       sqlite3VdbeAddOp3(v, OP_Copy, iSelect, iReg, nReg-1);
     }else
 #endif
@@ -147708,43 +147708,43 @@ static void whereIndexExprTrans(
 }
 
 /*
-** The pTruth expression is always true because it is the WHERE clause
-** a partial index that is driving a query loop.  Look through all of the
-** WHERE clause terms on the query, and if any of those terms must be
-** true because pTruth is true, then mark those WHERE clause terms as
-** coded.
-*/
-static void whereApplyPartialIndexConstraints(
-  Expr *pTruth,
-  int iTabCur,
-  WhereClause *pWC
-){
-  int i;
-  WhereTerm *pTerm;
-  while( pTruth->op==TK_AND ){
-    whereApplyPartialIndexConstraints(pTruth->pLeft, iTabCur, pWC);
-    pTruth = pTruth->pRight;
-  }
-  for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){
-    Expr *pExpr;
-    if( pTerm->wtFlags & TERM_CODED ) continue;
-    pExpr = pTerm->pExpr;
-    if( sqlite3ExprCompare(0, pExpr, pTruth, iTabCur)==0 ){
-      pTerm->wtFlags |= TERM_CODED;
-    }
-  }
-}
-
-/*
+** The pTruth expression is always true because it is the WHERE clause 
+** a partial index that is driving a query loop.  Look through all of the 
+** WHERE clause terms on the query, and if any of those terms must be 
+** true because pTruth is true, then mark those WHERE clause terms as 
+** coded. 
+*/ 
+static void whereApplyPartialIndexConstraints( 
+  Expr *pTruth, 
+  int iTabCur, 
+  WhereClause *pWC 
+){ 
+  int i; 
+  WhereTerm *pTerm; 
+  while( pTruth->op==TK_AND ){ 
+    whereApplyPartialIndexConstraints(pTruth->pLeft, iTabCur, pWC); 
+    pTruth = pTruth->pRight; 
+  } 
+  for(i=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){ 
+    Expr *pExpr; 
+    if( pTerm->wtFlags & TERM_CODED ) continue; 
+    pExpr = pTerm->pExpr; 
+    if( sqlite3ExprCompare(0, pExpr, pTruth, iTabCur)==0 ){ 
+      pTerm->wtFlags |= TERM_CODED; 
+    } 
+  } 
+} 
+ 
+/* 
 ** Generate code for the start of the iLevel-th loop in the WHERE clause
 ** implementation described by pWInfo.
 */
 SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
-  Parse *pParse,       /* Parsing context */
-  Vdbe *v,             /* Prepared statement under construction */
+  Parse *pParse,       /* Parsing context */ 
+  Vdbe *v,             /* Prepared statement under construction */ 
   WhereInfo *pWInfo,   /* Complete information about the WHERE clause */
   int iLevel,          /* Which level of pWInfo->a[] should be coded */
-  WhereLevel *pLevel,  /* The current level pointer */
+  WhereLevel *pLevel,  /* The current level pointer */ 
   Bitmask notReady     /* Which tables are currently available */
 ){
   int j, k;            /* Loop counters */
@@ -147798,16 +147798,16 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
   ** there are no IN operators in the constraints, the "addrNxt" label
   ** is the same as "addrBrk".
   */
-  addrBrk = pLevel->addrBrk = pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse);
-  addrCont = pLevel->addrCont = sqlite3VdbeMakeLabel(pParse);
+  addrBrk = pLevel->addrBrk = pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse); 
+  addrCont = pLevel->addrCont = sqlite3VdbeMakeLabel(pParse); 
 
   /* If this is the right table of a LEFT OUTER JOIN, allocate and
   ** initialize a memory cell that records if this table matches any
   ** row of the left table of the join.
   */
-  assert( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)
-       || pLevel->iFrom>0 || (pTabItem[0].fg.jointype & JT_LEFT)==0
-  );
+  assert( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE) 
+       || pLevel->iFrom>0 || (pTabItem[0].fg.jointype & JT_LEFT)==0 
+  ); 
   if( pLevel->iFrom>0 && (pTabItem[0].fg.jointype & JT_LEFT)!=0 ){
     pLevel->iLeftJoin = ++pParse->nMem;
     sqlite3VdbeAddOp2(v, OP_Integer, 0, pLevel->iLeftJoin);
@@ -147825,7 +147825,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub);
     pLevel->p2 =  sqlite3VdbeAddOp2(v, OP_Yield, regYield, addrBrk);
     VdbeCoverage(v);
-    VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
+    VdbeComment((v, "next row of %s", pTabItem->pTab->zName)); 
     pLevel->op = OP_Goto;
   }else
 
@@ -147995,15 +147995,15 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
       if( sqlite3ExprIsVector(pX->pRight) ){
         r1 = rTemp = sqlite3GetTempReg(pParse);
         codeExprOrVector(pParse, pX->pRight, r1, 1);
-        testcase( pX->op==TK_GT );
-        testcase( pX->op==TK_GE );
-        testcase( pX->op==TK_LT );
-        testcase( pX->op==TK_LE );
-        op = aMoveOp[((pX->op - TK_GT - 1) & 0x3) | 0x1];
-        assert( pX->op!=TK_GT || op==OP_SeekGE );
-        assert( pX->op!=TK_GE || op==OP_SeekGE );
-        assert( pX->op!=TK_LT || op==OP_SeekLE );
-        assert( pX->op!=TK_LE || op==OP_SeekLE );
+        testcase( pX->op==TK_GT ); 
+        testcase( pX->op==TK_GE ); 
+        testcase( pX->op==TK_LT ); 
+        testcase( pX->op==TK_LE ); 
+        op = aMoveOp[((pX->op - TK_GT - 1) & 0x3) | 0x1]; 
+        assert( pX->op!=TK_GT || op==OP_SeekGE ); 
+        assert( pX->op!=TK_GE || op==OP_SeekGE ); 
+        assert( pX->op!=TK_LT || op==OP_SeekLE ); 
+        assert( pX->op!=TK_LE || op==OP_SeekLE ); 
       }else{
         r1 = sqlite3ExprCodeTemp(pParse, pX->pRight, &rTemp);
         disableTerm(pLevel, pStart);
@@ -148121,7 +148121,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     char *zEndAff = 0;           /* Affinity for end of range constraint */
     u8 bSeekPastNull = 0;        /* True to seek past initial nulls */
     u8 bStopAtNull = 0;          /* Add condition to terminate at NULLs */
-    int omitTable;               /* True if we use the index only */
+    int omitTable;               /* True if we use the index only */ 
     int regBignull = 0;          /* big-null flag register */
     int addrSeekScan = 0;        /* Opcode of the OP_SeekScan, if any */
 
@@ -148269,7 +148269,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
       if( regBignull ){
         sqlite3VdbeAddOp2(v, OP_Integer, 1, regBignull);
         VdbeComment((v, "NULL-scan pass ctr"));
-      }
+      } 
 
       op = aStartOp[(start_constraints<<2) + (startEq<<1) + bRev];
       assert( op!=0 );
@@ -148402,11 +148402,11 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
 
     if( (pLoop->wsFlags & WHERE_IN_EARLYOUT)!=0 ){
       sqlite3VdbeAddOp3(v, OP_SeekHit, iIdxCur, nEq, nEq);
-    }
-
+    } 
+ 
     /* Seek the table cursor, if required */
     omitTable = (pLoop->wsFlags & WHERE_IDX_ONLY)!=0
-           && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0;
+           && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0; 
     if( omitTable ){
       /* pIdx is a covering index.  No need to access the main table. */
     }else if( HasRowid(pIdx->pTable) ){
@@ -148460,7 +148460,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
       ** The OR-optimization doesn't work for the right hand table of
       ** a LEFT JOIN: */
       assert( (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0 );
-    }
+    } 
 
     /* Record the instruction used to terminate the loop. */
     if( pLoop->wsFlags & WHERE_ONEROW ){
@@ -148533,7 +148533,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     int regReturn = ++pParse->nMem;           /* Register used with OP_Gosub */
     int regRowset = 0;                        /* Register for RowSet object */
     int regRowid = 0;                         /* Register holding rowid */
-    int iLoopBody = sqlite3VdbeMakeLabel(pParse);/* Start of loop body */
+    int iLoopBody = sqlite3VdbeMakeLabel(pParse);/* Start of loop body */ 
     int iRetInit;                             /* Address of regReturn init */
     int untestedTerms = 0;             /* Some terms not completely tested */
     int ii;                            /* Loop counter */
@@ -148621,15 +148621,15 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
         if( (pWC->a[iTerm].eOperator & WO_ALL)==0 ) continue;
         testcase( pWC->a[iTerm].wtFlags & TERM_ORINFO );
         pExpr = sqlite3ExprDup(db, pExpr, 0);
-        pAndExpr = sqlite3ExprAnd(pParse, pAndExpr, pExpr);
+        pAndExpr = sqlite3ExprAnd(pParse, pAndExpr, pExpr); 
       }
       if( pAndExpr ){
-        /* The extra 0x10000 bit on the opcode is masked off and does not
-        ** become part of the new Expr.op.  However, it does make the
-        ** op==TK_AND comparison inside of sqlite3PExpr() false, and this
+        /* The extra 0x10000 bit on the opcode is masked off and does not 
+        ** become part of the new Expr.op.  However, it does make the 
+        ** op==TK_AND comparison inside of sqlite3PExpr() false, and this 
         ** prevents sqlite3PExpr() from applying the AND short-circuit
-        ** optimization, which we do not want here. */
-        pAndExpr = sqlite3PExpr(pParse, TK_AND|0x10000, 0, pAndExpr);
+        ** optimization, which we do not want here. */ 
+        pAndExpr = sqlite3PExpr(pParse, TK_AND|0x10000, 0, pAndExpr); 
       }
     }
 
@@ -148637,7 +148637,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     ** eliminating duplicates from other WHERE clauses, the action for each
     ** sub-WHERE clause is to to invoke the main loop body as a subroutine.
     */
-    ExplainQueryPlan((pParse, 1, "MULTI-INDEX OR"));
+    ExplainQueryPlan((pParse, 1, "MULTI-INDEX OR")); 
     for(ii=0; ii<pOrWc->nTerm; ii++){
       WhereTerm *pOrTerm = &pOrWc->a[ii];
       if( pOrTerm->leftCursor==iCur || (pOrTerm->eOperator & WO_AND)!=0 ){
@@ -148653,12 +148653,12 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
           sqlite3ExprDelete(db, pDelete);
           continue;
         }
-        if( pAndExpr ){
+        if( pAndExpr ){ 
           pAndExpr->pLeft = pOrExpr;
           pOrExpr = pAndExpr;
         }
         /* Loop through table entries that match term pOrTerm. */
-        ExplainQueryPlan((pParse, 1, "INDEX %d", ii+1));
+        ExplainQueryPlan((pParse, 1, "INDEX %d", ii+1)); 
         WHERETRACE(0xffff, ("Subplan for OR-clause:\n"));
         pSubWInfo = sqlite3WhereBegin(pParse, pOrTab, pOrExpr, 0, 0,
                                       WHERE_OR_SUBCLAUSE, iCovCur);
@@ -148666,7 +148666,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
         if( pSubWInfo ){
           WhereLoop *pSubLoop;
           int addrExplain = sqlite3WhereExplainOneScan(
-              pParse, pOrTab, &pSubWInfo->a[0], 0
+              pParse, pOrTab, &pSubWInfo->a[0], 0 
           );
           sqlite3WhereAddScanStatus(v, pOrTab, &pSubWInfo->a[0], addrExplain);
 
@@ -148678,15 +148678,15 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
           if( (pWInfo->wctrlFlags & WHERE_DUPLICATES_OK)==0 ){
             int iSet = ((ii==pOrWc->nTerm-1)?-1:ii);
             if( HasRowid(pTab) ){
-              sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, regRowid);
+              sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, regRowid); 
               jmp1 = sqlite3VdbeAddOp4Int(v, OP_RowSetTest, regRowset, 0,
-                                          regRowid, iSet);
+                                          regRowid, iSet); 
               VdbeCoverage(v);
             }else{
               Index *pPk = sqlite3PrimaryKeyIndex(pTab);
               int nPk = pPk->nKeyCol;
               int iPk;
-              int r;
+              int r; 
 
               /* Read the PK into an array of temp registers. */
               r = sqlite3GetTempRange(pParse, nPk);
@@ -148765,12 +148765,12 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
 
           /* Finish the loop through table entries that match term pOrTerm. */
           sqlite3WhereEnd(pSubWInfo);
-          ExplainQueryPlanPop(pParse);
+          ExplainQueryPlanPop(pParse); 
         }
         sqlite3ExprDelete(db, pDelete);
       }
     }
-    ExplainQueryPlanPop(pParse);
+    ExplainQueryPlanPop(pParse); 
     assert( pLevel->pWLoop==pLoop );
     assert( (pLoop->wsFlags & WHERE_MULTI_OR)!=0 );
     assert( (pLoop->wsFlags & WHERE_IN_ABLE)==0 );
@@ -148784,7 +148784,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     sqlite3VdbeGoto(v, pLevel->addrBrk);
     sqlite3VdbeResolveLabel(v, iLoopBody);
 
-    if( pWInfo->nLevel>1 ){ sqlite3StackFree(db, pOrTab); }
+    if( pWInfo->nLevel>1 ){ sqlite3StackFree(db, pOrTab); } 
     if( !untestedTerms ) disableTerm(pLevel, pTerm);
   }else
 #endif /* SQLITE_OMIT_OR_OPTIMIZATION */
@@ -148846,7 +148846,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
       }
       pE = pTerm->pExpr;
       assert( pE!=0 );
-      if( (pTabItem->fg.jointype&JT_LEFT) && !ExprHasProperty(pE,EP_FromJoin) ){
+      if( (pTabItem->fg.jointype&JT_LEFT) && !ExprHasProperty(pE,EP_FromJoin) ){ 
         continue;
       }
 
@@ -148859,7 +148859,7 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
         continue;
       }
 
-      if( (pTerm->wtFlags & TERM_LIKECOND)!=0 ){
+      if( (pTerm->wtFlags & TERM_LIKECOND)!=0 ){ 
         /* If the TERM_LIKECOND flag is set, that means that the range search
         ** is sufficient to guarantee that the LIKE operator is true, so we
         ** can skip the call to the like(A,B) function.  But this only works
@@ -148869,11 +148869,11 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
         continue;
 #else
         u32 x = pLevel->iLikeRepCntr;
-        if( x>0 ){
-          skipLikeAddr = sqlite3VdbeAddOp1(v, (x&1)?OP_IfNot:OP_If,(int)(x>>1));
-          VdbeCoverageIf(v, (x&1)==1);
-          VdbeCoverageIf(v, (x&1)==0);
-        }
+        if( x>0 ){ 
+          skipLikeAddr = sqlite3VdbeAddOp1(v, (x&1)?OP_IfNot:OP_If,(int)(x>>1)); 
+          VdbeCoverageIf(v, (x&1)==1); 
+          VdbeCoverageIf(v, (x&1)==0); 
+        } 
 #endif
       }
 #ifdef WHERETRACE_ENABLED /* 0xffff */
@@ -148925,10 +148925,10 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     if( pAlt->wtFlags & (TERM_CODED) ) continue;
     if( (pAlt->eOperator & WO_IN)
      && ExprUseXSelect(pAlt->pExpr)
-     && (pAlt->pExpr->x.pSelect->pEList->nExpr>1)
-    ){
-      continue;
-    }
+     && (pAlt->pExpr->x.pSelect->pEList->nExpr>1) 
+    ){ 
+      continue; 
+    } 
     testcase( pAlt->eOperator & WO_EQ );
     testcase( pAlt->eOperator & WO_IS );
     testcase( pAlt->eOperator & WO_IN );
@@ -149156,18 +149156,18 @@ static int isLikeOrGlob(
   int *pisComplete, /* True if the only wildcard is % in the last character */
   int *pnoCase      /* True if uppercase is equivalent to lowercase */
 ){
-  const u8 *z = 0;           /* String on RHS of LIKE operator */
+  const u8 *z = 0;           /* String on RHS of LIKE operator */ 
   Expr *pRight, *pLeft;      /* Right and left size of LIKE operator */
   ExprList *pList;           /* List of operands to the LIKE operator */
-  u8 c;                      /* One character in z[] */
+  u8 c;                      /* One character in z[] */ 
   int cnt;                   /* Number of non-wildcard prefix characters */
-  u8 wc[4];                  /* Wildcard characters */
+  u8 wc[4];                  /* Wildcard characters */ 
   sqlite3 *db = pParse->db;  /* Database connection */
   sqlite3_value *pVal = 0;
   int op;                    /* Opcode of pRight */
   int rc;                    /* Result code to return */
 
-  if( !sqlite3IsLikeFunction(db, pExpr, pnoCase, (char*)wc) ){
+  if( !sqlite3IsLikeFunction(db, pExpr, pnoCase, (char*)wc) ){ 
     return 0;
   }
 #ifdef SQLITE_EBCDIC
@@ -149203,13 +149203,13 @@ static int isLikeOrGlob(
 
     /* The optimization is possible only if (1) the pattern does not begin
     ** with a wildcard and if (2) the non-wildcard prefix does not end with
-    ** an (illegal 0xff) character, or (3) the pattern does not consist of
-    ** a single escape character. The second condition is necessary so
+    ** an (illegal 0xff) character, or (3) the pattern does not consist of 
+    ** a single escape character. The second condition is necessary so 
     ** that we can increment the prefix key to find an upper bound for the
-    ** range search. The third is because the caller assumes that the pattern
-    ** consists of at least one character after all escapes have been
-    ** removed.  */
-    if( cnt!=0 && 255!=(u8)z[cnt-1] && (cnt>1 || z[0]!=wc[3]) ){
+    ** range search. The third is because the caller assumes that the pattern 
+    ** consists of at least one character after all escapes have been 
+    ** removed.  */ 
+    if( cnt!=0 && 255!=(u8)z[cnt-1] && (cnt>1 || z[0]!=wc[3]) ){ 
       Expr *pPrefix;
 
       /* A "complete" match if the pattern ends with "*" or "%" */
@@ -149228,31 +149228,31 @@ static int isLikeOrGlob(
           zNew[iTo++] = zNew[iFrom];
         }
         zNew[iTo] = 0;
-        assert( iTo>0 );
-
-        /* If the LHS is not an ordinary column with TEXT affinity, then the
-        ** pattern prefix boundaries (both the start and end boundaries) must
-        ** not look like a number.  Otherwise the pattern might be treated as
-        ** a number, which will invalidate the LIKE optimization.
-        **
-        ** Getting this right has been a persistent source of bugs in the
-        ** LIKE optimization.  See, for example:
-        **    2018-09-10 https://sqlite.org/src/info/c94369cae9b561b1
-        **    2019-05-02 https://sqlite.org/src/info/b043a54c3de54b28
-        **    2019-06-10 https://sqlite.org/src/info/fd76310a5e843e07
-        **    2019-06-14 https://sqlite.org/src/info/ce8717f0885af975
+        assert( iTo>0 ); 
+ 
+        /* If the LHS is not an ordinary column with TEXT affinity, then the 
+        ** pattern prefix boundaries (both the start and end boundaries) must 
+        ** not look like a number.  Otherwise the pattern might be treated as 
+        ** a number, which will invalidate the LIKE optimization. 
+        ** 
+        ** Getting this right has been a persistent source of bugs in the 
+        ** LIKE optimization.  See, for example: 
+        **    2018-09-10 https://sqlite.org/src/info/c94369cae9b561b1 
+        **    2019-05-02 https://sqlite.org/src/info/b043a54c3de54b28 
+        **    2019-06-10 https://sqlite.org/src/info/fd76310a5e843e07 
+        **    2019-06-14 https://sqlite.org/src/info/ce8717f0885af975 
         **    2019-09-03 https://sqlite.org/src/info/0f0428096f17252a
-        */
+        */ 
         if( pLeft->op!=TK_COLUMN
          || sqlite3ExprAffinity(pLeft)!=SQLITE_AFF_TEXT
          || (ALWAYS( ExprUseYTab(pLeft) )
              && pLeft->y.pTab
              && IsVirtual(pLeft->y.pTab))  /* Might be numeric */
-        ){
-          int isNum;
-          double rDummy;
-          isNum = sqlite3AtoF(zNew, &rDummy, iTo, SQLITE_UTF8);
-          if( isNum<=0 ){
+        ){ 
+          int isNum; 
+          double rDummy; 
+          isNum = sqlite3AtoF(zNew, &rDummy, iTo, SQLITE_UTF8); 
+          if( isNum<=0 ){ 
             if( iTo==1 && zNew[0]=='-' ){
               isNum = +1;
             }else{
@@ -149260,13 +149260,13 @@ static int isLikeOrGlob(
               isNum = sqlite3AtoF(zNew, &rDummy, iTo, SQLITE_UTF8);
               zNew[iTo-1]--;
             }
-          }
-          if( isNum>0 ){
-            sqlite3ExprDelete(db, pPrefix);
-            sqlite3ValueFree(pVal);
-            return 0;
-          }
-        }
+          } 
+          if( isNum>0 ){ 
+            sqlite3ExprDelete(db, pPrefix); 
+            sqlite3ValueFree(pVal); 
+            return 0; 
+          } 
+        } 
       }
       *ppPrefix = pPrefix;
 
@@ -149329,7 +149329,7 @@ static int isLikeOrGlob(
 ** If the expression matches none of the patterns above, return 0.
 */
 static int isAuxiliaryVtabOperator(
-  sqlite3 *db,                    /* Parsing context */
+  sqlite3 *db,                    /* Parsing context */ 
   Expr *pExpr,                    /* Test this expression */
   unsigned char *peOp2,           /* OUT: 0 for MATCH, or else an op2 value */
   Expr **ppLeft,                  /* Column expression to left of MATCH/op2 */
@@ -149354,60 +149354,60 @@ static int isAuxiliaryVtabOperator(
     if( pList==0 || pList->nExpr!=2 ){
       return 0;
     }
-
-    /* Built-in operators MATCH, GLOB, LIKE, and REGEXP attach to a
-    ** virtual table on their second argument, which is the same as
-    ** the left-hand side operand in their in-fix form.
-    **
-    **       vtab_column MATCH expression
-    **       MATCH(expression,vtab_column)
-    */
+ 
+    /* Built-in operators MATCH, GLOB, LIKE, and REGEXP attach to a 
+    ** virtual table on their second argument, which is the same as 
+    ** the left-hand side operand in their in-fix form. 
+    ** 
+    **       vtab_column MATCH expression 
+    **       MATCH(expression,vtab_column) 
+    */ 
     pCol = pList->a[1].pExpr;
     assert( pCol->op!=TK_COLUMN || ExprUseYTab(pCol) );
     testcase( pCol->op==TK_COLUMN && pCol->y.pTab==0 );
     if( ExprIsVtab(pCol) ){
-      for(i=0; i<ArraySize(aOp); i++){
+      for(i=0; i<ArraySize(aOp); i++){ 
         assert( !ExprHasProperty(pExpr, EP_IntValue) );
-        if( sqlite3StrICmp(pExpr->u.zToken, aOp[i].zOp)==0 ){
-          *peOp2 = aOp[i].eOp2;
-          *ppRight = pList->a[0].pExpr;
-          *ppLeft = pCol;
-          return 1;
-        }
-      }
-    }
-
-    /* We can also match against the first column of overloaded
-    ** functions where xFindFunction returns a value of at least
-    ** SQLITE_INDEX_CONSTRAINT_FUNCTION.
-    **
-    **      OVERLOADED(vtab_column,expression)
-    **
-    ** Historically, xFindFunction expected to see lower-case function
-    ** names.  But for this use case, xFindFunction is expected to deal
-    ** with function names in an arbitrary case.
-    */
-    pCol = pList->a[0].pExpr;
+        if( sqlite3StrICmp(pExpr->u.zToken, aOp[i].zOp)==0 ){ 
+          *peOp2 = aOp[i].eOp2; 
+          *ppRight = pList->a[0].pExpr; 
+          *ppLeft = pCol; 
+          return 1; 
+        } 
+      } 
+    }
+ 
+    /* We can also match against the first column of overloaded 
+    ** functions where xFindFunction returns a value of at least 
+    ** SQLITE_INDEX_CONSTRAINT_FUNCTION. 
+    ** 
+    **      OVERLOADED(vtab_column,expression) 
+    ** 
+    ** Historically, xFindFunction expected to see lower-case function 
+    ** names.  But for this use case, xFindFunction is expected to deal 
+    ** with function names in an arbitrary case. 
+    */ 
+    pCol = pList->a[0].pExpr; 
     assert( pCol->op!=TK_COLUMN || ExprUseYTab(pCol) );
     testcase( pCol->op==TK_COLUMN && pCol->y.pTab==0 );
     if( ExprIsVtab(pCol) ){
-      sqlite3_vtab *pVtab;
-      sqlite3_module *pMod;
-      void (*xNotUsed)(sqlite3_context*,int,sqlite3_value**);
-      void *pNotUsed;
-      pVtab = sqlite3GetVTable(db, pCol->y.pTab)->pVtab;
-      assert( pVtab!=0 );
-      assert( pVtab->pModule!=0 );
+      sqlite3_vtab *pVtab; 
+      sqlite3_module *pMod; 
+      void (*xNotUsed)(sqlite3_context*,int,sqlite3_value**); 
+      void *pNotUsed; 
+      pVtab = sqlite3GetVTable(db, pCol->y.pTab)->pVtab; 
+      assert( pVtab!=0 ); 
+      assert( pVtab->pModule!=0 ); 
       assert( !ExprHasProperty(pExpr, EP_IntValue) );
        pMod = (sqlite3_module *)pVtab->pModule;
-      if( pMod->xFindFunction!=0 ){
-        i = pMod->xFindFunction(pVtab,2, pExpr->u.zToken, &xNotUsed, &pNotUsed);
-        if( i>=SQLITE_INDEX_CONSTRAINT_FUNCTION ){
-          *peOp2 = i;
-          *ppRight = pList->a[1].pExpr;
-          *ppLeft = pCol;
-          return 1;
-        }
+      if( pMod->xFindFunction!=0 ){ 
+        i = pMod->xFindFunction(pVtab,2, pExpr->u.zToken, &xNotUsed, &pNotUsed); 
+        if( i>=SQLITE_INDEX_CONSTRAINT_FUNCTION ){ 
+          *peOp2 = i; 
+          *ppRight = pList->a[1].pExpr; 
+          *ppLeft = pCol; 
+          return 1; 
+        } 
       }
     }
   }else if( pExpr->op==TK_NE || pExpr->op==TK_ISNOT || pExpr->op==TK_NOTNULL ){
@@ -149717,9 +149717,9 @@ static void exprAnalyzeOrTerm(
   pOrInfo->indexable = indexable;
   pTerm->eOperator = WO_OR;
   pTerm->leftCursor = -1;
-  if( indexable ){
-    pWC->hasOr = 1;
-  }
+  if( indexable ){ 
+    pWC->hasOr = 1; 
+  } 
 
   /* For a two-way OR, attempt to implementation case 2.
   */
@@ -149769,7 +149769,7 @@ static void exprAnalyzeOrTerm(
     ** and column is found but leave okToChngToIN false if not found.
     */
     for(j=0; j<2 && !okToChngToIN; j++){
-      Expr *pLeft = 0;
+      Expr *pLeft = 0; 
       pOrTerm = pOrWc->a;
       for(i=pOrWc->nTerm-1; i>=0; i--, pOrTerm++){
         assert( pOrTerm->eOperator & WO_EQ );
@@ -149794,7 +149794,7 @@ static void exprAnalyzeOrTerm(
         assert( (pOrTerm->eOperator & (WO_OR|WO_AND))==0 );
         iColumn = pOrTerm->u.x.leftColumn;
         iCursor = pOrTerm->leftCursor;
-        pLeft = pOrTerm->pExpr->pLeft;
+        pLeft = pOrTerm->pExpr->pLeft; 
         break;
       }
       if( i<0 ){
@@ -149816,8 +149816,8 @@ static void exprAnalyzeOrTerm(
         if( pOrTerm->leftCursor!=iCursor ){
           pOrTerm->wtFlags &= ~TERM_OR_OK;
         }else if( pOrTerm->u.x.leftColumn!=iColumn || (iColumn==XN_EXPR
-               && sqlite3ExprCompare(pParse, pOrTerm->pExpr->pLeft, pLeft, -1)
-        )){
+               && sqlite3ExprCompare(pParse, pOrTerm->pExpr->pLeft, pLeft, -1) 
+        )){ 
           okToChngToIN = 0;
         }else{
           int affLeft, affRight;
@@ -149906,7 +149906,7 @@ static int termIsEquivalence(Parse *pParse, Expr *pExpr){
     return 0;
   }
   pColl = sqlite3ExprCompareCollSeq(pParse, pExpr);
-  if( sqlite3IsBinary(pColl) ) return 1;
+  if( sqlite3IsBinary(pColl) ) return 1; 
   return sqlite3ExprCollSeqMatch(pParse, pExpr->pLeft, pExpr->pRight);
 }
 
@@ -149929,9 +149929,9 @@ static Bitmask exprSelectUsage(WhereMaskSet *pMaskSet, Select *pS){
       for(i=0; i<pSrc->nSrc; i++){
         mask |= exprSelectUsage(pMaskSet, pSrc->a[i].pSelect);
         mask |= sqlite3WhereExprUsage(pMaskSet, pSrc->a[i].pOn);
-        if( pSrc->a[i].fg.isTabFunc ){
-          mask |= sqlite3WhereExprListUsage(pMaskSet, pSrc->a[i].u1.pFuncArg);
-        }
+        if( pSrc->a[i].fg.isTabFunc ){ 
+          mask |= sqlite3WhereExprListUsage(pMaskSet, pSrc->a[i].u1.pFuncArg); 
+        } 
       }
     }
     pS = pS->pPrior;
@@ -150068,7 +150068,7 @@ static void exprAnalyze(
     pTerm->prereqRight = sqlite3WhereExprUsage(pMaskSet, pExpr->pRight);
   }
   pMaskSet->bVarSelect = 0;
-  prereqAll = sqlite3WhereExprUsageNN(pMaskSet, pExpr);
+  prereqAll = sqlite3WhereExprUsageNN(pMaskSet, pExpr); 
   if( pMaskSet->bVarSelect ) pTerm->wtFlags |= TERM_VARSELECT;
   if( ExprHasProperty(pExpr, EP_FromJoin) ){
     Bitmask x = sqlite3WhereGetMask(pMaskSet, pExpr->iRightJoinTable);
@@ -150308,7 +150308,7 @@ static void exprAnalyze(
       }
       *pC = c + 1;
     }
-    zCollSeqName = noCase ? "NOCASE" : sqlite3StrBINARY;
+    zCollSeqName = noCase ? "NOCASE" : sqlite3StrBINARY; 
     pNewExpr1 = sqlite3ExprDup(db, pLeft, 0);
     pNewExpr1 = sqlite3PExpr(pParse, TK_GE,
            sqlite3ExprAddCollateString(pParse,pNewExpr1,zCollSeqName),
@@ -150360,7 +150360,7 @@ static void exprAnalyze(
       exprAnalyze(pSrc, pWC, idxNew);
     }
     pTerm = &pWC->a[idxTerm];
-    pTerm->wtFlags |= TERM_CODED|TERM_VIRTUAL;  /* Disable the original */
+    pTerm->wtFlags |= TERM_CODED|TERM_VIRTUAL;  /* Disable the original */ 
     pTerm->eOperator = 0;
   }
 
@@ -150490,7 +150490,7 @@ SQLITE_PRIVATE void sqlite3WhereClauseInit(
   WhereInfo *pWInfo        /* The WHERE processing context */
 ){
   pWC->pWInfo = pWInfo;
-  pWC->hasOr = 0;
+  pWC->hasOr = 0; 
   pWC->pOuter = 0;
   pWC->nTerm = 0;
   pWC->nSlot = ArraySize(pWC->aStatic);
@@ -150527,18 +150527,18 @@ SQLITE_PRIVATE void sqlite3WhereClauseClear(WhereClause *pWC){
 ** a bitmask indicating which tables are used in that expression
 ** tree.
 */
-SQLITE_PRIVATE Bitmask sqlite3WhereExprUsageNN(WhereMaskSet *pMaskSet, Expr *p){
+SQLITE_PRIVATE Bitmask sqlite3WhereExprUsageNN(WhereMaskSet *pMaskSet, Expr *p){ 
   Bitmask mask;
-  if( p->op==TK_COLUMN && !ExprHasProperty(p, EP_FixedCol) ){
+  if( p->op==TK_COLUMN && !ExprHasProperty(p, EP_FixedCol) ){ 
     return sqlite3WhereGetMask(pMaskSet, p->iTable);
-  }else if( ExprHasProperty(p, EP_TokenOnly|EP_Leaf) ){
-    assert( p->op!=TK_IF_NULL_ROW );
-    return 0;
+  }else if( ExprHasProperty(p, EP_TokenOnly|EP_Leaf) ){ 
+    assert( p->op!=TK_IF_NULL_ROW ); 
+    return 0; 
   }
   mask = (p->op==TK_IF_NULL_ROW) ? sqlite3WhereGetMask(pMaskSet, p->iTable) : 0;
-  if( p->pLeft ) mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pLeft);
+  if( p->pLeft ) mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pLeft); 
   if( p->pRight ){
-    mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pRight);
+    mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pRight); 
     assert( p->x.pList==0 );
   }else if( ExprUseXSelect(p) ){
     if( ExprHasProperty(p, EP_VarSelect) ) pMaskSet->bVarSelect = 1;
@@ -150546,19 +150546,19 @@ SQLITE_PRIVATE Bitmask sqlite3WhereExprUsageNN(WhereMaskSet *pMaskSet, Expr *p){
   }else if( p->x.pList ){
     mask |= sqlite3WhereExprListUsage(pMaskSet, p->x.pList);
   }
-#ifndef SQLITE_OMIT_WINDOWFUNC
+#ifndef SQLITE_OMIT_WINDOWFUNC 
   if( (p->op==TK_FUNCTION || p->op==TK_AGG_FUNCTION) && ExprUseYWin(p) ){
     assert( p->y.pWin!=0 );
-    mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pPartition);
-    mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pOrderBy);
+    mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pPartition); 
+    mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pOrderBy); 
     mask |= sqlite3WhereExprUsage(pMaskSet, p->y.pWin->pFilter);
-  }
-#endif
+  } 
+#endif 
   return mask;
 }
-SQLITE_PRIVATE Bitmask sqlite3WhereExprUsage(WhereMaskSet *pMaskSet, Expr *p){
-  return p ? sqlite3WhereExprUsageNN(pMaskSet,p) : 0;
-}
+SQLITE_PRIVATE Bitmask sqlite3WhereExprUsage(WhereMaskSet *pMaskSet, Expr *p){ 
+  return p ? sqlite3WhereExprUsageNN(pMaskSet,p) : 0; 
+} 
 SQLITE_PRIVATE Bitmask sqlite3WhereExprListUsage(WhereMaskSet *pMaskSet, ExprList *pList){
   int i;
   Bitmask mask = 0;
@@ -150612,7 +150612,7 @@ SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(
   pArgs = pItem->u1.pFuncArg;
   if( pArgs==0 ) return;
   for(j=k=0; j<pArgs->nExpr; j++){
-    Expr *pRhs;
+    Expr *pRhs; 
     while( k<pTab->nCol && (pTab->aCol[k].colFlags & COLFLAG_HIDDEN)==0 ){k++;}
     if( k>=pTab->nCol ){
       sqlite3ErrorMsg(pParse, "too many arguments on %s() - max %d",
@@ -150624,10 +150624,10 @@ SQLITE_PRIVATE void sqlite3WhereTabFuncArgs(
     pColRef->iTable = pItem->iCursor;
     pColRef->iColumn = k++;
     assert( ExprUseYTab(pColRef) );
-    pColRef->y.pTab = pTab;
+    pColRef->y.pTab = pTab; 
     pRhs = sqlite3PExpr(pParse, TK_UPLUS,
-        sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0);
-    pTerm = sqlite3PExpr(pParse, TK_EQ, pColRef, pRhs);
+        sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0); 
+    pTerm = sqlite3PExpr(pParse, TK_EQ, pColRef, pRhs); 
     if( pItem->fg.jointype & JT_LEFT ){
       sqlite3SetJoinExpr(pTerm, pItem->iCursor);
     }
@@ -150704,38 +150704,38 @@ SQLITE_PRIVATE int sqlite3WhereIsOrdered(WhereInfo *pWInfo){
 }
 
 /*
-** In the ORDER BY LIMIT optimization, if the inner-most loop is known
-** to emit rows in increasing order, and if the last row emitted by the
-** inner-most loop did not fit within the sorter, then we can skip all
-** subsequent rows for the current iteration of the inner loop (because they
-** will not fit in the sorter either) and continue with the second inner
-** loop - the loop immediately outside the inner-most.
-**
-** When a row does not fit in the sorter (because the sorter already
-** holds LIMIT+OFFSET rows that are smaller), then a jump is made to the
-** label returned by this function.
-**
-** If the ORDER BY LIMIT optimization applies, the jump destination should
-** be the continuation for the second-inner-most loop.  If the ORDER BY
-** LIMIT optimization does not apply, then the jump destination should
-** be the continuation for the inner-most loop.
-**
-** It is always safe for this routine to return the continuation of the
+** In the ORDER BY LIMIT optimization, if the inner-most loop is known 
+** to emit rows in increasing order, and if the last row emitted by the 
+** inner-most loop did not fit within the sorter, then we can skip all 
+** subsequent rows for the current iteration of the inner loop (because they 
+** will not fit in the sorter either) and continue with the second inner 
+** loop - the loop immediately outside the inner-most. 
+**
+** When a row does not fit in the sorter (because the sorter already 
+** holds LIMIT+OFFSET rows that are smaller), then a jump is made to the 
+** label returned by this function. 
+** 
+** If the ORDER BY LIMIT optimization applies, the jump destination should 
+** be the continuation for the second-inner-most loop.  If the ORDER BY 
+** LIMIT optimization does not apply, then the jump destination should 
+** be the continuation for the inner-most loop. 
+** 
+** It is always safe for this routine to return the continuation of the 
 ** inner-most loop, in the sense that a correct answer will result.
-** Returning the continuation the second inner loop is an optimization
-** that might make the code run a little faster, but should not change
-** the final answer.
+** Returning the continuation the second inner loop is an optimization 
+** that might make the code run a little faster, but should not change 
+** the final answer. 
 */
-SQLITE_PRIVATE int sqlite3WhereOrderByLimitOptLabel(WhereInfo *pWInfo){
-  WhereLevel *pInner;
-  if( !pWInfo->bOrderedInnerLoop ){
+SQLITE_PRIVATE int sqlite3WhereOrderByLimitOptLabel(WhereInfo *pWInfo){ 
+  WhereLevel *pInner; 
+  if( !pWInfo->bOrderedInnerLoop ){ 
     /* The ORDER BY LIMIT optimization does not apply.  Jump to the
-    ** continuation of the inner-most loop. */
-    return pWInfo->iContinue;
-  }
-  pInner = &pWInfo->a[pWInfo->nLevel-1];
-  assert( pInner->addrNxt!=0 );
-  return pInner->addrNxt;
+    ** continuation of the inner-most loop. */ 
+    return pWInfo->iContinue; 
+  } 
+  pInner = &pWInfo->a[pWInfo->nLevel-1]; 
+  assert( pInner->addrNxt!=0 ); 
+  return pInner->addrNxt; 
 }
 
 /*
@@ -151008,17 +151008,17 @@ static WhereTerm *whereScanNext(WhereScan *pScan){
 }
 
 /*
-** This is whereScanInit() for the case of an index on an expression.
-** It is factored out into a separate tail-recursion subroutine so that
-** the normal whereScanInit() routine, which is a high-runner, does not
-** need to push registers onto the stack as part of its prologue.
-*/
-static SQLITE_NOINLINE WhereTerm *whereScanInitIndexExpr(WhereScan *pScan){
-  pScan->idxaff = sqlite3ExprAffinity(pScan->pIdxExpr);
-  return whereScanNext(pScan);
-}
-
-/*
+** This is whereScanInit() for the case of an index on an expression. 
+** It is factored out into a separate tail-recursion subroutine so that 
+** the normal whereScanInit() routine, which is a high-runner, does not 
+** need to push registers onto the stack as part of its prologue. 
+*/ 
+static SQLITE_NOINLINE WhereTerm *whereScanInitIndexExpr(WhereScan *pScan){ 
+  pScan->idxaff = sqlite3ExprAffinity(pScan->pIdxExpr); 
+  return whereScanNext(pScan); 
+} 
+ 
+/* 
 ** Initialize a WHERE clause scanner object.  Return a pointer to the
 ** first match.  Return NULL if there are no matches.
 **
@@ -151050,19 +151050,19 @@ static WhereTerm *whereScanInit(
   pScan->pIdxExpr = 0;
   pScan->idxaff = 0;
   pScan->zCollName = 0;
-  pScan->opMask = opMask;
-  pScan->k = 0;
-  pScan->aiCur[0] = iCur;
-  pScan->nEquiv = 1;
-  pScan->iEquiv = 1;
+  pScan->opMask = opMask; 
+  pScan->k = 0; 
+  pScan->aiCur[0] = iCur; 
+  pScan->nEquiv = 1; 
+  pScan->iEquiv = 1; 
   if( pIdx ){
     int j = iColumn;
     iColumn = pIdx->aiColumn[j];
     if( iColumn==XN_EXPR ){
       pScan->pIdxExpr = pIdx->aColExpr->a[j].pExpr;
       pScan->zCollName = pIdx->azColl[j];
-      pScan->aiColumn[0] = XN_EXPR;
-      return whereScanInitIndexExpr(pScan);
+      pScan->aiColumn[0] = XN_EXPR; 
+      return whereScanInitIndexExpr(pScan); 
     }else if( iColumn==pIdx->pTable->iPKey ){
       iColumn = XN_ROWID;
     }else if( iColumn>=0 ){
@@ -151263,17 +151263,17 @@ static LogEst estLog(LogEst N){
 ** opcodes into OP_Copy when the table is being accessed via co-routine
 ** instead of via table lookup.
 **
-** If the iAutoidxCur is not zero, then any OP_Rowid instructions on
-** cursor iTabCur are transformed into OP_Sequence opcode for the
-** iAutoidxCur cursor, in order to generate unique rowids for the
-** automatic index being generated.
+** If the iAutoidxCur is not zero, then any OP_Rowid instructions on 
+** cursor iTabCur are transformed into OP_Sequence opcode for the 
+** iAutoidxCur cursor, in order to generate unique rowids for the 
+** automatic index being generated. 
 */
 static void translateColumnToCopy(
   Parse *pParse,      /* Parsing context */
   int iStart,         /* Translate from this opcode to the end */
   int iTabCur,        /* OP_Column/OP_Rowid references to this table */
   int iRegister,      /* The first column is in this register */
-  int iAutoidxCur     /* If non-zero, cursor of autoindex being generated */
+  int iAutoidxCur     /* If non-zero, cursor of autoindex being generated */ 
 ){
   Vdbe *v = pParse->pVdbe;
   VdbeOp *pOp = sqlite3VdbeGetOp(v, iStart);
@@ -151437,7 +151437,7 @@ static void constructAutomaticIndex(
      && (pTerm->wtFlags & TERM_VIRTUAL)==0
      && !ExprHasProperty(pExpr, EP_FromJoin)
      && sqlite3ExprIsTableConstant(pExpr, pSrc->iCursor) ){
-      pPartial = sqlite3ExprAnd(pParse, pPartial,
+      pPartial = sqlite3ExprAnd(pParse, pPartial, 
                                 sqlite3ExprDup(pParse->db, pExpr, 0));
     }
     if( termCanDriveIndex(pTerm, pSrc, notReady) ){
@@ -151552,12 +151552,12 @@ static void constructAutomaticIndex(
     sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub);
     addrTop =  sqlite3VdbeAddOp1(v, OP_Yield, regYield);
     VdbeCoverage(v);
-    VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
+    VdbeComment((v, "next row of %s", pTabItem->pTab->zName)); 
   }else{
     addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, pLevel->iTabCur); VdbeCoverage(v);
   }
   if( pPartial ){
-    iContinue = sqlite3VdbeMakeLabel(pParse);
+    iContinue = sqlite3VdbeMakeLabel(pParse); 
     sqlite3ExprIfFalse(pParse, pPartial, iContinue, SQLITE_JUMPIFNULL);
     pLoop->wsFlags |= WHERE_PARTIALIDX;
   }
@@ -151571,9 +151571,9 @@ static void constructAutomaticIndex(
   if( pTabItem->fg.viaCoroutine ){
     sqlite3VdbeChangeP2(v, addrCounter, regBase+n);
     testcase( pParse->db->mallocFailed );
-    assert( pLevel->iIdxCur>0 );
+    assert( pLevel->iIdxCur>0 ); 
     translateColumnToCopy(pParse, addrTop, pLevel->iTabCur,
-                          pTabItem->regResult, pLevel->iIdxCur);
+                          pTabItem->regResult, pLevel->iIdxCur); 
     sqlite3VdbeGoto(v, addrTop);
     pTabItem->fg.viaCoroutine = 0;
   }else{
@@ -151684,11 +151684,11 @@ static sqlite3_index_info *allocateIndexInfo(
     /* tag-20191211-002: WHERE-clause constraints are not useful to the
     ** right-hand table of a LEFT JOIN.  See tag-20191211-001 for the
     ** equivalent restriction for ordinary tables. */
-    if( (pSrc->fg.jointype & JT_LEFT)!=0
-     && !ExprHasProperty(pTerm->pExpr, EP_FromJoin)
-    ){
-      continue;
-    }
+    if( (pSrc->fg.jointype & JT_LEFT)!=0 
+     && !ExprHasProperty(pTerm->pExpr, EP_FromJoin) 
+    ){ 
+      continue; 
+    } 
     assert( (pTerm->eOperator & (WO_OR|WO_AND))==0 );
     assert( pTerm->u.x.leftColumn>=(-1) );
     pIdxCons[j].iColumn = pTerm->u.x.leftColumn;
@@ -151744,11 +151744,11 @@ static sqlite3_index_info *allocateIndexInfo(
 ** method of the virtual table with the sqlite3_index_info object that
 ** comes in as the 3rd argument to this function.
 **
-** If an error occurs, pParse is populated with an error message and an
-** appropriate error code is returned.  A return of SQLITE_CONSTRAINT from
-** xBestIndex is not considered an error.  SQLITE_CONSTRAINT indicates that
-** the current configuration of "unusable" flags in sqlite3_index_info can
-** not result in a valid plan.
+** If an error occurs, pParse is populated with an error message and an 
+** appropriate error code is returned.  A return of SQLITE_CONSTRAINT from 
+** xBestIndex is not considered an error.  SQLITE_CONSTRAINT indicates that 
+** the current configuration of "unusable" flags in sqlite3_index_info can 
+** not result in a valid plan. 
 **
 ** Whether or not an error is returned, it is the responsibility of the
 ** caller to eventually free p->idxStr if p->needToFreeIdxStr indicates
@@ -151762,7 +151762,7 @@ static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
   rc = pVtab->pModule->xBestIndex(pVtab, p);
   whereTraceIndexInfoOutputs(p);
 
-  if( rc!=SQLITE_OK && rc!=SQLITE_CONSTRAINT ){
+  if( rc!=SQLITE_OK && rc!=SQLITE_CONSTRAINT ){ 
     if( rc==SQLITE_NOMEM ){
       sqlite3OomFault(pParse->db);
     }else if( !pVtab->zErrMsg ){
@@ -151773,7 +151773,7 @@ static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
   }
   sqlite3_free(pVtab->zErrMsg);
   pVtab->zErrMsg = 0;
-  return rc;
+  return rc; 
 }
 #endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) */
 
@@ -152176,7 +152176,7 @@ static int whereRangeScanEst(
 
   if( p->nSample>0 && ALWAYS(nEq<p->nSampleCol)
    && OptimizationEnabled(pParse->db, SQLITE_Stat4)
-  ){
+  ){ 
     if( nEq==pBuilder->nRecValid ){
       UnpackedRecord *pRec = pBuilder->pRec;
       tRowcnt a[2];
@@ -152853,14 +152853,14 @@ static int whereLoopInsert(WhereLoopBuilder *pBuilder, WhereLoop *pTemplate){
   sqlite3 *db = pWInfo->pParse->db;
   int rc;
 
-  /* Stop the search once we hit the query planner search limit */
-  if( pBuilder->iPlanLimit==0 ){
-    WHERETRACE(0xffffffff,("=== query planner search limit reached ===\n"));
-    if( pBuilder->pOrSet ) pBuilder->pOrSet->n = 0;
-    return SQLITE_DONE;
-  }
-  pBuilder->iPlanLimit--;
-
+  /* Stop the search once we hit the query planner search limit */ 
+  if( pBuilder->iPlanLimit==0 ){ 
+    WHERETRACE(0xffffffff,("=== query planner search limit reached ===\n")); 
+    if( pBuilder->pOrSet ) pBuilder->pOrSet->n = 0; 
+    return SQLITE_DONE; 
+  } 
+  pBuilder->iPlanLimit--; 
+ 
   whereLoopAdjustCost(pWInfo->pLoops, pTemplate);
 
   /* If pBuilder->pOrSet is defined, then only keep track of the costs
@@ -152948,7 +152948,7 @@ static int whereLoopInsert(WhereLoopBuilder *pBuilder, WhereLoop *pTemplate){
   rc = whereLoopXfer(db, p, pTemplate);
   if( (p->wsFlags & WHERE_VIRTUALTABLE)==0 ){
     Index *pIndex = p->u.btree.pIndex;
-    if( pIndex && pIndex->idxType==SQLITE_IDXTYPE_IPK ){
+    if( pIndex && pIndex->idxType==SQLITE_IDXTYPE_IPK ){ 
       p->u.btree.pIndex = 0;
     }
   }
@@ -153126,7 +153126,7 @@ static int whereRangeVectorLen(
 ** function returns.
 **
 ** If pProbe->idxType==SQLITE_IDXTYPE_IPK, that means pIndex is
-** a fake index used for the INTEGER PRIMARY KEY.
+** a fake index used for the INTEGER PRIMARY KEY. 
 */
 static int whereLoopAddBtreeIndex(
   WhereLoopBuilder *pBuilder,     /* The WhereLoop factory */
@@ -153256,32 +153256,32 @@ static int whereLoopAddBtreeIndex(
       }
       if( pProbe->hasStat1 && rLogSize>=10 ){
         LogEst M, logK, x;
-        /* Let:
-        **   N = the total number of rows in the table
-        **   K = the number of entries on the RHS of the IN operator
+        /* Let: 
+        **   N = the total number of rows in the table 
+        **   K = the number of entries on the RHS of the IN operator 
         **   M = the number of rows in the table that match terms to the
-        **       to the left in the same index.  If the IN operator is on
-        **       the left-most index column, M==N.
-        **
-        ** Given the definitions above, it is better to omit the IN operator
-        ** from the index lookup and instead do a scan of the M elements,
-        ** testing each scanned row against the IN operator separately, if:
-        **
-        **        M*log(K) < K*log(N)
-        **
-        ** Our estimates for M, K, and N might be inaccurate, so we build in
-        ** a safety margin of 2 (LogEst: 10) that favors using the IN operator
-        ** with the index, as using an index has better worst-case behavior.
-        ** If we do not have real sqlite_stat1 data, always prefer to use
+        **       to the left in the same index.  If the IN operator is on 
+        **       the left-most index column, M==N. 
+        ** 
+        ** Given the definitions above, it is better to omit the IN operator 
+        ** from the index lookup and instead do a scan of the M elements, 
+        ** testing each scanned row against the IN operator separately, if: 
+        ** 
+        **        M*log(K) < K*log(N) 
+        ** 
+        ** Our estimates for M, K, and N might be inaccurate, so we build in 
+        ** a safety margin of 2 (LogEst: 10) that favors using the IN operator 
+        ** with the index, as using an index has better worst-case behavior. 
+        ** If we do not have real sqlite_stat1 data, always prefer to use 
         ** the index.  Do not bother with this optimization on very small
         ** tables (less than 2 rows) as it is pointless in that case.
-        */
-        M = pProbe->aiRowLogEst[saved_nEq];
-        logK = estLog(nIn);
+        */ 
+        M = pProbe->aiRowLogEst[saved_nEq]; 
+        logK = estLog(nIn); 
         /* TUNING      v-----  10 to bias toward indexed IN */
         x = M + logK + 10 - (nIn + rLogSize);
         if( x>=0 ){
-          WHERETRACE(0x40,
+          WHERETRACE(0x40, 
             ("IN operator (N=%d M=%d logK=%d nIn=%d rLogSize=%d x=%d) "
              "prefers indexed lookup\n",
              saved_nEq, M, logK, nIn, rLogSize, x));
@@ -153291,15 +153291,15 @@ static int whereLoopAddBtreeIndex(
              " nInMul=%d) prefers skip-scan\n",
              saved_nEq, M, logK, nIn, rLogSize, x, nInMul));
           pNew->wsFlags |= WHERE_IN_SEEKSCAN;
-        }else{
-          WHERETRACE(0x40,
+        }else{ 
+          WHERETRACE(0x40, 
             ("IN operator (N=%d M=%d logK=%d nIn=%d rLogSize=%d x=%d"
              " nInMul=%d) prefers normal scan\n",
              saved_nEq, M, logK, nIn, rLogSize, x, nInMul));
           continue;
-        }
-      }
-      pNew->wsFlags |= WHERE_COLUMN_IN;
+        } 
+      } 
+      pNew->wsFlags |= WHERE_COLUMN_IN; 
     }else if( eOp & (WO_EQ|WO_IS) ){
       int iCol = pProbe->aiColumn[saved_nEq];
       pNew->wsFlags |= WHERE_COLUMN_EQ;
@@ -153309,9 +153309,9 @@ static int whereLoopAddBtreeIndex(
       ){
         if( iCol==XN_ROWID || pProbe->uniqNotNull
          || (pProbe->nKeyCol==1 && pProbe->onError && eOp==WO_EQ)
-        ){
-          pNew->wsFlags |= WHERE_ONEROW;
-        }else{
+        ){ 
+          pNew->wsFlags |= WHERE_ONEROW; 
+        }else{ 
           pNew->wsFlags |= WHERE_UNQ_WANTED;
         }
       }
@@ -153494,7 +153494,7 @@ static int whereLoopAddBtreeIndex(
    && saved_nEq==pNew->nLTerm
    && pProbe->noSkipScan==0
    && pProbe->hasStat1!=0
-   && OptimizationEnabled(db, SQLITE_SkipScan)
+   && OptimizationEnabled(db, SQLITE_SkipScan) 
    && pProbe->aiRowLogEst[saved_nEq+1]>=42  /* TUNING: Minimum for skip-scan */
    && (rc = whereLoopResize(db, pNew, pNew->nLTerm+1))==SQLITE_OK
   ){
@@ -153515,8 +153515,8 @@ static int whereLoopAddBtreeIndex(
     pNew->wsFlags = saved_wsFlags;
   }
 
-  WHERETRACE(0x800, ("END %s.addBtreeIdx(%s), nEq=%d, rc=%d\n",
-                      pProbe->pTable->zName, pProbe->zName, saved_nEq, rc));
+  WHERETRACE(0x800, ("END %s.addBtreeIdx(%s), nEq=%d, rc=%d\n", 
+                      pProbe->pTable->zName, pProbe->zName, saved_nEq, rc)); 
   return rc;
 }
 
@@ -153673,7 +153673,7 @@ static int whereLoopAddBtree(
     sPk.onError = OE_Replace;
     sPk.pTable = pTab;
     sPk.szIdxRow = pTab->szTabRow;
-    sPk.idxType = SQLITE_IDXTYPE_IPK;
+    sPk.idxType = SQLITE_IDXTYPE_IPK; 
     aiRowEstPk[0] = pTab->nRowLogEst;
     aiRowEstPk[1] = 0;
     pFirst = pSrc->pTab->pIndex;
@@ -153713,16 +153713,16 @@ static int whereLoopAddBtree(
         /* TUNING: One-time cost for computing the automatic index is
         ** estimated to be X*N*log2(N) where N is the number of rows in
         ** the table being indexed and where X is 7 (LogEst=28) for normal
-        ** tables or 0.5 (LogEst=-10) for views and subqueries.  The value
+        ** tables or 0.5 (LogEst=-10) for views and subqueries.  The value 
         ** of X is smaller for views and subqueries so that the query planner
         ** will be more aggressive about generating automatic indexes for
         ** those objects, since there is no opportunity to add schema
         ** indexes on subqueries and views. */
-        pNew->rSetup = rLogSize + rSize;
+        pNew->rSetup = rLogSize + rSize; 
         if( !IsView(pTab) && (pTab->tabFlags & TF_Ephemeral)==0 ){
-          pNew->rSetup += 28;
-        }else{
-          pNew->rSetup -= 10;
+          pNew->rSetup += 28; 
+        }else{ 
+          pNew->rSetup -= 10; 
         }
         ApplyCostMultiplier(pNew->rSetup, pTab->costMult);
         if( pNew->rSetup<0 ) pNew->rSetup = 0;
@@ -153769,7 +153769,7 @@ static int whereLoopAddBtree(
 
     /* The ONEPASS_DESIRED flags never occurs together with ORDER BY */
     assert( (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || b==0 );
-    if( pProbe->idxType==SQLITE_IDXTYPE_IPK ){
+    if( pProbe->idxType==SQLITE_IDXTYPE_IPK ){ 
       /* Integer primary key index */
       pNew->wsFlags = WHERE_IPK;
 
@@ -153803,7 +153803,7 @@ static int whereLoopAddBtree(
         pNew->wsFlags = WHERE_IDX_ONLY | WHERE_INDEXED;
         m = 0;
       }else{
-        m = pSrc->colUsed & pProbe->colNotIdxed;
+        m = pSrc->colUsed & pProbe->colNotIdxed; 
         pNew->wsFlags = (m==0) ? (WHERE_IDX_ONLY|WHERE_INDEXED) : WHERE_INDEXED;
       }
 
@@ -153951,17 +153951,17 @@ static int whereLoopAddVirtualOne(
 
   /* Invoke the virtual table xBestIndex() method */
   rc = vtabBestIndex(pParse, pSrc->pTab, pIdxInfo);
-  if( rc ){
-    if( rc==SQLITE_CONSTRAINT ){
-      /* If the xBestIndex method returns SQLITE_CONSTRAINT, that means
-      ** that the particular combination of parameters provided is unusable.
-      ** Make no entries in the loop table.
-      */
-      WHERETRACE(0xffff, ("  ^^^^--- non-viable plan rejected!\n"));
-      return SQLITE_OK;
-    }
-    return rc;
-  }
+  if( rc ){ 
+    if( rc==SQLITE_CONSTRAINT ){ 
+      /* If the xBestIndex method returns SQLITE_CONSTRAINT, that means 
+      ** that the particular combination of parameters provided is unusable. 
+      ** Make no entries in the loop table. 
+      */ 
+      WHERETRACE(0xffff, ("  ^^^^--- non-viable plan rejected!\n")); 
+      return SQLITE_OK; 
+    } 
+    return rc; 
+  } 
 
   mxTerm = -1;
   assert( pNew->nLSlot>=nConstraint );
@@ -153980,8 +153980,8 @@ static int whereLoopAddVirtualOne(
        || pIdxCons->usable==0
       ){
         sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
-        testcase( pIdxInfo->needToFreeIdxStr );
-        return SQLITE_ERROR;
+        testcase( pIdxInfo->needToFreeIdxStr ); 
+        return SQLITE_ERROR; 
       }
       testcase( iTerm==nConstraint-1 );
       testcase( j==0 );
@@ -154015,15 +154015,15 @@ static int whereLoopAddVirtualOne(
   }
 
   pNew->nLTerm = mxTerm+1;
-  for(i=0; i<=mxTerm; i++){
-    if( pNew->aLTerm[i]==0 ){
-      /* The non-zero argvIdx values must be contiguous.  Raise an
-      ** error if they are not */
-      sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
-      testcase( pIdxInfo->needToFreeIdxStr );
-      return SQLITE_ERROR;
-    }
-  }
+  for(i=0; i<=mxTerm; i++){ 
+    if( pNew->aLTerm[i]==0 ){ 
+      /* The non-zero argvIdx values must be contiguous.  Raise an 
+      ** error if they are not */ 
+      sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName); 
+      testcase( pIdxInfo->needToFreeIdxStr ); 
+      return SQLITE_ERROR; 
+    } 
+  } 
   assert( pNew->nLTerm<=pNew->nLSlot );
   pNew->u.vtab.idxNum = pIdxInfo->idxNum;
   pNew->u.vtab.needFree = pIdxInfo->needToFreeIdxStr;
@@ -154071,7 +154071,7 @@ SQLITE_API const char *sqlite3_vtab_collation(sqlite3_index_info *pIdxInfo, int
     if( pX->pLeft ){
       pC = sqlite3ExprCompareCollSeq(pHidden->pParse, pX);
     }
-    zRet = (pC ? pC->zName : sqlite3StrBINARY);
+    zRet = (pC ? pC->zName : sqlite3StrBINARY); 
   }
   return zRet;
 }
@@ -154139,16 +154139,16 @@ static int whereLoopAddVirtual(
   }
 
   /* First call xBestIndex() with all constraints usable. */
-  WHERETRACE(0x800, ("BEGIN %s.addVirtual()\n", pSrc->pTab->zName));
+  WHERETRACE(0x800, ("BEGIN %s.addVirtual()\n", pSrc->pTab->zName)); 
   WHERETRACE(0x40, ("  VirtualOne: all usable\n"));
   rc = whereLoopAddVirtualOne(pBuilder, mPrereq, ALLBITS, 0, p, mNoOmit, &bIn);
 
   /* If the call to xBestIndex() with all terms enabled produced a plan
-  ** that does not require any source tables (IOW: a plan with mBest==0)
+  ** that does not require any source tables (IOW: a plan with mBest==0) 
   ** and does not use an IN(...) operator, then there is no point in making
-  ** any further calls to xBestIndex() since they will all return the same
-  ** result (if the xBestIndex() implementation is sane). */
-  if( rc==SQLITE_OK && ((mBest = (pNew->prereq & ~mPrereq))!=0 || bIn) ){
+  ** any further calls to xBestIndex() since they will all return the same 
+  ** result (if the xBestIndex() implementation is sane). */ 
+  if( rc==SQLITE_OK && ((mBest = (pNew->prereq & ~mPrereq))!=0 || bIn) ){ 
     int seenZero = 0;             /* True if a plan with no prereqs seen */
     int seenZeroNoIN = 0;         /* Plan with no prereqs and no IN(...) seen */
     Bitmask mPrev = 0;
@@ -154215,7 +154215,7 @@ static int whereLoopAddVirtual(
 
   if( p->needToFreeIdxStr ) sqlite3_free(p->idxStr);
   sqlite3DbFreeNN(pParse->db, p);
-  WHERETRACE(0x800, ("END %s.addVirtual(), rc=%d\n", pSrc->pTab->zName, rc));
+  WHERETRACE(0x800, ("END %s.addVirtual(), rc=%d\n", pSrc->pTab->zName, rc)); 
   return rc;
 }
 #endif /* SQLITE_OMIT_VIRTUALTABLE */
@@ -154365,11 +154365,11 @@ static int whereLoopAddAll(WhereLoopBuilder *pBuilder){
   /* Loop over the tables in the join, from left to right */
   pNew = pBuilder->pNew;
   whereLoopInit(pNew);
-  pBuilder->iPlanLimit = SQLITE_QUERY_PLANNER_LIMIT;
+  pBuilder->iPlanLimit = SQLITE_QUERY_PLANNER_LIMIT; 
   for(iTab=0, pItem=pTabList->a; pItem<pEnd; iTab++, pItem++){
     Bitmask mUnusable = 0;
     pNew->iTab = iTab;
-    pBuilder->iPlanLimit += SQLITE_QUERY_PLANNER_LIMIT_INCR;
+    pBuilder->iPlanLimit += SQLITE_QUERY_PLANNER_LIMIT_INCR; 
     pNew->maskSelf = sqlite3WhereGetMask(&pWInfo->sMaskSet, pItem->iCursor);
     if( (pItem->fg.jointype & (JT_LEFT|JT_CROSS))!=0 ){
       /* This condition is true when pItem is the FROM clause term on the
@@ -154392,19 +154392,19 @@ static int whereLoopAddAll(WhereLoopBuilder *pBuilder){
     {
       rc = whereLoopAddBtree(pBuilder, mPrereq);
     }
-    if( rc==SQLITE_OK && pBuilder->pWC->hasOr ){
+    if( rc==SQLITE_OK && pBuilder->pWC->hasOr ){ 
       rc = whereLoopAddOr(pBuilder, mPrereq, mUnusable);
     }
     mPrior |= pNew->maskSelf;
-    if( rc || db->mallocFailed ){
-      if( rc==SQLITE_DONE ){
-        /* We hit the query planner search limit set by iPlanLimit */
-        sqlite3_log(SQLITE_WARNING, "abbreviated query algorithm search");
-        rc = SQLITE_OK;
-      }else{
-        break;
-      }
-    }
+    if( rc || db->mallocFailed ){ 
+      if( rc==SQLITE_DONE ){ 
+        /* We hit the query planner search limit set by iPlanLimit */ 
+        sqlite3_log(SQLITE_WARNING, "abbreviated query algorithm search"); 
+        rc = SQLITE_OK; 
+      }else{ 
+        break; 
+      } 
+    } 
   }
 
   whereLoopClear(db, pNew);
@@ -154951,15 +154951,15 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){
 
         if( (pWLoop->prereq & ~pFrom->maskLoop)!=0 ) continue;
         if( (pWLoop->maskSelf & pFrom->maskLoop)!=0 ) continue;
-        if( (pWLoop->wsFlags & WHERE_AUTO_INDEX)!=0 && pFrom->nRow<3 ){
+        if( (pWLoop->wsFlags & WHERE_AUTO_INDEX)!=0 && pFrom->nRow<3 ){ 
           /* Do not use an automatic index if the this loop is expected
-          ** to run less than 1.25 times.  It is tempting to also exclude
-          ** automatic index usage on an outer loop, but sometimes an automatic
-          ** index is useful in the outer loop of a correlated subquery. */
+          ** to run less than 1.25 times.  It is tempting to also exclude 
+          ** automatic index usage on an outer loop, but sometimes an automatic 
+          ** index is useful in the outer loop of a correlated subquery. */ 
           assert( 10==sqlite3LogEst(2) );
           continue;
         }
-
+ 
         /* At this point, pWLoop is a candidate to be the next loop.
         ** Compute its cost */
         rUnsorted = sqlite3LogEstAdd(pWLoop->rSetup,pWLoop->rRun + pFrom->nRow);
@@ -154979,11 +154979,11 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){
                 pWInfo, nRowEst, nOrderBy, isOrdered
             );
           }
-          /* TUNING:  Add a small extra penalty (5) to sorting as an
-          ** extra encouragment to the query planner to select a plan
-          ** where the rows emerge in the correct order without any sorting
-          ** required. */
-          rCost = sqlite3LogEstAdd(rUnsorted, aSortCost[isOrdered]) + 5;
+          /* TUNING:  Add a small extra penalty (5) to sorting as an 
+          ** extra encouragment to the query planner to select a plan 
+          ** where the rows emerge in the correct order without any sorting 
+          ** required. */ 
+          rCost = sqlite3LogEstAdd(rUnsorted, aSortCost[isOrdered]) + 5; 
 
           WHERETRACE(0x002,
               ("---- sort cost=%-3d (%d/%d) increases cost %3d to %-3d\n",
@@ -155173,7 +155173,7 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){
       pWInfo->eDistinct = WHERE_DISTINCT_ORDERED;
     }
   }
-  pWInfo->bOrderedInnerLoop = 0;
+  pWInfo->bOrderedInnerLoop = 0; 
   if( pWInfo->pOrderBy ){
     if( pWInfo->wctrlFlags & WHERE_DISTINCTBY ){
       if( pFrom->isOrdered==pWInfo->pOrderBy->nExpr ){
@@ -155293,7 +155293,7 @@ static int whereShortCut(WhereLoopBuilder *pBuilder){
       }
       if( j!=pIdx->nKeyCol ) continue;
       pLoop->wsFlags = WHERE_COLUMN_EQ|WHERE_ONEROW|WHERE_INDEXED;
-      if( pIdx->isCovering || (pItem->colUsed & pIdx->colNotIdxed)==0 ){
+      if( pIdx->isCovering || (pItem->colUsed & pIdx->colNotIdxed)==0 ){ 
         pLoop->wsFlags |= WHERE_IDX_ONLY;
       }
       pLoop->nLTerm = j;
@@ -155550,7 +155550,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
   pWInfo->pResultSet = pResultSet;
   pWInfo->aiCurOnePass[0] = pWInfo->aiCurOnePass[1] = -1;
   pWInfo->nLevel = nTabList;
-  pWInfo->iBreak = pWInfo->iContinue = sqlite3VdbeMakeLabel(pParse);
+  pWInfo->iBreak = pWInfo->iContinue = sqlite3VdbeMakeLabel(pParse); 
   pWInfo->wctrlFlags = wctrlFlags;
   pWInfo->iLimit = iAuxArg;
   pWInfo->savedNQueryLoop = pParse->nQueryLoop;
@@ -155582,7 +155582,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
     if( wctrlFlags & WHERE_WANT_DISTINCT ){
       pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE;
     }
-    ExplainQueryPlan((pParse, 0, "SCAN CONSTANT ROW"));
+    ExplainQueryPlan((pParse, 0, "SCAN CONSTANT ROW")); 
   }else{
     /* Assign a bit from the bitmask to every term in the FROM clause.
     **
@@ -155632,7 +155632,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
   */
   for(ii=0; ii<sWLB.pWC->nTerm; ii++){
     WhereTerm *pT = &sWLB.pWC->a[ii];
-    if( pT->wtFlags & TERM_VIRTUAL ) continue;
+    if( pT->wtFlags & TERM_VIRTUAL ) continue; 
     if( pT->prereqAll==0 && (nTabList==0 || exprIsDeterministic(pT->pExpr)) ){
       sqlite3ExprIfFalse(pParse, pT->pExpr, pWInfo->iBreak, SQLITE_JUMPIFNULL);
       pT->wtFlags |= TERM_CODED;
@@ -155851,10 +155851,10 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
   if( (wctrlFlags & WHERE_ONEPASS_DESIRED)!=0 ){
     int wsFlags = pWInfo->a[0].pWLoop->wsFlags;
     int bOnerow = (wsFlags & WHERE_ONEROW)!=0;
-    assert( !(wsFlags & WHERE_VIRTUALTABLE) || IsVirtual(pTabList->a[0].pTab) );
+    assert( !(wsFlags & WHERE_VIRTUALTABLE) || IsVirtual(pTabList->a[0].pTab) ); 
     if( bOnerow || (
         0!=(wctrlFlags & WHERE_ONEPASS_MULTIROW)
-     && !IsVirtual(pTabList->a[0].pTab)
+     && !IsVirtual(pTabList->a[0].pTab) 
      && (0==(wsFlags & WHERE_MULTI_OR) || (wctrlFlags & WHERE_DUPLICATES_OK))
     )){
       pWInfo->eOnePass = bOnerow ? ONEPASS_SINGLE : ONEPASS_MULTI;
@@ -156015,10 +156015,10 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
     }
 #endif
     addrExplain = sqlite3WhereExplainOneScan(
-        pParse, pTabList, pLevel, wctrlFlags
+        pParse, pTabList, pLevel, wctrlFlags 
     );
     pLevel->addrBody = sqlite3VdbeCurrentAddr(v);
-    notReady = sqlite3WhereCodeOneLoopStart(pParse,v,pWInfo,ii,pLevel,notReady);
+    notReady = sqlite3WhereCodeOneLoopStart(pParse,v,pWInfo,ii,pLevel,notReady); 
     pWInfo->iContinue = pLevel->addrCont;
     if( (wsFlags&WHERE_MULTI_OR)==0 && (wctrlFlags&WHERE_OR_SUBCLAUSE)==0 ){
       sqlite3WhereAddScanStatus(v, pTabList, pLevel, addrExplain);
@@ -156042,26 +156042,26 @@ whereBeginError:
 }
 
 /*
-** Part of sqlite3WhereEnd() will rewrite opcodes to reference the
-** index rather than the main table.  In SQLITE_DEBUG mode, we want
-** to trace those changes if PRAGMA vdbe_addoptrace=on.  This routine
-** does that.
-*/
-#ifndef SQLITE_DEBUG
-# define OpcodeRewriteTrace(D,K,P) /* no-op */
-#else
-# define OpcodeRewriteTrace(D,K,P) sqlite3WhereOpcodeRewriteTrace(D,K,P)
-  static void sqlite3WhereOpcodeRewriteTrace(
-    sqlite3 *db,
-    int pc,
-    VdbeOp *pOp
-  ){
-    if( (db->flags & SQLITE_VdbeAddopTrace)==0 ) return;
-    sqlite3VdbePrintOp(0, pc, pOp);
-  }
-#endif
-
-/*
+** Part of sqlite3WhereEnd() will rewrite opcodes to reference the 
+** index rather than the main table.  In SQLITE_DEBUG mode, we want 
+** to trace those changes if PRAGMA vdbe_addoptrace=on.  This routine 
+** does that. 
+*/ 
+#ifndef SQLITE_DEBUG 
+# define OpcodeRewriteTrace(D,K,P) /* no-op */ 
+#else 
+# define OpcodeRewriteTrace(D,K,P) sqlite3WhereOpcodeRewriteTrace(D,K,P) 
+  static void sqlite3WhereOpcodeRewriteTrace( 
+    sqlite3 *db, 
+    int pc, 
+    VdbeOp *pOp 
+  ){ 
+    if( (db->flags & SQLITE_VdbeAddopTrace)==0 ) return; 
+    sqlite3VdbePrintOp(0, pc, pOp); 
+  } 
+#endif 
+ 
+/* 
 ** Generate the end of the WHERE loop.  See comments on
 ** sqlite3WhereBegin() for additional information.
 */
@@ -156135,7 +156135,7 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
                  || pParse->db->mallocFailed );
         sqlite3VdbeJumpHere(v, pIn->addrInTop+1);
         if( pIn->eEndLoopOp!=OP_Noop ){
-          if( pIn->nPrefix ){
+          if( pIn->nPrefix ){ 
             int bEarlyOut =
                 (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0
                  && (pLoop->wsFlags & WHERE_IN_EARLYOUT)!=0;
@@ -156163,11 +156163,11 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
               ** required by OP_IfNoHope. */
               sqlite3VdbeJumpHere(v, pIn->addrInTop+1);
             }
-          }
+          } 
           sqlite3VdbeAddOp2(v, pIn->eEndLoopOp, pIn->iCur, pIn->addrInTop);
           VdbeCoverage(v);
-          VdbeCoverageIf(v, pIn->eEndLoopOp==OP_Prev);
-          VdbeCoverageIf(v, pIn->eEndLoopOp==OP_Next);
+          VdbeCoverageIf(v, pIn->eEndLoopOp==OP_Prev); 
+          VdbeCoverageIf(v, pIn->eEndLoopOp==OP_Next); 
         }
         sqlite3VdbeJumpHere(v, pIn->addrInTop-1);
       }
@@ -156242,29 +156242,29 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
       continue;
     }
 
-#ifdef SQLITE_ENABLE_EARLY_CURSOR_CLOSE
-    /* Close all of the cursors that were opened by sqlite3WhereBegin.
-    ** Except, do not close cursors that will be reused by the OR optimization
-    ** (WHERE_OR_SUBCLAUSE).  And do not close the OP_OpenWrite cursors
-    ** created for the ONEPASS optimization.
-    */
-    if( (pTab->tabFlags & TF_Ephemeral)==0
+#ifdef SQLITE_ENABLE_EARLY_CURSOR_CLOSE 
+    /* Close all of the cursors that were opened by sqlite3WhereBegin. 
+    ** Except, do not close cursors that will be reused by the OR optimization 
+    ** (WHERE_OR_SUBCLAUSE).  And do not close the OP_OpenWrite cursors 
+    ** created for the ONEPASS optimization. 
+    */ 
+    if( (pTab->tabFlags & TF_Ephemeral)==0 
      && !IsView(pTab)
-     && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0
-    ){
-      int ws = pLoop->wsFlags;
-      if( pWInfo->eOnePass==ONEPASS_OFF && (ws & WHERE_IDX_ONLY)==0 ){
-        sqlite3VdbeAddOp1(v, OP_Close, pTabItem->iCursor);
-      }
-      if( (ws & WHERE_INDEXED)!=0
+     && (pWInfo->wctrlFlags & WHERE_OR_SUBCLAUSE)==0 
+    ){ 
+      int ws = pLoop->wsFlags; 
+      if( pWInfo->eOnePass==ONEPASS_OFF && (ws & WHERE_IDX_ONLY)==0 ){ 
+        sqlite3VdbeAddOp1(v, OP_Close, pTabItem->iCursor); 
+      } 
+      if( (ws & WHERE_INDEXED)!=0 
        && (ws & (WHERE_IPK|WHERE_AUTO_INDEX))==0
-       && pLevel->iIdxCur!=pWInfo->aiCurOnePass[1]
-      ){
-        sqlite3VdbeAddOp1(v, OP_Close, pLevel->iIdxCur);
-      }
-    }
-#endif
-
+       && pLevel->iIdxCur!=pWInfo->aiCurOnePass[1] 
+      ){ 
+        sqlite3VdbeAddOp1(v, OP_Close, pLevel->iIdxCur); 
+      } 
+    } 
+#endif 
+ 
     /* If this scan uses an index, make VDBE code substitutions to read data
     ** from the index instead of from the table where possible.  In some cases
     ** this optimization prevents the table from ever being read, which can
@@ -156290,16 +156290,16 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
         last = pWInfo->iEndWhere;
       }
       k = pLevel->addrBody + 1;
-#ifdef SQLITE_DEBUG
-      if( db->flags & SQLITE_VdbeAddopTrace ){
-        printf("TRANSLATE opcodes in range %d..%d\n", k, last-1);
-      }
+#ifdef SQLITE_DEBUG 
+      if( db->flags & SQLITE_VdbeAddopTrace ){ 
+        printf("TRANSLATE opcodes in range %d..%d\n", k, last-1); 
+      } 
       /* Proof that the "+1" on the k value above is safe */
       pOp = sqlite3VdbeGetOp(v, k - 1);
       assert( pOp->opcode!=OP_Column || pOp->p1!=pLevel->iTabCur );
       assert( pOp->opcode!=OP_Rowid  || pOp->p1!=pLevel->iTabCur );
       assert( pOp->opcode!=OP_IfNullRow || pOp->p1!=pLevel->iTabCur );
-#endif
+#endif 
       pOp = sqlite3VdbeGetOp(v, k);
       pLastOp = pOp + (last - k);
       assert( pOp<=pLastOp );
@@ -156325,25 +156325,25 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
           if( x>=0 ){
             pOp->p2 = x;
             pOp->p1 = pLevel->iIdxCur;
-            OpcodeRewriteTrace(db, k, pOp);
+            OpcodeRewriteTrace(db, k, pOp); 
           }
           assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 || x>=0
               || pWInfo->eOnePass );
         }else if( pOp->opcode==OP_Rowid ){
           pOp->p1 = pLevel->iIdxCur;
           pOp->opcode = OP_IdxRowid;
-          OpcodeRewriteTrace(db, k, pOp);
+          OpcodeRewriteTrace(db, k, pOp); 
         }else if( pOp->opcode==OP_IfNullRow ){
           pOp->p1 = pLevel->iIdxCur;
-          OpcodeRewriteTrace(db, k, pOp);
+          OpcodeRewriteTrace(db, k, pOp); 
         }
-#ifdef SQLITE_DEBUG
+#ifdef SQLITE_DEBUG 
         k++;
 #endif
       }while( (++pOp)<pLastOp );
 #ifdef SQLITE_DEBUG
-      if( db->flags & SQLITE_VdbeAddopTrace ) printf("TRANSLATE complete\n");
-#endif
+      if( db->flags & SQLITE_VdbeAddopTrace ) printf("TRANSLATE complete\n"); 
+#endif 
     }
   }
 
@@ -156356,706 +156356,706 @@ SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){
 }
 
 /************** End of where.c ***********************************************/
-/************** Begin file window.c ******************************************/
-/*
-** 2018 May 08
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-*************************************************************************
-*/
-/* #include "sqliteInt.h" */
-
-#ifndef SQLITE_OMIT_WINDOWFUNC
-
-/*
-** SELECT REWRITING
-**
-**   Any SELECT statement that contains one or more window functions in
-**   either the select list or ORDER BY clause (the only two places window
-**   functions may be used) is transformed by function sqlite3WindowRewrite()
-**   in order to support window function processing. For example, with the
-**   schema:
-**
-**     CREATE TABLE t1(a, b, c, d, e, f, g);
-**
-**   the statement:
-**
-**     SELECT a+1, max(b) OVER (PARTITION BY c ORDER BY d) FROM t1 ORDER BY e;
-**
-**   is transformed to:
-**
-**     SELECT a+1, max(b) OVER (PARTITION BY c ORDER BY d) FROM (
-**         SELECT a, e, c, d, b FROM t1 ORDER BY c, d
-**     ) ORDER BY e;
-**
-**   The flattening optimization is disabled when processing this transformed
-**   SELECT statement. This allows the implementation of the window function
-**   (in this case max()) to process rows sorted in order of (c, d), which
-**   makes things easier for obvious reasons. More generally:
-**
+/************** Begin file window.c ******************************************/ 
+/* 
+** 2018 May 08 
+** 
+** The author disclaims copyright to this source code.  In place of 
+** a legal notice, here is a blessing: 
+** 
+**    May you do good and not evil. 
+**    May you find forgiveness for yourself and forgive others. 
+**    May you share freely, never taking more than you give. 
+** 
+************************************************************************* 
+*/ 
+/* #include "sqliteInt.h" */ 
+ 
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+ 
+/* 
+** SELECT REWRITING 
+** 
+**   Any SELECT statement that contains one or more window functions in 
+**   either the select list or ORDER BY clause (the only two places window 
+**   functions may be used) is transformed by function sqlite3WindowRewrite() 
+**   in order to support window function processing. For example, with the 
+**   schema: 
+** 
+**     CREATE TABLE t1(a, b, c, d, e, f, g); 
+** 
+**   the statement: 
+** 
+**     SELECT a+1, max(b) OVER (PARTITION BY c ORDER BY d) FROM t1 ORDER BY e; 
+** 
+**   is transformed to: 
+** 
+**     SELECT a+1, max(b) OVER (PARTITION BY c ORDER BY d) FROM ( 
+**         SELECT a, e, c, d, b FROM t1 ORDER BY c, d 
+**     ) ORDER BY e; 
+** 
+**   The flattening optimization is disabled when processing this transformed 
+**   SELECT statement. This allows the implementation of the window function 
+**   (in this case max()) to process rows sorted in order of (c, d), which 
+**   makes things easier for obvious reasons. More generally: 
+** 
 **     * FROM, WHERE, GROUP BY and HAVING clauses are all moved to
-**       the sub-query.
-**
-**     * ORDER BY, LIMIT and OFFSET remain part of the parent query.
-**
+**       the sub-query. 
+** 
+**     * ORDER BY, LIMIT and OFFSET remain part of the parent query. 
+** 
 **     * Terminals from each of the expression trees that make up the
-**       select-list and ORDER BY expressions in the parent query are
-**       selected by the sub-query. For the purposes of the transformation,
-**       terminals are column references and aggregate functions.
-**
-**   If there is more than one window function in the SELECT that uses
-**   the same window declaration (the OVER bit), then a single scan may
-**   be used to process more than one window function. For example:
-**
+**       select-list and ORDER BY expressions in the parent query are 
+**       selected by the sub-query. For the purposes of the transformation, 
+**       terminals are column references and aggregate functions. 
+** 
+**   If there is more than one window function in the SELECT that uses 
+**   the same window declaration (the OVER bit), then a single scan may 
+**   be used to process more than one window function. For example: 
+** 
 **     SELECT max(b) OVER (PARTITION BY c ORDER BY d),
 **            min(e) OVER (PARTITION BY c ORDER BY d)
-**     FROM t1;
-**
-**   is transformed in the same way as the example above. However:
-**
+**     FROM t1; 
+** 
+**   is transformed in the same way as the example above. However: 
+** 
 **     SELECT max(b) OVER (PARTITION BY c ORDER BY d),
 **            min(e) OVER (PARTITION BY a ORDER BY b)
-**     FROM t1;
-**
-**   Must be transformed to:
-**
-**     SELECT max(b) OVER (PARTITION BY c ORDER BY d) FROM (
-**         SELECT e, min(e) OVER (PARTITION BY a ORDER BY b), c, d, b FROM
-**           SELECT a, e, c, d, b FROM t1 ORDER BY a, b
-**         ) ORDER BY c, d
-**     ) ORDER BY e;
-**
-**   so that both min() and max() may process rows in the order defined by
-**   their respective window declarations.
-**
-** INTERFACE WITH SELECT.C
-**
-**   When processing the rewritten SELECT statement, code in select.c calls
-**   sqlite3WhereBegin() to begin iterating through the results of the
-**   sub-query, which is always implemented as a co-routine. It then calls
-**   sqlite3WindowCodeStep() to process rows and finish the scan by calling
-**   sqlite3WhereEnd().
-**
-**   sqlite3WindowCodeStep() generates VM code so that, for each row returned
-**   by the sub-query a sub-routine (OP_Gosub) coded by select.c is invoked.
-**   When the sub-routine is invoked:
-**
-**     * The results of all window-functions for the row are stored
-**       in the associated Window.regResult registers.
-**
-**     * The required terminal values are stored in the current row of
-**       temp table Window.iEphCsr.
-**
-**   In some cases, depending on the window frame and the specific window
-**   functions invoked, sqlite3WindowCodeStep() caches each entire partition
-**   in a temp table before returning any rows. In other cases it does not.
-**   This detail is encapsulated within this file, the code generated by
-**   select.c is the same in either case.
-**
-** BUILT-IN WINDOW FUNCTIONS
-**
-**   This implementation features the following built-in window functions:
-**
-**     row_number()
-**     rank()
-**     dense_rank()
-**     percent_rank()
-**     cume_dist()
-**     ntile(N)
-**     lead(expr [, offset [, default]])
-**     lag(expr [, offset [, default]])
-**     first_value(expr)
-**     last_value(expr)
-**     nth_value(expr, N)
+**     FROM t1; 
+** 
+**   Must be transformed to: 
+** 
+**     SELECT max(b) OVER (PARTITION BY c ORDER BY d) FROM ( 
+**         SELECT e, min(e) OVER (PARTITION BY a ORDER BY b), c, d, b FROM 
+**           SELECT a, e, c, d, b FROM t1 ORDER BY a, b 
+**         ) ORDER BY c, d 
+**     ) ORDER BY e; 
+** 
+**   so that both min() and max() may process rows in the order defined by 
+**   their respective window declarations. 
+** 
+** INTERFACE WITH SELECT.C 
+** 
+**   When processing the rewritten SELECT statement, code in select.c calls 
+**   sqlite3WhereBegin() to begin iterating through the results of the 
+**   sub-query, which is always implemented as a co-routine. It then calls 
+**   sqlite3WindowCodeStep() to process rows and finish the scan by calling 
+**   sqlite3WhereEnd(). 
+** 
+**   sqlite3WindowCodeStep() generates VM code so that, for each row returned 
+**   by the sub-query a sub-routine (OP_Gosub) coded by select.c is invoked. 
+**   When the sub-routine is invoked: 
+** 
+**     * The results of all window-functions for the row are stored 
+**       in the associated Window.regResult registers. 
+** 
+**     * The required terminal values are stored in the current row of 
+**       temp table Window.iEphCsr. 
+** 
+**   In some cases, depending on the window frame and the specific window 
+**   functions invoked, sqlite3WindowCodeStep() caches each entire partition 
+**   in a temp table before returning any rows. In other cases it does not. 
+**   This detail is encapsulated within this file, the code generated by 
+**   select.c is the same in either case. 
+** 
+** BUILT-IN WINDOW FUNCTIONS 
+** 
+**   This implementation features the following built-in window functions: 
+** 
+**     row_number() 
+**     rank() 
+**     dense_rank() 
+**     percent_rank() 
+**     cume_dist() 
+**     ntile(N) 
+**     lead(expr [, offset [, default]]) 
+**     lag(expr [, offset [, default]]) 
+**     first_value(expr) 
+**     last_value(expr) 
+**     nth_value(expr, N) 
 **
 **   These are the same built-in window functions supported by Postgres.
-**   Although the behaviour of aggregate window functions (functions that
-**   can be used as either aggregates or window funtions) allows them to
-**   be implemented using an API, built-in window functions are much more
+**   Although the behaviour of aggregate window functions (functions that 
+**   can be used as either aggregates or window funtions) allows them to 
+**   be implemented using an API, built-in window functions are much more 
 **   esoteric. Additionally, some window functions (e.g. nth_value())
-**   may only be implemented by caching the entire partition in memory.
-**   As such, some built-in window functions use the same API as aggregate
+**   may only be implemented by caching the entire partition in memory. 
+**   As such, some built-in window functions use the same API as aggregate 
 **   window functions and some are implemented directly using VDBE
-**   instructions. Additionally, for those functions that use the API, the
-**   window frame is sometimes modified before the SELECT statement is
-**   rewritten. For example, regardless of the specified window frame, the
-**   row_number() function always uses:
-**
-**     ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
-**
-**   See sqlite3WindowUpdate() for details.
-**
-**   As well as some of the built-in window functions, aggregate window
-**   functions min() and max() are implemented using VDBE instructions if
+**   instructions. Additionally, for those functions that use the API, the 
+**   window frame is sometimes modified before the SELECT statement is 
+**   rewritten. For example, regardless of the specified window frame, the 
+**   row_number() function always uses: 
+** 
+**     ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW 
+** 
+**   See sqlite3WindowUpdate() for details. 
+** 
+**   As well as some of the built-in window functions, aggregate window 
+**   functions min() and max() are implemented using VDBE instructions if 
 **   the start of the window frame is declared as anything other than
-**   UNBOUNDED PRECEDING.
-*/
-
-/*
-** Implementation of built-in window function row_number(). Assumes that the
-** window frame has been coerced to:
-**
-**   ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
-*/
-static void row_numberStepFunc(
+**   UNBOUNDED PRECEDING. 
+*/ 
+ 
+/* 
+** Implementation of built-in window function row_number(). Assumes that the 
+** window frame has been coerced to: 
+** 
+**   ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW 
+*/ 
+static void row_numberStepFunc( 
   sqlite3_context *pCtx,
-  int nArg,
-  sqlite3_value **apArg
-){
-  i64 *p = (i64*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( p ) (*p)++;
-  UNUSED_PARAMETER(nArg);
-  UNUSED_PARAMETER(apArg);
-}
-static void row_numberValueFunc(sqlite3_context *pCtx){
-  i64 *p = (i64*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  sqlite3_result_int64(pCtx, (p ? *p : 0));
-}
-
-/*
-** Context object type used by rank(), dense_rank(), percent_rank() and
-** cume_dist().
-*/
-struct CallCount {
-  i64 nValue;
-  i64 nStep;
-  i64 nTotal;
-};
-
-/*
-** Implementation of built-in window function dense_rank(). Assumes that
-** the window frame has been set to:
-**
+  int nArg, 
+  sqlite3_value **apArg 
+){ 
+  i64 *p = (i64*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  if( p ) (*p)++; 
+  UNUSED_PARAMETER(nArg); 
+  UNUSED_PARAMETER(apArg); 
+} 
+static void row_numberValueFunc(sqlite3_context *pCtx){ 
+  i64 *p = (i64*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  sqlite3_result_int64(pCtx, (p ? *p : 0)); 
+} 
+ 
+/* 
+** Context object type used by rank(), dense_rank(), percent_rank() and 
+** cume_dist(). 
+*/ 
+struct CallCount { 
+  i64 nValue; 
+  i64 nStep; 
+  i64 nTotal; 
+}; 
+ 
+/* 
+** Implementation of built-in window function dense_rank(). Assumes that 
+** the window frame has been set to: 
+** 
 **   RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
-*/
-static void dense_rankStepFunc(
+*/ 
+static void dense_rankStepFunc( 
   sqlite3_context *pCtx,
-  int nArg,
-  sqlite3_value **apArg
-){
-  struct CallCount *p;
-  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( p ) p->nStep = 1;
-  UNUSED_PARAMETER(nArg);
-  UNUSED_PARAMETER(apArg);
-}
-static void dense_rankValueFunc(sqlite3_context *pCtx){
-  struct CallCount *p;
-  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( p ){
-    if( p->nStep ){
-      p->nValue++;
-      p->nStep = 0;
-    }
-    sqlite3_result_int64(pCtx, p->nValue);
-  }
-}
-
-/*
-** Implementation of built-in window function nth_value(). This
-** implementation is used in "slow mode" only - when the EXCLUDE clause
-** is not set to the default value "NO OTHERS".
-*/
-struct NthValueCtx {
-  i64 nStep;
-  sqlite3_value *pValue;
-};
-static void nth_valueStepFunc(
+  int nArg, 
+  sqlite3_value **apArg 
+){ 
+  struct CallCount *p; 
+  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  if( p ) p->nStep = 1; 
+  UNUSED_PARAMETER(nArg); 
+  UNUSED_PARAMETER(apArg); 
+} 
+static void dense_rankValueFunc(sqlite3_context *pCtx){ 
+  struct CallCount *p; 
+  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  if( p ){ 
+    if( p->nStep ){ 
+      p->nValue++; 
+      p->nStep = 0; 
+    } 
+    sqlite3_result_int64(pCtx, p->nValue); 
+  } 
+} 
+ 
+/* 
+** Implementation of built-in window function nth_value(). This 
+** implementation is used in "slow mode" only - when the EXCLUDE clause 
+** is not set to the default value "NO OTHERS". 
+*/ 
+struct NthValueCtx { 
+  i64 nStep; 
+  sqlite3_value *pValue; 
+}; 
+static void nth_valueStepFunc( 
   sqlite3_context *pCtx,
-  int nArg,
-  sqlite3_value **apArg
-){
-  struct NthValueCtx *p;
-  p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( p ){
-    i64 iVal;
-    switch( sqlite3_value_numeric_type(apArg[1]) ){
-      case SQLITE_INTEGER:
-        iVal = sqlite3_value_int64(apArg[1]);
-        break;
-      case SQLITE_FLOAT: {
-        double fVal = sqlite3_value_double(apArg[1]);
-        if( ((i64)fVal)!=fVal ) goto error_out;
-        iVal = (i64)fVal;
-        break;
-      }
-      default:
-        goto error_out;
-    }
-    if( iVal<=0 ) goto error_out;
-
-    p->nStep++;
-    if( iVal==p->nStep ){
-      p->pValue = sqlite3_value_dup(apArg[0]);
-      if( !p->pValue ){
-        sqlite3_result_error_nomem(pCtx);
-      }
-    }
-  }
-  UNUSED_PARAMETER(nArg);
-  UNUSED_PARAMETER(apArg);
-  return;
-
- error_out:
-  sqlite3_result_error(
-      pCtx, "second argument to nth_value must be a positive integer", -1
-  );
-}
-static void nth_valueFinalizeFunc(sqlite3_context *pCtx){
-  struct NthValueCtx *p;
-  p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, 0);
-  if( p && p->pValue ){
-    sqlite3_result_value(pCtx, p->pValue);
-    sqlite3_value_free(p->pValue);
-    p->pValue = 0;
-  }
-}
-#define nth_valueInvFunc noopStepFunc
-#define nth_valueValueFunc noopValueFunc
-
-static void first_valueStepFunc(
+  int nArg, 
+  sqlite3_value **apArg 
+){ 
+  struct NthValueCtx *p; 
+  p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  if( p ){ 
+    i64 iVal; 
+    switch( sqlite3_value_numeric_type(apArg[1]) ){ 
+      case SQLITE_INTEGER: 
+        iVal = sqlite3_value_int64(apArg[1]); 
+        break; 
+      case SQLITE_FLOAT: { 
+        double fVal = sqlite3_value_double(apArg[1]); 
+        if( ((i64)fVal)!=fVal ) goto error_out; 
+        iVal = (i64)fVal; 
+        break; 
+      } 
+      default: 
+        goto error_out; 
+    } 
+    if( iVal<=0 ) goto error_out; 
+ 
+    p->nStep++; 
+    if( iVal==p->nStep ){ 
+      p->pValue = sqlite3_value_dup(apArg[0]); 
+      if( !p->pValue ){ 
+        sqlite3_result_error_nomem(pCtx); 
+      } 
+    } 
+  } 
+  UNUSED_PARAMETER(nArg); 
+  UNUSED_PARAMETER(apArg); 
+  return; 
+ 
+ error_out: 
+  sqlite3_result_error( 
+      pCtx, "second argument to nth_value must be a positive integer", -1 
+  ); 
+} 
+static void nth_valueFinalizeFunc(sqlite3_context *pCtx){ 
+  struct NthValueCtx *p; 
+  p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, 0); 
+  if( p && p->pValue ){ 
+    sqlite3_result_value(pCtx, p->pValue); 
+    sqlite3_value_free(p->pValue); 
+    p->pValue = 0; 
+  } 
+} 
+#define nth_valueInvFunc noopStepFunc 
+#define nth_valueValueFunc noopValueFunc 
+ 
+static void first_valueStepFunc( 
   sqlite3_context *pCtx,
-  int nArg,
-  sqlite3_value **apArg
-){
-  struct NthValueCtx *p;
-  p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( p && p->pValue==0 ){
-    p->pValue = sqlite3_value_dup(apArg[0]);
-    if( !p->pValue ){
-      sqlite3_result_error_nomem(pCtx);
-    }
-  }
-  UNUSED_PARAMETER(nArg);
-  UNUSED_PARAMETER(apArg);
-}
-static void first_valueFinalizeFunc(sqlite3_context *pCtx){
-  struct NthValueCtx *p;
-  p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( p && p->pValue ){
-    sqlite3_result_value(pCtx, p->pValue);
-    sqlite3_value_free(p->pValue);
-    p->pValue = 0;
-  }
-}
-#define first_valueInvFunc noopStepFunc
-#define first_valueValueFunc noopValueFunc
-
-/*
-** Implementation of built-in window function rank(). Assumes that
-** the window frame has been set to:
-**
+  int nArg, 
+  sqlite3_value **apArg 
+){ 
+  struct NthValueCtx *p; 
+  p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  if( p && p->pValue==0 ){ 
+    p->pValue = sqlite3_value_dup(apArg[0]); 
+    if( !p->pValue ){ 
+      sqlite3_result_error_nomem(pCtx); 
+    } 
+  } 
+  UNUSED_PARAMETER(nArg); 
+  UNUSED_PARAMETER(apArg); 
+} 
+static void first_valueFinalizeFunc(sqlite3_context *pCtx){ 
+  struct NthValueCtx *p; 
+  p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  if( p && p->pValue ){ 
+    sqlite3_result_value(pCtx, p->pValue); 
+    sqlite3_value_free(p->pValue); 
+    p->pValue = 0; 
+  } 
+} 
+#define first_valueInvFunc noopStepFunc 
+#define first_valueValueFunc noopValueFunc 
+ 
+/* 
+** Implementation of built-in window function rank(). Assumes that 
+** the window frame has been set to: 
+** 
 **   RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
-*/
-static void rankStepFunc(
+*/ 
+static void rankStepFunc( 
   sqlite3_context *pCtx,
-  int nArg,
-  sqlite3_value **apArg
-){
-  struct CallCount *p;
-  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( p ){
-    p->nStep++;
-    if( p->nValue==0 ){
-      p->nValue = p->nStep;
-    }
-  }
-  UNUSED_PARAMETER(nArg);
-  UNUSED_PARAMETER(apArg);
-}
-static void rankValueFunc(sqlite3_context *pCtx){
-  struct CallCount *p;
-  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( p ){
-    sqlite3_result_int64(pCtx, p->nValue);
-    p->nValue = 0;
-  }
-}
-
-/*
-** Implementation of built-in window function percent_rank(). Assumes that
-** the window frame has been set to:
-**
-**   GROUPS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
-*/
-static void percent_rankStepFunc(
+  int nArg, 
+  sqlite3_value **apArg 
+){ 
+  struct CallCount *p; 
+  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  if( p ){ 
+    p->nStep++; 
+    if( p->nValue==0 ){ 
+      p->nValue = p->nStep; 
+    } 
+  } 
+  UNUSED_PARAMETER(nArg); 
+  UNUSED_PARAMETER(apArg); 
+} 
+static void rankValueFunc(sqlite3_context *pCtx){ 
+  struct CallCount *p; 
+  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  if( p ){ 
+    sqlite3_result_int64(pCtx, p->nValue); 
+    p->nValue = 0; 
+  } 
+} 
+ 
+/* 
+** Implementation of built-in window function percent_rank(). Assumes that 
+** the window frame has been set to: 
+** 
+**   GROUPS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING 
+*/ 
+static void percent_rankStepFunc( 
   sqlite3_context *pCtx,
-  int nArg,
-  sqlite3_value **apArg
-){
-  struct CallCount *p;
-  UNUSED_PARAMETER(nArg); assert( nArg==0 );
-  UNUSED_PARAMETER(apArg);
-  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( p ){
-    p->nTotal++;
-  }
-}
-static void percent_rankInvFunc(
+  int nArg, 
+  sqlite3_value **apArg 
+){ 
+  struct CallCount *p; 
+  UNUSED_PARAMETER(nArg); assert( nArg==0 ); 
+  UNUSED_PARAMETER(apArg); 
+  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  if( p ){ 
+    p->nTotal++; 
+  } 
+} 
+static void percent_rankInvFunc( 
   sqlite3_context *pCtx,
-  int nArg,
-  sqlite3_value **apArg
-){
-  struct CallCount *p;
-  UNUSED_PARAMETER(nArg); assert( nArg==0 );
-  UNUSED_PARAMETER(apArg);
-  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  p->nStep++;
-}
-static void percent_rankValueFunc(sqlite3_context *pCtx){
-  struct CallCount *p;
-  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( p ){
-    p->nValue = p->nStep;
-    if( p->nTotal>1 ){
-      double r = (double)p->nValue / (double)(p->nTotal-1);
-      sqlite3_result_double(pCtx, r);
-    }else{
-      sqlite3_result_double(pCtx, 0.0);
-    }
-  }
-}
-#define percent_rankFinalizeFunc percent_rankValueFunc
-
-/*
-** Implementation of built-in window function cume_dist(). Assumes that
-** the window frame has been set to:
-**
-**   GROUPS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING
-*/
-static void cume_distStepFunc(
+  int nArg, 
+  sqlite3_value **apArg 
+){ 
+  struct CallCount *p; 
+  UNUSED_PARAMETER(nArg); assert( nArg==0 ); 
+  UNUSED_PARAMETER(apArg); 
+  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  p->nStep++; 
+} 
+static void percent_rankValueFunc(sqlite3_context *pCtx){ 
+  struct CallCount *p; 
+  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  if( p ){ 
+    p->nValue = p->nStep; 
+    if( p->nTotal>1 ){ 
+      double r = (double)p->nValue / (double)(p->nTotal-1); 
+      sqlite3_result_double(pCtx, r); 
+    }else{ 
+      sqlite3_result_double(pCtx, 0.0); 
+    } 
+  } 
+} 
+#define percent_rankFinalizeFunc percent_rankValueFunc 
+ 
+/* 
+** Implementation of built-in window function cume_dist(). Assumes that 
+** the window frame has been set to: 
+** 
+**   GROUPS BETWEEN 1 FOLLOWING AND UNBOUNDED FOLLOWING 
+*/ 
+static void cume_distStepFunc( 
   sqlite3_context *pCtx,
-  int nArg,
-  sqlite3_value **apArg
-){
-  struct CallCount *p;
-  UNUSED_PARAMETER(nArg); assert( nArg==0 );
-  UNUSED_PARAMETER(apArg);
-  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( p ){
-    p->nTotal++;
-  }
-}
-static void cume_distInvFunc(
+  int nArg, 
+  sqlite3_value **apArg 
+){ 
+  struct CallCount *p; 
+  UNUSED_PARAMETER(nArg); assert( nArg==0 ); 
+  UNUSED_PARAMETER(apArg); 
+  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  if( p ){ 
+    p->nTotal++; 
+  } 
+} 
+static void cume_distInvFunc( 
   sqlite3_context *pCtx,
-  int nArg,
-  sqlite3_value **apArg
-){
-  struct CallCount *p;
-  UNUSED_PARAMETER(nArg); assert( nArg==0 );
-  UNUSED_PARAMETER(apArg);
-  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  p->nStep++;
-}
-static void cume_distValueFunc(sqlite3_context *pCtx){
-  struct CallCount *p;
-  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, 0);
-  if( p ){
-    double r = (double)(p->nStep) / (double)(p->nTotal);
-    sqlite3_result_double(pCtx, r);
-  }
-}
-#define cume_distFinalizeFunc cume_distValueFunc
-
-/*
-** Context object for ntile() window function.
-*/
-struct NtileCtx {
-  i64 nTotal;                     /* Total rows in partition */
-  i64 nParam;                     /* Parameter passed to ntile(N) */
-  i64 iRow;                       /* Current row */
-};
-
-/*
-** Implementation of ntile(). This assumes that the window frame has
-** been coerced to:
-**
-**   ROWS CURRENT ROW AND UNBOUNDED FOLLOWING
-*/
-static void ntileStepFunc(
+  int nArg, 
+  sqlite3_value **apArg 
+){ 
+  struct CallCount *p; 
+  UNUSED_PARAMETER(nArg); assert( nArg==0 ); 
+  UNUSED_PARAMETER(apArg); 
+  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  p->nStep++; 
+} 
+static void cume_distValueFunc(sqlite3_context *pCtx){ 
+  struct CallCount *p; 
+  p = (struct CallCount*)sqlite3_aggregate_context(pCtx, 0); 
+  if( p ){ 
+    double r = (double)(p->nStep) / (double)(p->nTotal); 
+    sqlite3_result_double(pCtx, r); 
+  } 
+} 
+#define cume_distFinalizeFunc cume_distValueFunc 
+ 
+/* 
+** Context object for ntile() window function. 
+*/ 
+struct NtileCtx { 
+  i64 nTotal;                     /* Total rows in partition */ 
+  i64 nParam;                     /* Parameter passed to ntile(N) */ 
+  i64 iRow;                       /* Current row */ 
+}; 
+ 
+/* 
+** Implementation of ntile(). This assumes that the window frame has 
+** been coerced to: 
+** 
+**   ROWS CURRENT ROW AND UNBOUNDED FOLLOWING 
+*/ 
+static void ntileStepFunc( 
   sqlite3_context *pCtx,
-  int nArg,
-  sqlite3_value **apArg
-){
-  struct NtileCtx *p;
-  assert( nArg==1 ); UNUSED_PARAMETER(nArg);
-  p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( p ){
-    if( p->nTotal==0 ){
-      p->nParam = sqlite3_value_int64(apArg[0]);
-      if( p->nParam<=0 ){
-        sqlite3_result_error(
-            pCtx, "argument of ntile must be a positive integer", -1
-        );
-      }
-    }
-    p->nTotal++;
-  }
-}
-static void ntileInvFunc(
+  int nArg, 
+  sqlite3_value **apArg 
+){ 
+  struct NtileCtx *p; 
+  assert( nArg==1 ); UNUSED_PARAMETER(nArg); 
+  p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  if( p ){ 
+    if( p->nTotal==0 ){ 
+      p->nParam = sqlite3_value_int64(apArg[0]); 
+      if( p->nParam<=0 ){ 
+        sqlite3_result_error( 
+            pCtx, "argument of ntile must be a positive integer", -1 
+        ); 
+      } 
+    } 
+    p->nTotal++; 
+  } 
+} 
+static void ntileInvFunc( 
   sqlite3_context *pCtx,
-  int nArg,
-  sqlite3_value **apArg
-){
-  struct NtileCtx *p;
-  assert( nArg==1 ); UNUSED_PARAMETER(nArg);
-  UNUSED_PARAMETER(apArg);
-  p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  p->iRow++;
-}
-static void ntileValueFunc(sqlite3_context *pCtx){
-  struct NtileCtx *p;
-  p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( p && p->nParam>0 ){
-    int nSize = (p->nTotal / p->nParam);
-    if( nSize==0 ){
-      sqlite3_result_int64(pCtx, p->iRow+1);
-    }else{
-      i64 nLarge = p->nTotal - p->nParam*nSize;
-      i64 iSmall = nLarge*(nSize+1);
-      i64 iRow = p->iRow;
-
-      assert( (nLarge*(nSize+1) + (p->nParam-nLarge)*nSize)==p->nTotal );
-
-      if( iRow<iSmall ){
-        sqlite3_result_int64(pCtx, 1 + iRow/(nSize+1));
-      }else{
-        sqlite3_result_int64(pCtx, 1 + nLarge + (iRow-iSmall)/nSize);
-      }
-    }
-  }
-}
-#define ntileFinalizeFunc ntileValueFunc
-
-/*
-** Context object for last_value() window function.
-*/
-struct LastValueCtx {
-  sqlite3_value *pVal;
-  int nVal;
-};
-
-/*
-** Implementation of last_value().
-*/
-static void last_valueStepFunc(
+  int nArg, 
+  sqlite3_value **apArg 
+){ 
+  struct NtileCtx *p; 
+  assert( nArg==1 ); UNUSED_PARAMETER(nArg); 
+  UNUSED_PARAMETER(apArg); 
+  p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  p->iRow++; 
+} 
+static void ntileValueFunc(sqlite3_context *pCtx){ 
+  struct NtileCtx *p; 
+  p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  if( p && p->nParam>0 ){ 
+    int nSize = (p->nTotal / p->nParam); 
+    if( nSize==0 ){ 
+      sqlite3_result_int64(pCtx, p->iRow+1); 
+    }else{ 
+      i64 nLarge = p->nTotal - p->nParam*nSize; 
+      i64 iSmall = nLarge*(nSize+1); 
+      i64 iRow = p->iRow; 
+ 
+      assert( (nLarge*(nSize+1) + (p->nParam-nLarge)*nSize)==p->nTotal ); 
+ 
+      if( iRow<iSmall ){ 
+        sqlite3_result_int64(pCtx, 1 + iRow/(nSize+1)); 
+      }else{ 
+        sqlite3_result_int64(pCtx, 1 + nLarge + (iRow-iSmall)/nSize); 
+      } 
+    } 
+  } 
+} 
+#define ntileFinalizeFunc ntileValueFunc 
+ 
+/* 
+** Context object for last_value() window function. 
+*/ 
+struct LastValueCtx { 
+  sqlite3_value *pVal; 
+  int nVal; 
+}; 
+ 
+/* 
+** Implementation of last_value(). 
+*/ 
+static void last_valueStepFunc( 
   sqlite3_context *pCtx,
-  int nArg,
-  sqlite3_value **apArg
-){
-  struct LastValueCtx *p;
-  UNUSED_PARAMETER(nArg);
-  p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( p ){
-    sqlite3_value_free(p->pVal);
-    p->pVal = sqlite3_value_dup(apArg[0]);
-    if( p->pVal==0 ){
-      sqlite3_result_error_nomem(pCtx);
-    }else{
-      p->nVal++;
-    }
-  }
-}
-static void last_valueInvFunc(
+  int nArg, 
+  sqlite3_value **apArg 
+){ 
+  struct LastValueCtx *p; 
+  UNUSED_PARAMETER(nArg); 
+  p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  if( p ){ 
+    sqlite3_value_free(p->pVal); 
+    p->pVal = sqlite3_value_dup(apArg[0]); 
+    if( p->pVal==0 ){ 
+      sqlite3_result_error_nomem(pCtx); 
+    }else{ 
+      p->nVal++; 
+    } 
+  } 
+} 
+static void last_valueInvFunc( 
   sqlite3_context *pCtx,
-  int nArg,
-  sqlite3_value **apArg
-){
-  struct LastValueCtx *p;
-  UNUSED_PARAMETER(nArg);
-  UNUSED_PARAMETER(apArg);
-  p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( ALWAYS(p) ){
-    p->nVal--;
-    if( p->nVal==0 ){
-      sqlite3_value_free(p->pVal);
-      p->pVal = 0;
-    }
-  }
-}
-static void last_valueValueFunc(sqlite3_context *pCtx){
-  struct LastValueCtx *p;
-  p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, 0);
-  if( p && p->pVal ){
-    sqlite3_result_value(pCtx, p->pVal);
-  }
-}
-static void last_valueFinalizeFunc(sqlite3_context *pCtx){
-  struct LastValueCtx *p;
-  p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
-  if( p && p->pVal ){
-    sqlite3_result_value(pCtx, p->pVal);
-    sqlite3_value_free(p->pVal);
-    p->pVal = 0;
-  }
-}
-
-/*
-** Static names for the built-in window function names.  These static
-** names are used, rather than string literals, so that FuncDef objects
-** can be associated with a particular window function by direct
-** comparison of the zName pointer.  Example:
-**
-**       if( pFuncDef->zName==row_valueName ){ ... }
-*/
-static const char row_numberName[] =   "row_number";
-static const char dense_rankName[] =   "dense_rank";
-static const char rankName[] =         "rank";
-static const char percent_rankName[] = "percent_rank";
-static const char cume_distName[] =    "cume_dist";
-static const char ntileName[] =        "ntile";
-static const char last_valueName[] =   "last_value";
-static const char nth_valueName[] =    "nth_value";
-static const char first_valueName[] =  "first_value";
-static const char leadName[] =         "lead";
-static const char lagName[] =          "lag";
-
-/*
-** No-op implementations of xStep() and xFinalize().  Used as place-holders
-** for built-in window functions that never call those interfaces.
-**
-** The noopValueFunc() is called but is expected to do nothing.  The
-** noopStepFunc() is never called, and so it is marked with NO_TEST to
-** let the test coverage routine know not to expect this function to be
-** invoked.
-*/
-static void noopStepFunc(    /*NO_TEST*/
-  sqlite3_context *p,        /*NO_TEST*/
-  int n,                     /*NO_TEST*/
-  sqlite3_value **a          /*NO_TEST*/
-){                           /*NO_TEST*/
-  UNUSED_PARAMETER(p);       /*NO_TEST*/
-  UNUSED_PARAMETER(n);       /*NO_TEST*/
-  UNUSED_PARAMETER(a);       /*NO_TEST*/
-  assert(0);                 /*NO_TEST*/
-}                            /*NO_TEST*/
-static void noopValueFunc(sqlite3_context *p){ UNUSED_PARAMETER(p); /*no-op*/ }
-
-/* Window functions that use all window interfaces: xStep, xFinal,
-** xValue, and xInverse */
-#define WINDOWFUNCALL(name,nArg,extra) {                                   \
+  int nArg, 
+  sqlite3_value **apArg 
+){ 
+  struct LastValueCtx *p; 
+  UNUSED_PARAMETER(nArg); 
+  UNUSED_PARAMETER(apArg); 
+  p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  if( ALWAYS(p) ){ 
+    p->nVal--; 
+    if( p->nVal==0 ){ 
+      sqlite3_value_free(p->pVal); 
+      p->pVal = 0; 
+    } 
+  } 
+} 
+static void last_valueValueFunc(sqlite3_context *pCtx){ 
+  struct LastValueCtx *p; 
+  p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, 0); 
+  if( p && p->pVal ){ 
+    sqlite3_result_value(pCtx, p->pVal); 
+  } 
+} 
+static void last_valueFinalizeFunc(sqlite3_context *pCtx){ 
+  struct LastValueCtx *p; 
+  p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p)); 
+  if( p && p->pVal ){ 
+    sqlite3_result_value(pCtx, p->pVal); 
+    sqlite3_value_free(p->pVal); 
+    p->pVal = 0; 
+  } 
+} 
+ 
+/* 
+** Static names for the built-in window function names.  These static 
+** names are used, rather than string literals, so that FuncDef objects 
+** can be associated with a particular window function by direct 
+** comparison of the zName pointer.  Example: 
+** 
+**       if( pFuncDef->zName==row_valueName ){ ... } 
+*/ 
+static const char row_numberName[] =   "row_number"; 
+static const char dense_rankName[] =   "dense_rank"; 
+static const char rankName[] =         "rank"; 
+static const char percent_rankName[] = "percent_rank"; 
+static const char cume_distName[] =    "cume_dist"; 
+static const char ntileName[] =        "ntile"; 
+static const char last_valueName[] =   "last_value"; 
+static const char nth_valueName[] =    "nth_value"; 
+static const char first_valueName[] =  "first_value"; 
+static const char leadName[] =         "lead"; 
+static const char lagName[] =          "lag"; 
+ 
+/* 
+** No-op implementations of xStep() and xFinalize().  Used as place-holders 
+** for built-in window functions that never call those interfaces. 
+** 
+** The noopValueFunc() is called but is expected to do nothing.  The 
+** noopStepFunc() is never called, and so it is marked with NO_TEST to 
+** let the test coverage routine know not to expect this function to be 
+** invoked. 
+*/ 
+static void noopStepFunc(    /*NO_TEST*/ 
+  sqlite3_context *p,        /*NO_TEST*/ 
+  int n,                     /*NO_TEST*/ 
+  sqlite3_value **a          /*NO_TEST*/ 
+){                           /*NO_TEST*/ 
+  UNUSED_PARAMETER(p);       /*NO_TEST*/ 
+  UNUSED_PARAMETER(n);       /*NO_TEST*/ 
+  UNUSED_PARAMETER(a);       /*NO_TEST*/ 
+  assert(0);                 /*NO_TEST*/ 
+}                            /*NO_TEST*/ 
+static void noopValueFunc(sqlite3_context *p){ UNUSED_PARAMETER(p); /*no-op*/ } 
+ 
+/* Window functions that use all window interfaces: xStep, xFinal, 
+** xValue, and xInverse */ 
+#define WINDOWFUNCALL(name,nArg,extra) {                                   \ 
   nArg, (SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0,  \
-  name ## StepFunc, name ## FinalizeFunc, name ## ValueFunc,               \
-  name ## InvFunc, name ## Name, {0}                                       \
-}
-
-/* Window functions that are implemented using bytecode and thus have
-** no-op routines for their methods */
-#define WINDOWFUNCNOOP(name,nArg,extra) {                                  \
+  name ## StepFunc, name ## FinalizeFunc, name ## ValueFunc,               \ 
+  name ## InvFunc, name ## Name, {0}                                       \ 
+} 
+ 
+/* Window functions that are implemented using bytecode and thus have 
+** no-op routines for their methods */ 
+#define WINDOWFUNCNOOP(name,nArg,extra) {                                  \ 
   nArg, (SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0,  \
-  noopStepFunc, noopValueFunc, noopValueFunc,                              \
-  noopStepFunc, name ## Name, {0}                                          \
-}
-
-/* Window functions that use all window interfaces: xStep, the
-** same routine for xFinalize and xValue and which never call
-** xInverse. */
-#define WINDOWFUNCX(name,nArg,extra) {                                     \
+  noopStepFunc, noopValueFunc, noopValueFunc,                              \ 
+  noopStepFunc, name ## Name, {0}                                          \ 
+} 
+ 
+/* Window functions that use all window interfaces: xStep, the 
+** same routine for xFinalize and xValue and which never call 
+** xInverse. */ 
+#define WINDOWFUNCX(name,nArg,extra) {                                     \ 
   nArg, (SQLITE_FUNC_BUILTIN|SQLITE_UTF8|SQLITE_FUNC_WINDOW|extra), 0, 0,  \
-  name ## StepFunc, name ## ValueFunc, name ## ValueFunc,                  \
-  noopStepFunc, name ## Name, {0}                                          \
-}
-
-
-/*
-** Register those built-in window functions that are not also aggregates.
-*/
-SQLITE_PRIVATE void sqlite3WindowFunctions(void){
-  static FuncDef aWindowFuncs[] = {
-    WINDOWFUNCX(row_number, 0, 0),
-    WINDOWFUNCX(dense_rank, 0, 0),
-    WINDOWFUNCX(rank, 0, 0),
-    WINDOWFUNCALL(percent_rank, 0, 0),
-    WINDOWFUNCALL(cume_dist, 0, 0),
-    WINDOWFUNCALL(ntile, 1, 0),
-    WINDOWFUNCALL(last_value, 1, 0),
-    WINDOWFUNCALL(nth_value, 2, 0),
-    WINDOWFUNCALL(first_value, 1, 0),
-    WINDOWFUNCNOOP(lead, 1, 0),
-    WINDOWFUNCNOOP(lead, 2, 0),
-    WINDOWFUNCNOOP(lead, 3, 0),
-    WINDOWFUNCNOOP(lag, 1, 0),
-    WINDOWFUNCNOOP(lag, 2, 0),
-    WINDOWFUNCNOOP(lag, 3, 0),
-  };
-  sqlite3InsertBuiltinFuncs(aWindowFuncs, ArraySize(aWindowFuncs));
-}
-
-static Window *windowFind(Parse *pParse, Window *pList, const char *zName){
-  Window *p;
-  for(p=pList; p; p=p->pNextWin){
-    if( sqlite3StrICmp(p->zName, zName)==0 ) break;
-  }
-  if( p==0 ){
-    sqlite3ErrorMsg(pParse, "no such window: %s", zName);
-  }
-  return p;
-}
-
-/*
-** This function is called immediately after resolving the function name
-** for a window function within a SELECT statement. Argument pList is a
-** linked list of WINDOW definitions for the current SELECT statement.
-** Argument pFunc is the function definition just resolved and pWin
-** is the Window object representing the associated OVER clause. This
-** function updates the contents of pWin as follows:
-**
-**   * If the OVER clause refered to a named window (as in "max(x) OVER win"),
-**     search list pList for a matching WINDOW definition, and update pWin
-**     accordingly. If no such WINDOW clause can be found, leave an error
-**     in pParse.
-**
-**   * If the function is a built-in window function that requires the
-**     window to be coerced (see "BUILT-IN WINDOW FUNCTIONS" at the top
-**     of this file), pWin is updated here.
-*/
-SQLITE_PRIVATE void sqlite3WindowUpdate(
+  name ## StepFunc, name ## ValueFunc, name ## ValueFunc,                  \ 
+  noopStepFunc, name ## Name, {0}                                          \ 
+} 
+ 
+ 
+/* 
+** Register those built-in window functions that are not also aggregates. 
+*/ 
+SQLITE_PRIVATE void sqlite3WindowFunctions(void){ 
+  static FuncDef aWindowFuncs[] = { 
+    WINDOWFUNCX(row_number, 0, 0), 
+    WINDOWFUNCX(dense_rank, 0, 0), 
+    WINDOWFUNCX(rank, 0, 0), 
+    WINDOWFUNCALL(percent_rank, 0, 0), 
+    WINDOWFUNCALL(cume_dist, 0, 0), 
+    WINDOWFUNCALL(ntile, 1, 0), 
+    WINDOWFUNCALL(last_value, 1, 0), 
+    WINDOWFUNCALL(nth_value, 2, 0), 
+    WINDOWFUNCALL(first_value, 1, 0), 
+    WINDOWFUNCNOOP(lead, 1, 0), 
+    WINDOWFUNCNOOP(lead, 2, 0), 
+    WINDOWFUNCNOOP(lead, 3, 0), 
+    WINDOWFUNCNOOP(lag, 1, 0), 
+    WINDOWFUNCNOOP(lag, 2, 0), 
+    WINDOWFUNCNOOP(lag, 3, 0), 
+  }; 
+  sqlite3InsertBuiltinFuncs(aWindowFuncs, ArraySize(aWindowFuncs)); 
+} 
+ 
+static Window *windowFind(Parse *pParse, Window *pList, const char *zName){ 
+  Window *p; 
+  for(p=pList; p; p=p->pNextWin){ 
+    if( sqlite3StrICmp(p->zName, zName)==0 ) break; 
+  } 
+  if( p==0 ){ 
+    sqlite3ErrorMsg(pParse, "no such window: %s", zName); 
+  } 
+  return p; 
+} 
+ 
+/* 
+** This function is called immediately after resolving the function name 
+** for a window function within a SELECT statement. Argument pList is a 
+** linked list of WINDOW definitions for the current SELECT statement. 
+** Argument pFunc is the function definition just resolved and pWin 
+** is the Window object representing the associated OVER clause. This 
+** function updates the contents of pWin as follows: 
+** 
+**   * If the OVER clause refered to a named window (as in "max(x) OVER win"), 
+**     search list pList for a matching WINDOW definition, and update pWin 
+**     accordingly. If no such WINDOW clause can be found, leave an error 
+**     in pParse. 
+** 
+**   * If the function is a built-in window function that requires the 
+**     window to be coerced (see "BUILT-IN WINDOW FUNCTIONS" at the top 
+**     of this file), pWin is updated here. 
+*/ 
+SQLITE_PRIVATE void sqlite3WindowUpdate( 
   Parse *pParse,
-  Window *pList,                  /* List of named windows for this SELECT */
-  Window *pWin,                   /* Window frame to update */
-  FuncDef *pFunc                  /* Window function definition */
-){
-  if( pWin->zName && pWin->eFrmType==0 ){
-    Window *p = windowFind(pParse, pList, pWin->zName);
-    if( p==0 ) return;
-    pWin->pPartition = sqlite3ExprListDup(pParse->db, p->pPartition, 0);
-    pWin->pOrderBy = sqlite3ExprListDup(pParse->db, p->pOrderBy, 0);
-    pWin->pStart = sqlite3ExprDup(pParse->db, p->pStart, 0);
-    pWin->pEnd = sqlite3ExprDup(pParse->db, p->pEnd, 0);
-    pWin->eStart = p->eStart;
-    pWin->eEnd = p->eEnd;
-    pWin->eFrmType = p->eFrmType;
-    pWin->eExclude = p->eExclude;
-  }else{
-    sqlite3WindowChain(pParse, pWin, pList);
-  }
-  if( (pWin->eFrmType==TK_RANGE)
+  Window *pList,                  /* List of named windows for this SELECT */ 
+  Window *pWin,                   /* Window frame to update */ 
+  FuncDef *pFunc                  /* Window function definition */ 
+){ 
+  if( pWin->zName && pWin->eFrmType==0 ){ 
+    Window *p = windowFind(pParse, pList, pWin->zName); 
+    if( p==0 ) return; 
+    pWin->pPartition = sqlite3ExprListDup(pParse->db, p->pPartition, 0); 
+    pWin->pOrderBy = sqlite3ExprListDup(pParse->db, p->pOrderBy, 0); 
+    pWin->pStart = sqlite3ExprDup(pParse->db, p->pStart, 0); 
+    pWin->pEnd = sqlite3ExprDup(pParse->db, p->pEnd, 0); 
+    pWin->eStart = p->eStart; 
+    pWin->eEnd = p->eEnd; 
+    pWin->eFrmType = p->eFrmType; 
+    pWin->eExclude = p->eExclude; 
+  }else{ 
+    sqlite3WindowChain(pParse, pWin, pList); 
+  } 
+  if( (pWin->eFrmType==TK_RANGE) 
    && (pWin->pStart || pWin->pEnd)
-   && (pWin->pOrderBy==0 || pWin->pOrderBy->nExpr!=1)
-  ){
+   && (pWin->pOrderBy==0 || pWin->pOrderBy->nExpr!=1) 
+  ){ 
     sqlite3ErrorMsg(pParse,
-      "RANGE with offset PRECEDING/FOLLOWING requires one ORDER BY expression"
-    );
-  }else
-  if( pFunc->funcFlags & SQLITE_FUNC_WINDOW ){
-    sqlite3 *db = pParse->db;
-    if( pWin->pFilter ){
+      "RANGE with offset PRECEDING/FOLLOWING requires one ORDER BY expression" 
+    ); 
+  }else 
+  if( pFunc->funcFlags & SQLITE_FUNC_WINDOW ){ 
+    sqlite3 *db = pParse->db; 
+    if( pWin->pFilter ){ 
       sqlite3ErrorMsg(pParse,
-          "FILTER clause may only be used with aggregate window functions"
-      );
-    }else{
-      struct WindowUpdate {
-        const char *zFunc;
-        int eFrmType;
-        int eStart;
-        int eEnd;
-      } aUp[] = {
+          "FILTER clause may only be used with aggregate window functions" 
+      ); 
+    }else{ 
+      struct WindowUpdate { 
+        const char *zFunc; 
+        int eFrmType; 
+        int eStart; 
+        int eEnd; 
+      } aUp[] = { 
         { row_numberName,   TK_ROWS,   TK_UNBOUNDED, TK_CURRENT },
         { dense_rankName,   TK_RANGE,  TK_UNBOUNDED, TK_CURRENT },
         { rankName,         TK_RANGE,  TK_UNBOUNDED, TK_CURRENT },
@@ -157064,91 +157064,91 @@ SQLITE_PRIVATE void sqlite3WindowUpdate(
         { ntileName,        TK_ROWS,   TK_CURRENT,   TK_UNBOUNDED },
         { leadName,         TK_ROWS,   TK_UNBOUNDED, TK_UNBOUNDED },
         { lagName,          TK_ROWS,   TK_UNBOUNDED, TK_CURRENT },
-      };
-      int i;
-      for(i=0; i<ArraySize(aUp); i++){
-        if( pFunc->zName==aUp[i].zFunc ){
-          sqlite3ExprDelete(db, pWin->pStart);
-          sqlite3ExprDelete(db, pWin->pEnd);
-          pWin->pEnd = pWin->pStart = 0;
-          pWin->eFrmType = aUp[i].eFrmType;
-          pWin->eStart = aUp[i].eStart;
-          pWin->eEnd = aUp[i].eEnd;
-          pWin->eExclude = 0;
-          if( pWin->eStart==TK_FOLLOWING ){
-            pWin->pStart = sqlite3Expr(db, TK_INTEGER, "1");
-          }
-          break;
-        }
-      }
-    }
-  }
-  pWin->pFunc = pFunc;
-}
-
-/*
-** Context object passed through sqlite3WalkExprList() to
-** selectWindowRewriteExprCb() by selectWindowRewriteEList().
-*/
-typedef struct WindowRewrite WindowRewrite;
-struct WindowRewrite {
-  Window *pWin;
-  SrcList *pSrc;
-  ExprList *pSub;
-  Table *pTab;
-  Select *pSubSelect;             /* Current sub-select, if any */
-};
-
-/*
-** Callback function used by selectWindowRewriteEList(). If necessary,
+      }; 
+      int i; 
+      for(i=0; i<ArraySize(aUp); i++){ 
+        if( pFunc->zName==aUp[i].zFunc ){ 
+          sqlite3ExprDelete(db, pWin->pStart); 
+          sqlite3ExprDelete(db, pWin->pEnd); 
+          pWin->pEnd = pWin->pStart = 0; 
+          pWin->eFrmType = aUp[i].eFrmType; 
+          pWin->eStart = aUp[i].eStart; 
+          pWin->eEnd = aUp[i].eEnd; 
+          pWin->eExclude = 0; 
+          if( pWin->eStart==TK_FOLLOWING ){ 
+            pWin->pStart = sqlite3Expr(db, TK_INTEGER, "1"); 
+          } 
+          break; 
+        } 
+      } 
+    } 
+  } 
+  pWin->pFunc = pFunc; 
+} 
+ 
+/* 
+** Context object passed through sqlite3WalkExprList() to 
+** selectWindowRewriteExprCb() by selectWindowRewriteEList(). 
+*/ 
+typedef struct WindowRewrite WindowRewrite; 
+struct WindowRewrite { 
+  Window *pWin; 
+  SrcList *pSrc; 
+  ExprList *pSub; 
+  Table *pTab; 
+  Select *pSubSelect;             /* Current sub-select, if any */ 
+}; 
+ 
+/* 
+** Callback function used by selectWindowRewriteEList(). If necessary, 
 ** this function appends to the output expression-list and updates
-** expression (*ppExpr) in place.
-*/
-static int selectWindowRewriteExprCb(Walker *pWalker, Expr *pExpr){
-  struct WindowRewrite *p = pWalker->u.pRewrite;
-  Parse *pParse = pWalker->pParse;
+** expression (*ppExpr) in place. 
+*/ 
+static int selectWindowRewriteExprCb(Walker *pWalker, Expr *pExpr){ 
+  struct WindowRewrite *p = pWalker->u.pRewrite; 
+  Parse *pParse = pWalker->pParse; 
   assert( p!=0 );
   assert( p->pWin!=0 );
-
-  /* If this function is being called from within a scalar sub-select
-  ** that used by the SELECT statement being processed, only process
-  ** TK_COLUMN expressions that refer to it (the outer SELECT). Do
-  ** not process aggregates or window functions at all, as they belong
-  ** to the scalar sub-select.  */
-  if( p->pSubSelect ){
-    if( pExpr->op!=TK_COLUMN ){
-      return WRC_Continue;
-    }else{
-      int nSrc = p->pSrc->nSrc;
-      int i;
-      for(i=0; i<nSrc; i++){
-        if( pExpr->iTable==p->pSrc->a[i].iCursor ) break;
-      }
-      if( i==nSrc ) return WRC_Continue;
-    }
-  }
-
-  switch( pExpr->op ){
-
-    case TK_FUNCTION:
-      if( !ExprHasProperty(pExpr, EP_WinFunc) ){
-        break;
-      }else{
-        Window *pWin;
-        for(pWin=p->pWin; pWin; pWin=pWin->pNextWin){
-          if( pExpr->y.pWin==pWin ){
-            assert( pWin->pOwner==pExpr );
-            return WRC_Prune;
-          }
-        }
-      }
+ 
+  /* If this function is being called from within a scalar sub-select 
+  ** that used by the SELECT statement being processed, only process 
+  ** TK_COLUMN expressions that refer to it (the outer SELECT). Do 
+  ** not process aggregates or window functions at all, as they belong 
+  ** to the scalar sub-select.  */ 
+  if( p->pSubSelect ){ 
+    if( pExpr->op!=TK_COLUMN ){ 
+      return WRC_Continue; 
+    }else{ 
+      int nSrc = p->pSrc->nSrc; 
+      int i; 
+      for(i=0; i<nSrc; i++){ 
+        if( pExpr->iTable==p->pSrc->a[i].iCursor ) break; 
+      } 
+      if( i==nSrc ) return WRC_Continue; 
+    } 
+  } 
+ 
+  switch( pExpr->op ){ 
+ 
+    case TK_FUNCTION: 
+      if( !ExprHasProperty(pExpr, EP_WinFunc) ){ 
+        break; 
+      }else{ 
+        Window *pWin; 
+        for(pWin=p->pWin; pWin; pWin=pWin->pNextWin){ 
+          if( pExpr->y.pWin==pWin ){ 
+            assert( pWin->pOwner==pExpr ); 
+            return WRC_Prune; 
+          } 
+        } 
+      } 
       /* no break */ deliberate_fall_through
-
-    case TK_AGG_FUNCTION:
-    case TK_COLUMN: {
+ 
+    case TK_AGG_FUNCTION: 
+    case TK_COLUMN: { 
       int iCol = -1;
       if( pParse->db->mallocFailed ) return WRC_Abort;
-      if( p->pSub ){
+      if( p->pSub ){ 
         int i;
         for(i=0; i<p->pSub->nExpr; i++){
           if( 0==sqlite3ExprCompare(0, p->pSub->a[i].pExpr, pExpr, -1) ){
@@ -157164,99 +157164,99 @@ static int selectWindowRewriteExprCb(Walker *pWalker, Expr *pExpr){
       }
       if( p->pSub ){
         int f = pExpr->flags & EP_Collate;
-        assert( ExprHasProperty(pExpr, EP_Static)==0 );
-        ExprSetProperty(pExpr, EP_Static);
-        sqlite3ExprDelete(pParse->db, pExpr);
-        ExprClearProperty(pExpr, EP_Static);
-        memset(pExpr, 0, sizeof(Expr));
-
-        pExpr->op = TK_COLUMN;
+        assert( ExprHasProperty(pExpr, EP_Static)==0 ); 
+        ExprSetProperty(pExpr, EP_Static); 
+        sqlite3ExprDelete(pParse->db, pExpr); 
+        ExprClearProperty(pExpr, EP_Static); 
+        memset(pExpr, 0, sizeof(Expr)); 
+ 
+        pExpr->op = TK_COLUMN; 
         pExpr->iColumn = (iCol<0 ? p->pSub->nExpr-1: iCol);
-        pExpr->iTable = p->pWin->iEphCsr;
-        pExpr->y.pTab = p->pTab;
+        pExpr->iTable = p->pWin->iEphCsr; 
+        pExpr->y.pTab = p->pTab; 
         pExpr->flags = f;
-      }
+      } 
       if( pParse->db->mallocFailed ) return WRC_Abort;
-      break;
-    }
-
-    default: /* no-op */
-      break;
-  }
-
-  return WRC_Continue;
-}
-static int selectWindowRewriteSelectCb(Walker *pWalker, Select *pSelect){
-  struct WindowRewrite *p = pWalker->u.pRewrite;
-  Select *pSave = p->pSubSelect;
-  if( pSave==pSelect ){
-    return WRC_Continue;
-  }else{
-    p->pSubSelect = pSelect;
-    sqlite3WalkSelect(pWalker, pSelect);
-    p->pSubSelect = pSave;
-  }
-  return WRC_Prune;
-}
-
-
-/*
-** Iterate through each expression in expression-list pEList. For each:
-**
-**   * TK_COLUMN,
-**   * aggregate function, or
+      break; 
+    } 
+ 
+    default: /* no-op */ 
+      break; 
+  } 
+ 
+  return WRC_Continue; 
+} 
+static int selectWindowRewriteSelectCb(Walker *pWalker, Select *pSelect){ 
+  struct WindowRewrite *p = pWalker->u.pRewrite; 
+  Select *pSave = p->pSubSelect; 
+  if( pSave==pSelect ){ 
+    return WRC_Continue; 
+  }else{ 
+    p->pSubSelect = pSelect; 
+    sqlite3WalkSelect(pWalker, pSelect); 
+    p->pSubSelect = pSave; 
+  } 
+  return WRC_Prune; 
+} 
+ 
+ 
+/* 
+** Iterate through each expression in expression-list pEList. For each: 
+** 
+**   * TK_COLUMN, 
+**   * aggregate function, or 
 **   * window function with a Window object that is not a member of the
-**     Window list passed as the second argument (pWin).
-**
-** Append the node to output expression-list (*ppSub). And replace it
+**     Window list passed as the second argument (pWin). 
+** 
+** Append the node to output expression-list (*ppSub). And replace it 
 ** with a TK_COLUMN that reads the (N-1)th element of table
-** pWin->iEphCsr, where N is the number of elements in (*ppSub) after
-** appending the new one.
-*/
-static void selectWindowRewriteEList(
+** pWin->iEphCsr, where N is the number of elements in (*ppSub) after 
+** appending the new one. 
+*/ 
+static void selectWindowRewriteEList( 
   Parse *pParse,
-  Window *pWin,
-  SrcList *pSrc,
-  ExprList *pEList,               /* Rewrite expressions in this list */
-  Table *pTab,
-  ExprList **ppSub                /* IN/OUT: Sub-select expression-list */
-){
-  Walker sWalker;
-  WindowRewrite sRewrite;
-
+  Window *pWin, 
+  SrcList *pSrc, 
+  ExprList *pEList,               /* Rewrite expressions in this list */ 
+  Table *pTab, 
+  ExprList **ppSub                /* IN/OUT: Sub-select expression-list */ 
+){ 
+  Walker sWalker; 
+  WindowRewrite sRewrite; 
+ 
   assert( pWin!=0 );
-  memset(&sWalker, 0, sizeof(Walker));
-  memset(&sRewrite, 0, sizeof(WindowRewrite));
-
-  sRewrite.pSub = *ppSub;
-  sRewrite.pWin = pWin;
-  sRewrite.pSrc = pSrc;
-  sRewrite.pTab = pTab;
-
-  sWalker.pParse = pParse;
-  sWalker.xExprCallback = selectWindowRewriteExprCb;
-  sWalker.xSelectCallback = selectWindowRewriteSelectCb;
-  sWalker.u.pRewrite = &sRewrite;
-
-  (void)sqlite3WalkExprList(&sWalker, pEList);
-
-  *ppSub = sRewrite.pSub;
-}
-
-/*
-** Append a copy of each expression in expression-list pAppend to
-** expression list pList. Return a pointer to the result list.
-*/
-static ExprList *exprListAppendList(
-  Parse *pParse,          /* Parsing context */
-  ExprList *pList,        /* List to which to append. Might be NULL */
-  ExprList *pAppend,      /* List of values to append. Might be NULL */
-  int bIntToNull
-){
-  if( pAppend ){
-    int i;
-    int nInit = pList ? pList->nExpr : 0;
-    for(i=0; i<pAppend->nExpr; i++){
+  memset(&sWalker, 0, sizeof(Walker)); 
+  memset(&sRewrite, 0, sizeof(WindowRewrite)); 
+ 
+  sRewrite.pSub = *ppSub; 
+  sRewrite.pWin = pWin; 
+  sRewrite.pSrc = pSrc; 
+  sRewrite.pTab = pTab; 
+ 
+  sWalker.pParse = pParse; 
+  sWalker.xExprCallback = selectWindowRewriteExprCb; 
+  sWalker.xSelectCallback = selectWindowRewriteSelectCb; 
+  sWalker.u.pRewrite = &sRewrite; 
+ 
+  (void)sqlite3WalkExprList(&sWalker, pEList); 
+ 
+  *ppSub = sRewrite.pSub; 
+} 
+ 
+/* 
+** Append a copy of each expression in expression-list pAppend to 
+** expression list pList. Return a pointer to the result list. 
+*/ 
+static ExprList *exprListAppendList( 
+  Parse *pParse,          /* Parsing context */ 
+  ExprList *pList,        /* List to which to append. Might be NULL */ 
+  ExprList *pAppend,      /* List of values to append. Might be NULL */ 
+  int bIntToNull 
+){ 
+  if( pAppend ){ 
+    int i; 
+    int nInit = pList ? pList->nExpr : 0; 
+    for(i=0; i<pAppend->nExpr; i++){ 
       sqlite3 *db = pParse->db;
       Expr *pDup = sqlite3ExprDup(db, pAppend->a[i].pExpr, 0);
       assert( pDup==0 || !ExprHasProperty(pDup, EP_MemToken) );
@@ -157273,15 +157273,15 @@ static ExprList *exprListAppendList(
           pSub->flags &= ~(EP_IntValue|EP_IsTrue|EP_IsFalse);
           pSub->u.zToken = 0;
         }
-      }
-      pList = sqlite3ExprListAppend(pParse, pList, pDup);
+      } 
+      pList = sqlite3ExprListAppend(pParse, pList, pDup); 
       if( pList ) pList->a[nInit+i].sortFlags = pAppend->a[i].sortFlags;
-    }
-  }
-  return pList;
-}
-
-/*
+    } 
+  } 
+  return pList; 
+} 
+ 
+/* 
 ** When rewriting a query, if the new subquery in the FROM clause
 ** contains TK_AGG_FUNCTION nodes that refer to an outer query,
 ** then we have to increase the Expr->op2 values of those nodes
@@ -157308,36 +157308,36 @@ static int disallowAggregatesInOrderByCb(Walker *pWalker, Expr *pExpr){
 }
 
 /*
-** If the SELECT statement passed as the second argument does not invoke
+** If the SELECT statement passed as the second argument does not invoke 
 ** any SQL window functions, this function is a no-op. Otherwise, it
-** rewrites the SELECT statement so that window function xStep functions
-** are invoked in the correct order as described under "SELECT REWRITING"
-** at the top of this file.
-*/
-SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){
-  int rc = SQLITE_OK;
+** rewrites the SELECT statement so that window function xStep functions 
+** are invoked in the correct order as described under "SELECT REWRITING" 
+** at the top of this file. 
+*/ 
+SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){ 
+  int rc = SQLITE_OK; 
   if( p->pWin && p->pPrior==0 && ALWAYS((p->selFlags & SF_WinRewrite)==0) ){
-    Vdbe *v = sqlite3GetVdbe(pParse);
-    sqlite3 *db = pParse->db;
-    Select *pSub = 0;             /* The subquery */
-    SrcList *pSrc = p->pSrc;
-    Expr *pWhere = p->pWhere;
-    ExprList *pGroupBy = p->pGroupBy;
-    Expr *pHaving = p->pHaving;
-    ExprList *pSort = 0;
-
-    ExprList *pSublist = 0;       /* Expression list for sub-query */
+    Vdbe *v = sqlite3GetVdbe(pParse); 
+    sqlite3 *db = pParse->db; 
+    Select *pSub = 0;             /* The subquery */ 
+    SrcList *pSrc = p->pSrc; 
+    Expr *pWhere = p->pWhere; 
+    ExprList *pGroupBy = p->pGroupBy; 
+    Expr *pHaving = p->pHaving; 
+    ExprList *pSort = 0; 
+ 
+    ExprList *pSublist = 0;       /* Expression list for sub-query */ 
     Window *pMWin = p->pWin;      /* Main window object */
-    Window *pWin;                 /* Window object iterator */
-    Table *pTab;
+    Window *pWin;                 /* Window object iterator */ 
+    Table *pTab; 
     Walker w;
-
+ 
     u32 selFlags = p->selFlags;
 
-    pTab = sqlite3DbMallocZero(db, sizeof(Table));
-    if( pTab==0 ){
+    pTab = sqlite3DbMallocZero(db, sizeof(Table)); 
+    if( pTab==0 ){ 
       return sqlite3ErrorToParser(db, SQLITE_NOMEM);
-    }
+    } 
     sqlite3AggInfoPersistWalkerInit(&w, pParse);
     sqlite3WalkSelect(&w, p);
     if( (p->selFlags & SF_Aggregate)==0 ){
@@ -157345,50 +157345,50 @@ SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){
       w.xSelectCallback = 0;
       sqlite3WalkExprList(&w, p->pOrderBy);
     }
-
-    p->pSrc = 0;
-    p->pWhere = 0;
-    p->pGroupBy = 0;
-    p->pHaving = 0;
-    p->selFlags &= ~SF_Aggregate;
+ 
+    p->pSrc = 0; 
+    p->pWhere = 0; 
+    p->pGroupBy = 0; 
+    p->pHaving = 0; 
+    p->selFlags &= ~SF_Aggregate; 
     p->selFlags |= SF_WinRewrite;
-
-    /* Create the ORDER BY clause for the sub-select. This is the concatenation
-    ** of the window PARTITION and ORDER BY clauses. Then, if this makes it
-    ** redundant, remove the ORDER BY from the parent SELECT.  */
+ 
+    /* Create the ORDER BY clause for the sub-select. This is the concatenation 
+    ** of the window PARTITION and ORDER BY clauses. Then, if this makes it 
+    ** redundant, remove the ORDER BY from the parent SELECT.  */ 
     pSort = exprListAppendList(pParse, 0, pMWin->pPartition, 1);
-    pSort = exprListAppendList(pParse, pSort, pMWin->pOrderBy, 1);
+    pSort = exprListAppendList(pParse, pSort, pMWin->pOrderBy, 1); 
     if( pSort && p->pOrderBy && p->pOrderBy->nExpr<=pSort->nExpr ){
       int nSave = pSort->nExpr;
       pSort->nExpr = p->pOrderBy->nExpr;
-      if( sqlite3ExprListCompare(pSort, p->pOrderBy, -1)==0 ){
-        sqlite3ExprListDelete(db, p->pOrderBy);
-        p->pOrderBy = 0;
-      }
+      if( sqlite3ExprListCompare(pSort, p->pOrderBy, -1)==0 ){ 
+        sqlite3ExprListDelete(db, p->pOrderBy); 
+        p->pOrderBy = 0; 
+      } 
       pSort->nExpr = nSave;
-    }
-
-    /* Assign a cursor number for the ephemeral table used to buffer rows.
-    ** The OpenEphemeral instruction is coded later, after it is known how
-    ** many columns the table will have.  */
-    pMWin->iEphCsr = pParse->nTab++;
-    pParse->nTab += 3;
-
-    selectWindowRewriteEList(pParse, pMWin, pSrc, p->pEList, pTab, &pSublist);
-    selectWindowRewriteEList(pParse, pMWin, pSrc, p->pOrderBy, pTab, &pSublist);
-    pMWin->nBufferCol = (pSublist ? pSublist->nExpr : 0);
-
+    } 
+ 
+    /* Assign a cursor number for the ephemeral table used to buffer rows. 
+    ** The OpenEphemeral instruction is coded later, after it is known how 
+    ** many columns the table will have.  */ 
+    pMWin->iEphCsr = pParse->nTab++; 
+    pParse->nTab += 3; 
+ 
+    selectWindowRewriteEList(pParse, pMWin, pSrc, p->pEList, pTab, &pSublist); 
+    selectWindowRewriteEList(pParse, pMWin, pSrc, p->pOrderBy, pTab, &pSublist); 
+    pMWin->nBufferCol = (pSublist ? pSublist->nExpr : 0); 
+ 
     /* Append the PARTITION BY and ORDER BY expressions to the to the
     ** sub-select expression list. They are required to figure out where
-    ** boundaries for partitions and sets of peer rows lie.  */
-    pSublist = exprListAppendList(pParse, pSublist, pMWin->pPartition, 0);
-    pSublist = exprListAppendList(pParse, pSublist, pMWin->pOrderBy, 0);
-
-    /* Append the arguments passed to each window function to the
-    ** sub-select expression list. Also allocate two registers for each
-    ** window function - one for the accumulator, another for interim
-    ** results.  */
-    for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
+    ** boundaries for partitions and sets of peer rows lie.  */ 
+    pSublist = exprListAppendList(pParse, pSublist, pMWin->pPartition, 0); 
+    pSublist = exprListAppendList(pParse, pSublist, pMWin->pOrderBy, 0); 
+ 
+    /* Append the arguments passed to each window function to the 
+    ** sub-select expression list. Also allocate two registers for each 
+    ** window function - one for the accumulator, another for interim 
+    ** results.  */ 
+    for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ 
       ExprList *pArgs;
       assert( ExprUseXList(pWin->pOwner) );
       pArgs = pWin->pOwner->x.pList;
@@ -157400,81 +157400,81 @@ SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){
         pWin->iArgCol = (pSublist ? pSublist->nExpr : 0);
         pSublist = exprListAppendList(pParse, pSublist, pArgs, 0);
       }
-      if( pWin->pFilter ){
-        Expr *pFilter = sqlite3ExprDup(db, pWin->pFilter, 0);
-        pSublist = sqlite3ExprListAppend(pParse, pSublist, pFilter);
-      }
-      pWin->regAccum = ++pParse->nMem;
-      pWin->regResult = ++pParse->nMem;
-      sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
-    }
-
-    /* If there is no ORDER BY or PARTITION BY clause, and the window
-    ** function accepts zero arguments, and there are no other columns
-    ** selected (e.g. "SELECT row_number() OVER () FROM t1"), it is possible
+      if( pWin->pFilter ){ 
+        Expr *pFilter = sqlite3ExprDup(db, pWin->pFilter, 0); 
+        pSublist = sqlite3ExprListAppend(pParse, pSublist, pFilter); 
+      } 
+      pWin->regAccum = ++pParse->nMem; 
+      pWin->regResult = ++pParse->nMem; 
+      sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum); 
+    } 
+ 
+    /* If there is no ORDER BY or PARTITION BY clause, and the window 
+    ** function accepts zero arguments, and there are no other columns 
+    ** selected (e.g. "SELECT row_number() OVER () FROM t1"), it is possible 
     ** that pSublist is still NULL here. Add a constant expression here to
     ** keep everything legal in this case.
-    */
-    if( pSublist==0 ){
+    */ 
+    if( pSublist==0 ){ 
       pSublist = sqlite3ExprListAppend(pParse, 0,
         sqlite3Expr(db, TK_INTEGER, "0")
-      );
-    }
-
-    pSub = sqlite3SelectNew(
-        pParse, pSublist, pSrc, pWhere, pGroupBy, pHaving, pSort, 0, 0
-    );
+      ); 
+    } 
+ 
+    pSub = sqlite3SelectNew( 
+        pParse, pSublist, pSrc, pWhere, pGroupBy, pHaving, pSort, 0, 0 
+    ); 
     SELECTTRACE(1,pParse,pSub,
        ("New window-function subquery in FROM clause of (%u/%p)\n",
        p->selId, p));
-    p->pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
+    p->pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0); 
     assert( pSub!=0 || p->pSrc==0 ); /* Due to db->mallocFailed test inside
                                      ** of sqlite3DbMallocRawNN() called from
                                      ** sqlite3SrcListAppend() */
-    if( p->pSrc ){
-      Table *pTab2;
-      p->pSrc->a[0].pSelect = pSub;
-      sqlite3SrcListAssignCursors(pParse, p->pSrc);
+    if( p->pSrc ){ 
+      Table *pTab2; 
+      p->pSrc->a[0].pSelect = pSub; 
+      sqlite3SrcListAssignCursors(pParse, p->pSrc); 
       pSub->selFlags |= SF_Expanded|SF_OrderByReqd;
       pTab2 = sqlite3ResultSetOfSelect(pParse, pSub, SQLITE_AFF_NONE);
       pSub->selFlags |= (selFlags & SF_Aggregate);
-      if( pTab2==0 ){
+      if( pTab2==0 ){ 
         /* Might actually be some other kind of error, but in that case
         ** pParse->nErr will be set, so if SQLITE_NOMEM is set, we will get
         ** the correct error message regardless. */
-        rc = SQLITE_NOMEM;
-      }else{
-        memcpy(pTab, pTab2, sizeof(Table));
-        pTab->tabFlags |= TF_Ephemeral;
-        p->pSrc->a[0].pTab = pTab;
-        pTab = pTab2;
+        rc = SQLITE_NOMEM; 
+      }else{ 
+        memcpy(pTab, pTab2, sizeof(Table)); 
+        pTab->tabFlags |= TF_Ephemeral; 
+        p->pSrc->a[0].pTab = pTab; 
+        pTab = pTab2; 
         memset(&w, 0, sizeof(w));
         w.xExprCallback = sqlite3WindowExtraAggFuncDepth;
         w.xSelectCallback = sqlite3WalkerDepthIncrease;
         w.xSelectCallback2 = sqlite3WalkerDepthDecrease;
         sqlite3WalkSelect(&w, pSub);
-      }
-    }else{
-      sqlite3SelectDelete(db, pSub);
-    }
-    if( db->mallocFailed ) rc = SQLITE_NOMEM;
+      } 
+    }else{ 
+      sqlite3SelectDelete(db, pSub); 
+    } 
+    if( db->mallocFailed ) rc = SQLITE_NOMEM; 
 
     /* Defer deleting the temporary table pTab because if an error occurred,
     ** there could still be references to that table embedded in the
     ** result-set or ORDER BY clause of the SELECT statement p.  */
     sqlite3ParserAddCleanup(pParse, sqlite3DbFree, pTab);
-  }
-
+  } 
+ 
   if( rc ){
     if( pParse->nErr==0 ){
       assert( pParse->db->mallocFailed );
       sqlite3ErrorToParser(pParse->db, SQLITE_NOMEM);
     }
   }
-  return rc;
-}
-
-/*
+  return rc; 
+} 
+ 
+/* 
 ** Unlink the Window object from the Select to which it is attached,
 ** if it is attached.
 */
@@ -157487,188 +157487,188 @@ SQLITE_PRIVATE void sqlite3WindowUnlinkFromSelect(Window *p){
 }
 
 /*
-** Free the Window object passed as the second argument.
-*/
-SQLITE_PRIVATE void sqlite3WindowDelete(sqlite3 *db, Window *p){
-  if( p ){
+** Free the Window object passed as the second argument. 
+*/ 
+SQLITE_PRIVATE void sqlite3WindowDelete(sqlite3 *db, Window *p){ 
+  if( p ){ 
     sqlite3WindowUnlinkFromSelect(p);
-    sqlite3ExprDelete(db, p->pFilter);
-    sqlite3ExprListDelete(db, p->pPartition);
-    sqlite3ExprListDelete(db, p->pOrderBy);
-    sqlite3ExprDelete(db, p->pEnd);
-    sqlite3ExprDelete(db, p->pStart);
-    sqlite3DbFree(db, p->zName);
-    sqlite3DbFree(db, p->zBase);
-    sqlite3DbFree(db, p);
-  }
-}
-
-/*
-** Free the linked list of Window objects starting at the second argument.
-*/
-SQLITE_PRIVATE void sqlite3WindowListDelete(sqlite3 *db, Window *p){
-  while( p ){
-    Window *pNext = p->pNextWin;
-    sqlite3WindowDelete(db, p);
-    p = pNext;
-  }
-}
-
-/*
-** The argument expression is an PRECEDING or FOLLOWING offset.  The
-** value should be a non-negative integer.  If the value is not a
-** constant, change it to NULL.  The fact that it is then a non-negative
-** integer will be caught later.  But it is important not to leave
-** variable values in the expression tree.
-*/
-static Expr *sqlite3WindowOffsetExpr(Parse *pParse, Expr *pExpr){
-  if( 0==sqlite3ExprIsConstant(pExpr) ){
-    if( IN_RENAME_OBJECT ) sqlite3RenameExprUnmap(pParse, pExpr);
-    sqlite3ExprDelete(pParse->db, pExpr);
-    pExpr = sqlite3ExprAlloc(pParse->db, TK_NULL, 0, 0);
-  }
-  return pExpr;
-}
-
-/*
-** Allocate and return a new Window object describing a Window Definition.
-*/
-SQLITE_PRIVATE Window *sqlite3WindowAlloc(
-  Parse *pParse,    /* Parsing context */
-  int eType,        /* Frame type. TK_RANGE, TK_ROWS, TK_GROUPS, or 0 */
-  int eStart,       /* Start type: CURRENT, PRECEDING, FOLLOWING, UNBOUNDED */
-  Expr *pStart,     /* Start window size if TK_PRECEDING or FOLLOWING */
-  int eEnd,         /* End type: CURRENT, FOLLOWING, TK_UNBOUNDED, PRECEDING */
-  Expr *pEnd,       /* End window size if TK_FOLLOWING or PRECEDING */
-  u8 eExclude       /* EXCLUDE clause */
-){
-  Window *pWin = 0;
-  int bImplicitFrame = 0;
-
-  /* Parser assures the following: */
-  assert( eType==0 || eType==TK_RANGE || eType==TK_ROWS || eType==TK_GROUPS );
-  assert( eStart==TK_CURRENT || eStart==TK_PRECEDING
-           || eStart==TK_UNBOUNDED || eStart==TK_FOLLOWING );
-  assert( eEnd==TK_CURRENT || eEnd==TK_FOLLOWING
-           || eEnd==TK_UNBOUNDED || eEnd==TK_PRECEDING );
-  assert( (eStart==TK_PRECEDING || eStart==TK_FOLLOWING)==(pStart!=0) );
-  assert( (eEnd==TK_FOLLOWING || eEnd==TK_PRECEDING)==(pEnd!=0) );
-
-  if( eType==0 ){
-    bImplicitFrame = 1;
-    eType = TK_RANGE;
-  }
-
-  /* Additionally, the
-  ** starting boundary type may not occur earlier in the following list than
-  ** the ending boundary type:
-  **
-  **   UNBOUNDED PRECEDING
-  **   <expr> PRECEDING
-  **   CURRENT ROW
-  **   <expr> FOLLOWING
-  **   UNBOUNDED FOLLOWING
-  **
-  ** The parser ensures that "UNBOUNDED PRECEDING" cannot be used as an ending
-  ** boundary, and than "UNBOUNDED FOLLOWING" cannot be used as a starting
-  ** frame boundary.
-  */
-  if( (eStart==TK_CURRENT && eEnd==TK_PRECEDING)
-   || (eStart==TK_FOLLOWING && (eEnd==TK_PRECEDING || eEnd==TK_CURRENT))
-  ){
-    sqlite3ErrorMsg(pParse, "unsupported frame specification");
-    goto windowAllocErr;
-  }
-
-  pWin = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
-  if( pWin==0 ) goto windowAllocErr;
-  pWin->eFrmType = eType;
-  pWin->eStart = eStart;
-  pWin->eEnd = eEnd;
-  if( eExclude==0 && OptimizationDisabled(pParse->db, SQLITE_WindowFunc) ){
-    eExclude = TK_NO;
-  }
-  pWin->eExclude = eExclude;
-  pWin->bImplicitFrame = bImplicitFrame;
-  pWin->pEnd = sqlite3WindowOffsetExpr(pParse, pEnd);
-  pWin->pStart = sqlite3WindowOffsetExpr(pParse, pStart);
-  return pWin;
-
-windowAllocErr:
-  sqlite3ExprDelete(pParse->db, pEnd);
-  sqlite3ExprDelete(pParse->db, pStart);
-  return 0;
-}
-
-/*
-** Attach PARTITION and ORDER BY clauses pPartition and pOrderBy to window
-** pWin. Also, if parameter pBase is not NULL, set pWin->zBase to the
-** equivalent nul-terminated string.
-*/
-SQLITE_PRIVATE Window *sqlite3WindowAssemble(
+    sqlite3ExprDelete(db, p->pFilter); 
+    sqlite3ExprListDelete(db, p->pPartition); 
+    sqlite3ExprListDelete(db, p->pOrderBy); 
+    sqlite3ExprDelete(db, p->pEnd); 
+    sqlite3ExprDelete(db, p->pStart); 
+    sqlite3DbFree(db, p->zName); 
+    sqlite3DbFree(db, p->zBase); 
+    sqlite3DbFree(db, p); 
+  } 
+} 
+ 
+/* 
+** Free the linked list of Window objects starting at the second argument. 
+*/ 
+SQLITE_PRIVATE void sqlite3WindowListDelete(sqlite3 *db, Window *p){ 
+  while( p ){ 
+    Window *pNext = p->pNextWin; 
+    sqlite3WindowDelete(db, p); 
+    p = pNext; 
+  } 
+} 
+ 
+/* 
+** The argument expression is an PRECEDING or FOLLOWING offset.  The 
+** value should be a non-negative integer.  If the value is not a 
+** constant, change it to NULL.  The fact that it is then a non-negative 
+** integer will be caught later.  But it is important not to leave 
+** variable values in the expression tree. 
+*/ 
+static Expr *sqlite3WindowOffsetExpr(Parse *pParse, Expr *pExpr){ 
+  if( 0==sqlite3ExprIsConstant(pExpr) ){ 
+    if( IN_RENAME_OBJECT ) sqlite3RenameExprUnmap(pParse, pExpr); 
+    sqlite3ExprDelete(pParse->db, pExpr); 
+    pExpr = sqlite3ExprAlloc(pParse->db, TK_NULL, 0, 0); 
+  } 
+  return pExpr; 
+} 
+ 
+/* 
+** Allocate and return a new Window object describing a Window Definition. 
+*/ 
+SQLITE_PRIVATE Window *sqlite3WindowAlloc( 
+  Parse *pParse,    /* Parsing context */ 
+  int eType,        /* Frame type. TK_RANGE, TK_ROWS, TK_GROUPS, or 0 */ 
+  int eStart,       /* Start type: CURRENT, PRECEDING, FOLLOWING, UNBOUNDED */ 
+  Expr *pStart,     /* Start window size if TK_PRECEDING or FOLLOWING */ 
+  int eEnd,         /* End type: CURRENT, FOLLOWING, TK_UNBOUNDED, PRECEDING */ 
+  Expr *pEnd,       /* End window size if TK_FOLLOWING or PRECEDING */ 
+  u8 eExclude       /* EXCLUDE clause */ 
+){ 
+  Window *pWin = 0; 
+  int bImplicitFrame = 0; 
+ 
+  /* Parser assures the following: */ 
+  assert( eType==0 || eType==TK_RANGE || eType==TK_ROWS || eType==TK_GROUPS ); 
+  assert( eStart==TK_CURRENT || eStart==TK_PRECEDING 
+           || eStart==TK_UNBOUNDED || eStart==TK_FOLLOWING ); 
+  assert( eEnd==TK_CURRENT || eEnd==TK_FOLLOWING 
+           || eEnd==TK_UNBOUNDED || eEnd==TK_PRECEDING ); 
+  assert( (eStart==TK_PRECEDING || eStart==TK_FOLLOWING)==(pStart!=0) ); 
+  assert( (eEnd==TK_FOLLOWING || eEnd==TK_PRECEDING)==(pEnd!=0) ); 
+ 
+  if( eType==0 ){ 
+    bImplicitFrame = 1; 
+    eType = TK_RANGE; 
+  } 
+ 
+  /* Additionally, the 
+  ** starting boundary type may not occur earlier in the following list than 
+  ** the ending boundary type: 
+  ** 
+  **   UNBOUNDED PRECEDING 
+  **   <expr> PRECEDING 
+  **   CURRENT ROW 
+  **   <expr> FOLLOWING 
+  **   UNBOUNDED FOLLOWING 
+  ** 
+  ** The parser ensures that "UNBOUNDED PRECEDING" cannot be used as an ending 
+  ** boundary, and than "UNBOUNDED FOLLOWING" cannot be used as a starting 
+  ** frame boundary. 
+  */ 
+  if( (eStart==TK_CURRENT && eEnd==TK_PRECEDING) 
+   || (eStart==TK_FOLLOWING && (eEnd==TK_PRECEDING || eEnd==TK_CURRENT)) 
+  ){ 
+    sqlite3ErrorMsg(pParse, "unsupported frame specification"); 
+    goto windowAllocErr; 
+  } 
+ 
+  pWin = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window)); 
+  if( pWin==0 ) goto windowAllocErr; 
+  pWin->eFrmType = eType; 
+  pWin->eStart = eStart; 
+  pWin->eEnd = eEnd; 
+  if( eExclude==0 && OptimizationDisabled(pParse->db, SQLITE_WindowFunc) ){ 
+    eExclude = TK_NO; 
+  } 
+  pWin->eExclude = eExclude; 
+  pWin->bImplicitFrame = bImplicitFrame; 
+  pWin->pEnd = sqlite3WindowOffsetExpr(pParse, pEnd); 
+  pWin->pStart = sqlite3WindowOffsetExpr(pParse, pStart); 
+  return pWin; 
+ 
+windowAllocErr: 
+  sqlite3ExprDelete(pParse->db, pEnd); 
+  sqlite3ExprDelete(pParse->db, pStart); 
+  return 0; 
+} 
+ 
+/* 
+** Attach PARTITION and ORDER BY clauses pPartition and pOrderBy to window 
+** pWin. Also, if parameter pBase is not NULL, set pWin->zBase to the 
+** equivalent nul-terminated string. 
+*/ 
+SQLITE_PRIVATE Window *sqlite3WindowAssemble( 
   Parse *pParse,
   Window *pWin,
   ExprList *pPartition,
   ExprList *pOrderBy,
-  Token *pBase
-){
-  if( pWin ){
-    pWin->pPartition = pPartition;
-    pWin->pOrderBy = pOrderBy;
-    if( pBase ){
-      pWin->zBase = sqlite3DbStrNDup(pParse->db, pBase->z, pBase->n);
-    }
-  }else{
-    sqlite3ExprListDelete(pParse->db, pPartition);
-    sqlite3ExprListDelete(pParse->db, pOrderBy);
-  }
-  return pWin;
-}
-
-/*
-** Window *pWin has just been created from a WINDOW clause. Tokne pBase
-** is the base window. Earlier windows from the same WINDOW clause are
-** stored in the linked list starting at pWin->pNextWin. This function
-** either updates *pWin according to the base specification, or else
-** leaves an error in pParse.
-*/
-SQLITE_PRIVATE void sqlite3WindowChain(Parse *pParse, Window *pWin, Window *pList){
-  if( pWin->zBase ){
-    sqlite3 *db = pParse->db;
-    Window *pExist = windowFind(pParse, pList, pWin->zBase);
-    if( pExist ){
-      const char *zErr = 0;
-      /* Check for errors */
-      if( pWin->pPartition ){
-        zErr = "PARTITION clause";
-      }else if( pExist->pOrderBy && pWin->pOrderBy ){
-        zErr = "ORDER BY clause";
-      }else if( pExist->bImplicitFrame==0 ){
-        zErr = "frame specification";
-      }
-      if( zErr ){
+  Token *pBase 
+){ 
+  if( pWin ){ 
+    pWin->pPartition = pPartition; 
+    pWin->pOrderBy = pOrderBy; 
+    if( pBase ){ 
+      pWin->zBase = sqlite3DbStrNDup(pParse->db, pBase->z, pBase->n); 
+    } 
+  }else{ 
+    sqlite3ExprListDelete(pParse->db, pPartition); 
+    sqlite3ExprListDelete(pParse->db, pOrderBy); 
+  } 
+  return pWin; 
+} 
+ 
+/* 
+** Window *pWin has just been created from a WINDOW clause. Tokne pBase 
+** is the base window. Earlier windows from the same WINDOW clause are 
+** stored in the linked list starting at pWin->pNextWin. This function 
+** either updates *pWin according to the base specification, or else 
+** leaves an error in pParse. 
+*/ 
+SQLITE_PRIVATE void sqlite3WindowChain(Parse *pParse, Window *pWin, Window *pList){ 
+  if( pWin->zBase ){ 
+    sqlite3 *db = pParse->db; 
+    Window *pExist = windowFind(pParse, pList, pWin->zBase); 
+    if( pExist ){ 
+      const char *zErr = 0; 
+      /* Check for errors */ 
+      if( pWin->pPartition ){ 
+        zErr = "PARTITION clause"; 
+      }else if( pExist->pOrderBy && pWin->pOrderBy ){ 
+        zErr = "ORDER BY clause"; 
+      }else if( pExist->bImplicitFrame==0 ){ 
+        zErr = "frame specification"; 
+      } 
+      if( zErr ){ 
         sqlite3ErrorMsg(pParse,
-            "cannot override %s of window: %s", zErr, pWin->zBase
-        );
-      }else{
-        pWin->pPartition = sqlite3ExprListDup(db, pExist->pPartition, 0);
-        if( pExist->pOrderBy ){
-          assert( pWin->pOrderBy==0 );
-          pWin->pOrderBy = sqlite3ExprListDup(db, pExist->pOrderBy, 0);
-        }
-        sqlite3DbFree(db, pWin->zBase);
-        pWin->zBase = 0;
-      }
-    }
-  }
-}
-
-/*
-** Attach window object pWin to expression p.
-*/
-SQLITE_PRIVATE void sqlite3WindowAttach(Parse *pParse, Expr *p, Window *pWin){
-  if( p ){
-    assert( p->op==TK_FUNCTION );
+            "cannot override %s of window: %s", zErr, pWin->zBase 
+        ); 
+      }else{ 
+        pWin->pPartition = sqlite3ExprListDup(db, pExist->pPartition, 0); 
+        if( pExist->pOrderBy ){ 
+          assert( pWin->pOrderBy==0 ); 
+          pWin->pOrderBy = sqlite3ExprListDup(db, pExist->pOrderBy, 0); 
+        } 
+        sqlite3DbFree(db, pWin->zBase); 
+        pWin->zBase = 0; 
+      } 
+    } 
+  } 
+} 
+ 
+/* 
+** Attach window object pWin to expression p. 
+*/ 
+SQLITE_PRIVATE void sqlite3WindowAttach(Parse *pParse, Expr *p, Window *pWin){ 
+  if( p ){ 
+    assert( p->op==TK_FUNCTION ); 
     assert( pWin );
     p->y.pWin = pWin;
     ExprSetProperty(p, EP_WinFunc);
@@ -157677,18 +157677,18 @@ SQLITE_PRIVATE void sqlite3WindowAttach(Parse *pParse, Expr *p, Window *pWin){
       sqlite3ErrorMsg(pParse,
           "DISTINCT is not supported for window functions"
       );
-    }
-  }else{
-    sqlite3WindowDelete(pParse->db, pWin);
-  }
-}
-
-/*
+    } 
+  }else{ 
+    sqlite3WindowDelete(pParse->db, pWin); 
+  } 
+} 
+ 
+/* 
 ** Possibly link window pWin into the list at pSel->pWin (window functions
 ** to be processed as part of SELECT statement pSel). The window is linked
 ** in if either (a) there are no other windows already linked to this
 ** SELECT, or (b) the windows already linked use a compatible window frame.
-*/
+*/ 
 SQLITE_PRIVATE void sqlite3WindowLink(Select *pSel, Window *pWin){
   if( pSel ){
     if( 0==pSel->pWin || 0==sqlite3WindowCompare(0, pSel->pWin, pWin, 0) ){
@@ -157719,12 +157719,12 @@ SQLITE_PRIVATE int sqlite3WindowCompare(
 ){
   int res;
   if( NEVER(p1==0) || NEVER(p2==0) ) return 1;
-  if( p1->eFrmType!=p2->eFrmType ) return 1;
-  if( p1->eStart!=p2->eStart ) return 1;
-  if( p1->eEnd!=p2->eEnd ) return 1;
-  if( p1->eExclude!=p2->eExclude ) return 1;
-  if( sqlite3ExprCompare(pParse, p1->pStart, p2->pStart, -1) ) return 1;
-  if( sqlite3ExprCompare(pParse, p1->pEnd, p2->pEnd, -1) ) return 1;
+  if( p1->eFrmType!=p2->eFrmType ) return 1; 
+  if( p1->eStart!=p2->eStart ) return 1; 
+  if( p1->eEnd!=p2->eEnd ) return 1; 
+  if( p1->eExclude!=p2->eExclude ) return 1; 
+  if( sqlite3ExprCompare(pParse, p1->pStart, p2->pStart, -1) ) return 1; 
+  if( sqlite3ExprCompare(pParse, p1->pEnd, p2->pEnd, -1) ) return 1; 
   if( (res = sqlite3ExprListCompare(p1->pPartition, p2->pPartition, -1)) ){
     return res;
   }
@@ -157736,160 +157736,160 @@ SQLITE_PRIVATE int sqlite3WindowCompare(
       return res;
     }
   }
-  return 0;
-}
-
-
-/*
-** This is called by code in select.c before it calls sqlite3WhereBegin()
-** to begin iterating through the sub-query results. It is used to allocate
-** and initialize registers and cursors used by sqlite3WindowCodeStep().
-*/
+  return 0; 
+} 
+ 
+ 
+/* 
+** This is called by code in select.c before it calls sqlite3WhereBegin() 
+** to begin iterating through the sub-query results. It is used to allocate 
+** and initialize registers and cursors used by sqlite3WindowCodeStep(). 
+*/ 
 SQLITE_PRIVATE void sqlite3WindowCodeInit(Parse *pParse, Select *pSelect){
   int nEphExpr = pSelect->pSrc->a[0].pSelect->pEList->nExpr;
   Window *pMWin = pSelect->pWin;
-  Window *pWin;
-  Vdbe *v = sqlite3GetVdbe(pParse);
-
+  Window *pWin; 
+  Vdbe *v = sqlite3GetVdbe(pParse); 
+ 
   sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pMWin->iEphCsr, nEphExpr);
   sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+1, pMWin->iEphCsr);
   sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+2, pMWin->iEphCsr);
   sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+3, pMWin->iEphCsr);
 
-  /* Allocate registers to use for PARTITION BY values, if any. Initialize
-  ** said registers to NULL.  */
-  if( pMWin->pPartition ){
-    int nExpr = pMWin->pPartition->nExpr;
-    pMWin->regPart = pParse->nMem+1;
-    pParse->nMem += nExpr;
-    sqlite3VdbeAddOp3(v, OP_Null, 0, pMWin->regPart, pMWin->regPart+nExpr-1);
-  }
-
-  pMWin->regOne = ++pParse->nMem;
-  sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regOne);
-
-  if( pMWin->eExclude ){
-    pMWin->regStartRowid = ++pParse->nMem;
-    pMWin->regEndRowid = ++pParse->nMem;
-    pMWin->csrApp = pParse->nTab++;
-    sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regStartRowid);
-    sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regEndRowid);
-    sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->csrApp, pMWin->iEphCsr);
-    return;
-  }
-
-  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
-    FuncDef *p = pWin->pFunc;
-    if( (p->funcFlags & SQLITE_FUNC_MINMAX) && pWin->eStart!=TK_UNBOUNDED ){
-      /* The inline versions of min() and max() require a single ephemeral
-      ** table and 3 registers. The registers are used as follows:
-      **
-      **   regApp+0: slot to copy min()/max() argument to for MakeRecord
-      **   regApp+1: integer value used to ensure keys are unique
-      **   regApp+2: output of MakeRecord
-      */
+  /* Allocate registers to use for PARTITION BY values, if any. Initialize 
+  ** said registers to NULL.  */ 
+  if( pMWin->pPartition ){ 
+    int nExpr = pMWin->pPartition->nExpr; 
+    pMWin->regPart = pParse->nMem+1; 
+    pParse->nMem += nExpr; 
+    sqlite3VdbeAddOp3(v, OP_Null, 0, pMWin->regPart, pMWin->regPart+nExpr-1); 
+  } 
+ 
+  pMWin->regOne = ++pParse->nMem; 
+  sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regOne); 
+ 
+  if( pMWin->eExclude ){ 
+    pMWin->regStartRowid = ++pParse->nMem; 
+    pMWin->regEndRowid = ++pParse->nMem; 
+    pMWin->csrApp = pParse->nTab++; 
+    sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regStartRowid); 
+    sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regEndRowid); 
+    sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->csrApp, pMWin->iEphCsr); 
+    return; 
+  } 
+ 
+  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ 
+    FuncDef *p = pWin->pFunc; 
+    if( (p->funcFlags & SQLITE_FUNC_MINMAX) && pWin->eStart!=TK_UNBOUNDED ){ 
+      /* The inline versions of min() and max() require a single ephemeral 
+      ** table and 3 registers. The registers are used as follows: 
+      ** 
+      **   regApp+0: slot to copy min()/max() argument to for MakeRecord 
+      **   regApp+1: integer value used to ensure keys are unique 
+      **   regApp+2: output of MakeRecord 
+      */ 
       ExprList *pList;
       KeyInfo *pKeyInfo;
       assert( ExprUseXList(pWin->pOwner) );
       pList = pWin->pOwner->x.pList;
       pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pList, 0, 0);
-      pWin->csrApp = pParse->nTab++;
-      pWin->regApp = pParse->nMem+1;
-      pParse->nMem += 3;
-      if( pKeyInfo && pWin->pFunc->zName[1]=='i' ){
+      pWin->csrApp = pParse->nTab++; 
+      pWin->regApp = pParse->nMem+1; 
+      pParse->nMem += 3; 
+      if( pKeyInfo && pWin->pFunc->zName[1]=='i' ){ 
         assert( pKeyInfo->aSortFlags[0]==0 );
         pKeyInfo->aSortFlags[0] = KEYINFO_ORDER_DESC;
-      }
-      sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pWin->csrApp, 2);
-      sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
-      sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
-    }
-    else if( p->zName==nth_valueName || p->zName==first_valueName ){
-      /* Allocate two registers at pWin->regApp. These will be used to
-      ** store the start and end index of the current frame.  */
-      pWin->regApp = pParse->nMem+1;
-      pWin->csrApp = pParse->nTab++;
-      pParse->nMem += 2;
-      sqlite3VdbeAddOp2(v, OP_OpenDup, pWin->csrApp, pMWin->iEphCsr);
-    }
-    else if( p->zName==leadName || p->zName==lagName ){
-      pWin->csrApp = pParse->nTab++;
-      sqlite3VdbeAddOp2(v, OP_OpenDup, pWin->csrApp, pMWin->iEphCsr);
-    }
-  }
-}
-
-#define WINDOW_STARTING_INT  0
-#define WINDOW_ENDING_INT    1
-#define WINDOW_NTH_VALUE_INT 2
-#define WINDOW_STARTING_NUM  3
-#define WINDOW_ENDING_NUM    4
-
-/*
-** A "PRECEDING <expr>" (eCond==0) or "FOLLOWING <expr>" (eCond==1) or the
-** value of the second argument to nth_value() (eCond==2) has just been
-** evaluated and the result left in register reg. This function generates VM
-** code to check that the value is a non-negative integer and throws an
-** exception if it is not.
-*/
-static void windowCheckValue(Parse *pParse, int reg, int eCond){
-  static const char *azErr[] = {
-    "frame starting offset must be a non-negative integer",
-    "frame ending offset must be a non-negative integer",
-    "second argument to nth_value must be a positive integer",
-    "frame starting offset must be a non-negative number",
-    "frame ending offset must be a non-negative number",
-  };
-  static int aOp[] = { OP_Ge, OP_Ge, OP_Gt, OP_Ge, OP_Ge };
-  Vdbe *v = sqlite3GetVdbe(pParse);
-  int regZero = sqlite3GetTempReg(pParse);
-  assert( eCond>=0 && eCond<ArraySize(azErr) );
-  sqlite3VdbeAddOp2(v, OP_Integer, 0, regZero);
-  if( eCond>=WINDOW_STARTING_NUM ){
-    int regString = sqlite3GetTempReg(pParse);
-    sqlite3VdbeAddOp4(v, OP_String8, 0, regString, 0, "", P4_STATIC);
-    sqlite3VdbeAddOp3(v, OP_Ge, regString, sqlite3VdbeCurrentAddr(v)+2, reg);
-    sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC|SQLITE_JUMPIFNULL);
-    VdbeCoverage(v);
-    assert( eCond==3 || eCond==4 );
-    VdbeCoverageIf(v, eCond==3);
-    VdbeCoverageIf(v, eCond==4);
-  }else{
-    sqlite3VdbeAddOp2(v, OP_MustBeInt, reg, sqlite3VdbeCurrentAddr(v)+2);
-    VdbeCoverage(v);
-    assert( eCond==0 || eCond==1 || eCond==2 );
-    VdbeCoverageIf(v, eCond==0);
-    VdbeCoverageIf(v, eCond==1);
-    VdbeCoverageIf(v, eCond==2);
-  }
-  sqlite3VdbeAddOp3(v, aOp[eCond], regZero, sqlite3VdbeCurrentAddr(v)+2, reg);
+      } 
+      sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pWin->csrApp, 2); 
+      sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO); 
+      sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1); 
+    } 
+    else if( p->zName==nth_valueName || p->zName==first_valueName ){ 
+      /* Allocate two registers at pWin->regApp. These will be used to 
+      ** store the start and end index of the current frame.  */ 
+      pWin->regApp = pParse->nMem+1; 
+      pWin->csrApp = pParse->nTab++; 
+      pParse->nMem += 2; 
+      sqlite3VdbeAddOp2(v, OP_OpenDup, pWin->csrApp, pMWin->iEphCsr); 
+    } 
+    else if( p->zName==leadName || p->zName==lagName ){ 
+      pWin->csrApp = pParse->nTab++; 
+      sqlite3VdbeAddOp2(v, OP_OpenDup, pWin->csrApp, pMWin->iEphCsr); 
+    } 
+  } 
+} 
+ 
+#define WINDOW_STARTING_INT  0 
+#define WINDOW_ENDING_INT    1 
+#define WINDOW_NTH_VALUE_INT 2 
+#define WINDOW_STARTING_NUM  3 
+#define WINDOW_ENDING_NUM    4 
+ 
+/* 
+** A "PRECEDING <expr>" (eCond==0) or "FOLLOWING <expr>" (eCond==1) or the 
+** value of the second argument to nth_value() (eCond==2) has just been 
+** evaluated and the result left in register reg. This function generates VM 
+** code to check that the value is a non-negative integer and throws an 
+** exception if it is not. 
+*/ 
+static void windowCheckValue(Parse *pParse, int reg, int eCond){ 
+  static const char *azErr[] = { 
+    "frame starting offset must be a non-negative integer", 
+    "frame ending offset must be a non-negative integer", 
+    "second argument to nth_value must be a positive integer", 
+    "frame starting offset must be a non-negative number", 
+    "frame ending offset must be a non-negative number", 
+  }; 
+  static int aOp[] = { OP_Ge, OP_Ge, OP_Gt, OP_Ge, OP_Ge }; 
+  Vdbe *v = sqlite3GetVdbe(pParse); 
+  int regZero = sqlite3GetTempReg(pParse); 
+  assert( eCond>=0 && eCond<ArraySize(azErr) ); 
+  sqlite3VdbeAddOp2(v, OP_Integer, 0, regZero); 
+  if( eCond>=WINDOW_STARTING_NUM ){ 
+    int regString = sqlite3GetTempReg(pParse); 
+    sqlite3VdbeAddOp4(v, OP_String8, 0, regString, 0, "", P4_STATIC); 
+    sqlite3VdbeAddOp3(v, OP_Ge, regString, sqlite3VdbeCurrentAddr(v)+2, reg); 
+    sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC|SQLITE_JUMPIFNULL); 
+    VdbeCoverage(v); 
+    assert( eCond==3 || eCond==4 ); 
+    VdbeCoverageIf(v, eCond==3); 
+    VdbeCoverageIf(v, eCond==4); 
+  }else{ 
+    sqlite3VdbeAddOp2(v, OP_MustBeInt, reg, sqlite3VdbeCurrentAddr(v)+2); 
+    VdbeCoverage(v); 
+    assert( eCond==0 || eCond==1 || eCond==2 ); 
+    VdbeCoverageIf(v, eCond==0); 
+    VdbeCoverageIf(v, eCond==1); 
+    VdbeCoverageIf(v, eCond==2); 
+  } 
+  sqlite3VdbeAddOp3(v, aOp[eCond], regZero, sqlite3VdbeCurrentAddr(v)+2, reg); 
   sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC);
-  VdbeCoverageNeverNullIf(v, eCond==0); /* NULL case captured by */
-  VdbeCoverageNeverNullIf(v, eCond==1); /*   the OP_MustBeInt */
-  VdbeCoverageNeverNullIf(v, eCond==2);
-  VdbeCoverageNeverNullIf(v, eCond==3); /* NULL case caught by */
-  VdbeCoverageNeverNullIf(v, eCond==4); /*   the OP_Ge */
-  sqlite3MayAbort(pParse);
-  sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_ERROR, OE_Abort);
-  sqlite3VdbeAppendP4(v, (void*)azErr[eCond], P4_STATIC);
-  sqlite3ReleaseTempReg(pParse, regZero);
-}
-
-/*
-** Return the number of arguments passed to the window-function associated
-** with the object passed as the only argument to this function.
-*/
-static int windowArgCount(Window *pWin){
+  VdbeCoverageNeverNullIf(v, eCond==0); /* NULL case captured by */ 
+  VdbeCoverageNeverNullIf(v, eCond==1); /*   the OP_MustBeInt */ 
+  VdbeCoverageNeverNullIf(v, eCond==2); 
+  VdbeCoverageNeverNullIf(v, eCond==3); /* NULL case caught by */ 
+  VdbeCoverageNeverNullIf(v, eCond==4); /*   the OP_Ge */ 
+  sqlite3MayAbort(pParse); 
+  sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_ERROR, OE_Abort); 
+  sqlite3VdbeAppendP4(v, (void*)azErr[eCond], P4_STATIC); 
+  sqlite3ReleaseTempReg(pParse, regZero); 
+} 
+ 
+/* 
+** Return the number of arguments passed to the window-function associated 
+** with the object passed as the only argument to this function. 
+*/ 
+static int windowArgCount(Window *pWin){ 
   const ExprList *pList;
   assert( ExprUseXList(pWin->pOwner) );
   pList = pWin->pOwner->x.pList;
-  return (pList ? pList->nExpr : 0);
-}
-
+  return (pList ? pList->nExpr : 0); 
+} 
+ 
 typedef struct WindowCodeArg WindowCodeArg;
 typedef struct WindowCsrAndReg WindowCsrAndReg;
 
-/*
+/* 
 ** See comments above struct WindowCodeArg.
 */
 struct WindowCsrAndReg {
@@ -157992,90 +157992,90 @@ static void windowReadPeerValues(
 /*
 ** Generate VM code to invoke either xStep() (if bInverse is 0) or
 ** xInverse (if bInverse is non-zero) for each window function in the
-** linked list starting at pMWin. Or, for built-in window functions
-** that do not use the standard function API, generate the required
-** inline VM code.
-**
-** If argument csr is greater than or equal to 0, then argument reg is
-** the first register in an array of registers guaranteed to be large
-** enough to hold the array of arguments for each function. In this case
-** the arguments are extracted from the current row of csr into the
-** array of registers before invoking OP_AggStep or OP_AggInverse
-**
-** Or, if csr is less than zero, then the array of registers at reg is
-** already populated with all columns from the current row of the sub-query.
-**
-** If argument regPartSize is non-zero, then it is a register containing the
-** number of rows in the current partition.
-*/
-static void windowAggStep(
+** linked list starting at pMWin. Or, for built-in window functions 
+** that do not use the standard function API, generate the required 
+** inline VM code. 
+** 
+** If argument csr is greater than or equal to 0, then argument reg is 
+** the first register in an array of registers guaranteed to be large 
+** enough to hold the array of arguments for each function. In this case 
+** the arguments are extracted from the current row of csr into the 
+** array of registers before invoking OP_AggStep or OP_AggInverse 
+** 
+** Or, if csr is less than zero, then the array of registers at reg is 
+** already populated with all columns from the current row of the sub-query. 
+** 
+** If argument regPartSize is non-zero, then it is a register containing the 
+** number of rows in the current partition. 
+*/ 
+static void windowAggStep( 
   WindowCodeArg *p,
-  Window *pMWin,                  /* Linked list of window functions */
-  int csr,                        /* Read arguments from this cursor */
-  int bInverse,                   /* True to invoke xInverse instead of xStep */
-  int reg                         /* Array of registers */
-){
+  Window *pMWin,                  /* Linked list of window functions */ 
+  int csr,                        /* Read arguments from this cursor */ 
+  int bInverse,                   /* True to invoke xInverse instead of xStep */ 
+  int reg                         /* Array of registers */ 
+){ 
   Parse *pParse = p->pParse;
-  Vdbe *v = sqlite3GetVdbe(pParse);
-  Window *pWin;
-  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
-    FuncDef *pFunc = pWin->pFunc;
-    int regArg;
+  Vdbe *v = sqlite3GetVdbe(pParse); 
+  Window *pWin; 
+  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ 
+    FuncDef *pFunc = pWin->pFunc; 
+    int regArg; 
     int nArg = pWin->bExprArgs ? 0 : windowArgCount(pWin);
-    int i;
-
+    int i; 
+ 
     assert( bInverse==0 || pWin->eStart!=TK_UNBOUNDED );
 
     /* All OVER clauses in the same window function aggregate step must
     ** be the same. */
     assert( pWin==pMWin || sqlite3WindowCompare(pParse,pWin,pMWin,0)!=1 );
 
-    for(i=0; i<nArg; i++){
-      if( i!=1 || pFunc->zName!=nth_valueName ){
-        sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol+i, reg+i);
-      }else{
-        sqlite3VdbeAddOp3(v, OP_Column, pMWin->iEphCsr, pWin->iArgCol+i, reg+i);
-      }
-    }
-    regArg = reg;
-
-    if( pMWin->regStartRowid==0
+    for(i=0; i<nArg; i++){ 
+      if( i!=1 || pFunc->zName!=nth_valueName ){ 
+        sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol+i, reg+i); 
+      }else{ 
+        sqlite3VdbeAddOp3(v, OP_Column, pMWin->iEphCsr, pWin->iArgCol+i, reg+i); 
+      } 
+    } 
+    regArg = reg; 
+ 
+    if( pMWin->regStartRowid==0 
      && (pFunc->funcFlags & SQLITE_FUNC_MINMAX)
-     && (pWin->eStart!=TK_UNBOUNDED)
-    ){
-      int addrIsNull = sqlite3VdbeAddOp1(v, OP_IsNull, regArg);
-      VdbeCoverage(v);
-      if( bInverse==0 ){
-        sqlite3VdbeAddOp2(v, OP_AddImm, pWin->regApp+1, 1);
-        sqlite3VdbeAddOp2(v, OP_SCopy, regArg, pWin->regApp);
-        sqlite3VdbeAddOp3(v, OP_MakeRecord, pWin->regApp, 2, pWin->regApp+2);
-        sqlite3VdbeAddOp2(v, OP_IdxInsert, pWin->csrApp, pWin->regApp+2);
-      }else{
-        sqlite3VdbeAddOp4Int(v, OP_SeekGE, pWin->csrApp, 0, regArg, 1);
-        VdbeCoverageNeverTaken(v);
-        sqlite3VdbeAddOp1(v, OP_Delete, pWin->csrApp);
-        sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
-      }
-      sqlite3VdbeJumpHere(v, addrIsNull);
-    }else if( pWin->regApp ){
-      assert( pFunc->zName==nth_valueName
-           || pFunc->zName==first_valueName
-      );
-      assert( bInverse==0 || bInverse==1 );
-      sqlite3VdbeAddOp2(v, OP_AddImm, pWin->regApp+1-bInverse, 1);
-    }else if( pFunc->xSFunc!=noopStepFunc ){
-      int addrIf = 0;
-      if( pWin->pFilter ){
-        int regTmp;
+     && (pWin->eStart!=TK_UNBOUNDED) 
+    ){ 
+      int addrIsNull = sqlite3VdbeAddOp1(v, OP_IsNull, regArg); 
+      VdbeCoverage(v); 
+      if( bInverse==0 ){ 
+        sqlite3VdbeAddOp2(v, OP_AddImm, pWin->regApp+1, 1); 
+        sqlite3VdbeAddOp2(v, OP_SCopy, regArg, pWin->regApp); 
+        sqlite3VdbeAddOp3(v, OP_MakeRecord, pWin->regApp, 2, pWin->regApp+2); 
+        sqlite3VdbeAddOp2(v, OP_IdxInsert, pWin->csrApp, pWin->regApp+2); 
+      }else{ 
+        sqlite3VdbeAddOp4Int(v, OP_SeekGE, pWin->csrApp, 0, regArg, 1); 
+        VdbeCoverageNeverTaken(v); 
+        sqlite3VdbeAddOp1(v, OP_Delete, pWin->csrApp); 
+        sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2); 
+      } 
+      sqlite3VdbeJumpHere(v, addrIsNull); 
+    }else if( pWin->regApp ){ 
+      assert( pFunc->zName==nth_valueName 
+           || pFunc->zName==first_valueName 
+      ); 
+      assert( bInverse==0 || bInverse==1 ); 
+      sqlite3VdbeAddOp2(v, OP_AddImm, pWin->regApp+1-bInverse, 1); 
+    }else if( pFunc->xSFunc!=noopStepFunc ){ 
+      int addrIf = 0; 
+      if( pWin->pFilter ){ 
+        int regTmp; 
         assert( ExprUseXList(pWin->pOwner) );
         assert( pWin->bExprArgs || !nArg ||nArg==pWin->pOwner->x.pList->nExpr );
         assert( pWin->bExprArgs || nArg  ||pWin->pOwner->x.pList==0 );
-        regTmp = sqlite3GetTempReg(pParse);
-        sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol+nArg,regTmp);
-        addrIf = sqlite3VdbeAddOp3(v, OP_IfNot, regTmp, 0, 1);
-        VdbeCoverage(v);
-        sqlite3ReleaseTempReg(pParse, regTmp);
-      }
+        regTmp = sqlite3GetTempReg(pParse); 
+        sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol+nArg,regTmp); 
+        addrIf = sqlite3VdbeAddOp3(v, OP_IfNot, regTmp, 0, 1); 
+        VdbeCoverage(v); 
+        sqlite3ReleaseTempReg(pParse, regTmp); 
+      } 
 
       if( pWin->bExprArgs ){
         int iOp = sqlite3VdbeCurrentAddr(v);
@@ -158093,349 +158093,349 @@ static void windowAggStep(
           }
         }
       }
-      if( pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){
-        CollSeq *pColl;
-        assert( nArg>0 );
+      if( pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL ){ 
+        CollSeq *pColl; 
+        assert( nArg>0 ); 
         assert( ExprUseXList(pWin->pOwner) );
-        pColl = sqlite3ExprNNCollSeq(pParse, pWin->pOwner->x.pList->a[0].pExpr);
-        sqlite3VdbeAddOp4(v, OP_CollSeq, 0,0,0, (const char*)pColl, P4_COLLSEQ);
-      }
+        pColl = sqlite3ExprNNCollSeq(pParse, pWin->pOwner->x.pList->a[0].pExpr); 
+        sqlite3VdbeAddOp4(v, OP_CollSeq, 0,0,0, (const char*)pColl, P4_COLLSEQ); 
+      } 
       sqlite3VdbeAddOp3(v, bInverse? OP_AggInverse : OP_AggStep,
-                        bInverse, regArg, pWin->regAccum);
-      sqlite3VdbeAppendP4(v, pFunc, P4_FUNCDEF);
-      sqlite3VdbeChangeP5(v, (u8)nArg);
+                        bInverse, regArg, pWin->regAccum); 
+      sqlite3VdbeAppendP4(v, pFunc, P4_FUNCDEF); 
+      sqlite3VdbeChangeP5(v, (u8)nArg); 
       if( pWin->bExprArgs ){
         sqlite3ReleaseTempRange(pParse, regArg, nArg);
       }
-      if( addrIf ) sqlite3VdbeJumpHere(v, addrIf);
-    }
-  }
-}
-
-/*
-** Values that may be passed as the second argument to windowCodeOp().
-*/
-#define WINDOW_RETURN_ROW 1
-#define WINDOW_AGGINVERSE 2
-#define WINDOW_AGGSTEP    3
-
-/*
-** Generate VM code to invoke either xValue() (bFin==0) or xFinalize()
-** (bFin==1) for each window function in the linked list starting at
-** pMWin. Or, for built-in window-functions that do not use the standard
-** API, generate the equivalent VM code.
-*/
-static void windowAggFinal(WindowCodeArg *p, int bFin){
-  Parse *pParse = p->pParse;
-  Window *pMWin = p->pMWin;
-  Vdbe *v = sqlite3GetVdbe(pParse);
-  Window *pWin;
-
-  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
-    if( pMWin->regStartRowid==0
+      if( addrIf ) sqlite3VdbeJumpHere(v, addrIf); 
+    } 
+  } 
+} 
+ 
+/* 
+** Values that may be passed as the second argument to windowCodeOp(). 
+*/ 
+#define WINDOW_RETURN_ROW 1 
+#define WINDOW_AGGINVERSE 2 
+#define WINDOW_AGGSTEP    3 
+ 
+/* 
+** Generate VM code to invoke either xValue() (bFin==0) or xFinalize() 
+** (bFin==1) for each window function in the linked list starting at 
+** pMWin. Or, for built-in window-functions that do not use the standard 
+** API, generate the equivalent VM code. 
+*/ 
+static void windowAggFinal(WindowCodeArg *p, int bFin){ 
+  Parse *pParse = p->pParse; 
+  Window *pMWin = p->pMWin; 
+  Vdbe *v = sqlite3GetVdbe(pParse); 
+  Window *pWin; 
+ 
+  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ 
+    if( pMWin->regStartRowid==0 
      && (pWin->pFunc->funcFlags & SQLITE_FUNC_MINMAX)
-     && (pWin->eStart!=TK_UNBOUNDED)
-    ){
-      sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult);
-      sqlite3VdbeAddOp1(v, OP_Last, pWin->csrApp);
-      VdbeCoverage(v);
-      sqlite3VdbeAddOp3(v, OP_Column, pWin->csrApp, 0, pWin->regResult);
-      sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
-    }else if( pWin->regApp ){
-      assert( pMWin->regStartRowid==0 );
-    }else{
-      int nArg = windowArgCount(pWin);
-      if( bFin ){
-        sqlite3VdbeAddOp2(v, OP_AggFinal, pWin->regAccum, nArg);
-        sqlite3VdbeAppendP4(v, pWin->pFunc, P4_FUNCDEF);
-        sqlite3VdbeAddOp2(v, OP_Copy, pWin->regAccum, pWin->regResult);
-        sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
-      }else{
-        sqlite3VdbeAddOp3(v, OP_AggValue,pWin->regAccum,nArg,pWin->regResult);
-        sqlite3VdbeAppendP4(v, pWin->pFunc, P4_FUNCDEF);
-      }
-    }
-  }
-}
-
-/*
-** Generate code to calculate the current values of all window functions in the
-** p->pMWin list by doing a full scan of the current window frame. Store the
-** results in the Window.regResult registers, ready to return the upper
-** layer.
-*/
-static void windowFullScan(WindowCodeArg *p){
-  Window *pWin;
-  Parse *pParse = p->pParse;
-  Window *pMWin = p->pMWin;
-  Vdbe *v = p->pVdbe;
-
-  int regCRowid = 0;              /* Current rowid value */
-  int regCPeer = 0;               /* Current peer values */
-  int regRowid = 0;               /* AggStep rowid value */
-  int regPeer = 0;                /* AggStep peer values */
-
-  int nPeer;
-  int lblNext;
-  int lblBrk;
-  int addrNext;
+     && (pWin->eStart!=TK_UNBOUNDED) 
+    ){ 
+      sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult); 
+      sqlite3VdbeAddOp1(v, OP_Last, pWin->csrApp); 
+      VdbeCoverage(v); 
+      sqlite3VdbeAddOp3(v, OP_Column, pWin->csrApp, 0, pWin->regResult); 
+      sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2); 
+    }else if( pWin->regApp ){ 
+      assert( pMWin->regStartRowid==0 ); 
+    }else{ 
+      int nArg = windowArgCount(pWin); 
+      if( bFin ){ 
+        sqlite3VdbeAddOp2(v, OP_AggFinal, pWin->regAccum, nArg); 
+        sqlite3VdbeAppendP4(v, pWin->pFunc, P4_FUNCDEF); 
+        sqlite3VdbeAddOp2(v, OP_Copy, pWin->regAccum, pWin->regResult); 
+        sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum); 
+      }else{ 
+        sqlite3VdbeAddOp3(v, OP_AggValue,pWin->regAccum,nArg,pWin->regResult); 
+        sqlite3VdbeAppendP4(v, pWin->pFunc, P4_FUNCDEF); 
+      } 
+    } 
+  } 
+} 
+ 
+/* 
+** Generate code to calculate the current values of all window functions in the 
+** p->pMWin list by doing a full scan of the current window frame. Store the 
+** results in the Window.regResult registers, ready to return the upper 
+** layer. 
+*/ 
+static void windowFullScan(WindowCodeArg *p){ 
+  Window *pWin; 
+  Parse *pParse = p->pParse; 
+  Window *pMWin = p->pMWin; 
+  Vdbe *v = p->pVdbe; 
+ 
+  int regCRowid = 0;              /* Current rowid value */ 
+  int regCPeer = 0;               /* Current peer values */ 
+  int regRowid = 0;               /* AggStep rowid value */ 
+  int regPeer = 0;                /* AggStep peer values */ 
+ 
+  int nPeer; 
+  int lblNext; 
+  int lblBrk; 
+  int addrNext; 
   int csr;
-
+ 
   VdbeModuleComment((v, "windowFullScan begin"));
 
   assert( pMWin!=0 );
   csr = pMWin->csrApp;
-  nPeer = (pMWin->pOrderBy ? pMWin->pOrderBy->nExpr : 0);
-
-  lblNext = sqlite3VdbeMakeLabel(pParse);
-  lblBrk = sqlite3VdbeMakeLabel(pParse);
-
-  regCRowid = sqlite3GetTempReg(pParse);
-  regRowid = sqlite3GetTempReg(pParse);
-  if( nPeer ){
-    regCPeer = sqlite3GetTempRange(pParse, nPeer);
-    regPeer = sqlite3GetTempRange(pParse, nPeer);
-  }
-
-  sqlite3VdbeAddOp2(v, OP_Rowid, pMWin->iEphCsr, regCRowid);
-  windowReadPeerValues(p, pMWin->iEphCsr, regCPeer);
-
-  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
-    sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
-  }
-
-  sqlite3VdbeAddOp3(v, OP_SeekGE, csr, lblBrk, pMWin->regStartRowid);
-  VdbeCoverage(v);
-  addrNext = sqlite3VdbeCurrentAddr(v);
-  sqlite3VdbeAddOp2(v, OP_Rowid, csr, regRowid);
-  sqlite3VdbeAddOp3(v, OP_Gt, pMWin->regEndRowid, lblBrk, regRowid);
-  VdbeCoverageNeverNull(v);
-
-  if( pMWin->eExclude==TK_CURRENT ){
-    sqlite3VdbeAddOp3(v, OP_Eq, regCRowid, lblNext, regRowid);
-    VdbeCoverageNeverNull(v);
-  }else if( pMWin->eExclude!=TK_NO ){
-    int addr;
-    int addrEq = 0;
-    KeyInfo *pKeyInfo = 0;
-
-    if( pMWin->pOrderBy ){
-      pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pMWin->pOrderBy, 0, 0);
-    }
-    if( pMWin->eExclude==TK_TIES ){
-      addrEq = sqlite3VdbeAddOp3(v, OP_Eq, regCRowid, 0, regRowid);
-      VdbeCoverageNeverNull(v);
-    }
-    if( pKeyInfo ){
-      windowReadPeerValues(p, csr, regPeer);
-      sqlite3VdbeAddOp3(v, OP_Compare, regPeer, regCPeer, nPeer);
-      sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
-      addr = sqlite3VdbeCurrentAddr(v)+1;
-      sqlite3VdbeAddOp3(v, OP_Jump, addr, lblNext, addr);
-      VdbeCoverageEqNe(v);
-    }else{
-      sqlite3VdbeAddOp2(v, OP_Goto, 0, lblNext);
-    }
-    if( addrEq ) sqlite3VdbeJumpHere(v, addrEq);
-  }
-
+  nPeer = (pMWin->pOrderBy ? pMWin->pOrderBy->nExpr : 0); 
+ 
+  lblNext = sqlite3VdbeMakeLabel(pParse); 
+  lblBrk = sqlite3VdbeMakeLabel(pParse); 
+ 
+  regCRowid = sqlite3GetTempReg(pParse); 
+  regRowid = sqlite3GetTempReg(pParse); 
+  if( nPeer ){ 
+    regCPeer = sqlite3GetTempRange(pParse, nPeer); 
+    regPeer = sqlite3GetTempRange(pParse, nPeer); 
+  } 
+ 
+  sqlite3VdbeAddOp2(v, OP_Rowid, pMWin->iEphCsr, regCRowid); 
+  windowReadPeerValues(p, pMWin->iEphCsr, regCPeer); 
+ 
+  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ 
+    sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum); 
+  } 
+ 
+  sqlite3VdbeAddOp3(v, OP_SeekGE, csr, lblBrk, pMWin->regStartRowid); 
+  VdbeCoverage(v); 
+  addrNext = sqlite3VdbeCurrentAddr(v); 
+  sqlite3VdbeAddOp2(v, OP_Rowid, csr, regRowid); 
+  sqlite3VdbeAddOp3(v, OP_Gt, pMWin->regEndRowid, lblBrk, regRowid); 
+  VdbeCoverageNeverNull(v); 
+ 
+  if( pMWin->eExclude==TK_CURRENT ){ 
+    sqlite3VdbeAddOp3(v, OP_Eq, regCRowid, lblNext, regRowid); 
+    VdbeCoverageNeverNull(v); 
+  }else if( pMWin->eExclude!=TK_NO ){ 
+    int addr; 
+    int addrEq = 0; 
+    KeyInfo *pKeyInfo = 0; 
+ 
+    if( pMWin->pOrderBy ){ 
+      pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pMWin->pOrderBy, 0, 0); 
+    } 
+    if( pMWin->eExclude==TK_TIES ){ 
+      addrEq = sqlite3VdbeAddOp3(v, OP_Eq, regCRowid, 0, regRowid); 
+      VdbeCoverageNeverNull(v); 
+    } 
+    if( pKeyInfo ){ 
+      windowReadPeerValues(p, csr, regPeer); 
+      sqlite3VdbeAddOp3(v, OP_Compare, regPeer, regCPeer, nPeer); 
+      sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO); 
+      addr = sqlite3VdbeCurrentAddr(v)+1; 
+      sqlite3VdbeAddOp3(v, OP_Jump, addr, lblNext, addr); 
+      VdbeCoverageEqNe(v); 
+    }else{ 
+      sqlite3VdbeAddOp2(v, OP_Goto, 0, lblNext); 
+    } 
+    if( addrEq ) sqlite3VdbeJumpHere(v, addrEq); 
+  } 
+ 
   windowAggStep(p, pMWin, csr, 0, p->regArg);
-
-  sqlite3VdbeResolveLabel(v, lblNext);
-  sqlite3VdbeAddOp2(v, OP_Next, csr, addrNext);
-  VdbeCoverage(v);
-  sqlite3VdbeJumpHere(v, addrNext-1);
-  sqlite3VdbeJumpHere(v, addrNext+1);
-  sqlite3ReleaseTempReg(pParse, regRowid);
-  sqlite3ReleaseTempReg(pParse, regCRowid);
-  if( nPeer ){
-    sqlite3ReleaseTempRange(pParse, regPeer, nPeer);
-    sqlite3ReleaseTempRange(pParse, regCPeer, nPeer);
-  }
-
-  windowAggFinal(p, 1);
+ 
+  sqlite3VdbeResolveLabel(v, lblNext); 
+  sqlite3VdbeAddOp2(v, OP_Next, csr, addrNext); 
+  VdbeCoverage(v); 
+  sqlite3VdbeJumpHere(v, addrNext-1); 
+  sqlite3VdbeJumpHere(v, addrNext+1); 
+  sqlite3ReleaseTempReg(pParse, regRowid); 
+  sqlite3ReleaseTempReg(pParse, regCRowid); 
+  if( nPeer ){ 
+    sqlite3ReleaseTempRange(pParse, regPeer, nPeer); 
+    sqlite3ReleaseTempRange(pParse, regCPeer, nPeer); 
+  } 
+ 
+  windowAggFinal(p, 1); 
   VdbeModuleComment((v, "windowFullScan end"));
-}
-
-/*
-** Invoke the sub-routine at regGosub (generated by code in select.c) to
-** return the current row of Window.iEphCsr. If all window functions are
-** aggregate window functions that use the standard API, a single
-** OP_Gosub instruction is all that this routine generates. Extra VM code
-** for per-row processing is only generated for the following built-in window
-** functions:
-**
-**   nth_value()
-**   first_value()
-**   lag()
-**   lead()
-*/
-static void windowReturnOneRow(WindowCodeArg *p){
-  Window *pMWin = p->pMWin;
-  Vdbe *v = p->pVdbe;
-
-  if( pMWin->regStartRowid ){
-    windowFullScan(p);
-  }else{
-    Parse *pParse = p->pParse;
-    Window *pWin;
-
-    for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
-      FuncDef *pFunc = pWin->pFunc;
+} 
+ 
+/* 
+** Invoke the sub-routine at regGosub (generated by code in select.c) to 
+** return the current row of Window.iEphCsr. If all window functions are 
+** aggregate window functions that use the standard API, a single 
+** OP_Gosub instruction is all that this routine generates. Extra VM code 
+** for per-row processing is only generated for the following built-in window 
+** functions: 
+** 
+**   nth_value() 
+**   first_value() 
+**   lag() 
+**   lead() 
+*/ 
+static void windowReturnOneRow(WindowCodeArg *p){ 
+  Window *pMWin = p->pMWin; 
+  Vdbe *v = p->pVdbe; 
+ 
+  if( pMWin->regStartRowid ){ 
+    windowFullScan(p); 
+  }else{ 
+    Parse *pParse = p->pParse; 
+    Window *pWin; 
+ 
+    for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ 
+      FuncDef *pFunc = pWin->pFunc; 
       assert( ExprUseXList(pWin->pOwner) );
-      if( pFunc->zName==nth_valueName
-       || pFunc->zName==first_valueName
-      ){
-        int csr = pWin->csrApp;
-        int lbl = sqlite3VdbeMakeLabel(pParse);
-        int tmpReg = sqlite3GetTempReg(pParse);
-        sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult);
-
-        if( pFunc->zName==nth_valueName ){
-          sqlite3VdbeAddOp3(v, OP_Column,pMWin->iEphCsr,pWin->iArgCol+1,tmpReg);
-          windowCheckValue(pParse, tmpReg, 2);
-        }else{
-          sqlite3VdbeAddOp2(v, OP_Integer, 1, tmpReg);
-        }
-        sqlite3VdbeAddOp3(v, OP_Add, tmpReg, pWin->regApp, tmpReg);
-        sqlite3VdbeAddOp3(v, OP_Gt, pWin->regApp+1, lbl, tmpReg);
-        VdbeCoverageNeverNull(v);
-        sqlite3VdbeAddOp3(v, OP_SeekRowid, csr, 0, tmpReg);
-        VdbeCoverageNeverTaken(v);
-        sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol, pWin->regResult);
-        sqlite3VdbeResolveLabel(v, lbl);
-        sqlite3ReleaseTempReg(pParse, tmpReg);
-      }
-      else if( pFunc->zName==leadName || pFunc->zName==lagName ){
-        int nArg = pWin->pOwner->x.pList->nExpr;
-        int csr = pWin->csrApp;
-        int lbl = sqlite3VdbeMakeLabel(pParse);
-        int tmpReg = sqlite3GetTempReg(pParse);
-        int iEph = pMWin->iEphCsr;
-
-        if( nArg<3 ){
-          sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult);
-        }else{
-          sqlite3VdbeAddOp3(v, OP_Column, iEph,pWin->iArgCol+2,pWin->regResult);
-        }
-        sqlite3VdbeAddOp2(v, OP_Rowid, iEph, tmpReg);
-        if( nArg<2 ){
-          int val = (pFunc->zName==leadName ? 1 : -1);
-          sqlite3VdbeAddOp2(v, OP_AddImm, tmpReg, val);
-        }else{
-          int op = (pFunc->zName==leadName ? OP_Add : OP_Subtract);
-          int tmpReg2 = sqlite3GetTempReg(pParse);
-          sqlite3VdbeAddOp3(v, OP_Column, iEph, pWin->iArgCol+1, tmpReg2);
-          sqlite3VdbeAddOp3(v, op, tmpReg2, tmpReg, tmpReg);
-          sqlite3ReleaseTempReg(pParse, tmpReg2);
-        }
-
-        sqlite3VdbeAddOp3(v, OP_SeekRowid, csr, lbl, tmpReg);
-        VdbeCoverage(v);
-        sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol, pWin->regResult);
-        sqlite3VdbeResolveLabel(v, lbl);
-        sqlite3ReleaseTempReg(pParse, tmpReg);
-      }
-    }
-  }
-  sqlite3VdbeAddOp2(v, OP_Gosub, p->regGosub, p->addrGosub);
-}
-
-/*
-** Generate code to set the accumulator register for each window function
-** in the linked list passed as the second argument to NULL. And perform
-** any equivalent initialization required by any built-in window functions
-** in the list.
-*/
-static int windowInitAccum(Parse *pParse, Window *pMWin){
-  Vdbe *v = sqlite3GetVdbe(pParse);
-  int regArg;
-  int nArg = 0;
-  Window *pWin;
-  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
-    FuncDef *pFunc = pWin->pFunc;
+      if( pFunc->zName==nth_valueName 
+       || pFunc->zName==first_valueName 
+      ){ 
+        int csr = pWin->csrApp; 
+        int lbl = sqlite3VdbeMakeLabel(pParse); 
+        int tmpReg = sqlite3GetTempReg(pParse); 
+        sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult); 
+
+        if( pFunc->zName==nth_valueName ){ 
+          sqlite3VdbeAddOp3(v, OP_Column,pMWin->iEphCsr,pWin->iArgCol+1,tmpReg); 
+          windowCheckValue(pParse, tmpReg, 2); 
+        }else{ 
+          sqlite3VdbeAddOp2(v, OP_Integer, 1, tmpReg); 
+        } 
+        sqlite3VdbeAddOp3(v, OP_Add, tmpReg, pWin->regApp, tmpReg); 
+        sqlite3VdbeAddOp3(v, OP_Gt, pWin->regApp+1, lbl, tmpReg); 
+        VdbeCoverageNeverNull(v); 
+        sqlite3VdbeAddOp3(v, OP_SeekRowid, csr, 0, tmpReg); 
+        VdbeCoverageNeverTaken(v); 
+        sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol, pWin->regResult); 
+        sqlite3VdbeResolveLabel(v, lbl); 
+        sqlite3ReleaseTempReg(pParse, tmpReg); 
+      } 
+      else if( pFunc->zName==leadName || pFunc->zName==lagName ){ 
+        int nArg = pWin->pOwner->x.pList->nExpr; 
+        int csr = pWin->csrApp; 
+        int lbl = sqlite3VdbeMakeLabel(pParse); 
+        int tmpReg = sqlite3GetTempReg(pParse); 
+        int iEph = pMWin->iEphCsr; 
+
+        if( nArg<3 ){ 
+          sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult); 
+        }else{ 
+          sqlite3VdbeAddOp3(v, OP_Column, iEph,pWin->iArgCol+2,pWin->regResult); 
+        } 
+        sqlite3VdbeAddOp2(v, OP_Rowid, iEph, tmpReg); 
+        if( nArg<2 ){ 
+          int val = (pFunc->zName==leadName ? 1 : -1); 
+          sqlite3VdbeAddOp2(v, OP_AddImm, tmpReg, val); 
+        }else{ 
+          int op = (pFunc->zName==leadName ? OP_Add : OP_Subtract); 
+          int tmpReg2 = sqlite3GetTempReg(pParse); 
+          sqlite3VdbeAddOp3(v, OP_Column, iEph, pWin->iArgCol+1, tmpReg2); 
+          sqlite3VdbeAddOp3(v, op, tmpReg2, tmpReg, tmpReg); 
+          sqlite3ReleaseTempReg(pParse, tmpReg2); 
+        } 
+
+        sqlite3VdbeAddOp3(v, OP_SeekRowid, csr, lbl, tmpReg); 
+        VdbeCoverage(v); 
+        sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol, pWin->regResult); 
+        sqlite3VdbeResolveLabel(v, lbl); 
+        sqlite3ReleaseTempReg(pParse, tmpReg); 
+      } 
+    } 
+  } 
+  sqlite3VdbeAddOp2(v, OP_Gosub, p->regGosub, p->addrGosub); 
+} 
+ 
+/* 
+** Generate code to set the accumulator register for each window function 
+** in the linked list passed as the second argument to NULL. And perform 
+** any equivalent initialization required by any built-in window functions 
+** in the list. 
+*/ 
+static int windowInitAccum(Parse *pParse, Window *pMWin){ 
+  Vdbe *v = sqlite3GetVdbe(pParse); 
+  int regArg; 
+  int nArg = 0; 
+  Window *pWin; 
+  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ 
+    FuncDef *pFunc = pWin->pFunc; 
     assert( pWin->regAccum );
-    sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
-    nArg = MAX(nArg, windowArgCount(pWin));
-    if( pMWin->regStartRowid==0 ){
-      if( pFunc->zName==nth_valueName || pFunc->zName==first_valueName ){
-        sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp);
-        sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
-      }
-
-      if( (pFunc->funcFlags & SQLITE_FUNC_MINMAX) && pWin->csrApp ){
-        assert( pWin->eStart!=TK_UNBOUNDED );
-        sqlite3VdbeAddOp1(v, OP_ResetSorter, pWin->csrApp);
-        sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
-      }
-    }
-  }
-  regArg = pParse->nMem+1;
-  pParse->nMem += nArg;
-  return regArg;
-}
-
-/*
-** Return true if the current frame should be cached in the ephemeral table,
-** even if there are no xInverse() calls required.
-*/
-static int windowCacheFrame(Window *pMWin){
-  Window *pWin;
-  if( pMWin->regStartRowid ) return 1;
-  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){
-    FuncDef *pFunc = pWin->pFunc;
-    if( (pFunc->zName==nth_valueName)
-     || (pFunc->zName==first_valueName)
-     || (pFunc->zName==leadName)
-     || (pFunc->zName==lagName)
-    ){
-      return 1;
-    }
-  }
-  return 0;
-}
-
-/*
-** regOld and regNew are each the first register in an array of size
-** pOrderBy->nExpr. This function generates code to compare the two
-** arrays of registers using the collation sequences and other comparison
+    sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum); 
+    nArg = MAX(nArg, windowArgCount(pWin)); 
+    if( pMWin->regStartRowid==0 ){ 
+      if( pFunc->zName==nth_valueName || pFunc->zName==first_valueName ){ 
+        sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp); 
+        sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1); 
+      } 
+ 
+      if( (pFunc->funcFlags & SQLITE_FUNC_MINMAX) && pWin->csrApp ){ 
+        assert( pWin->eStart!=TK_UNBOUNDED ); 
+        sqlite3VdbeAddOp1(v, OP_ResetSorter, pWin->csrApp); 
+        sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1); 
+      } 
+    } 
+  } 
+  regArg = pParse->nMem+1; 
+  pParse->nMem += nArg; 
+  return regArg; 
+} 
+ 
+/*
+** Return true if the current frame should be cached in the ephemeral table, 
+** even if there are no xInverse() calls required. 
+*/ 
+static int windowCacheFrame(Window *pMWin){ 
+  Window *pWin; 
+  if( pMWin->regStartRowid ) return 1; 
+  for(pWin=pMWin; pWin; pWin=pWin->pNextWin){ 
+    FuncDef *pFunc = pWin->pFunc; 
+    if( (pFunc->zName==nth_valueName) 
+     || (pFunc->zName==first_valueName) 
+     || (pFunc->zName==leadName) 
+     || (pFunc->zName==lagName) 
+    ){ 
+      return 1; 
+    } 
+  } 
+  return 0; 
+} 
+ 
+/* 
+** regOld and regNew are each the first register in an array of size 
+** pOrderBy->nExpr. This function generates code to compare the two 
+** arrays of registers using the collation sequences and other comparison 
 ** parameters specified by pOrderBy.
-**
+** 
 ** If the two arrays are not equal, the contents of regNew is copied to
-** regOld and control falls through. Otherwise, if the contents of the arrays
-** are equal, an OP_Goto is executed. The address of the OP_Goto is returned.
-*/
-static void windowIfNewPeer(
-  Parse *pParse,
-  ExprList *pOrderBy,
-  int regNew,                     /* First in array of new values */
-  int regOld,                     /* First in array of old values */
-  int addr                        /* Jump here */
-){
-  Vdbe *v = sqlite3GetVdbe(pParse);
-  if( pOrderBy ){
-    int nVal = pOrderBy->nExpr;
-    KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pOrderBy, 0, 0);
-    sqlite3VdbeAddOp3(v, OP_Compare, regOld, regNew, nVal);
-    sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
+** regOld and control falls through. Otherwise, if the contents of the arrays 
+** are equal, an OP_Goto is executed. The address of the OP_Goto is returned. 
+*/ 
+static void windowIfNewPeer( 
+  Parse *pParse, 
+  ExprList *pOrderBy, 
+  int regNew,                     /* First in array of new values */ 
+  int regOld,                     /* First in array of old values */ 
+  int addr                        /* Jump here */ 
+){ 
+  Vdbe *v = sqlite3GetVdbe(pParse); 
+  if( pOrderBy ){ 
+    int nVal = pOrderBy->nExpr; 
+    KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pOrderBy, 0, 0); 
+    sqlite3VdbeAddOp3(v, OP_Compare, regOld, regNew, nVal); 
+    sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO); 
     sqlite3VdbeAddOp3(v, OP_Jump,
-      sqlite3VdbeCurrentAddr(v)+1, addr, sqlite3VdbeCurrentAddr(v)+1
-    );
-    VdbeCoverageEqNe(v);
-    sqlite3VdbeAddOp3(v, OP_Copy, regNew, regOld, nVal-1);
-  }else{
-    sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
-  }
-}
-
-/*
-** This function is called as part of generating VM programs for RANGE
-** offset PRECEDING/FOLLOWING frame boundaries. Assuming "ASC" order for
+      sqlite3VdbeCurrentAddr(v)+1, addr, sqlite3VdbeCurrentAddr(v)+1 
+    ); 
+    VdbeCoverageEqNe(v); 
+    sqlite3VdbeAddOp3(v, OP_Copy, regNew, regOld, nVal-1); 
+  }else{ 
+    sqlite3VdbeAddOp2(v, OP_Goto, 0, addr); 
+  } 
+} 
+ 
+/* 
+** This function is called as part of generating VM programs for RANGE 
+** offset PRECEDING/FOLLOWING frame boundaries. Assuming "ASC" order for 
 ** the ORDER BY term in the window, and that argument op is OP_Ge, it generates
 ** code equivalent to:
-**
-**   if( csr1.peerVal + regVal >= csr2.peerVal ) goto lbl;
-**
+** 
+**   if( csr1.peerVal + regVal >= csr2.peerVal ) goto lbl; 
+** 
 ** The value of parameter op may also be OP_Gt or OP_Le. In these cases the
 ** operator in the above pseudo-code is replaced with ">" or "<=", respectively.
 **
@@ -158450,17 +158450,17 @@ static void windowIfNewPeer(
 ** A special type of arithmetic is used such that if csr1.peerVal is not
 ** a numeric type (real or integer), then the result of the addition
 ** or subtraction is a a copy of csr1.peerVal.
-*/
-static void windowCodeRangeTest(
+*/ 
+static void windowCodeRangeTest( 
   WindowCodeArg *p,
   int op,                         /* OP_Ge, OP_Gt, or OP_Le */
   int csr1,                       /* Cursor number for cursor 1 */
   int regVal,                     /* Register containing non-negative number */
   int csr2,                       /* Cursor number for cursor 2 */
   int lbl                         /* Jump destination if condition is true */
-){
-  Parse *pParse = p->pParse;
-  Vdbe *v = sqlite3GetVdbe(pParse);
+){ 
+  Parse *pParse = p->pParse; 
+  Vdbe *v = sqlite3GetVdbe(pParse); 
   ExprList *pOrderBy = p->pMWin->pOrderBy;  /* ORDER BY clause for window */
   int reg1 = sqlite3GetTempReg(pParse);     /* Reg. for csr1.peerVal+regVal */
   int reg2 = sqlite3GetTempReg(pParse);     /* Reg. for csr2.peerVal */
@@ -158469,22 +158469,22 @@ static void windowCodeRangeTest(
   int addrGe;                               /* Jump destination */
   int addrDone = sqlite3VdbeMakeLabel(pParse);   /* Address past OP_Ge */
   CollSeq *pColl;
-
+ 
   /* Read the peer-value from each cursor into a register */
   windowReadPeerValues(p, csr1, reg1);
   windowReadPeerValues(p, csr2, reg2);
 
-  assert( op==OP_Ge || op==OP_Gt || op==OP_Le );
+  assert( op==OP_Ge || op==OP_Gt || op==OP_Le ); 
   assert( pOrderBy && pOrderBy->nExpr==1 );
   if( pOrderBy->a[0].sortFlags & KEYINFO_ORDER_DESC ){
-    switch( op ){
-      case OP_Ge: op = OP_Le; break;
-      case OP_Gt: op = OP_Lt; break;
-      default: assert( op==OP_Le ); op = OP_Ge; break;
-    }
-    arith = OP_Subtract;
-  }
-
+    switch( op ){ 
+      case OP_Ge: op = OP_Le; break; 
+      case OP_Gt: op = OP_Lt; break; 
+      default: assert( op==OP_Le ); op = OP_Ge; break; 
+    } 
+    arith = OP_Subtract; 
+  } 
+ 
   VdbeModuleComment((v, "CodeRangeTest: if( R%d %s R%d %s R%d ) goto lbl",
       reg1, (arith==OP_Add ? "+" : "-"), regVal,
       ((op==OP_Ge) ? ">=" : (op==OP_Le) ? "<=" : (op==OP_Gt) ? ">" : "<"), reg2
@@ -158561,82 +158561,82 @@ static void windowCodeRangeTest(
   /* Compare registers reg2 and reg1, taking the jump if required. Note that
   ** control skips over this test if the BIGNULL flag is set and either
   ** reg1 or reg2 contain a NULL value.  */
-  sqlite3VdbeAddOp3(v, op, reg2, lbl, reg1); VdbeCoverage(v);
+  sqlite3VdbeAddOp3(v, op, reg2, lbl, reg1); VdbeCoverage(v); 
   pColl = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[0].pExpr);
   sqlite3VdbeAppendP4(v, (void*)pColl, P4_COLLSEQ);
-  sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
+  sqlite3VdbeChangeP5(v, SQLITE_NULLEQ); 
   sqlite3VdbeResolveLabel(v, addrDone);
 
-  assert( op==OP_Ge || op==OP_Gt || op==OP_Lt || op==OP_Le );
-  testcase(op==OP_Ge); VdbeCoverageIf(v, op==OP_Ge);
-  testcase(op==OP_Lt); VdbeCoverageIf(v, op==OP_Lt);
-  testcase(op==OP_Le); VdbeCoverageIf(v, op==OP_Le);
-  testcase(op==OP_Gt); VdbeCoverageIf(v, op==OP_Gt);
-  sqlite3ReleaseTempReg(pParse, reg1);
-  sqlite3ReleaseTempReg(pParse, reg2);
+  assert( op==OP_Ge || op==OP_Gt || op==OP_Lt || op==OP_Le ); 
+  testcase(op==OP_Ge); VdbeCoverageIf(v, op==OP_Ge); 
+  testcase(op==OP_Lt); VdbeCoverageIf(v, op==OP_Lt); 
+  testcase(op==OP_Le); VdbeCoverageIf(v, op==OP_Le); 
+  testcase(op==OP_Gt); VdbeCoverageIf(v, op==OP_Gt); 
+  sqlite3ReleaseTempReg(pParse, reg1); 
+  sqlite3ReleaseTempReg(pParse, reg2); 
 
   VdbeModuleComment((v, "CodeRangeTest: end"));
-}
-
-/*
-** Helper function for sqlite3WindowCodeStep(). Each call to this function
+} 
+ 
+/* 
+** Helper function for sqlite3WindowCodeStep(). Each call to this function 
 ** generates VM code for a single RETURN_ROW, AGGSTEP or AGGINVERSE
-** operation. Refer to the header comment for sqlite3WindowCodeStep() for
-** details.
-*/
-static int windowCodeOp(
- WindowCodeArg *p,                /* Context object */
- int op,                          /* WINDOW_RETURN_ROW, AGGSTEP or AGGINVERSE */
- int regCountdown,                /* Register for OP_IfPos countdown */
- int jumpOnEof                    /* Jump here if stepped cursor reaches EOF */
-){
-  int csr, reg;
-  Parse *pParse = p->pParse;
-  Window *pMWin = p->pMWin;
-  int ret = 0;
-  Vdbe *v = p->pVdbe;
-  int addrContinue = 0;
-  int bPeer = (pMWin->eFrmType!=TK_ROWS);
-
-  int lblDone = sqlite3VdbeMakeLabel(pParse);
-  int addrNextRange = 0;
-
-  /* Special case - WINDOW_AGGINVERSE is always a no-op if the frame
-  ** starts with UNBOUNDED PRECEDING. */
-  if( op==WINDOW_AGGINVERSE && pMWin->eStart==TK_UNBOUNDED ){
-    assert( regCountdown==0 && jumpOnEof==0 );
-    return 0;
-  }
-
-  if( regCountdown>0 ){
-    if( pMWin->eFrmType==TK_RANGE ){
-      addrNextRange = sqlite3VdbeCurrentAddr(v);
-      assert( op==WINDOW_AGGINVERSE || op==WINDOW_AGGSTEP );
-      if( op==WINDOW_AGGINVERSE ){
-        if( pMWin->eStart==TK_FOLLOWING ){
-          windowCodeRangeTest(
-              p, OP_Le, p->current.csr, regCountdown, p->start.csr, lblDone
-          );
-        }else{
-          windowCodeRangeTest(
-              p, OP_Ge, p->start.csr, regCountdown, p->current.csr, lblDone
-          );
-        }
-      }else{
-        windowCodeRangeTest(
-            p, OP_Gt, p->end.csr, regCountdown, p->current.csr, lblDone
-        );
-      }
-    }else{
+** operation. Refer to the header comment for sqlite3WindowCodeStep() for 
+** details. 
+*/ 
+static int windowCodeOp( 
+ WindowCodeArg *p,                /* Context object */ 
+ int op,                          /* WINDOW_RETURN_ROW, AGGSTEP or AGGINVERSE */ 
+ int regCountdown,                /* Register for OP_IfPos countdown */ 
+ int jumpOnEof                    /* Jump here if stepped cursor reaches EOF */ 
+){ 
+  int csr, reg; 
+  Parse *pParse = p->pParse; 
+  Window *pMWin = p->pMWin; 
+  int ret = 0; 
+  Vdbe *v = p->pVdbe; 
+  int addrContinue = 0; 
+  int bPeer = (pMWin->eFrmType!=TK_ROWS); 
+ 
+  int lblDone = sqlite3VdbeMakeLabel(pParse); 
+  int addrNextRange = 0; 
+ 
+  /* Special case - WINDOW_AGGINVERSE is always a no-op if the frame 
+  ** starts with UNBOUNDED PRECEDING. */ 
+  if( op==WINDOW_AGGINVERSE && pMWin->eStart==TK_UNBOUNDED ){ 
+    assert( regCountdown==0 && jumpOnEof==0 ); 
+    return 0; 
+  } 
+ 
+  if( regCountdown>0 ){ 
+    if( pMWin->eFrmType==TK_RANGE ){ 
+      addrNextRange = sqlite3VdbeCurrentAddr(v); 
+      assert( op==WINDOW_AGGINVERSE || op==WINDOW_AGGSTEP ); 
+      if( op==WINDOW_AGGINVERSE ){ 
+        if( pMWin->eStart==TK_FOLLOWING ){ 
+          windowCodeRangeTest( 
+              p, OP_Le, p->current.csr, regCountdown, p->start.csr, lblDone 
+          ); 
+        }else{ 
+          windowCodeRangeTest( 
+              p, OP_Ge, p->start.csr, regCountdown, p->current.csr, lblDone 
+          ); 
+        } 
+      }else{ 
+        windowCodeRangeTest( 
+            p, OP_Gt, p->end.csr, regCountdown, p->current.csr, lblDone 
+        ); 
+      } 
+    }else{ 
       sqlite3VdbeAddOp3(v, OP_IfPos, regCountdown, lblDone, 1);
-      VdbeCoverage(v);
-    }
-  }
-
-  if( op==WINDOW_RETURN_ROW && pMWin->regStartRowid==0 ){
-    windowAggFinal(p, 0);
-  }
-  addrContinue = sqlite3VdbeCurrentAddr(v);
+      VdbeCoverage(v); 
+    } 
+  } 
+ 
+  if( op==WINDOW_RETURN_ROW && pMWin->regStartRowid==0 ){ 
+    windowAggFinal(p, 0); 
+  } 
+  addrContinue = sqlite3VdbeCurrentAddr(v); 
 
   /* If this is a (RANGE BETWEEN a FOLLOWING AND b FOLLOWING) or
   ** (RANGE BETWEEN b PRECEDING AND a PRECEDING) frame, ensure the
@@ -158664,806 +158664,806 @@ static int windowCodeOp(
     assert( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_FOLLOWING );
   }
 
-  switch( op ){
-    case WINDOW_RETURN_ROW:
-      csr = p->current.csr;
-      reg = p->current.reg;
-      windowReturnOneRow(p);
-      break;
-
-    case WINDOW_AGGINVERSE:
-      csr = p->start.csr;
-      reg = p->start.reg;
-      if( pMWin->regStartRowid ){
-        assert( pMWin->regEndRowid );
-        sqlite3VdbeAddOp2(v, OP_AddImm, pMWin->regStartRowid, 1);
-      }else{
+  switch( op ){ 
+    case WINDOW_RETURN_ROW: 
+      csr = p->current.csr; 
+      reg = p->current.reg; 
+      windowReturnOneRow(p); 
+      break; 
+ 
+    case WINDOW_AGGINVERSE: 
+      csr = p->start.csr; 
+      reg = p->start.reg; 
+      if( pMWin->regStartRowid ){ 
+        assert( pMWin->regEndRowid ); 
+        sqlite3VdbeAddOp2(v, OP_AddImm, pMWin->regStartRowid, 1); 
+      }else{ 
         windowAggStep(p, pMWin, csr, 1, p->regArg);
-      }
-      break;
-
-    default:
-      assert( op==WINDOW_AGGSTEP );
-      csr = p->end.csr;
-      reg = p->end.reg;
-      if( pMWin->regStartRowid ){
-        assert( pMWin->regEndRowid );
-        sqlite3VdbeAddOp2(v, OP_AddImm, pMWin->regEndRowid, 1);
-      }else{
+      } 
+      break; 
+ 
+    default: 
+      assert( op==WINDOW_AGGSTEP ); 
+      csr = p->end.csr; 
+      reg = p->end.reg; 
+      if( pMWin->regStartRowid ){ 
+        assert( pMWin->regEndRowid ); 
+        sqlite3VdbeAddOp2(v, OP_AddImm, pMWin->regEndRowid, 1); 
+      }else{ 
         windowAggStep(p, pMWin, csr, 0, p->regArg);
-      }
-      break;
-  }
-
-  if( op==p->eDelete ){
-    sqlite3VdbeAddOp1(v, OP_Delete, csr);
-    sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION);
-  }
-
-  if( jumpOnEof ){
-    sqlite3VdbeAddOp2(v, OP_Next, csr, sqlite3VdbeCurrentAddr(v)+2);
-    VdbeCoverage(v);
-    ret = sqlite3VdbeAddOp0(v, OP_Goto);
-  }else{
-    sqlite3VdbeAddOp2(v, OP_Next, csr, sqlite3VdbeCurrentAddr(v)+1+bPeer);
-    VdbeCoverage(v);
-    if( bPeer ){
+      } 
+      break; 
+  } 
+ 
+  if( op==p->eDelete ){ 
+    sqlite3VdbeAddOp1(v, OP_Delete, csr); 
+    sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION); 
+  } 
+ 
+  if( jumpOnEof ){ 
+    sqlite3VdbeAddOp2(v, OP_Next, csr, sqlite3VdbeCurrentAddr(v)+2); 
+    VdbeCoverage(v); 
+    ret = sqlite3VdbeAddOp0(v, OP_Goto); 
+  }else{ 
+    sqlite3VdbeAddOp2(v, OP_Next, csr, sqlite3VdbeCurrentAddr(v)+1+bPeer); 
+    VdbeCoverage(v); 
+    if( bPeer ){ 
       sqlite3VdbeAddOp2(v, OP_Goto, 0, lblDone);
-    }
-  }
-
-  if( bPeer ){
-    int nReg = (pMWin->pOrderBy ? pMWin->pOrderBy->nExpr : 0);
-    int regTmp = (nReg ? sqlite3GetTempRange(pParse, nReg) : 0);
-    windowReadPeerValues(p, csr, regTmp);
-    windowIfNewPeer(pParse, pMWin->pOrderBy, regTmp, reg, addrContinue);
-    sqlite3ReleaseTempRange(pParse, regTmp, nReg);
-  }
-
-  if( addrNextRange ){
-    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrNextRange);
-  }
-  sqlite3VdbeResolveLabel(v, lblDone);
-  return ret;
-}
-
-
-/*
-** Allocate and return a duplicate of the Window object indicated by the
-** third argument. Set the Window.pOwner field of the new object to
-** pOwner.
-*/
-SQLITE_PRIVATE Window *sqlite3WindowDup(sqlite3 *db, Expr *pOwner, Window *p){
-  Window *pNew = 0;
-  if( ALWAYS(p) ){
-    pNew = sqlite3DbMallocZero(db, sizeof(Window));
-    if( pNew ){
-      pNew->zName = sqlite3DbStrDup(db, p->zName);
+    } 
+  } 
+ 
+  if( bPeer ){ 
+    int nReg = (pMWin->pOrderBy ? pMWin->pOrderBy->nExpr : 0); 
+    int regTmp = (nReg ? sqlite3GetTempRange(pParse, nReg) : 0); 
+    windowReadPeerValues(p, csr, regTmp); 
+    windowIfNewPeer(pParse, pMWin->pOrderBy, regTmp, reg, addrContinue); 
+    sqlite3ReleaseTempRange(pParse, regTmp, nReg); 
+  } 
+ 
+  if( addrNextRange ){ 
+    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrNextRange); 
+  } 
+  sqlite3VdbeResolveLabel(v, lblDone); 
+  return ret; 
+} 
+ 
+ 
+/* 
+** Allocate and return a duplicate of the Window object indicated by the 
+** third argument. Set the Window.pOwner field of the new object to 
+** pOwner. 
+*/ 
+SQLITE_PRIVATE Window *sqlite3WindowDup(sqlite3 *db, Expr *pOwner, Window *p){ 
+  Window *pNew = 0; 
+  if( ALWAYS(p) ){ 
+    pNew = sqlite3DbMallocZero(db, sizeof(Window)); 
+    if( pNew ){ 
+      pNew->zName = sqlite3DbStrDup(db, p->zName); 
       pNew->zBase = sqlite3DbStrDup(db, p->zBase);
-      pNew->pFilter = sqlite3ExprDup(db, p->pFilter, 0);
-      pNew->pFunc = p->pFunc;
-      pNew->pPartition = sqlite3ExprListDup(db, p->pPartition, 0);
-      pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, 0);
-      pNew->eFrmType = p->eFrmType;
-      pNew->eEnd = p->eEnd;
-      pNew->eStart = p->eStart;
-      pNew->eExclude = p->eExclude;
+      pNew->pFilter = sqlite3ExprDup(db, p->pFilter, 0); 
+      pNew->pFunc = p->pFunc; 
+      pNew->pPartition = sqlite3ExprListDup(db, p->pPartition, 0); 
+      pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, 0); 
+      pNew->eFrmType = p->eFrmType; 
+      pNew->eEnd = p->eEnd; 
+      pNew->eStart = p->eStart; 
+      pNew->eExclude = p->eExclude; 
       pNew->regResult = p->regResult;
       pNew->regAccum = p->regAccum;
       pNew->iArgCol = p->iArgCol;
       pNew->iEphCsr = p->iEphCsr;
       pNew->bExprArgs = p->bExprArgs;
-      pNew->pStart = sqlite3ExprDup(db, p->pStart, 0);
-      pNew->pEnd = sqlite3ExprDup(db, p->pEnd, 0);
-      pNew->pOwner = pOwner;
+      pNew->pStart = sqlite3ExprDup(db, p->pStart, 0); 
+      pNew->pEnd = sqlite3ExprDup(db, p->pEnd, 0); 
+      pNew->pOwner = pOwner; 
       pNew->bImplicitFrame = p->bImplicitFrame;
-    }
-  }
-  return pNew;
-}
-
-/*
-** Return a copy of the linked list of Window objects passed as the
-** second argument.
-*/
-SQLITE_PRIVATE Window *sqlite3WindowListDup(sqlite3 *db, Window *p){
-  Window *pWin;
-  Window *pRet = 0;
-  Window **pp = &pRet;
-
-  for(pWin=p; pWin; pWin=pWin->pNextWin){
-    *pp = sqlite3WindowDup(db, 0, pWin);
-    if( *pp==0 ) break;
-    pp = &((*pp)->pNextWin);
-  }
-
-  return pRet;
-}
-
-/*
+    } 
+  } 
+  return pNew; 
+} 
+ 
+/* 
+** Return a copy of the linked list of Window objects passed as the 
+** second argument. 
+*/ 
+SQLITE_PRIVATE Window *sqlite3WindowListDup(sqlite3 *db, Window *p){ 
+  Window *pWin; 
+  Window *pRet = 0; 
+  Window **pp = &pRet; 
+ 
+  for(pWin=p; pWin; pWin=pWin->pNextWin){ 
+    *pp = sqlite3WindowDup(db, 0, pWin); 
+    if( *pp==0 ) break; 
+    pp = &((*pp)->pNextWin); 
+  } 
+ 
+  return pRet; 
+} 
+ 
+/* 
 ** Return true if it can be determined at compile time that expression
 ** pExpr evaluates to a value that, when cast to an integer, is greater
-** than zero. False otherwise.
-**
+** than zero. False otherwise. 
+** 
 ** If an OOM error occurs, this function sets the Parse.db.mallocFailed
-** flag and returns zero.
-*/
-static int windowExprGtZero(Parse *pParse, Expr *pExpr){
-  int ret = 0;
-  sqlite3 *db = pParse->db;
-  sqlite3_value *pVal = 0;
-  sqlite3ValueFromExpr(db, pExpr, db->enc, SQLITE_AFF_NUMERIC, &pVal);
-  if( pVal && sqlite3_value_int(pVal)>0 ){
-    ret = 1;
-  }
-  sqlite3ValueFree(pVal);
-  return ret;
-}
-
-/*
+** flag and returns zero. 
+*/ 
+static int windowExprGtZero(Parse *pParse, Expr *pExpr){ 
+  int ret = 0; 
+  sqlite3 *db = pParse->db; 
+  sqlite3_value *pVal = 0; 
+  sqlite3ValueFromExpr(db, pExpr, db->enc, SQLITE_AFF_NUMERIC, &pVal); 
+  if( pVal && sqlite3_value_int(pVal)>0 ){ 
+    ret = 1; 
+  } 
+  sqlite3ValueFree(pVal); 
+  return ret; 
+} 
+ 
+/* 
 ** sqlite3WhereBegin() has already been called for the SELECT statement
-** passed as the second argument when this function is invoked. It generates
+** passed as the second argument when this function is invoked. It generates 
 ** code to populate the Window.regResult register for each window function
-** and invoke the sub-routine at instruction addrGosub once for each row.
+** and invoke the sub-routine at instruction addrGosub once for each row. 
 ** sqlite3WhereEnd() is always called before returning.
-**
-** This function handles several different types of window frames, which
-** require slightly different processing. The following pseudo code is
-** used to implement window frames of the form:
-**
-**   ROWS BETWEEN <expr1> PRECEDING AND <expr2> FOLLOWING
-**
-** Other window frame types use variants of the following:
-**
-**     ... loop started by sqlite3WhereBegin() ...
-**       if( new partition ){
-**         Gosub flush
-**       }
-**       Insert new row into eph table.
-**
-**       if( first row of partition ){
-**         // Rewind three cursors, all open on the eph table.
-**         Rewind(csrEnd);
-**         Rewind(csrStart);
-**         Rewind(csrCurrent);
-**
-**         regEnd = <expr2>          // FOLLOWING expression
-**         regStart = <expr1>        // PRECEDING expression
-**       }else{
+** 
+** This function handles several different types of window frames, which 
+** require slightly different processing. The following pseudo code is 
+** used to implement window frames of the form: 
+** 
+**   ROWS BETWEEN <expr1> PRECEDING AND <expr2> FOLLOWING 
+** 
+** Other window frame types use variants of the following: 
+** 
+**     ... loop started by sqlite3WhereBegin() ... 
+**       if( new partition ){ 
+**         Gosub flush 
+**       } 
+**       Insert new row into eph table. 
+**
+**       if( first row of partition ){ 
+**         // Rewind three cursors, all open on the eph table. 
+**         Rewind(csrEnd); 
+**         Rewind(csrStart); 
+**         Rewind(csrCurrent); 
+**
+**         regEnd = <expr2>          // FOLLOWING expression 
+**         regStart = <expr1>        // PRECEDING expression 
+**       }else{ 
 **         // First time this branch is taken, the eph table contains two
-**         // rows. The first row in the partition, which all three cursors
-**         // currently point to, and the following row.
-**         AGGSTEP
-**         if( (regEnd--)<=0 ){
-**           RETURN_ROW
-**           if( (regStart--)<=0 ){
-**             AGGINVERSE
-**           }
-**         }
-**       }
-**     }
-**     flush:
-**       AGGSTEP
-**       while( 1 ){
-**         RETURN ROW
-**         if( csrCurrent is EOF ) break;
-**         if( (regStart--)<=0 ){
-**           AggInverse(csrStart)
-**           Next(csrStart)
-**         }
-**       }
-**
-** The pseudo-code above uses the following shorthand:
-**
-**   AGGSTEP:    invoke the aggregate xStep() function for each window function
-**               with arguments read from the current row of cursor csrEnd, then
-**               step cursor csrEnd forward one row (i.e. sqlite3BtreeNext()).
-**
+**         // rows. The first row in the partition, which all three cursors 
+**         // currently point to, and the following row. 
+**         AGGSTEP 
+**         if( (regEnd--)<=0 ){ 
+**           RETURN_ROW 
+**           if( (regStart--)<=0 ){ 
+**             AGGINVERSE 
+**           } 
+**         } 
+**       } 
+**     } 
+**     flush: 
+**       AGGSTEP 
+**       while( 1 ){ 
+**         RETURN ROW 
+**         if( csrCurrent is EOF ) break; 
+**         if( (regStart--)<=0 ){ 
+**           AggInverse(csrStart) 
+**           Next(csrStart) 
+**         } 
+**       } 
+** 
+** The pseudo-code above uses the following shorthand: 
+** 
+**   AGGSTEP:    invoke the aggregate xStep() function for each window function 
+**               with arguments read from the current row of cursor csrEnd, then 
+**               step cursor csrEnd forward one row (i.e. sqlite3BtreeNext()). 
+** 
 **   RETURN_ROW: return a row to the caller based on the contents of the
 **               current row of csrCurrent and the current state of all
-**               aggregates. Then step cursor csrCurrent forward one row.
-**
+**               aggregates. Then step cursor csrCurrent forward one row. 
+** 
 **   AGGINVERSE: invoke the aggregate xInverse() function for each window
-**               functions with arguments read from the current row of cursor
-**               csrStart. Then step csrStart forward one row.
-**
-** There are two other ROWS window frames that are handled significantly
-** differently from the above - "BETWEEN <expr> PRECEDING AND <expr> PRECEDING"
+**               functions with arguments read from the current row of cursor 
+**               csrStart. Then step csrStart forward one row. 
+** 
+** There are two other ROWS window frames that are handled significantly 
+** differently from the above - "BETWEEN <expr> PRECEDING AND <expr> PRECEDING" 
 ** and "BETWEEN <expr> FOLLOWING AND <expr> FOLLOWING". These are special
-** cases because they change the order in which the three cursors (csrStart,
-** csrCurrent and csrEnd) iterate through the ephemeral table. Cases that
-** use UNBOUNDED or CURRENT ROW are much simpler variations on one of these
-** three.
-**
-**   ROWS BETWEEN <expr1> PRECEDING AND <expr2> PRECEDING
-**
-**     ... loop started by sqlite3WhereBegin() ...
-**       if( new partition ){
-**         Gosub flush
-**       }
-**       Insert new row into eph table.
-**       if( first row of partition ){
-**         Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent)
-**         regEnd = <expr2>
-**         regStart = <expr1>
-**       }else{
-**         if( (regEnd--)<=0 ){
-**           AGGSTEP
-**         }
-**         RETURN_ROW
-**         if( (regStart--)<=0 ){
-**           AGGINVERSE
-**         }
-**       }
-**     }
-**     flush:
-**       if( (regEnd--)<=0 ){
-**         AGGSTEP
-**       }
-**       RETURN_ROW
-**
-**
-**   ROWS BETWEEN <expr1> FOLLOWING AND <expr2> FOLLOWING
-**
-**     ... loop started by sqlite3WhereBegin() ...
-**     if( new partition ){
-**       Gosub flush
-**     }
-**     Insert new row into eph table.
-**     if( first row of partition ){
-**       Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent)
-**       regEnd = <expr2>
-**       regStart = regEnd - <expr1>
-**     }else{
-**       AGGSTEP
-**       if( (regEnd--)<=0 ){
-**         RETURN_ROW
-**       }
-**       if( (regStart--)<=0 ){
-**         AGGINVERSE
-**       }
-**     }
-**   }
-**   flush:
-**     AGGSTEP
-**     while( 1 ){
-**       if( (regEnd--)<=0 ){
-**         RETURN_ROW
-**         if( eof ) break;
-**       }
-**       if( (regStart--)<=0 ){
-**         AGGINVERSE
-**         if( eof ) break
-**       }
-**     }
-**     while( !eof csrCurrent ){
-**       RETURN_ROW
-**     }
-**
-** For the most part, the patterns above are adapted to support UNBOUNDED by
-** assuming that it is equivalent to "infinity PRECEDING/FOLLOWING" and
-** CURRENT ROW by assuming that it is equivilent to "0 PRECEDING/FOLLOWING".
-** This is optimized of course - branches that will never be taken and
-** conditions that are always true are omitted from the VM code. The only
-** exceptional case is:
-**
-**   ROWS BETWEEN <expr1> FOLLOWING AND UNBOUNDED FOLLOWING
-**
-**     ... loop started by sqlite3WhereBegin() ...
-**     if( new partition ){
-**       Gosub flush
-**     }
-**     Insert new row into eph table.
-**     if( first row of partition ){
-**       Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent)
-**       regStart = <expr1>
-**     }else{
-**       AGGSTEP
-**     }
-**   }
-**   flush:
-**     AGGSTEP
-**     while( 1 ){
-**       if( (regStart--)<=0 ){
-**         AGGINVERSE
-**         if( eof ) break
-**       }
-**       RETURN_ROW
-**     }
-**     while( !eof csrCurrent ){
-**       RETURN_ROW
-**     }
-**
-** Also requiring special handling are the cases:
-**
-**   ROWS BETWEEN <expr1> PRECEDING AND <expr2> PRECEDING
-**   ROWS BETWEEN <expr1> FOLLOWING AND <expr2> FOLLOWING
-**
-** when (expr1 < expr2). This is detected at runtime, not by this function.
-** To handle this case, the pseudo-code programs depicted above are modified
-** slightly to be:
-**
-**     ... loop started by sqlite3WhereBegin() ...
-**     if( new partition ){
-**       Gosub flush
-**     }
-**     Insert new row into eph table.
-**     if( first row of partition ){
-**       Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent)
-**       regEnd = <expr2>
-**       regStart = <expr1>
-**       if( regEnd < regStart ){
-**         RETURN_ROW
-**         delete eph table contents
-**         continue
-**       }
-**     ...
-**
-** The new "continue" statement in the above jumps to the next iteration
-** of the outer loop - the one started by sqlite3WhereBegin().
-**
-** The various GROUPS cases are implemented using the same patterns as
-** ROWS. The VM code is modified slightly so that:
-**
-**   1. The else branch in the main loop is only taken if the row just
-**      added to the ephemeral table is the start of a new group. In
-**      other words, it becomes:
-**
-**         ... loop started by sqlite3WhereBegin() ...
-**         if( new partition ){
-**           Gosub flush
-**         }
-**         Insert new row into eph table.
-**         if( first row of partition ){
-**           Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent)
-**           regEnd = <expr2>
-**           regStart = <expr1>
-**         }else if( new group ){
+** cases because they change the order in which the three cursors (csrStart, 
+** csrCurrent and csrEnd) iterate through the ephemeral table. Cases that 
+** use UNBOUNDED or CURRENT ROW are much simpler variations on one of these 
+** three. 
+** 
+**   ROWS BETWEEN <expr1> PRECEDING AND <expr2> PRECEDING 
+** 
+**     ... loop started by sqlite3WhereBegin() ... 
+**       if( new partition ){ 
+**         Gosub flush 
+**       } 
+**       Insert new row into eph table. 
+**       if( first row of partition ){ 
+**         Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) 
+**         regEnd = <expr2> 
+**         regStart = <expr1> 
+**       }else{ 
+**         if( (regEnd--)<=0 ){ 
+**           AGGSTEP 
+**         } 
+**         RETURN_ROW 
+**         if( (regStart--)<=0 ){ 
+**           AGGINVERSE 
+**         } 
+**       } 
+**     } 
+**     flush: 
+**       if( (regEnd--)<=0 ){ 
+**         AGGSTEP 
+**       } 
+**       RETURN_ROW 
+** 
+** 
+**   ROWS BETWEEN <expr1> FOLLOWING AND <expr2> FOLLOWING 
+** 
+**     ... loop started by sqlite3WhereBegin() ... 
+**     if( new partition ){ 
+**       Gosub flush 
+**     } 
+**     Insert new row into eph table. 
+**     if( first row of partition ){ 
+**       Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) 
+**       regEnd = <expr2> 
+**       regStart = regEnd - <expr1> 
+**     }else{ 
+**       AGGSTEP 
+**       if( (regEnd--)<=0 ){ 
+**         RETURN_ROW 
+**       } 
+**       if( (regStart--)<=0 ){ 
+**         AGGINVERSE 
+**       } 
+**     } 
+**   } 
+**   flush: 
+**     AGGSTEP 
+**     while( 1 ){ 
+**       if( (regEnd--)<=0 ){ 
+**         RETURN_ROW 
+**         if( eof ) break; 
+**       } 
+**       if( (regStart--)<=0 ){ 
+**         AGGINVERSE 
+**         if( eof ) break 
+**       } 
+**     } 
+**     while( !eof csrCurrent ){ 
+**       RETURN_ROW 
+**     } 
+** 
+** For the most part, the patterns above are adapted to support UNBOUNDED by 
+** assuming that it is equivalent to "infinity PRECEDING/FOLLOWING" and 
+** CURRENT ROW by assuming that it is equivilent to "0 PRECEDING/FOLLOWING". 
+** This is optimized of course - branches that will never be taken and 
+** conditions that are always true are omitted from the VM code. The only 
+** exceptional case is: 
+** 
+**   ROWS BETWEEN <expr1> FOLLOWING AND UNBOUNDED FOLLOWING 
+** 
+**     ... loop started by sqlite3WhereBegin() ... 
+**     if( new partition ){ 
+**       Gosub flush 
+**     } 
+**     Insert new row into eph table. 
+**     if( first row of partition ){ 
+**       Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) 
+**       regStart = <expr1> 
+**     }else{ 
+**       AGGSTEP 
+**     } 
+**   } 
+**   flush: 
+**     AGGSTEP 
+**     while( 1 ){ 
+**       if( (regStart--)<=0 ){ 
+**         AGGINVERSE 
+**         if( eof ) break 
+**       } 
+**       RETURN_ROW 
+**     } 
+**     while( !eof csrCurrent ){ 
+**       RETURN_ROW 
+**     } 
+** 
+** Also requiring special handling are the cases: 
+** 
+**   ROWS BETWEEN <expr1> PRECEDING AND <expr2> PRECEDING 
+**   ROWS BETWEEN <expr1> FOLLOWING AND <expr2> FOLLOWING 
+** 
+** when (expr1 < expr2). This is detected at runtime, not by this function. 
+** To handle this case, the pseudo-code programs depicted above are modified 
+** slightly to be: 
+** 
+**     ... loop started by sqlite3WhereBegin() ... 
+**     if( new partition ){ 
+**       Gosub flush 
+**     } 
+**     Insert new row into eph table. 
+**     if( first row of partition ){ 
+**       Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) 
+**       regEnd = <expr2> 
+**       regStart = <expr1> 
+**       if( regEnd < regStart ){ 
+**         RETURN_ROW 
+**         delete eph table contents 
+**         continue 
+**       } 
+**     ... 
+** 
+** The new "continue" statement in the above jumps to the next iteration 
+** of the outer loop - the one started by sqlite3WhereBegin(). 
+** 
+** The various GROUPS cases are implemented using the same patterns as 
+** ROWS. The VM code is modified slightly so that: 
+** 
+**   1. The else branch in the main loop is only taken if the row just 
+**      added to the ephemeral table is the start of a new group. In 
+**      other words, it becomes: 
+** 
+**         ... loop started by sqlite3WhereBegin() ... 
+**         if( new partition ){ 
+**           Gosub flush 
+**         } 
+**         Insert new row into eph table. 
+**         if( first row of partition ){ 
+**           Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) 
+**           regEnd = <expr2> 
+**           regStart = <expr1> 
+**         }else if( new group ){ 
 **           ...
-**         }
-**       }
-**
+**         } 
+**       } 
+** 
 **   2. Instead of processing a single row, each RETURN_ROW, AGGSTEP or
-**      AGGINVERSE step processes the current row of the relevant cursor and
-**      all subsequent rows belonging to the same group.
-**
+**      AGGINVERSE step processes the current row of the relevant cursor and 
+**      all subsequent rows belonging to the same group. 
+** 
 ** RANGE window frames are a little different again. As for GROUPS, the
-** main loop runs once per group only. And RETURN_ROW, AGGSTEP and AGGINVERSE
-** deal in groups instead of rows. As for ROWS and GROUPS, there are three
-** basic cases:
-**
-**   RANGE BETWEEN <expr1> PRECEDING AND <expr2> FOLLOWING
-**
-**     ... loop started by sqlite3WhereBegin() ...
-**       if( new partition ){
-**         Gosub flush
-**       }
-**       Insert new row into eph table.
-**       if( first row of partition ){
-**         Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent)
-**         regEnd = <expr2>
-**         regStart = <expr1>
-**       }else{
-**         AGGSTEP
-**         while( (csrCurrent.key + regEnd) < csrEnd.key ){
-**           RETURN_ROW
-**           while( csrStart.key + regStart) < csrCurrent.key ){
-**             AGGINVERSE
-**           }
-**         }
-**       }
-**     }
-**     flush:
-**       AGGSTEP
-**       while( 1 ){
-**         RETURN ROW
-**         if( csrCurrent is EOF ) break;
-**           while( csrStart.key + regStart) < csrCurrent.key ){
-**             AGGINVERSE
-**           }
-**         }
-**       }
-**
+** main loop runs once per group only. And RETURN_ROW, AGGSTEP and AGGINVERSE 
+** deal in groups instead of rows. As for ROWS and GROUPS, there are three 
+** basic cases: 
+** 
+**   RANGE BETWEEN <expr1> PRECEDING AND <expr2> FOLLOWING 
+** 
+**     ... loop started by sqlite3WhereBegin() ... 
+**       if( new partition ){ 
+**         Gosub flush 
+**       } 
+**       Insert new row into eph table. 
+**       if( first row of partition ){ 
+**         Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) 
+**         regEnd = <expr2> 
+**         regStart = <expr1> 
+**       }else{ 
+**         AGGSTEP 
+**         while( (csrCurrent.key + regEnd) < csrEnd.key ){ 
+**           RETURN_ROW 
+**           while( csrStart.key + regStart) < csrCurrent.key ){ 
+**             AGGINVERSE 
+**           } 
+**         } 
+**       } 
+**     } 
+**     flush: 
+**       AGGSTEP 
+**       while( 1 ){ 
+**         RETURN ROW 
+**         if( csrCurrent is EOF ) break; 
+**           while( csrStart.key + regStart) < csrCurrent.key ){ 
+**             AGGINVERSE 
+**           } 
+**         } 
+**       } 
+** 
 ** In the above notation, "csr.key" means the current value of the ORDER BY
-** expression (there is only ever 1 for a RANGE that uses an <expr> FOLLOWING
-** or <expr PRECEDING) read from cursor csr.
-**
-**   RANGE BETWEEN <expr1> PRECEDING AND <expr2> PRECEDING
-**
-**     ... loop started by sqlite3WhereBegin() ...
-**       if( new partition ){
-**         Gosub flush
-**       }
-**       Insert new row into eph table.
-**       if( first row of partition ){
-**         Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent)
-**         regEnd = <expr2>
-**         regStart = <expr1>
-**       }else{
+** expression (there is only ever 1 for a RANGE that uses an <expr> FOLLOWING 
+** or <expr PRECEDING) read from cursor csr. 
+** 
+**   RANGE BETWEEN <expr1> PRECEDING AND <expr2> PRECEDING 
+** 
+**     ... loop started by sqlite3WhereBegin() ... 
+**       if( new partition ){ 
+**         Gosub flush 
+**       } 
+**       Insert new row into eph table. 
+**       if( first row of partition ){ 
+**         Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) 
+**         regEnd = <expr2> 
+**         regStart = <expr1> 
+**       }else{ 
 **         while( (csrEnd.key + regEnd) <= csrCurrent.key ){
-**           AGGSTEP
-**         }
-**         while( (csrStart.key + regStart) < csrCurrent.key ){
-**           AGGINVERSE
-**         }
-**         RETURN_ROW
-**       }
-**     }
-**     flush:
-**       while( (csrEnd.key + regEnd) <= csrCurrent.key ){
-**         AGGSTEP
-**       }
-**       while( (csrStart.key + regStart) < csrCurrent.key ){
-**         AGGINVERSE
-**       }
-**       RETURN_ROW
-**
-**   RANGE BETWEEN <expr1> FOLLOWING AND <expr2> FOLLOWING
-**
-**     ... loop started by sqlite3WhereBegin() ...
-**       if( new partition ){
-**         Gosub flush
-**       }
-**       Insert new row into eph table.
-**       if( first row of partition ){
-**         Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent)
-**         regEnd = <expr2>
-**         regStart = <expr1>
-**       }else{
-**         AGGSTEP
-**         while( (csrCurrent.key + regEnd) < csrEnd.key ){
-**           while( (csrCurrent.key + regStart) > csrStart.key ){
-**             AGGINVERSE
-**           }
-**           RETURN_ROW
-**         }
-**       }
-**     }
-**     flush:
-**       AGGSTEP
-**       while( 1 ){
-**         while( (csrCurrent.key + regStart) > csrStart.key ){
-**           AGGINVERSE
-**           if( eof ) break "while( 1 )" loop.
-**         }
-**         RETURN_ROW
-**       }
-**       while( !eof csrCurrent ){
-**         RETURN_ROW
-**       }
-**
-** The text above leaves out many details. Refer to the code and comments
-** below for a more complete picture.
-*/
-SQLITE_PRIVATE void sqlite3WindowCodeStep(
-  Parse *pParse,                  /* Parse context */
-  Select *p,                      /* Rewritten SELECT statement */
-  WhereInfo *pWInfo,              /* Context returned by sqlite3WhereBegin() */
-  int regGosub,                   /* Register for OP_Gosub */
-  int addrGosub                   /* OP_Gosub here to return each row */
-){
-  Window *pMWin = p->pWin;
-  ExprList *pOrderBy = pMWin->pOrderBy;
-  Vdbe *v = sqlite3GetVdbe(pParse);
-  int csrWrite;                   /* Cursor used to write to eph. table */
-  int csrInput = p->pSrc->a[0].iCursor;     /* Cursor of sub-select */
-  int nInput = p->pSrc->a[0].pTab->nCol;    /* Number of cols returned by sub */
-  int iInput;                               /* To iterate through sub cols */
-  int addrNe;                     /* Address of OP_Ne */
-  int addrGosubFlush = 0;         /* Address of OP_Gosub to flush: */
-  int addrInteger = 0;            /* Address of OP_Integer */
-  int addrEmpty;                  /* Address of OP_Rewind in flush: */
-  int regNew;                     /* Array of registers holding new input row */
-  int regRecord;                  /* regNew array in record form */
-  int regNewPeer = 0;             /* Peer values for new row (part of regNew) */
-  int regPeer = 0;                /* Peer values for current row */
-  int regFlushPart = 0;           /* Register for "Gosub flush_partition" */
-  WindowCodeArg s;                /* Context object for sub-routines */
-  int lblWhereEnd;                /* Label just before sqlite3WhereEnd() code */
+**           AGGSTEP 
+**         } 
+**         while( (csrStart.key + regStart) < csrCurrent.key ){ 
+**           AGGINVERSE 
+**         } 
+**         RETURN_ROW 
+**       } 
+**     } 
+**     flush: 
+**       while( (csrEnd.key + regEnd) <= csrCurrent.key ){ 
+**         AGGSTEP 
+**       } 
+**       while( (csrStart.key + regStart) < csrCurrent.key ){ 
+**         AGGINVERSE 
+**       } 
+**       RETURN_ROW 
+** 
+**   RANGE BETWEEN <expr1> FOLLOWING AND <expr2> FOLLOWING 
+** 
+**     ... loop started by sqlite3WhereBegin() ... 
+**       if( new partition ){ 
+**         Gosub flush 
+**       } 
+**       Insert new row into eph table. 
+**       if( first row of partition ){ 
+**         Rewind(csrEnd) ; Rewind(csrStart) ; Rewind(csrCurrent) 
+**         regEnd = <expr2> 
+**         regStart = <expr1> 
+**       }else{ 
+**         AGGSTEP 
+**         while( (csrCurrent.key + regEnd) < csrEnd.key ){ 
+**           while( (csrCurrent.key + regStart) > csrStart.key ){ 
+**             AGGINVERSE 
+**           } 
+**           RETURN_ROW 
+**         } 
+**       } 
+**     } 
+**     flush: 
+**       AGGSTEP 
+**       while( 1 ){ 
+**         while( (csrCurrent.key + regStart) > csrStart.key ){ 
+**           AGGINVERSE 
+**           if( eof ) break "while( 1 )" loop. 
+**         } 
+**         RETURN_ROW 
+**       } 
+**       while( !eof csrCurrent ){ 
+**         RETURN_ROW 
+**       } 
+** 
+** The text above leaves out many details. Refer to the code and comments 
+** below for a more complete picture. 
+*/ 
+SQLITE_PRIVATE void sqlite3WindowCodeStep( 
+  Parse *pParse,                  /* Parse context */ 
+  Select *p,                      /* Rewritten SELECT statement */ 
+  WhereInfo *pWInfo,              /* Context returned by sqlite3WhereBegin() */ 
+  int regGosub,                   /* Register for OP_Gosub */ 
+  int addrGosub                   /* OP_Gosub here to return each row */ 
+){ 
+  Window *pMWin = p->pWin; 
+  ExprList *pOrderBy = pMWin->pOrderBy; 
+  Vdbe *v = sqlite3GetVdbe(pParse); 
+  int csrWrite;                   /* Cursor used to write to eph. table */ 
+  int csrInput = p->pSrc->a[0].iCursor;     /* Cursor of sub-select */ 
+  int nInput = p->pSrc->a[0].pTab->nCol;    /* Number of cols returned by sub */ 
+  int iInput;                               /* To iterate through sub cols */ 
+  int addrNe;                     /* Address of OP_Ne */ 
+  int addrGosubFlush = 0;         /* Address of OP_Gosub to flush: */ 
+  int addrInteger = 0;            /* Address of OP_Integer */ 
+  int addrEmpty;                  /* Address of OP_Rewind in flush: */ 
+  int regNew;                     /* Array of registers holding new input row */ 
+  int regRecord;                  /* regNew array in record form */ 
+  int regNewPeer = 0;             /* Peer values for new row (part of regNew) */ 
+  int regPeer = 0;                /* Peer values for current row */ 
+  int regFlushPart = 0;           /* Register for "Gosub flush_partition" */ 
+  WindowCodeArg s;                /* Context object for sub-routines */ 
+  int lblWhereEnd;                /* Label just before sqlite3WhereEnd() code */ 
   int regStart = 0;               /* Value of <expr> PRECEDING */
   int regEnd = 0;                 /* Value of <expr> FOLLOWING */
-
+ 
   assert( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_CURRENT
        || pMWin->eStart==TK_FOLLOWING || pMWin->eStart==TK_UNBOUNDED
-  );
+  ); 
   assert( pMWin->eEnd==TK_FOLLOWING || pMWin->eEnd==TK_CURRENT
        || pMWin->eEnd==TK_UNBOUNDED || pMWin->eEnd==TK_PRECEDING
-  );
-  assert( pMWin->eExclude==0 || pMWin->eExclude==TK_CURRENT
-       || pMWin->eExclude==TK_GROUP || pMWin->eExclude==TK_TIES
-       || pMWin->eExclude==TK_NO
-  );
-
-  lblWhereEnd = sqlite3VdbeMakeLabel(pParse);
-
-  /* Fill in the context object */
-  memset(&s, 0, sizeof(WindowCodeArg));
-  s.pParse = pParse;
-  s.pMWin = pMWin;
-  s.pVdbe = v;
-  s.regGosub = regGosub;
-  s.addrGosub = addrGosub;
-  s.current.csr = pMWin->iEphCsr;
-  csrWrite = s.current.csr+1;
-  s.start.csr = s.current.csr+2;
-  s.end.csr = s.current.csr+3;
-
-  /* Figure out when rows may be deleted from the ephemeral table. There
+  ); 
+  assert( pMWin->eExclude==0 || pMWin->eExclude==TK_CURRENT 
+       || pMWin->eExclude==TK_GROUP || pMWin->eExclude==TK_TIES 
+       || pMWin->eExclude==TK_NO 
+  ); 
+ 
+  lblWhereEnd = sqlite3VdbeMakeLabel(pParse); 
+ 
+  /* Fill in the context object */ 
+  memset(&s, 0, sizeof(WindowCodeArg)); 
+  s.pParse = pParse; 
+  s.pMWin = pMWin; 
+  s.pVdbe = v; 
+  s.regGosub = regGosub; 
+  s.addrGosub = addrGosub; 
+  s.current.csr = pMWin->iEphCsr; 
+  csrWrite = s.current.csr+1; 
+  s.start.csr = s.current.csr+2; 
+  s.end.csr = s.current.csr+3; 
+ 
+  /* Figure out when rows may be deleted from the ephemeral table. There 
   ** are four options - they may never be deleted (eDelete==0), they may
-  ** be deleted as soon as they are no longer part of the window frame
+  ** be deleted as soon as they are no longer part of the window frame 
   ** (eDelete==WINDOW_AGGINVERSE), they may be deleted as after the row
-  ** has been returned to the caller (WINDOW_RETURN_ROW), or they may
-  ** be deleted after they enter the frame (WINDOW_AGGSTEP). */
-  switch( pMWin->eStart ){
-    case TK_FOLLOWING:
-      if( pMWin->eFrmType!=TK_RANGE
-       && windowExprGtZero(pParse, pMWin->pStart)
-      ){
-        s.eDelete = WINDOW_RETURN_ROW;
-      }
-      break;
-    case TK_UNBOUNDED:
-      if( windowCacheFrame(pMWin)==0 ){
-        if( pMWin->eEnd==TK_PRECEDING ){
-          if( pMWin->eFrmType!=TK_RANGE
-           && windowExprGtZero(pParse, pMWin->pEnd)
-          ){
-            s.eDelete = WINDOW_AGGSTEP;
-          }
-        }else{
-          s.eDelete = WINDOW_RETURN_ROW;
-        }
-      }
-      break;
-    default:
-      s.eDelete = WINDOW_AGGINVERSE;
-      break;
-  }
-
-  /* Allocate registers for the array of values from the sub-query, the
-  ** samve values in record form, and the rowid used to insert said record
-  ** into the ephemeral table.  */
-  regNew = pParse->nMem+1;
-  pParse->nMem += nInput;
-  regRecord = ++pParse->nMem;
+  ** has been returned to the caller (WINDOW_RETURN_ROW), or they may 
+  ** be deleted after they enter the frame (WINDOW_AGGSTEP). */ 
+  switch( pMWin->eStart ){ 
+    case TK_FOLLOWING: 
+      if( pMWin->eFrmType!=TK_RANGE 
+       && windowExprGtZero(pParse, pMWin->pStart) 
+      ){ 
+        s.eDelete = WINDOW_RETURN_ROW; 
+      } 
+      break; 
+    case TK_UNBOUNDED: 
+      if( windowCacheFrame(pMWin)==0 ){ 
+        if( pMWin->eEnd==TK_PRECEDING ){ 
+          if( pMWin->eFrmType!=TK_RANGE 
+           && windowExprGtZero(pParse, pMWin->pEnd) 
+          ){ 
+            s.eDelete = WINDOW_AGGSTEP; 
+          } 
+        }else{ 
+          s.eDelete = WINDOW_RETURN_ROW; 
+        } 
+      } 
+      break; 
+    default: 
+      s.eDelete = WINDOW_AGGINVERSE; 
+      break; 
+  } 
+ 
+  /* Allocate registers for the array of values from the sub-query, the 
+  ** samve values in record form, and the rowid used to insert said record 
+  ** into the ephemeral table.  */ 
+  regNew = pParse->nMem+1; 
+  pParse->nMem += nInput; 
+  regRecord = ++pParse->nMem; 
   s.regRowid = ++pParse->nMem;
-
-  /* If the window frame contains an "<expr> PRECEDING" or "<expr> FOLLOWING"
-  ** clause, allocate registers to store the results of evaluating each
-  ** <expr>.  */
-  if( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_FOLLOWING ){
-    regStart = ++pParse->nMem;
-  }
-  if( pMWin->eEnd==TK_PRECEDING || pMWin->eEnd==TK_FOLLOWING ){
-    regEnd = ++pParse->nMem;
-  }
-
-  /* If this is not a "ROWS BETWEEN ..." frame, then allocate arrays of
+ 
+  /* If the window frame contains an "<expr> PRECEDING" or "<expr> FOLLOWING" 
+  ** clause, allocate registers to store the results of evaluating each 
+  ** <expr>.  */ 
+  if( pMWin->eStart==TK_PRECEDING || pMWin->eStart==TK_FOLLOWING ){ 
+    regStart = ++pParse->nMem; 
+  } 
+  if( pMWin->eEnd==TK_PRECEDING || pMWin->eEnd==TK_FOLLOWING ){ 
+    regEnd = ++pParse->nMem; 
+  } 
+ 
+  /* If this is not a "ROWS BETWEEN ..." frame, then allocate arrays of 
   ** registers to store copies of the ORDER BY expressions (peer values)
-  ** for the main loop, and for each cursor (start, current and end). */
-  if( pMWin->eFrmType!=TK_ROWS ){
-    int nPeer = (pOrderBy ? pOrderBy->nExpr : 0);
-    regNewPeer = regNew + pMWin->nBufferCol;
-    if( pMWin->pPartition ) regNewPeer += pMWin->pPartition->nExpr;
-    regPeer = pParse->nMem+1;       pParse->nMem += nPeer;
-    s.start.reg = pParse->nMem+1;   pParse->nMem += nPeer;
-    s.current.reg = pParse->nMem+1; pParse->nMem += nPeer;
-    s.end.reg = pParse->nMem+1;     pParse->nMem += nPeer;
-  }
-
-  /* Load the column values for the row returned by the sub-select
-  ** into an array of registers starting at regNew. Assemble them into
-  ** a record in register regRecord. */
-  for(iInput=0; iInput<nInput; iInput++){
-    sqlite3VdbeAddOp3(v, OP_Column, csrInput, iInput, regNew+iInput);
-  }
-  sqlite3VdbeAddOp3(v, OP_MakeRecord, regNew, nInput, regRecord);
-
-  /* An input row has just been read into an array of registers starting
+  ** for the main loop, and for each cursor (start, current and end). */ 
+  if( pMWin->eFrmType!=TK_ROWS ){ 
+    int nPeer = (pOrderBy ? pOrderBy->nExpr : 0); 
+    regNewPeer = regNew + pMWin->nBufferCol; 
+    if( pMWin->pPartition ) regNewPeer += pMWin->pPartition->nExpr; 
+    regPeer = pParse->nMem+1;       pParse->nMem += nPeer; 
+    s.start.reg = pParse->nMem+1;   pParse->nMem += nPeer; 
+    s.current.reg = pParse->nMem+1; pParse->nMem += nPeer; 
+    s.end.reg = pParse->nMem+1;     pParse->nMem += nPeer; 
+  } 
+ 
+  /* Load the column values for the row returned by the sub-select 
+  ** into an array of registers starting at regNew. Assemble them into 
+  ** a record in register regRecord. */ 
+  for(iInput=0; iInput<nInput; iInput++){ 
+    sqlite3VdbeAddOp3(v, OP_Column, csrInput, iInput, regNew+iInput); 
+  } 
+  sqlite3VdbeAddOp3(v, OP_MakeRecord, regNew, nInput, regRecord); 
+ 
+  /* An input row has just been read into an array of registers starting 
   ** at regNew. If the window has a PARTITION clause, this block generates
-  ** VM code to check if the input row is the start of a new partition.
-  ** If so, it does an OP_Gosub to an address to be filled in later. The
-  ** address of the OP_Gosub is stored in local variable addrGosubFlush. */
-  if( pMWin->pPartition ){
-    int addr;
-    ExprList *pPart = pMWin->pPartition;
-    int nPart = pPart->nExpr;
-    int regNewPart = regNew + pMWin->nBufferCol;
-    KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pPart, 0, 0);
-
-    regFlushPart = ++pParse->nMem;
-    addr = sqlite3VdbeAddOp3(v, OP_Compare, regNewPart, pMWin->regPart, nPart);
-    sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
-    sqlite3VdbeAddOp3(v, OP_Jump, addr+2, addr+4, addr+2);
-    VdbeCoverageEqNe(v);
-    addrGosubFlush = sqlite3VdbeAddOp1(v, OP_Gosub, regFlushPart);
-    VdbeComment((v, "call flush_partition"));
-    sqlite3VdbeAddOp3(v, OP_Copy, regNewPart, pMWin->regPart, nPart-1);
-  }
-
-  /* Insert the new row into the ephemeral table */
+  ** VM code to check if the input row is the start of a new partition. 
+  ** If so, it does an OP_Gosub to an address to be filled in later. The 
+  ** address of the OP_Gosub is stored in local variable addrGosubFlush. */ 
+  if( pMWin->pPartition ){ 
+    int addr; 
+    ExprList *pPart = pMWin->pPartition; 
+    int nPart = pPart->nExpr; 
+    int regNewPart = regNew + pMWin->nBufferCol; 
+    KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pPart, 0, 0); 
+ 
+    regFlushPart = ++pParse->nMem; 
+    addr = sqlite3VdbeAddOp3(v, OP_Compare, regNewPart, pMWin->regPart, nPart); 
+    sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO); 
+    sqlite3VdbeAddOp3(v, OP_Jump, addr+2, addr+4, addr+2); 
+    VdbeCoverageEqNe(v); 
+    addrGosubFlush = sqlite3VdbeAddOp1(v, OP_Gosub, regFlushPart); 
+    VdbeComment((v, "call flush_partition")); 
+    sqlite3VdbeAddOp3(v, OP_Copy, regNewPart, pMWin->regPart, nPart-1); 
+  } 
+ 
+  /* Insert the new row into the ephemeral table */ 
   sqlite3VdbeAddOp2(v, OP_NewRowid, csrWrite, s.regRowid);
   sqlite3VdbeAddOp3(v, OP_Insert, csrWrite, regRecord, s.regRowid);
   addrNe = sqlite3VdbeAddOp3(v, OP_Ne, pMWin->regOne, 0, s.regRowid);
-  VdbeCoverageNeverNull(v);
-
-  /* This block is run for the first row of each partition */
-  s.regArg = windowInitAccum(pParse, pMWin);
-
-  if( regStart ){
-    sqlite3ExprCode(pParse, pMWin->pStart, regStart);
+  VdbeCoverageNeverNull(v); 
+ 
+  /* This block is run for the first row of each partition */ 
+  s.regArg = windowInitAccum(pParse, pMWin); 
+ 
+  if( regStart ){ 
+    sqlite3ExprCode(pParse, pMWin->pStart, regStart); 
     windowCheckValue(pParse, regStart, 0 + (pMWin->eFrmType==TK_RANGE?3:0));
-  }
-  if( regEnd ){
-    sqlite3ExprCode(pParse, pMWin->pEnd, regEnd);
+  } 
+  if( regEnd ){ 
+    sqlite3ExprCode(pParse, pMWin->pEnd, regEnd); 
     windowCheckValue(pParse, regEnd, 1 + (pMWin->eFrmType==TK_RANGE?3:0));
-  }
-
+  } 
+ 
   if( pMWin->eFrmType!=TK_RANGE && pMWin->eStart==pMWin->eEnd && regStart ){
-    int op = ((pMWin->eStart==TK_FOLLOWING) ? OP_Ge : OP_Le);
-    int addrGe = sqlite3VdbeAddOp3(v, op, regStart, 0, regEnd);
-    VdbeCoverageNeverNullIf(v, op==OP_Ge); /* NeverNull because bound <expr> */
-    VdbeCoverageNeverNullIf(v, op==OP_Le); /*   values previously checked */
-    windowAggFinal(&s, 0);
-    sqlite3VdbeAddOp2(v, OP_Rewind, s.current.csr, 1);
-    VdbeCoverageNeverTaken(v);
-    windowReturnOneRow(&s);
-    sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr);
-    sqlite3VdbeAddOp2(v, OP_Goto, 0, lblWhereEnd);
-    sqlite3VdbeJumpHere(v, addrGe);
-  }
-  if( pMWin->eStart==TK_FOLLOWING && pMWin->eFrmType!=TK_RANGE && regEnd ){
-    assert( pMWin->eEnd==TK_FOLLOWING );
-    sqlite3VdbeAddOp3(v, OP_Subtract, regStart, regEnd, regStart);
-  }
-
-  if( pMWin->eStart!=TK_UNBOUNDED ){
-    sqlite3VdbeAddOp2(v, OP_Rewind, s.start.csr, 1);
-    VdbeCoverageNeverTaken(v);
-  }
-  sqlite3VdbeAddOp2(v, OP_Rewind, s.current.csr, 1);
-  VdbeCoverageNeverTaken(v);
-  sqlite3VdbeAddOp2(v, OP_Rewind, s.end.csr, 1);
-  VdbeCoverageNeverTaken(v);
-  if( regPeer && pOrderBy ){
-    sqlite3VdbeAddOp3(v, OP_Copy, regNewPeer, regPeer, pOrderBy->nExpr-1);
-    sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.start.reg, pOrderBy->nExpr-1);
-    sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.current.reg, pOrderBy->nExpr-1);
-    sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.end.reg, pOrderBy->nExpr-1);
-  }
-
-  sqlite3VdbeAddOp2(v, OP_Goto, 0, lblWhereEnd);
-
-  sqlite3VdbeJumpHere(v, addrNe);
-
-  /* Beginning of the block executed for the second and subsequent rows. */
-  if( regPeer ){
-    windowIfNewPeer(pParse, pOrderBy, regNewPeer, regPeer, lblWhereEnd);
-  }
-  if( pMWin->eStart==TK_FOLLOWING ){
-    windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0);
-    if( pMWin->eEnd!=TK_UNBOUNDED ){
-      if( pMWin->eFrmType==TK_RANGE ){
-        int lbl = sqlite3VdbeMakeLabel(pParse);
-        int addrNext = sqlite3VdbeCurrentAddr(v);
-        windowCodeRangeTest(&s, OP_Ge, s.current.csr, regEnd, s.end.csr, lbl);
-        windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
-        windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0);
-        sqlite3VdbeAddOp2(v, OP_Goto, 0, addrNext);
-        sqlite3VdbeResolveLabel(v, lbl);
-      }else{
-        windowCodeOp(&s, WINDOW_RETURN_ROW, regEnd, 0);
-        windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
-      }
-    }
-  }else
-  if( pMWin->eEnd==TK_PRECEDING ){
-    int bRPS = (pMWin->eStart==TK_PRECEDING && pMWin->eFrmType==TK_RANGE);
-    windowCodeOp(&s, WINDOW_AGGSTEP, regEnd, 0);
-    if( bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
-    windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0);
-    if( !bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
-  }else{
-    int addr = 0;
-    windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0);
-    if( pMWin->eEnd!=TK_UNBOUNDED ){
-      if( pMWin->eFrmType==TK_RANGE ){
-        int lbl = 0;
-        addr = sqlite3VdbeCurrentAddr(v);
-        if( regEnd ){
-          lbl = sqlite3VdbeMakeLabel(pParse);
-          windowCodeRangeTest(&s, OP_Ge, s.current.csr, regEnd, s.end.csr, lbl);
-        }
-        windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0);
-        windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
-        if( regEnd ){
-          sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
-          sqlite3VdbeResolveLabel(v, lbl);
-        }
-      }else{
-        if( regEnd ){
-          addr = sqlite3VdbeAddOp3(v, OP_IfPos, regEnd, 0, 1);
-          VdbeCoverage(v);
-        }
-        windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0);
-        windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
-        if( regEnd ) sqlite3VdbeJumpHere(v, addr);
-      }
-    }
-  }
-
-  /* End of the main input loop */
-  sqlite3VdbeResolveLabel(v, lblWhereEnd);
-  sqlite3WhereEnd(pWInfo);
-
-  /* Fall through */
-  if( pMWin->pPartition ){
-    addrInteger = sqlite3VdbeAddOp2(v, OP_Integer, 0, regFlushPart);
-    sqlite3VdbeJumpHere(v, addrGosubFlush);
-  }
-
+    int op = ((pMWin->eStart==TK_FOLLOWING) ? OP_Ge : OP_Le); 
+    int addrGe = sqlite3VdbeAddOp3(v, op, regStart, 0, regEnd); 
+    VdbeCoverageNeverNullIf(v, op==OP_Ge); /* NeverNull because bound <expr> */ 
+    VdbeCoverageNeverNullIf(v, op==OP_Le); /*   values previously checked */ 
+    windowAggFinal(&s, 0); 
+    sqlite3VdbeAddOp2(v, OP_Rewind, s.current.csr, 1); 
+    VdbeCoverageNeverTaken(v); 
+    windowReturnOneRow(&s); 
+    sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr); 
+    sqlite3VdbeAddOp2(v, OP_Goto, 0, lblWhereEnd); 
+    sqlite3VdbeJumpHere(v, addrGe); 
+  } 
+  if( pMWin->eStart==TK_FOLLOWING && pMWin->eFrmType!=TK_RANGE && regEnd ){ 
+    assert( pMWin->eEnd==TK_FOLLOWING ); 
+    sqlite3VdbeAddOp3(v, OP_Subtract, regStart, regEnd, regStart); 
+  } 
+ 
+  if( pMWin->eStart!=TK_UNBOUNDED ){ 
+    sqlite3VdbeAddOp2(v, OP_Rewind, s.start.csr, 1); 
+    VdbeCoverageNeverTaken(v); 
+  } 
+  sqlite3VdbeAddOp2(v, OP_Rewind, s.current.csr, 1); 
+  VdbeCoverageNeverTaken(v); 
+  sqlite3VdbeAddOp2(v, OP_Rewind, s.end.csr, 1); 
+  VdbeCoverageNeverTaken(v); 
+  if( regPeer && pOrderBy ){ 
+    sqlite3VdbeAddOp3(v, OP_Copy, regNewPeer, regPeer, pOrderBy->nExpr-1); 
+    sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.start.reg, pOrderBy->nExpr-1); 
+    sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.current.reg, pOrderBy->nExpr-1); 
+    sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.end.reg, pOrderBy->nExpr-1); 
+  } 
+ 
+  sqlite3VdbeAddOp2(v, OP_Goto, 0, lblWhereEnd); 
+ 
+  sqlite3VdbeJumpHere(v, addrNe); 
+ 
+  /* Beginning of the block executed for the second and subsequent rows. */ 
+  if( regPeer ){ 
+    windowIfNewPeer(pParse, pOrderBy, regNewPeer, regPeer, lblWhereEnd); 
+  } 
+  if( pMWin->eStart==TK_FOLLOWING ){ 
+    windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0); 
+    if( pMWin->eEnd!=TK_UNBOUNDED ){ 
+      if( pMWin->eFrmType==TK_RANGE ){ 
+        int lbl = sqlite3VdbeMakeLabel(pParse); 
+        int addrNext = sqlite3VdbeCurrentAddr(v); 
+        windowCodeRangeTest(&s, OP_Ge, s.current.csr, regEnd, s.end.csr, lbl); 
+        windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); 
+        windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0); 
+        sqlite3VdbeAddOp2(v, OP_Goto, 0, addrNext); 
+        sqlite3VdbeResolveLabel(v, lbl); 
+      }else{ 
+        windowCodeOp(&s, WINDOW_RETURN_ROW, regEnd, 0); 
+        windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); 
+      } 
+    } 
+  }else 
+  if( pMWin->eEnd==TK_PRECEDING ){ 
+    int bRPS = (pMWin->eStart==TK_PRECEDING && pMWin->eFrmType==TK_RANGE); 
+    windowCodeOp(&s, WINDOW_AGGSTEP, regEnd, 0); 
+    if( bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); 
+    windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0); 
+    if( !bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); 
+  }else{ 
+    int addr = 0; 
+    windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0); 
+    if( pMWin->eEnd!=TK_UNBOUNDED ){ 
+      if( pMWin->eFrmType==TK_RANGE ){ 
+        int lbl = 0; 
+        addr = sqlite3VdbeCurrentAddr(v); 
+        if( regEnd ){ 
+          lbl = sqlite3VdbeMakeLabel(pParse); 
+          windowCodeRangeTest(&s, OP_Ge, s.current.csr, regEnd, s.end.csr, lbl); 
+        } 
+        windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0); 
+        windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); 
+        if( regEnd ){ 
+          sqlite3VdbeAddOp2(v, OP_Goto, 0, addr); 
+          sqlite3VdbeResolveLabel(v, lbl); 
+        } 
+      }else{ 
+        if( regEnd ){ 
+          addr = sqlite3VdbeAddOp3(v, OP_IfPos, regEnd, 0, 1); 
+          VdbeCoverage(v); 
+        } 
+        windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0); 
+        windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); 
+        if( regEnd ) sqlite3VdbeJumpHere(v, addr); 
+      } 
+    } 
+  } 
+ 
+  /* End of the main input loop */ 
+  sqlite3VdbeResolveLabel(v, lblWhereEnd); 
+  sqlite3WhereEnd(pWInfo); 
+ 
+  /* Fall through */ 
+  if( pMWin->pPartition ){ 
+    addrInteger = sqlite3VdbeAddOp2(v, OP_Integer, 0, regFlushPart); 
+    sqlite3VdbeJumpHere(v, addrGosubFlush); 
+  } 
+ 
   s.regRowid = 0;
-  addrEmpty = sqlite3VdbeAddOp1(v, OP_Rewind, csrWrite);
-  VdbeCoverage(v);
-  if( pMWin->eEnd==TK_PRECEDING ){
-    int bRPS = (pMWin->eStart==TK_PRECEDING && pMWin->eFrmType==TK_RANGE);
-    windowCodeOp(&s, WINDOW_AGGSTEP, regEnd, 0);
-    if( bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
-    windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0);
-  }else if( pMWin->eStart==TK_FOLLOWING ){
-    int addrStart;
-    int addrBreak1;
-    int addrBreak2;
-    int addrBreak3;
-    windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0);
-    if( pMWin->eFrmType==TK_RANGE ){
-      addrStart = sqlite3VdbeCurrentAddr(v);
-      addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 1);
-      addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1);
-    }else
-    if( pMWin->eEnd==TK_UNBOUNDED ){
-      addrStart = sqlite3VdbeCurrentAddr(v);
-      addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, regStart, 1);
-      addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, 0, 1);
-    }else{
-      assert( pMWin->eEnd==TK_FOLLOWING );
-      addrStart = sqlite3VdbeCurrentAddr(v);
-      addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, regEnd, 1);
-      addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 1);
-    }
-    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart);
-    sqlite3VdbeJumpHere(v, addrBreak2);
-    addrStart = sqlite3VdbeCurrentAddr(v);
-    addrBreak3 = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1);
-    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart);
-    sqlite3VdbeJumpHere(v, addrBreak1);
-    sqlite3VdbeJumpHere(v, addrBreak3);
-  }else{
-    int addrBreak;
-    int addrStart;
-    windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0);
-    addrStart = sqlite3VdbeCurrentAddr(v);
-    addrBreak = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1);
-    windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0);
-    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart);
-    sqlite3VdbeJumpHere(v, addrBreak);
-  }
-  sqlite3VdbeJumpHere(v, addrEmpty);
-
-  sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr);
-  if( pMWin->pPartition ){
-    if( pMWin->regStartRowid ){
-      sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regStartRowid);
-      sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regEndRowid);
-    }
-    sqlite3VdbeChangeP1(v, addrInteger, sqlite3VdbeCurrentAddr(v));
-    sqlite3VdbeAddOp1(v, OP_Return, regFlushPart);
-  }
-}
-
-#endif /* SQLITE_OMIT_WINDOWFUNC */
-
-/************** End of window.c **********************************************/
+  addrEmpty = sqlite3VdbeAddOp1(v, OP_Rewind, csrWrite); 
+  VdbeCoverage(v); 
+  if( pMWin->eEnd==TK_PRECEDING ){ 
+    int bRPS = (pMWin->eStart==TK_PRECEDING && pMWin->eFrmType==TK_RANGE); 
+    windowCodeOp(&s, WINDOW_AGGSTEP, regEnd, 0); 
+    if( bRPS ) windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); 
+    windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 0); 
+  }else if( pMWin->eStart==TK_FOLLOWING ){ 
+    int addrStart; 
+    int addrBreak1; 
+    int addrBreak2; 
+    int addrBreak3; 
+    windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0); 
+    if( pMWin->eFrmType==TK_RANGE ){ 
+      addrStart = sqlite3VdbeCurrentAddr(v); 
+      addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 1); 
+      addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1); 
+    }else 
+    if( pMWin->eEnd==TK_UNBOUNDED ){ 
+      addrStart = sqlite3VdbeCurrentAddr(v); 
+      addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, regStart, 1); 
+      addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, 0, 1); 
+    }else{ 
+      assert( pMWin->eEnd==TK_FOLLOWING ); 
+      addrStart = sqlite3VdbeCurrentAddr(v); 
+      addrBreak1 = windowCodeOp(&s, WINDOW_RETURN_ROW, regEnd, 1); 
+      addrBreak2 = windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 1); 
+    } 
+    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart); 
+    sqlite3VdbeJumpHere(v, addrBreak2); 
+    addrStart = sqlite3VdbeCurrentAddr(v); 
+    addrBreak3 = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1); 
+    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart); 
+    sqlite3VdbeJumpHere(v, addrBreak1); 
+    sqlite3VdbeJumpHere(v, addrBreak3); 
+  }else{ 
+    int addrBreak; 
+    int addrStart; 
+    windowCodeOp(&s, WINDOW_AGGSTEP, 0, 0); 
+    addrStart = sqlite3VdbeCurrentAddr(v); 
+    addrBreak = windowCodeOp(&s, WINDOW_RETURN_ROW, 0, 1); 
+    windowCodeOp(&s, WINDOW_AGGINVERSE, regStart, 0); 
+    sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart); 
+    sqlite3VdbeJumpHere(v, addrBreak); 
+  } 
+  sqlite3VdbeJumpHere(v, addrEmpty); 
+ 
+  sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr); 
+  if( pMWin->pPartition ){ 
+    if( pMWin->regStartRowid ){ 
+      sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regStartRowid); 
+      sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regEndRowid); 
+    } 
+    sqlite3VdbeChangeP1(v, addrInteger, sqlite3VdbeCurrentAddr(v)); 
+    sqlite3VdbeAddOp1(v, OP_Return, regFlushPart); 
+  } 
+} 
+ 
+#endif /* SQLITE_OMIT_WINDOWFUNC */ 
+ 
+/************** End of window.c **********************************************/ 
 /************** Begin file parse.c *******************************************/
 /* This file is automatically generated by Lemon from input grammar
 ** source file "parse.y". */
@@ -159537,8 +159537,8 @@ SQLITE_PRIVATE void sqlite3WindowCodeStep(
 */
 struct TrigEvent { int a; IdList * b; };
 
-struct FrameBound     { int eType; Expr *pExpr; };
-
+struct FrameBound     { int eType; Expr *pExpr; }; 
+ 
 /*
 ** Disable lookaside memory allocation for objects that might be
 ** shared across database connections.
@@ -159625,41 +159625,41 @@ static void updateDeleteLimitError(
   static Expr *tokenExpr(Parse *pParse, int op, Token t){
     Expr *p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)+t.n+1);
     if( p ){
-      /* memset(p, 0, sizeof(Expr)); */
+      /* memset(p, 0, sizeof(Expr)); */ 
       p->op = (u8)op;
       p->affExpr = 0;
       p->flags = EP_Leaf;
       ExprClearVVAProperties(p);
       p->iAgg = -1;
-      p->pLeft = p->pRight = 0;
-      p->pAggInfo = 0;
+      p->pLeft = p->pRight = 0; 
+      p->pAggInfo = 0; 
       memset(&p->x, 0, sizeof(p->x));
       memset(&p->y, 0, sizeof(p->y));
-      p->op2 = 0;
-      p->iTable = 0;
-      p->iColumn = 0;
+      p->op2 = 0; 
+      p->iTable = 0; 
+      p->iColumn = 0; 
       p->u.zToken = (char*)&p[1];
       memcpy(p->u.zToken, t.z, t.n);
       p->u.zToken[t.n] = 0;
       if( sqlite3Isquote(p->u.zToken[0]) ){
-        sqlite3DequoteExpr(p);
+        sqlite3DequoteExpr(p); 
       }
 #if SQLITE_MAX_EXPR_DEPTH>0
       p->nHeight = 1;
 #endif
-      if( IN_RENAME_OBJECT ){
-        return (Expr*)sqlite3RenameTokenMap(pParse, (void*)p, &t);
-      }
+      if( IN_RENAME_OBJECT ){ 
+        return (Expr*)sqlite3RenameTokenMap(pParse, (void*)p, &t); 
+      } 
     }
     return p;
   }
 
-
+ 
   /* A routine to convert a binary TK_IS or TK_ISNOT expression into a
   ** unary TK_ISNULL or TK_NOTNULL expression. */
   static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){
     sqlite3 *db = pParse->db;
-    if( pA && pY && pY->op==TK_NULL && !IN_RENAME_OBJECT ){
+    if( pA && pY && pY->op==TK_NULL && !IN_RENAME_OBJECT ){ 
       pA->op = (u8)op;
       sqlite3ExprDelete(db, pA->pRight);
       pA->pRight = 0;
@@ -159688,10 +159688,10 @@ static void updateDeleteLimitError(
     sqlite3ExprListSetName(pParse, p, pIdToken, 1);
     return p;
   }
-
-#if TK_SPAN>255
-# error too many tokens in the grammar
-#endif
+ 
+#if TK_SPAN>255 
+# error too many tokens in the grammar 
+#endif 
 /**************** End of %include directives **********************************/
 /* These constants specify the various numeric values for terminal symbols.
 ***************** Begin token definitions *************************************/
@@ -159915,10 +159915,10 @@ static void updateDeleteLimitError(
 **                       zero the stack is dynamically sized using realloc()
 **    sqlite3ParserARG_SDECL     A static variable declaration for the %extra_argument
 **    sqlite3ParserARG_PDECL     A parameter declaration for the %extra_argument
-**    sqlite3ParserARG_PARAM     Code to pass %extra_argument as a subroutine parameter
+**    sqlite3ParserARG_PARAM     Code to pass %extra_argument as a subroutine parameter 
 **    sqlite3ParserARG_STORE     Code to store %extra_argument into yypParser
 **    sqlite3ParserARG_FETCH     Code to extract %extra_argument from yypParser
-**    sqlite3ParserCTX_*         As sqlite3ParserARG_ except for %extra_context
+**    sqlite3ParserCTX_*         As sqlite3ParserARG_ except for %extra_context 
 **    YYERRORSYMBOL      is the code number of the error symbol.  If not
 **                       defined, then do no error processing.
 **    YYNSTATE           the combined number of states.
@@ -159937,7 +159937,7 @@ static void updateDeleteLimitError(
 # define INTERFACE 1
 #endif
 /************* Begin control #defines *****************************************/
-#define YYCODETYPE unsigned short int
+#define YYCODETYPE unsigned short int 
 #define YYNOCODE 318
 #define YYACTIONTYPE unsigned short int
 #define YYWILDCARD 101
@@ -159966,16 +159966,16 @@ typedef union {
 #ifndef YYSTACKDEPTH
 #define YYSTACKDEPTH 100
 #endif
-#define sqlite3ParserARG_SDECL
-#define sqlite3ParserARG_PDECL
-#define sqlite3ParserARG_PARAM
-#define sqlite3ParserARG_FETCH
-#define sqlite3ParserARG_STORE
-#define sqlite3ParserCTX_SDECL Parse *pParse;
-#define sqlite3ParserCTX_PDECL ,Parse *pParse
-#define sqlite3ParserCTX_PARAM ,pParse
-#define sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse;
-#define sqlite3ParserCTX_STORE yypParser->pParse=pParse;
+#define sqlite3ParserARG_SDECL 
+#define sqlite3ParserARG_PDECL 
+#define sqlite3ParserARG_PARAM 
+#define sqlite3ParserARG_FETCH 
+#define sqlite3ParserARG_STORE 
+#define sqlite3ParserCTX_SDECL Parse *pParse; 
+#define sqlite3ParserCTX_PDECL ,Parse *pParse 
+#define sqlite3ParserCTX_PARAM ,pParse 
+#define sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse; 
+#define sqlite3ParserCTX_STORE yypParser->pParse=pParse; 
 #define YYFALLBACK 1
 #define YYNSTATE             576
 #define YYNRULE              401
@@ -159990,7 +159990,7 @@ typedef union {
 #define YY_MIN_REDUCE        1237
 #define YY_MAX_REDUCE        1637
 /************* End control #defines *******************************************/
-#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
+#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0]))) 
 
 /* Define the yytestcase() macro to be a no-op if is not already defined
 ** otherwise.
@@ -160737,7 +160737,7 @@ static const YYCODETYPE yyFallback[] = {
     0,  /*     ESCAPE => nothing */
     0,  /*         ID => nothing */
    59,  /*   COLUMNKW => ID */
-   59,  /*         DO => ID */
+   59,  /*         DO => ID */ 
    59,  /*        FOR => ID */
    59,  /*     IGNORE => ID */
    59,  /*  INITIALLY => ID */
@@ -160752,7 +160752,7 @@ static const YYCODETYPE yyFallback[] = {
    59,  /*    REPLACE => ID */
    59,  /*   RESTRICT => ID */
    59,  /*        ROW => ID */
-   59,  /*       ROWS => ID */
+   59,  /*       ROWS => ID */ 
    59,  /*    TRIGGER => ID */
    59,  /*     VACUUM => ID */
    59,  /*       VIEW => ID */
@@ -160761,16 +160761,16 @@ static const YYCODETYPE yyFallback[] = {
    59,  /*      NULLS => ID */
    59,  /*      FIRST => ID */
    59,  /*       LAST => ID */
-   59,  /*    CURRENT => ID */
-   59,  /*  FOLLOWING => ID */
-   59,  /*  PARTITION => ID */
-   59,  /*  PRECEDING => ID */
-   59,  /*      RANGE => ID */
-   59,  /*  UNBOUNDED => ID */
-   59,  /*    EXCLUDE => ID */
-   59,  /*     GROUPS => ID */
-   59,  /*     OTHERS => ID */
-   59,  /*       TIES => ID */
+   59,  /*    CURRENT => ID */ 
+   59,  /*  FOLLOWING => ID */ 
+   59,  /*  PARTITION => ID */ 
+   59,  /*  PRECEDING => ID */ 
+   59,  /*      RANGE => ID */ 
+   59,  /*  UNBOUNDED => ID */ 
+   59,  /*    EXCLUDE => ID */ 
+   59,  /*     GROUPS => ID */ 
+   59,  /*     OTHERS => ID */ 
+   59,  /*       TIES => ID */ 
    59,  /*  GENERATED => ID */
    59,  /*     ALWAYS => ID */
    59,  /* MATERIALIZED => ID */
@@ -160899,7 +160899,7 @@ struct yyParser {
   int yyerrcnt;                 /* Shifts left before out of the error */
 #endif
   sqlite3ParserARG_SDECL                /* A place to hold %extra_argument */
-  sqlite3ParserCTX_SDECL                /* A place to hold %extra_context */
+  sqlite3ParserCTX_SDECL                /* A place to hold %extra_context */ 
 #if YYSTACKDEPTH<=0
   int yystksz;                  /* Current side of the stack */
   yyStackEntry *yystack;        /* The parser's stack */
@@ -161009,27 +161009,27 @@ static const char *const yyTokenName[] = {
   /*   58 */ "ESCAPE",
   /*   59 */ "ID",
   /*   60 */ "COLUMNKW",
-  /*   61 */ "DO",
-  /*   62 */ "FOR",
-  /*   63 */ "IGNORE",
-  /*   64 */ "INITIALLY",
-  /*   65 */ "INSTEAD",
-  /*   66 */ "NO",
-  /*   67 */ "KEY",
-  /*   68 */ "OF",
-  /*   69 */ "OFFSET",
-  /*   70 */ "PRAGMA",
-  /*   71 */ "RAISE",
-  /*   72 */ "RECURSIVE",
-  /*   73 */ "REPLACE",
-  /*   74 */ "RESTRICT",
-  /*   75 */ "ROW",
-  /*   76 */ "ROWS",
-  /*   77 */ "TRIGGER",
-  /*   78 */ "VACUUM",
-  /*   79 */ "VIEW",
-  /*   80 */ "VIRTUAL",
-  /*   81 */ "WITH",
+  /*   61 */ "DO", 
+  /*   62 */ "FOR", 
+  /*   63 */ "IGNORE", 
+  /*   64 */ "INITIALLY", 
+  /*   65 */ "INSTEAD", 
+  /*   66 */ "NO", 
+  /*   67 */ "KEY", 
+  /*   68 */ "OF", 
+  /*   69 */ "OFFSET", 
+  /*   70 */ "PRAGMA", 
+  /*   71 */ "RAISE", 
+  /*   72 */ "RECURSIVE", 
+  /*   73 */ "REPLACE", 
+  /*   74 */ "RESTRICT", 
+  /*   75 */ "ROW", 
+  /*   76 */ "ROWS", 
+  /*   77 */ "TRIGGER", 
+  /*   78 */ "VACUUM", 
+  /*   79 */ "VIEW", 
+  /*   80 */ "VIRTUAL", 
+  /*   81 */ "WITH", 
   /*   82 */ "NULLS",
   /*   83 */ "FIRST",
   /*   84 */ "LAST",
@@ -161722,29 +161722,29 @@ static int yyGrowStack(yyParser *p){
 
 /* Initialize a new parser that has already been allocated.
 */
-SQLITE_PRIVATE void sqlite3ParserInit(void *yypRawParser sqlite3ParserCTX_PDECL){
-  yyParser *yypParser = (yyParser*)yypRawParser;
-  sqlite3ParserCTX_STORE
+SQLITE_PRIVATE void sqlite3ParserInit(void *yypRawParser sqlite3ParserCTX_PDECL){ 
+  yyParser *yypParser = (yyParser*)yypRawParser; 
+  sqlite3ParserCTX_STORE 
 #ifdef YYTRACKMAXSTACKDEPTH
-  yypParser->yyhwm = 0;
+  yypParser->yyhwm = 0; 
 #endif
 #if YYSTACKDEPTH<=0
-  yypParser->yytos = NULL;
-  yypParser->yystack = NULL;
-  yypParser->yystksz = 0;
-  if( yyGrowStack(yypParser) ){
-    yypParser->yystack = &yypParser->yystk0;
-    yypParser->yystksz = 1;
+  yypParser->yytos = NULL; 
+  yypParser->yystack = NULL; 
+  yypParser->yystksz = 0; 
+  if( yyGrowStack(yypParser) ){ 
+    yypParser->yystack = &yypParser->yystk0; 
+    yypParser->yystksz = 1; 
   }
 #endif
 #ifndef YYNOERRORRECOVERY
-  yypParser->yyerrcnt = -1;
+  yypParser->yyerrcnt = -1; 
 #endif
-  yypParser->yytos = yypParser->yystack;
-  yypParser->yystack[0].stateno = 0;
-  yypParser->yystack[0].major = 0;
+  yypParser->yytos = yypParser->yystack; 
+  yypParser->yystack[0].stateno = 0; 
+  yypParser->yystack[0].major = 0; 
 #if YYSTACKDEPTH>0
-  yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH-1];
+  yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH-1]; 
 #endif
 }
 
@@ -161761,14 +161761,14 @@ SQLITE_PRIVATE void sqlite3ParserInit(void *yypRawParser sqlite3ParserCTX_PDECL)
 ** A pointer to a parser.  This pointer is used in subsequent calls
 ** to sqlite3Parser and sqlite3ParserFree.
 */
-SQLITE_PRIVATE void *sqlite3ParserAlloc(void *(*mallocProc)(YYMALLOCARGTYPE) sqlite3ParserCTX_PDECL){
-  yyParser *yypParser;
-  yypParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );
-  if( yypParser ){
-    sqlite3ParserCTX_STORE
-    sqlite3ParserInit(yypParser sqlite3ParserCTX_PARAM);
-  }
-  return (void*)yypParser;
+SQLITE_PRIVATE void *sqlite3ParserAlloc(void *(*mallocProc)(YYMALLOCARGTYPE) sqlite3ParserCTX_PDECL){ 
+  yyParser *yypParser; 
+  yypParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) ); 
+  if( yypParser ){ 
+    sqlite3ParserCTX_STORE 
+    sqlite3ParserInit(yypParser sqlite3ParserCTX_PARAM); 
+  } 
+  return (void*)yypParser; 
 }
 #endif /* sqlite3Parser_ENGINEALWAYSONSTACK */
 
@@ -161785,8 +161785,8 @@ static void yy_destructor(
   YYCODETYPE yymajor,     /* Type code for object to destroy */
   YYMINORTYPE *yypminor   /* The object to be destroyed */
 ){
-  sqlite3ParserARG_FETCH
-  sqlite3ParserCTX_FETCH
+  sqlite3ParserARG_FETCH 
+  sqlite3ParserCTX_FETCH 
   switch( yymajor ){
     /* Here is inserted the actions which take place when a
     ** terminal or non-terminal is destroyed.  This can happen
@@ -161878,22 +161878,22 @@ sqlite3WindowDelete(pParse->db, (yypminor->yy375));
       break;
     case 285: /* trigger_cmd_list */
     case 290: /* trigger_cmd */
-{
+{ 
 sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy95));
-}
-      break;
+} 
+      break; 
     case 287: /* trigger_event */
-{
+{ 
 sqlite3IdListDelete(pParse->db, (yypminor->yy570).b);
-}
-      break;
+} 
+      break; 
     case 313: /* frame_bound */
     case 314: /* frame_bound_s */
     case 315: /* frame_bound_e */
-{
+{ 
 sqlite3ExprDelete(pParse->db, (yypminor->yy81).pExpr);
-}
-      break;
+} 
+      break; 
 /********* End destructor definitions *****************************************/
     default:  break;   /* If no destructor action specified: do nothing */
   }
@@ -162003,12 +162003,12 @@ SQLITE_PRIVATE int sqlite3ParserCoverage(FILE *out){
 ** Find the appropriate action for a parser given the terminal
 ** look-ahead token iLookAhead.
 */
-static YYACTIONTYPE yy_find_shift_action(
-  YYCODETYPE iLookAhead,    /* The look-ahead token */
-  YYACTIONTYPE stateno      /* Current state number */
+static YYACTIONTYPE yy_find_shift_action( 
+  YYCODETYPE iLookAhead,    /* The look-ahead token */ 
+  YYACTIONTYPE stateno      /* Current state number */ 
 ){
   int i;
-
+ 
   if( stateno>YY_MAX_SHIFT ) return stateno;
   assert( stateno <= YY_SHIFT_COUNT );
 #if defined(YYCOVERAGE)
@@ -162016,7 +162016,7 @@ static YYACTIONTYPE yy_find_shift_action(
 #endif
   do{
     i = yy_shift_ofst[stateno];
-    assert( i>=0 );
+    assert( i>=0 ); 
     assert( i<=YY_ACTTAB_COUNT );
     assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD );
     assert( iLookAhead!=YYNOCODE );
@@ -162068,8 +162068,8 @@ static YYACTIONTYPE yy_find_shift_action(
 ** Find the appropriate action for a parser given the non-terminal
 ** look-ahead token iLookAhead.
 */
-static YYACTIONTYPE yy_find_reduce_action(
-  YYACTIONTYPE stateno,     /* Current state number */
+static YYACTIONTYPE yy_find_reduce_action( 
+  YYACTIONTYPE stateno,     /* Current state number */ 
   YYCODETYPE iLookAhead     /* The look-ahead token */
 ){
   int i;
@@ -162098,8 +162098,8 @@ static YYACTIONTYPE yy_find_reduce_action(
 ** The following routine is called if the stack overflows.
 */
 static void yyStackOverflow(yyParser *yypParser){
-   sqlite3ParserARG_FETCH
-   sqlite3ParserCTX_FETCH
+   sqlite3ParserARG_FETCH 
+   sqlite3ParserCTX_FETCH 
 #ifndef NDEBUG
    if( yyTraceFILE ){
      fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
@@ -162112,8 +162112,8 @@ static void yyStackOverflow(yyParser *yypParser){
 
   sqlite3ErrorMsg(pParse, "parser stack overflow");
 /******** End %stack_overflow code ********************************************/
-   sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument var */
-   sqlite3ParserCTX_STORE
+   sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument var */ 
+   sqlite3ParserCTX_STORE 
 }
 
 /*
@@ -162142,8 +162142,8 @@ static void yyTraceShift(yyParser *yypParser, int yyNewState, const char *zTag){
 */
 static void yy_shift(
   yyParser *yypParser,          /* The parser to be shifted */
-  YYACTIONTYPE yyNewState,      /* The new state to shift in */
-  YYCODETYPE yyMajor,           /* The major token to shift in */
+  YYACTIONTYPE yyNewState,      /* The new state to shift in */ 
+  YYCODETYPE yyMajor,           /* The major token to shift in */ 
   sqlite3ParserTOKENTYPE yyMinor        /* The minor token to shift in */
 ){
   yyStackEntry *yytos;
@@ -162173,15 +162173,15 @@ static void yy_shift(
     yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
   }
   yytos = yypParser->yytos;
-  yytos->stateno = yyNewState;
-  yytos->major = yyMajor;
+  yytos->stateno = yyNewState; 
+  yytos->major = yyMajor; 
   yytos->minor.yy0 = yyMinor;
   yyTraceShift(yypParser, yyNewState, "Shift");
 }
 
-/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side
-** of that rule */
-static const YYCODETYPE yyRuleInfoLhs[] = {
+/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side 
+** of that rule */ 
+static const YYCODETYPE yyRuleInfoLhs[] = { 
    188,  /* (0) explain ::= EXPLAIN */
    188,  /* (1) explain ::= EXPLAIN QUERY PLAN */
    187,  /* (2) cmdx ::= cmd */
@@ -162585,30 +162585,30 @@ static const YYCODETYPE yyRuleInfoLhs[] = {
    265,  /* (400) with ::= */
 };
 
-/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
-** of symbols on the right-hand side of that rule. */
-static const signed char yyRuleInfoNRhs[] = {
-   -1,  /* (0) explain ::= EXPLAIN */
-   -3,  /* (1) explain ::= EXPLAIN QUERY PLAN */
-   -1,  /* (2) cmdx ::= cmd */
-   -3,  /* (3) cmd ::= BEGIN transtype trans_opt */
-    0,  /* (4) transtype ::= */
-   -1,  /* (5) transtype ::= DEFERRED */
-   -1,  /* (6) transtype ::= IMMEDIATE */
-   -1,  /* (7) transtype ::= EXCLUSIVE */
-   -2,  /* (8) cmd ::= COMMIT|END trans_opt */
-   -2,  /* (9) cmd ::= ROLLBACK trans_opt */
-   -2,  /* (10) cmd ::= SAVEPOINT nm */
-   -3,  /* (11) cmd ::= RELEASE savepoint_opt nm */
-   -5,  /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */
-   -6,  /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */
-   -1,  /* (14) createkw ::= CREATE */
-    0,  /* (15) ifnotexists ::= */
-   -3,  /* (16) ifnotexists ::= IF NOT EXISTS */
-   -1,  /* (17) temp ::= TEMP */
-    0,  /* (18) temp ::= */
+/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number 
+** of symbols on the right-hand side of that rule. */ 
+static const signed char yyRuleInfoNRhs[] = { 
+   -1,  /* (0) explain ::= EXPLAIN */ 
+   -3,  /* (1) explain ::= EXPLAIN QUERY PLAN */ 
+   -1,  /* (2) cmdx ::= cmd */ 
+   -3,  /* (3) cmd ::= BEGIN transtype trans_opt */ 
+    0,  /* (4) transtype ::= */ 
+   -1,  /* (5) transtype ::= DEFERRED */ 
+   -1,  /* (6) transtype ::= IMMEDIATE */ 
+   -1,  /* (7) transtype ::= EXCLUSIVE */ 
+   -2,  /* (8) cmd ::= COMMIT|END trans_opt */ 
+   -2,  /* (9) cmd ::= ROLLBACK trans_opt */ 
+   -2,  /* (10) cmd ::= SAVEPOINT nm */ 
+   -3,  /* (11) cmd ::= RELEASE savepoint_opt nm */ 
+   -5,  /* (12) cmd ::= ROLLBACK trans_opt TO savepoint_opt nm */ 
+   -6,  /* (13) create_table ::= createkw temp TABLE ifnotexists nm dbnm */ 
+   -1,  /* (14) createkw ::= CREATE */ 
+    0,  /* (15) ifnotexists ::= */ 
+   -3,  /* (16) ifnotexists ::= IF NOT EXISTS */ 
+   -1,  /* (17) temp ::= TEMP */ 
+    0,  /* (18) temp ::= */ 
    -5,  /* (19) create_table_args ::= LP columnlist conslist_opt RP table_option_set */
-   -2,  /* (20) create_table_args ::= AS select */
+   -2,  /* (20) create_table_args ::= AS select */ 
     0,  /* (21) table_option_set ::= */
    -3,  /* (22) table_option_set ::= table_option_set COMMA table_option */
    -2,  /* (23) table_option ::= WITHOUT nm */
@@ -162989,8 +162989,8 @@ static const signed char yyRuleInfoNRhs[] = {
    -4,  /* (398) anylist ::= anylist LP anylist RP */
    -2,  /* (399) anylist ::= anylist ANY */
     0,  /* (400) with ::= */
-};
-
+}; 
+ 
 static void yy_accept(yyParser*);  /* Forward Declaration */
 
 /*
@@ -163003,18 +163003,18 @@ static void yy_accept(yyParser*);  /* Forward Declaration */
 ** only called from one place, optimizing compilers will in-line it, which
 ** means that the extra parameters have no performance impact.
 */
-static YYACTIONTYPE yy_reduce(
+static YYACTIONTYPE yy_reduce( 
   yyParser *yypParser,         /* The parser */
   unsigned int yyruleno,       /* Number of the rule by which to reduce */
   int yyLookahead,             /* Lookahead token, or YYNOCODE if none */
   sqlite3ParserTOKENTYPE yyLookaheadToken  /* Value of the lookahead token */
-  sqlite3ParserCTX_PDECL                   /* %extra_context */
+  sqlite3ParserCTX_PDECL                   /* %extra_context */ 
 ){
   int yygoto;                     /* The next state */
-  YYACTIONTYPE yyact;             /* The next action */
+  YYACTIONTYPE yyact;             /* The next action */ 
   yyStackEntry *yymsp;            /* The top of the parser's stack */
   int yysize;                     /* Amount to pop the stack */
-  sqlite3ParserARG_FETCH
+  sqlite3ParserARG_FETCH 
   (void)yyLookahead;
   (void)yyLookaheadToken;
   yymsp = yypParser->yytos;
@@ -163161,11 +163161,11 @@ static YYACTIONTYPE yy_reduce(
 }
         break;
       case 31: /* scantok ::= */
-{
-  assert( yyLookahead!=YYNOCODE );
-  yymsp[1].minor.yy0 = yyLookaheadToken;
-}
-        break;
+{ 
+  assert( yyLookahead!=YYNOCODE ); 
+  yymsp[1].minor.yy0 = yyLookaheadToken; 
+} 
+        break; 
       case 32: /* ccons ::= CONSTRAINT nm */
       case 67: /* tcons ::= CONSTRAINT nm */ yytestcase(yyruleno==67);
 {pParse->constraintName = yymsp[0].minor.yy0;}
@@ -163182,17 +163182,17 @@ static YYACTIONTYPE yy_reduce(
       case 36: /* ccons ::= DEFAULT MINUS scantok term */
 {
   Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy626, 0);
-  sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);
+  sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]); 
 }
         break;
       case 37: /* ccons ::= DEFAULT scantok ID|INDEXED */
 {
   Expr *p = tokenExpr(pParse, TK_STRING, yymsp[0].minor.yy0);
-  if( p ){
-    sqlite3ExprIdToTrueFalse(p);
-    testcase( p->op==TK_TRUEFALSE && sqlite3ExprTruthValue(p) );
-  }
-    sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n);
+  if( p ){ 
+    sqlite3ExprIdToTrueFalse(p); 
+    testcase( p->op==TK_TRUEFALSE && sqlite3ExprTruthValue(p) ); 
+  } 
+    sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n); 
 }
         break;
       case 38: /* ccons ::= NOT NULL onconf */
@@ -163337,18 +163337,18 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 86: /* select ::= WITH RECURSIVE wqlist selectnowith */
 {yymsp[-3].minor.yy303 = attachWithToSelect(pParse,yymsp[0].minor.yy303,yymsp[-1].minor.yy43);}
-        break;
+        break; 
       case 87: /* select ::= selectnowith */
-{
+{ 
   Select *p = yymsp[0].minor.yy303;
-  if( p ){
-    parserDoubleLinkSelect(pParse, p);
-  }
+  if( p ){ 
+    parserDoubleLinkSelect(pParse, p); 
+  } 
   yymsp[0].minor.yy303 = p; /*A-overwrites-X*/
-}
-        break;
+} 
+        break; 
       case 88: /* selectnowith ::= selectnowith multiselect_op oneselect */
-{
+{ 
   Select *pRhs = yymsp[0].minor.yy303;
   Select *pLhs = yymsp[-2].minor.yy303;
   if( pRhs && pRhs->pPrior ){
@@ -163381,14 +163381,14 @@ static YYACTIONTYPE yy_reduce(
       case 92: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt */
 {
   yymsp[-8].minor.yy303 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy562,yymsp[-5].minor.yy607,yymsp[-4].minor.yy626,yymsp[-3].minor.yy562,yymsp[-2].minor.yy626,yymsp[-1].minor.yy562,yymsp[-7].minor.yy64,yymsp[0].minor.yy626);
-}
-        break;
+} 
+        break; 
       case 93: /* oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt window_clause orderby_opt limit_opt */
-{
+{ 
   yymsp[-9].minor.yy303 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy562,yymsp[-6].minor.yy607,yymsp[-5].minor.yy626,yymsp[-4].minor.yy562,yymsp[-3].minor.yy626,yymsp[-1].minor.yy562,yymsp[-8].minor.yy64,yymsp[0].minor.yy626);
   if( yymsp[-9].minor.yy303 ){
     yymsp[-9].minor.yy303->pWinDefn = yymsp[-2].minor.yy375;
-  }else{
+  }else{ 
     sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy375);
   }
 }
@@ -163497,12 +163497,12 @@ static YYACTIONTYPE yy_reduce(
         pNew->zName = pOld->zName;
         pNew->zDatabase = pOld->zDatabase;
         pNew->pSelect = pOld->pSelect;
-        if( pOld->fg.isTabFunc ){
-          pNew->u1.pFuncArg = pOld->u1.pFuncArg;
-          pOld->u1.pFuncArg = 0;
-          pOld->fg.isTabFunc = 0;
-          pNew->fg.isTabFunc = 1;
-        }
+        if( pOld->fg.isTabFunc ){ 
+          pNew->u1.pFuncArg = pOld->u1.pFuncArg; 
+          pOld->u1.pFuncArg = 0; 
+          pOld->fg.isTabFunc = 0; 
+          pNew->fg.isTabFunc = 1; 
+        } 
         pOld->zName = pOld->zDatabase = 0;
         pOld->pSelect = 0;
       }
@@ -163520,17 +163520,17 @@ static YYACTIONTYPE yy_reduce(
 {yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;}
         break;
       case 115: /* fullname ::= nm */
-{
+{ 
   yylhsminor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0);
   if( IN_RENAME_OBJECT && yylhsminor.yy607 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy607->a[0].zName, &yymsp[0].minor.yy0);
-}
+} 
   yymsp[0].minor.yy607 = yylhsminor.yy607;
         break;
       case 116: /* fullname ::= nm DOT nm */
-{
+{ 
   yylhsminor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
   if( IN_RENAME_OBJECT && yylhsminor.yy607 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy607->a[0].zName, &yymsp[0].minor.yy0);
-}
+} 
   yymsp[-2].minor.yy607 = yylhsminor.yy607;
         break;
       case 117: /* xfullname ::= nm */
@@ -163540,29 +163540,29 @@ static YYACTIONTYPE yy_reduce(
 {yymsp[-2].minor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/}
         break;
       case 119: /* xfullname ::= nm DOT nm AS nm */
-{
+{ 
    yymsp[-4].minor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/
    if( yymsp[-4].minor.yy607 ) yymsp[-4].minor.yy607->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
-}
+} 
         break;
       case 120: /* xfullname ::= nm AS nm */
 {
    yymsp[-2].minor.yy607 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/
    if( yymsp[-2].minor.yy607 ) yymsp[-2].minor.yy607->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
-}
+} 
         break;
       case 121: /* joinop ::= COMMA|JOIN */
 { yymsp[0].minor.yy64 = JT_INNER; }
         break;
       case 122: /* joinop ::= JOIN_KW JOIN */
 {yymsp[-1].minor.yy64 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0);  /*X-overwrites-A*/}
-        break;
+        break; 
       case 123: /* joinop ::= JOIN_KW nm JOIN */
 {yymsp[-2].minor.yy64 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/}
-        break;
+        break; 
       case 124: /* joinop ::= JOIN_KW nm nm JOIN */
 {yymsp[-3].minor.yy64 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/}
-        break;
+        break; 
       case 125: /* on_opt ::= ON expr */
       case 145: /* having_opt ::= HAVING expr */ yytestcase(yyruleno==145);
       case 152: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==152);
@@ -163570,7 +163570,7 @@ static YYACTIONTYPE yy_reduce(
       case 225: /* case_else ::= ELSE expr */ yytestcase(yyruleno==225);
       case 246: /* vinto ::= INTO expr */ yytestcase(yyruleno==246);
 {yymsp[-1].minor.yy626 = yymsp[0].minor.yy626;}
-        break;
+        break; 
       case 126: /* on_opt ::= */
       case 144: /* having_opt ::= */ yytestcase(yyruleno==144);
       case 146: /* limit_opt ::= */ yytestcase(yyruleno==146);
@@ -163580,7 +163580,7 @@ static YYACTIONTYPE yy_reduce(
       case 228: /* case_operand ::= */ yytestcase(yyruleno==228);
       case 247: /* vinto ::= */ yytestcase(yyruleno==247);
 {yymsp[1].minor.yy626 = 0;}
-        break;
+        break; 
       case 128: /* indexed_opt ::= INDEXED BY nm */
 {yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;}
         break;
@@ -163638,13 +163638,13 @@ static YYACTIONTYPE yy_reduce(
       case 150: /* cmd ::= with DELETE FROM xfullname indexed_opt where_opt_ret orderby_opt limit_opt */
 {
   sqlite3SrcListIndexedBy(pParse, yymsp[-4].minor.yy607, &yymsp[-3].minor.yy0);
-#ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT
+#ifndef SQLITE_ENABLE_UPDATE_DELETE_LIMIT 
   if( yymsp[-1].minor.yy562 || yymsp[0].minor.yy626 ){
     updateDeleteLimitError(pParse,yymsp[-1].minor.yy562,yymsp[0].minor.yy626);
     yymsp[-1].minor.yy562 = 0;
     yymsp[0].minor.yy626 = 0;
   }
-#endif
+#endif 
   sqlite3DeleteFrom(pParse,yymsp[-4].minor.yy607,yymsp[-2].minor.yy626,yymsp[-1].minor.yy562,yymsp[0].minor.yy626);
 }
         break;
@@ -163719,16 +163719,16 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 169: /* upsert ::= ON CONFLICT DO UPDATE SET setlist where_opt returning */
 { yymsp[-7].minor.yy138 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy562,yymsp[-1].minor.yy626,0);}
-        break;
+        break; 
       case 170: /* returning ::= RETURNING selcollist */
 {sqlite3AddReturning(pParse,yymsp[0].minor.yy562);}
-        break;
+        break; 
       case 174: /* idlist_opt ::= LP idlist RP */
 {yymsp[-2].minor.yy240 = yymsp[-1].minor.yy240;}
-        break;
+        break; 
       case 175: /* idlist ::= idlist COMMA nm */
 {yymsp[-2].minor.yy240 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy240,&yymsp[0].minor.yy0);}
-        break;
+        break; 
       case 176: /* idlist ::= nm */
 {yymsp[0].minor.yy240 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/}
         break;
@@ -163743,10 +163743,10 @@ static YYACTIONTYPE yy_reduce(
 {
   Expr *temp1 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
   Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[0].minor.yy0, 1);
-  if( IN_RENAME_OBJECT ){
-    sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[0].minor.yy0);
-    sqlite3RenameTokenMap(pParse, (void*)temp1, &yymsp[-2].minor.yy0);
-  }
+  if( IN_RENAME_OBJECT ){ 
+    sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[0].minor.yy0); 
+    sqlite3RenameTokenMap(pParse, (void*)temp1, &yymsp[-2].minor.yy0); 
+  } 
   yylhsminor.yy626 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
 }
   yymsp[-2].minor.yy626 = yylhsminor.yy626;
@@ -163757,10 +163757,10 @@ static YYACTIONTYPE yy_reduce(
   Expr *temp2 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[-2].minor.yy0, 1);
   Expr *temp3 = sqlite3ExprAlloc(pParse->db, TK_ID, &yymsp[0].minor.yy0, 1);
   Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3);
-  if( IN_RENAME_OBJECT ){
-    sqlite3RenameTokenMap(pParse, (void*)temp3, &yymsp[0].minor.yy0);
-    sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[-2].minor.yy0);
-  }
+  if( IN_RENAME_OBJECT ){ 
+    sqlite3RenameTokenMap(pParse, (void*)temp3, &yymsp[0].minor.yy0); 
+    sqlite3RenameTokenMap(pParse, (void*)temp2, &yymsp[-2].minor.yy0); 
+  } 
   yylhsminor.yy626 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
 }
   yymsp[-4].minor.yy626 = yylhsminor.yy626;
@@ -163831,17 +163831,17 @@ static YYACTIONTYPE yy_reduce(
 {
   yylhsminor.yy626 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0);
   sqlite3WindowAttach(pParse, yylhsminor.yy626, yymsp[0].minor.yy375);
-}
+} 
   yymsp[-4].minor.yy626 = yylhsminor.yy626;
-        break;
+        break; 
       case 192: /* term ::= CTIME_KW */
-{
+{ 
   yylhsminor.yy626 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0);
-}
+} 
   yymsp[0].minor.yy626 = yylhsminor.yy626;
-        break;
+        break; 
       case 193: /* expr ::= LP nexprlist COMMA expr RP */
-{
+{ 
   ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy562, yymsp[-1].minor.yy626);
   yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
   if( yymsp[-4].minor.yy626 ){
@@ -163865,7 +163865,7 @@ static YYACTIONTYPE yy_reduce(
       case 200: /* expr ::= expr STAR|SLASH|REM expr */ yytestcase(yyruleno==200);
       case 201: /* expr ::= expr CONCAT expr */ yytestcase(yyruleno==201);
 {yymsp[-2].minor.yy626=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy626,yymsp[0].minor.yy626);}
-        break;
+        break; 
       case 202: /* likeop ::= NOT LIKE_KW|MATCH */
 {yymsp[-1].minor.yy0=yymsp[0].minor.yy0; yymsp[-1].minor.yy0.n|=0x80000000; /*yymsp[-1].minor.yy0-overwrite-yymsp[0].minor.yy0*/}
         break;
@@ -163917,10 +163917,10 @@ static YYACTIONTYPE yy_reduce(
 {yymsp[-1].minor.yy626 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy626, 0);/*A-overwrites-B*/}
         break;
       case 211: /* expr ::= PLUS|MINUS expr */
-{
+{ 
   yymsp[-1].minor.yy626 = sqlite3PExpr(pParse, yymsp[-1].major==TK_PLUS ? TK_UPLUS : TK_UMINUS, yymsp[0].minor.yy626, 0);
-  /*A-overwrites-B*/
-}
+  /*A-overwrites-B*/ 
+} 
         break;
       case 212: /* between_op ::= BETWEEN */
       case 215: /* in_op ::= IN */ yytestcase(yyruleno==215);
@@ -163994,7 +163994,7 @@ static YYACTIONTYPE yy_reduce(
         break;
       case 220: /* expr ::= expr in_op nm dbnm paren_exprlist */
 {
-    SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);
+    SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); 
     Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0);
     if( yymsp[0].minor.yy562 )  sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy562);
     yymsp[-4].minor.yy626 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy626, 0);
@@ -164051,9 +164051,9 @@ static YYACTIONTYPE yy_reduce(
   sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0,
                      sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy562, yymsp[-10].minor.yy64,
                       &yymsp[-11].minor.yy0, yymsp[0].minor.yy626, SQLITE_SO_ASC, yymsp[-8].minor.yy64, SQLITE_IDXTYPE_APPDEF);
-  if( IN_RENAME_OBJECT && pParse->pNewIndex ){
-    sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
-  }
+  if( IN_RENAME_OBJECT && pParse->pNewIndex ){ 
+    sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0); 
+  } 
 }
         break;
       case 235: /* uniqueflag ::= UNIQUE */
@@ -164175,9 +164175,9 @@ static YYACTIONTYPE yy_reduce(
   yymsp[-8].minor.yy95 = yylhsminor.yy95;
         break;
       case 271: /* trigger_cmd ::= scanpt insert_cmd INTO trnm idlist_opt select upsert scanpt */
-{
+{ 
    yylhsminor.yy95 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy240,yymsp[-2].minor.yy303,yymsp[-6].minor.yy64,yymsp[-1].minor.yy138,yymsp[-7].minor.yy600,yymsp[0].minor.yy600);/*yylhsminor.yy95-overwrites-yymsp[-6].minor.yy64*/
-}
+} 
   yymsp[-7].minor.yy95 = yylhsminor.yy95;
         break;
       case 272: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt scanpt */
@@ -164260,10 +164260,10 @@ static YYACTIONTYPE yy_reduce(
 }
         break;
       case 292: /* cmd ::= ALTER TABLE fullname RENAME kwcolumn_opt nm TO nm */
-{
+{ 
   sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy607, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
-}
-        break;
+} 
+        break; 
       case 293: /* cmd ::= create_vtab */
 {sqlite3VtabFinishParse(pParse,0);}
         break;
@@ -164297,20 +164297,20 @@ static YYACTIONTYPE yy_reduce(
 {yymsp[-2].minor.yy534 = M10d_No;}
         break;
       case 305: /* wqitem ::= nm eidlist_opt wqas LP select RP */
-{
+{ 
   yymsp[-5].minor.yy255 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy562, yymsp[-1].minor.yy303, yymsp[-3].minor.yy534); /*A-overwrites-X*/
-}
+} 
         break;
       case 306: /* wqlist ::= wqitem */
-{
+{ 
   yymsp[0].minor.yy43 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy255); /*A-overwrites-X*/
-}
+} 
         break;
       case 307: /* wqlist ::= wqlist COMMA wqitem */
 {
   yymsp[-2].minor.yy43 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy43, yymsp[0].minor.yy255);
 }
-        break;
+        break; 
       case 308: /* windowdefn_list ::= windowdefn */
 { yylhsminor.yy375 = yymsp[0].minor.yy375; }
   yymsp[0].minor.yy375 = yylhsminor.yy375;
@@ -164328,123 +164328,123 @@ static YYACTIONTYPE yy_reduce(
 {
   if( ALWAYS(yymsp[-1].minor.yy375) ){
     yymsp[-1].minor.yy375->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
-  }
+  } 
   yylhsminor.yy375 = yymsp[-1].minor.yy375;
 }
   yymsp[-4].minor.yy375 = yylhsminor.yy375;
         break;
       case 311: /* window ::= PARTITION BY nexprlist orderby_opt frame_opt */
-{
+{ 
   yymsp[-4].minor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, yymsp[-2].minor.yy562, yymsp[-1].minor.yy562, 0);
-}
-        break;
+} 
+        break; 
       case 312: /* window ::= nm PARTITION BY nexprlist orderby_opt frame_opt */
-{
+{ 
   yylhsminor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, yymsp[-2].minor.yy562, yymsp[-1].minor.yy562, &yymsp[-5].minor.yy0);
-}
+} 
   yymsp[-5].minor.yy375 = yylhsminor.yy375;
-        break;
+        break; 
       case 313: /* window ::= ORDER BY sortlist frame_opt */
-{
+{ 
   yymsp[-3].minor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, 0, yymsp[-1].minor.yy562, 0);
-}
-        break;
+} 
+        break; 
       case 314: /* window ::= nm ORDER BY sortlist frame_opt */
-{
+{ 
   yylhsminor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, 0, yymsp[-1].minor.yy562, &yymsp[-4].minor.yy0);
-}
+} 
   yymsp[-4].minor.yy375 = yylhsminor.yy375;
-        break;
+        break; 
       case 315: /* window ::= frame_opt */
       case 334: /* filter_over ::= over_clause */ yytestcase(yyruleno==334);
-{
+{ 
   yylhsminor.yy375 = yymsp[0].minor.yy375;
-}
+} 
   yymsp[0].minor.yy375 = yylhsminor.yy375;
-        break;
+        break; 
       case 316: /* window ::= nm frame_opt */
-{
+{ 
   yylhsminor.yy375 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy375, 0, 0, &yymsp[-1].minor.yy0);
-}
+} 
   yymsp[-1].minor.yy375 = yylhsminor.yy375;
-        break;
+        break; 
       case 317: /* frame_opt ::= */
 {
   yymsp[1].minor.yy375 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
-}
-        break;
+} 
+        break; 
       case 318: /* frame_opt ::= range_or_rows frame_bound_s frame_exclude_opt */
 {
   yylhsminor.yy375 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy64, yymsp[-1].minor.yy81.eType, yymsp[-1].minor.yy81.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy534);
-}
+} 
   yymsp[-2].minor.yy375 = yylhsminor.yy375;
-        break;
+        break; 
       case 319: /* frame_opt ::= range_or_rows BETWEEN frame_bound_s AND frame_bound_e frame_exclude_opt */
 {
   yylhsminor.yy375 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy64, yymsp[-3].minor.yy81.eType, yymsp[-3].minor.yy81.pExpr, yymsp[-1].minor.yy81.eType, yymsp[-1].minor.yy81.pExpr, yymsp[0].minor.yy534);
-}
+} 
   yymsp[-5].minor.yy375 = yylhsminor.yy375;
-        break;
+        break; 
       case 321: /* frame_bound_s ::= frame_bound */
       case 323: /* frame_bound_e ::= frame_bound */ yytestcase(yyruleno==323);
 {yylhsminor.yy81 = yymsp[0].minor.yy81;}
   yymsp[0].minor.yy81 = yylhsminor.yy81;
-        break;
+        break; 
       case 322: /* frame_bound_s ::= UNBOUNDED PRECEDING */
       case 324: /* frame_bound_e ::= UNBOUNDED FOLLOWING */ yytestcase(yyruleno==324);
       case 326: /* frame_bound ::= CURRENT ROW */ yytestcase(yyruleno==326);
 {yylhsminor.yy81.eType = yymsp[-1].major; yylhsminor.yy81.pExpr = 0;}
   yymsp[-1].minor.yy81 = yylhsminor.yy81;
-        break;
+        break; 
       case 325: /* frame_bound ::= expr PRECEDING|FOLLOWING */
 {yylhsminor.yy81.eType = yymsp[0].major; yylhsminor.yy81.pExpr = yymsp[-1].minor.yy626;}
   yymsp[-1].minor.yy81 = yylhsminor.yy81;
-        break;
+        break; 
       case 327: /* frame_exclude_opt ::= */
 {yymsp[1].minor.yy534 = 0;}
-        break;
+        break; 
       case 328: /* frame_exclude_opt ::= EXCLUDE frame_exclude */
 {yymsp[-1].minor.yy534 = yymsp[0].minor.yy534;}
-        break;
+        break; 
       case 329: /* frame_exclude ::= NO OTHERS */
       case 330: /* frame_exclude ::= CURRENT ROW */ yytestcase(yyruleno==330);
 {yymsp[-1].minor.yy534 = yymsp[-1].major; /*A-overwrites-X*/}
-        break;
+        break; 
       case 331: /* frame_exclude ::= GROUP|TIES */
 {yymsp[0].minor.yy534 = yymsp[0].major; /*A-overwrites-X*/}
-        break;
+        break; 
       case 332: /* window_clause ::= WINDOW windowdefn_list */
 { yymsp[-1].minor.yy375 = yymsp[0].minor.yy375; }
-        break;
+        break; 
       case 333: /* filter_over ::= filter_clause over_clause */
-{
+{ 
   if( yymsp[0].minor.yy375 ){
     yymsp[0].minor.yy375->pFilter = yymsp[-1].minor.yy626;
   }else{
     sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy626);
   }
   yylhsminor.yy375 = yymsp[0].minor.yy375;
-}
+} 
   yymsp[-1].minor.yy375 = yylhsminor.yy375;
-        break;
+        break; 
       case 335: /* filter_over ::= filter_clause */
-{
+{ 
   yylhsminor.yy375 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
   if( yylhsminor.yy375 ){
     yylhsminor.yy375->eFrmType = TK_FILTER;
     yylhsminor.yy375->pFilter = yymsp[0].minor.yy626;
-  }else{
+  }else{ 
     sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy626);
-  }
-}
+  } 
+} 
   yymsp[0].minor.yy375 = yylhsminor.yy375;
-        break;
+        break; 
       case 336: /* over_clause ::= OVER LP window RP */
 {
   yymsp[-3].minor.yy375 = yymsp[-1].minor.yy375;
   assert( yymsp[-3].minor.yy375!=0 );
 }
-        break;
+        break; 
       case 337: /* over_clause ::= OVER nm */
 {
   yymsp[-1].minor.yy375 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
@@ -164522,9 +164522,9 @@ static YYACTIONTYPE yy_reduce(
         break;
 /********** End reduce actions ************************************************/
   };
-  assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );
-  yygoto = yyRuleInfoLhs[yyruleno];
-  yysize = yyRuleInfoNRhs[yyruleno];
+  assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) ); 
+  yygoto = yyRuleInfoLhs[yyruleno]; 
+  yysize = yyRuleInfoNRhs[yyruleno]; 
   yyact = yy_find_reduce_action(yymsp[yysize].stateno,(YYCODETYPE)yygoto);
 
   /* There are no SHIFTREDUCE actions on nonterminals because the table
@@ -164539,7 +164539,7 @@ static YYACTIONTYPE yy_reduce(
   yymsp->stateno = (YYACTIONTYPE)yyact;
   yymsp->major = (YYCODETYPE)yygoto;
   yyTraceShift(yypParser, yyact, "... then shift");
-  return yyact;
+  return yyact; 
 }
 
 /*
@@ -164549,8 +164549,8 @@ static YYACTIONTYPE yy_reduce(
 static void yy_parse_failed(
   yyParser *yypParser           /* The parser */
 ){
-  sqlite3ParserARG_FETCH
-  sqlite3ParserCTX_FETCH
+  sqlite3ParserARG_FETCH 
+  sqlite3ParserCTX_FETCH 
 #ifndef NDEBUG
   if( yyTraceFILE ){
     fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
@@ -164561,8 +164561,8 @@ static void yy_parse_failed(
   ** parser fails */
 /************ Begin %parse_failure code ***************************************/
 /************ End %parse_failure code *****************************************/
-  sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument variable */
-  sqlite3ParserCTX_STORE
+  sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument variable */ 
+  sqlite3ParserCTX_STORE 
 }
 #endif /* YYNOERRORRECOVERY */
 
@@ -164574,8 +164574,8 @@ static void yy_syntax_error(
   int yymajor,                   /* The major type of the error token */
   sqlite3ParserTOKENTYPE yyminor         /* The minor type of the error token */
 ){
-  sqlite3ParserARG_FETCH
-  sqlite3ParserCTX_FETCH
+  sqlite3ParserARG_FETCH 
+  sqlite3ParserCTX_FETCH 
 #define TOKEN yyminor
 /************ Begin %syntax_error code ****************************************/
 
@@ -164586,8 +164586,8 @@ static void yy_syntax_error(
     sqlite3ErrorMsg(pParse, "incomplete input");
   }
 /************ End %syntax_error code ******************************************/
-  sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument variable */
-  sqlite3ParserCTX_STORE
+  sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument variable */ 
+  sqlite3ParserCTX_STORE 
 }
 
 /*
@@ -164596,8 +164596,8 @@ static void yy_syntax_error(
 static void yy_accept(
   yyParser *yypParser           /* The parser */
 ){
-  sqlite3ParserARG_FETCH
-  sqlite3ParserCTX_FETCH
+  sqlite3ParserARG_FETCH 
+  sqlite3ParserCTX_FETCH 
 #ifndef NDEBUG
   if( yyTraceFILE ){
     fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
@@ -164611,8 +164611,8 @@ static void yy_accept(
   ** parser accepts */
 /*********** Begin %parse_accept code *****************************************/
 /*********** End %parse_accept code *******************************************/
-  sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument variable */
-  sqlite3ParserCTX_STORE
+  sqlite3ParserARG_STORE /* Suppress warning about unused %extra_argument variable */ 
+  sqlite3ParserCTX_STORE 
 }
 
 /* The main parser program.
@@ -164641,39 +164641,39 @@ SQLITE_PRIVATE void sqlite3Parser(
   sqlite3ParserARG_PDECL               /* Optional %extra_argument parameter */
 ){
   YYMINORTYPE yyminorunion;
-  YYACTIONTYPE yyact;   /* The parser action. */
+  YYACTIONTYPE yyact;   /* The parser action. */ 
 #if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
   int yyendofinput;     /* True if we are at the end of input */
 #endif
 #ifdef YYERRORSYMBOL
   int yyerrorhit = 0;   /* True if yymajor has invoked an error */
 #endif
-  yyParser *yypParser = (yyParser*)yyp;  /* The parser */
-  sqlite3ParserCTX_FETCH
-  sqlite3ParserARG_STORE
+  yyParser *yypParser = (yyParser*)yyp;  /* The parser */ 
+  sqlite3ParserCTX_FETCH 
+  sqlite3ParserARG_STORE 
 
   assert( yypParser->yytos!=0 );
 #if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
   yyendofinput = (yymajor==0);
 #endif
 
-  yyact = yypParser->yytos->stateno;
+  yyact = yypParser->yytos->stateno; 
 #ifndef NDEBUG
   if( yyTraceFILE ){
-    if( yyact < YY_MIN_REDUCE ){
+    if( yyact < YY_MIN_REDUCE ){ 
       fprintf(yyTraceFILE,"%sInput '%s' in state %d\n",
-              yyTracePrompt,yyTokenName[yymajor],yyact);
+              yyTracePrompt,yyTokenName[yymajor],yyact); 
     }else{
       fprintf(yyTraceFILE,"%sInput '%s' with pending reduce %d\n",
-              yyTracePrompt,yyTokenName[yymajor],yyact-YY_MIN_REDUCE);
+              yyTracePrompt,yyTokenName[yymajor],yyact-YY_MIN_REDUCE); 
     }
   }
 #endif
 
   while(1){ /* Exit by "break" */
     assert( yypParser->yytos>=yypParser->yystack );
-    assert( yyact==yypParser->yytos->stateno );
-    yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact);
+    assert( yyact==yypParser->yytos->stateno ); 
+    yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact); 
     if( yyact >= YY_MIN_REDUCE ){
       unsigned int yyruleno = yyact - YY_MIN_REDUCE; /* Reduce by this rule */
 #ifndef NDEBUG
@@ -164721,11 +164721,11 @@ SQLITE_PRIVATE void sqlite3Parser(
       }
       yyact = yy_reduce(yypParser,yyruleno,yymajor,yyminor sqlite3ParserCTX_PARAM);
     }else if( yyact <= YY_MAX_SHIFTREDUCE ){
-      yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor);
+      yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor); 
 #ifndef YYNOERRORRECOVERY
       yypParser->yyerrcnt--;
 #endif
-      break;
+      break; 
     }else if( yyact==YY_ACCEPT_ACTION ){
       yypParser->yytos--;
       yy_accept(yypParser);
@@ -164794,8 +164794,8 @@ SQLITE_PRIVATE void sqlite3Parser(
       }
       yypParser->yyerrcnt = 3;
       yyerrorhit = 1;
-      if( yymajor==YYNOCODE ) break;
-      yyact = yypParser->yytos->stateno;
+      if( yymajor==YYNOCODE ) break; 
+      yyact = yypParser->yytos->stateno; 
 #elif defined(YYNOERRORRECOVERY)
       /* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
       ** do any kind of error recovery.  Instead, simply invoke the syntax
@@ -164806,7 +164806,7 @@ SQLITE_PRIVATE void sqlite3Parser(
       */
       yy_syntax_error(yypParser,yymajor, yyminor);
       yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
-      break;
+      break; 
 #else  /* YYERRORSYMBOL is not defined */
       /* This is what we do if the grammar does not define ERROR:
       **
@@ -164828,7 +164828,7 @@ SQLITE_PRIVATE void sqlite3Parser(
         yypParser->yyerrcnt = -1;
 #endif
       }
-      break;
+      break; 
 #endif
     }
   }
@@ -164847,20 +164847,20 @@ SQLITE_PRIVATE void sqlite3Parser(
   return;
 }
 
-/*
-** Return the fallback token corresponding to canonical token iToken, or
-** 0 if iToken has no fallback.
-*/
-SQLITE_PRIVATE int sqlite3ParserFallback(int iToken){
-#ifdef YYFALLBACK
+/* 
+** Return the fallback token corresponding to canonical token iToken, or 
+** 0 if iToken has no fallback. 
+*/ 
+SQLITE_PRIVATE int sqlite3ParserFallback(int iToken){ 
+#ifdef YYFALLBACK 
   assert( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) );
   return yyFallback[iToken];
-#else
-  (void)iToken;
+#else 
+  (void)iToken; 
   return 0;
-#endif
-}
-
+#endif 
+} 
+ 
 /************** End of parse.c ***********************************************/
 /************** Begin file tokenize.c ****************************************/
 /*
@@ -165044,7 +165044,7 @@ static const char zKWText[666] = {
   'E','C','K','E','Y','B','E','F','O','R','E','I','G','N','O','R','E','G',
   'E','X','P','L','A','I','N','S','T','E','A','D','D','A','T','A','B','A',
   'S','E','L','E','C','T','A','B','L','E','F','T','H','E','N','D','E','F',
-  'E','R','R','A','B','L','E','L','S','E','X','C','L','U','D','E','L','E',
+  'E','R','R','A','B','L','E','L','S','E','X','C','L','U','D','E','L','E', 
   'T','E','M','P','O','R','A','R','Y','I','S','N','U','L','L','S','A','V',
   'E','P','O','I','N','T','E','R','S','E','C','T','I','E','S','N','O','T',
   'N','U','L','L','I','K','E','X','C','E','P','T','R','A','N','S','A','C',
@@ -165111,7 +165111,7 @@ static const unsigned char aKWNext[147] = {
 /* aKWLen[i] is the length (in bytes) of the i-th keyword */
 static const unsigned char aKWLen[147] = {
      7,   7,   5,   4,   6,   4,   5,   3,   6,   7,   3,   6,   6,
-     7,   7,   3,   8,   2,   6,   5,   4,   4,   3,  10,   4,   7,
+     7,   7,   3,   8,   2,   6,   5,   4,   4,   3,  10,   4,   7, 
      6,   9,   4,   2,   6,   5,   9,   9,   4,   7,   3,   2,   4,
      4,   6,  11,   6,   2,   7,   5,   5,   9,   6,  10,   4,   6,
      2,   3,   7,   5,   9,   6,   6,   4,   5,   5,  10,   6,   5,
@@ -165350,11 +165350,11 @@ static int keywordCode(const char *z, int n, int *pType){
       testcase( i==22 ); /* END */
       testcase( i==23 ); /* DEFERRABLE */
       testcase( i==24 ); /* ELSE */
-      testcase( i==25 ); /* EXCLUDE */
-      testcase( i==26 ); /* DELETE */
-      testcase( i==27 ); /* TEMPORARY */
-      testcase( i==28 ); /* TEMP */
-      testcase( i==29 ); /* OR */
+      testcase( i==25 ); /* EXCLUDE */ 
+      testcase( i==26 ); /* DELETE */ 
+      testcase( i==27 ); /* TEMPORARY */ 
+      testcase( i==28 ); /* TEMP */ 
+      testcase( i==29 ); /* OR */ 
       testcase( i==30 ); /* ISNULL */
       testcase( i==31 ); /* NULLS */
       testcase( i==32 ); /* SAVEPOINT */
@@ -165484,16 +165484,16 @@ SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char *z, int n){
   return id;
 }
 #define SQLITE_N_KEYWORD 147
-SQLITE_API int sqlite3_keyword_name(int i,const char **pzName,int *pnName){
-  if( i<0 || i>=SQLITE_N_KEYWORD ) return SQLITE_ERROR;
-  *pzName = zKWText + aKWOffset[i];
-  *pnName = aKWLen[i];
-  return SQLITE_OK;
-}
-SQLITE_API int sqlite3_keyword_count(void){ return SQLITE_N_KEYWORD; }
-SQLITE_API int sqlite3_keyword_check(const char *zName, int nName){
-  return TK_ID!=sqlite3KeywordCode((const u8*)zName, nName);
-}
+SQLITE_API int sqlite3_keyword_name(int i,const char **pzName,int *pnName){ 
+  if( i<0 || i>=SQLITE_N_KEYWORD ) return SQLITE_ERROR; 
+  *pzName = zKWText + aKWOffset[i]; 
+  *pnName = aKWLen[i]; 
+  return SQLITE_OK; 
+} 
+SQLITE_API int sqlite3_keyword_count(void){ return SQLITE_N_KEYWORD; } 
+SQLITE_API int sqlite3_keyword_check(const char *zName, int nName){ 
+  return TK_ID!=sqlite3KeywordCode((const u8*)zName, nName); 
+} 
 
 /************** End of keywordhash.h *****************************************/
 /************** Continuing where we left off in tokenize.c *******************/
@@ -165537,87 +165537,87 @@ SQLITE_PRIVATE const char sqlite3IsEbcdicIdChar[] = {
 #define IdChar(C)  (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40]))
 #endif
 
-/* Make the IdChar function accessible from ctime.c and alter.c */
+/* Make the IdChar function accessible from ctime.c and alter.c */ 
 SQLITE_PRIVATE int sqlite3IsIdChar(u8 c){ return IdChar(c); }
 
-#ifndef SQLITE_OMIT_WINDOWFUNC
-/*
-** Return the id of the next token in string (*pz). Before returning, set
-** (*pz) to point to the byte following the parsed token.
-*/
-static int getToken(const unsigned char **pz){
-  const unsigned char *z = *pz;
-  int t;                          /* Token type to return */
-  do {
-    z += sqlite3GetToken(z, &t);
-  }while( t==TK_SPACE );
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+/* 
+** Return the id of the next token in string (*pz). Before returning, set 
+** (*pz) to point to the byte following the parsed token. 
+*/ 
+static int getToken(const unsigned char **pz){ 
+  const unsigned char *z = *pz; 
+  int t;                          /* Token type to return */ 
+  do { 
+    z += sqlite3GetToken(z, &t); 
+  }while( t==TK_SPACE ); 
   if( t==TK_ID
    || t==TK_STRING
    || t==TK_JOIN_KW
    || t==TK_WINDOW
    || t==TK_OVER
    || sqlite3ParserFallback(t)==TK_ID
-  ){
-    t = TK_ID;
-  }
-  *pz = z;
-  return t;
-}
-
-/*
-** The following three functions are called immediately after the tokenizer
-** reads the keywords WINDOW, OVER and FILTER, respectively, to determine
-** whether the token should be treated as a keyword or an SQL identifier.
-** This cannot be handled by the usual lemon %fallback method, due to
-** the ambiguity in some constructions. e.g.
-**
-**   SELECT sum(x) OVER ...
-**
+  ){ 
+    t = TK_ID; 
+  } 
+  *pz = z; 
+  return t; 
+} 
+
+/*
+** The following three functions are called immediately after the tokenizer 
+** reads the keywords WINDOW, OVER and FILTER, respectively, to determine 
+** whether the token should be treated as a keyword or an SQL identifier. 
+** This cannot be handled by the usual lemon %fallback method, due to 
+** the ambiguity in some constructions. e.g. 
+** 
+**   SELECT sum(x) OVER ... 
+** 
 ** In the above, "OVER" might be a keyword, or it might be an alias for the
 ** sum(x) expression. If a "%fallback ID OVER" directive were added to
-** grammar, then SQLite would always treat "OVER" as an alias, making it
-** impossible to call a window-function without a FILTER clause.
-**
-** WINDOW is treated as a keyword if:
-**
-**   * the following token is an identifier, or a keyword that can fallback
-**     to being an identifier, and
-**   * the token after than one is TK_AS.
-**
-** OVER is a keyword if:
-**
-**   * the previous token was TK_RP, and
-**   * the next token is either TK_LP or an identifier.
-**
-** FILTER is a keyword if:
-**
-**   * the previous token was TK_RP, and
-**   * the next token is TK_LP.
-*/
-static int analyzeWindowKeyword(const unsigned char *z){
-  int t;
-  t = getToken(&z);
-  if( t!=TK_ID ) return TK_ID;
-  t = getToken(&z);
-  if( t!=TK_AS ) return TK_ID;
-  return TK_WINDOW;
-}
-static int analyzeOverKeyword(const unsigned char *z, int lastToken){
-  if( lastToken==TK_RP ){
-    int t = getToken(&z);
-    if( t==TK_LP || t==TK_ID ) return TK_OVER;
-  }
-  return TK_ID;
-}
-static int analyzeFilterKeyword(const unsigned char *z, int lastToken){
-  if( lastToken==TK_RP && getToken(&z)==TK_LP ){
-    return TK_FILTER;
-  }
-  return TK_ID;
-}
-#endif /* SQLITE_OMIT_WINDOWFUNC */
-
-/*
+** grammar, then SQLite would always treat "OVER" as an alias, making it 
+** impossible to call a window-function without a FILTER clause. 
+** 
+** WINDOW is treated as a keyword if: 
+** 
+**   * the following token is an identifier, or a keyword that can fallback 
+**     to being an identifier, and 
+**   * the token after than one is TK_AS. 
+** 
+** OVER is a keyword if: 
+** 
+**   * the previous token was TK_RP, and 
+**   * the next token is either TK_LP or an identifier. 
+** 
+** FILTER is a keyword if: 
+** 
+**   * the previous token was TK_RP, and 
+**   * the next token is TK_LP. 
+*/ 
+static int analyzeWindowKeyword(const unsigned char *z){ 
+  int t; 
+  t = getToken(&z); 
+  if( t!=TK_ID ) return TK_ID; 
+  t = getToken(&z); 
+  if( t!=TK_AS ) return TK_ID; 
+  return TK_WINDOW; 
+} 
+static int analyzeOverKeyword(const unsigned char *z, int lastToken){ 
+  if( lastToken==TK_RP ){ 
+    int t = getToken(&z); 
+    if( t==TK_LP || t==TK_ID ) return TK_OVER; 
+  } 
+  return TK_ID; 
+} 
+static int analyzeFilterKeyword(const unsigned char *z, int lastToken){ 
+  if( lastToken==TK_RP && getToken(&z)==TK_LP ){ 
+    return TK_FILTER; 
+  } 
+  return TK_ID; 
+} 
+#endif /* SQLITE_OMIT_WINDOWFUNC */ 
+ 
+/* 
 ** Return the length (in bytes) of the token that begins at z[0].
 ** Store the token type in *tokenType before returning.
 */
@@ -165895,10 +165895,10 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
       i = 1;
       break;
     }
-    case CC_NUL: {
-      *tokenType = TK_ILLEGAL;
-      return 0;
-    }
+    case CC_NUL: { 
+      *tokenType = TK_ILLEGAL; 
+      return 0; 
+    } 
     default: {
       *tokenType = TK_ILLEGAL;
       return 1;
@@ -165928,7 +165928,7 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzEr
 #ifdef sqlite3Parser_ENGINEALWAYSONSTACK
   yyParser sEngine;    /* Space to hold the Lemon-generated Parser object */
 #endif
-  VVA_ONLY( u8 startedWithOom = db->mallocFailed );
+  VVA_ONLY( u8 startedWithOom = db->mallocFailed ); 
 
   assert( zSql!=0 );
   mxSqlLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
@@ -165938,19 +165938,19 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzEr
   pParse->rc = SQLITE_OK;
   pParse->zTail = zSql;
   assert( pzErrMsg!=0 );
-#ifdef SQLITE_DEBUG
-  if( db->flags & SQLITE_ParserTrace ){
-    printf("parser: [[[%s]]]\n", zSql);
-    sqlite3ParserTrace(stdout, "parser: ");
-  }else{
-    sqlite3ParserTrace(0, 0);
-  }
-#endif
+#ifdef SQLITE_DEBUG 
+  if( db->flags & SQLITE_ParserTrace ){ 
+    printf("parser: [[[%s]]]\n", zSql); 
+    sqlite3ParserTrace(stdout, "parser: "); 
+  }else{ 
+    sqlite3ParserTrace(0, 0); 
+  } 
+#endif 
 #ifdef sqlite3Parser_ENGINEALWAYSONSTACK
   pEngine = &sEngine;
-  sqlite3ParserInit(pEngine, pParse);
+  sqlite3ParserInit(pEngine, pParse); 
 #else
-  pEngine = sqlite3ParserAlloc(sqlite3Malloc, pParse);
+  pEngine = sqlite3ParserAlloc(sqlite3Malloc, pParse); 
   if( pEngine==0 ){
     sqlite3OomFault(db);
     return SQLITE_NOMEM_BKPT;
@@ -165961,65 +165961,65 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzEr
   assert( pParse->nVar==0 );
   assert( pParse->pVList==0 );
   pParentParse = db->pParse;
-  db->pParse = pParse;
+  db->pParse = pParse; 
   while( 1 ){
-    n = sqlite3GetToken((u8*)zSql, &tokenType);
-    mxSqlLen -= n;
-    if( mxSqlLen<0 ){
-      pParse->rc = SQLITE_TOOBIG;
-      break;
-    }
-#ifndef SQLITE_OMIT_WINDOWFUNC
-    if( tokenType>=TK_WINDOW ){
-      assert( tokenType==TK_SPACE || tokenType==TK_OVER || tokenType==TK_FILTER
+    n = sqlite3GetToken((u8*)zSql, &tokenType); 
+    mxSqlLen -= n; 
+    if( mxSqlLen<0 ){ 
+      pParse->rc = SQLITE_TOOBIG; 
+      break; 
+    }
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+    if( tokenType>=TK_WINDOW ){ 
+      assert( tokenType==TK_SPACE || tokenType==TK_OVER || tokenType==TK_FILTER 
            || tokenType==TK_ILLEGAL || tokenType==TK_WINDOW
-      );
-#else
+      ); 
+#else 
     if( tokenType>=TK_SPACE ){
       assert( tokenType==TK_SPACE || tokenType==TK_ILLEGAL );
-#endif /* SQLITE_OMIT_WINDOWFUNC */
+#endif /* SQLITE_OMIT_WINDOWFUNC */ 
       if( AtomicLoad(&db->u1.isInterrupted) ){
         pParse->rc = SQLITE_INTERRUPT;
         break;
       }
-      if( tokenType==TK_SPACE ){
-        zSql += n;
-        continue;
-      }
-      if( zSql[0]==0 ){
-        /* Upon reaching the end of input, call the parser two more times
-        ** with tokens TK_SEMI and 0, in that order. */
-        if( lastTokenParsed==TK_SEMI ){
-          tokenType = 0;
-        }else if( lastTokenParsed==0 ){
-          break;
-        }else{
-          tokenType = TK_SEMI;
-        }
-        n = 0;
-#ifndef SQLITE_OMIT_WINDOWFUNC
-      }else if( tokenType==TK_WINDOW ){
-        assert( n==6 );
-        tokenType = analyzeWindowKeyword((const u8*)&zSql[6]);
-      }else if( tokenType==TK_OVER ){
-        assert( n==4 );
-        tokenType = analyzeOverKeyword((const u8*)&zSql[4], lastTokenParsed);
-      }else if( tokenType==TK_FILTER ){
-        assert( n==6 );
-        tokenType = analyzeFilterKeyword((const u8*)&zSql[6], lastTokenParsed);
-#endif /* SQLITE_OMIT_WINDOWFUNC */
-      }else{
+      if( tokenType==TK_SPACE ){ 
+        zSql += n; 
+        continue; 
+      } 
+      if( zSql[0]==0 ){ 
+        /* Upon reaching the end of input, call the parser two more times 
+        ** with tokens TK_SEMI and 0, in that order. */ 
+        if( lastTokenParsed==TK_SEMI ){ 
+          tokenType = 0; 
+        }else if( lastTokenParsed==0 ){ 
+          break; 
+        }else{ 
+          tokenType = TK_SEMI; 
+        } 
+        n = 0; 
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+      }else if( tokenType==TK_WINDOW ){ 
+        assert( n==6 ); 
+        tokenType = analyzeWindowKeyword((const u8*)&zSql[6]); 
+      }else if( tokenType==TK_OVER ){ 
+        assert( n==4 ); 
+        tokenType = analyzeOverKeyword((const u8*)&zSql[4], lastTokenParsed); 
+      }else if( tokenType==TK_FILTER ){ 
+        assert( n==6 ); 
+        tokenType = analyzeFilterKeyword((const u8*)&zSql[6], lastTokenParsed); 
+#endif /* SQLITE_OMIT_WINDOWFUNC */ 
+      }else{ 
         sqlite3ErrorMsg(pParse, "unrecognized token: \"%.*s\"", n, zSql);
         break;
       }
     }
-    pParse->sLastToken.z = zSql;
-    pParse->sLastToken.n = n;
-    sqlite3Parser(pEngine, tokenType, pParse->sLastToken);
-    lastTokenParsed = tokenType;
-    zSql += n;
-    assert( db->mallocFailed==0 || pParse->rc!=SQLITE_OK || startedWithOom );
-    if( pParse->rc!=SQLITE_OK ) break;
+    pParse->sLastToken.z = zSql; 
+    pParse->sLastToken.n = n; 
+    sqlite3Parser(pEngine, tokenType, pParse->sLastToken); 
+    lastTokenParsed = tokenType; 
+    zSql += n; 
+    assert( db->mallocFailed==0 || pParse->rc!=SQLITE_OK || startedWithOom ); 
+    if( pParse->rc!=SQLITE_OK ) break; 
   }
   assert( nErr==0 );
 #ifdef YYTRACKMAXSTACKDEPTH
@@ -166044,11 +166044,11 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzEr
   if( pParse->zErrMsg ){
     *pzErrMsg = pParse->zErrMsg;
     sqlite3_log(pParse->rc, "%s in \"%s\"",
-                *pzErrMsg, pParse->zTail);
+                *pzErrMsg, pParse->zTail); 
     pParse->zErrMsg = 0;
     nErr++;
   }
-  pParse->zTail = zSql;
+  pParse->zTail = zSql; 
   if( pParse->pVdbe && pParse->nErr>0 && pParse->nested==0 ){
     sqlite3VdbeDelete(pParse->pVdbe);
     pParse->pVdbe = 0;
@@ -166064,157 +166064,157 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzEr
   sqlite3_free(pParse->apVtabLock);
 #endif
 
-  if( !IN_SPECIAL_PARSE ){
+  if( !IN_SPECIAL_PARSE ){ 
     /* If the pParse->declareVtab flag is set, do not delete any table
     ** structure built up in pParse->pNewTable. The calling code (see vtab.c)
     ** will take responsibility for freeing the Table structure.
     */
     sqlite3DeleteTable(db, pParse->pNewTable);
   }
-  if( !IN_RENAME_OBJECT ){
-    sqlite3DeleteTrigger(db, pParse->pNewTrigger);
-  }
+  if( !IN_RENAME_OBJECT ){ 
+    sqlite3DeleteTrigger(db, pParse->pNewTrigger); 
+  } 
   sqlite3DbFree(db, pParse->pVList);
   db->pParse = pParentParse;
   assert( nErr==0 || pParse->rc!=SQLITE_OK );
   return nErr;
 }
 
-
-#ifdef SQLITE_ENABLE_NORMALIZE
-/*
-** Insert a single space character into pStr if the current string
-** ends with an identifier
-*/
-static void addSpaceSeparator(sqlite3_str *pStr){
-  if( pStr->nChar && sqlite3IsIdChar(pStr->zText[pStr->nChar-1]) ){
-    sqlite3_str_append(pStr, " ", 1);
-  }
-}
-
-/*
-** Compute a normalization of the SQL given by zSql[0..nSql-1].  Return
-** the normalization in space obtained from sqlite3DbMalloc().  Or return
-** NULL if anything goes wrong or if zSql is NULL.
-*/
-SQLITE_PRIVATE char *sqlite3Normalize(
-  Vdbe *pVdbe,       /* VM being reprepared */
-  const char *zSql   /* The original SQL string */
-){
-  sqlite3 *db;       /* The database connection */
-  int i;             /* Next unread byte of zSql[] */
-  int n;             /* length of current token */
-  int tokenType;     /* type of current token */
-  int prevType = 0;  /* Previous non-whitespace token */
-  int nParen;        /* Number of nested levels of parentheses */
-  int iStartIN;      /* Start of RHS of IN operator in z[] */
-  int nParenAtIN;    /* Value of nParent at start of RHS of IN operator */
+ 
+#ifdef SQLITE_ENABLE_NORMALIZE 
+/* 
+** Insert a single space character into pStr if the current string 
+** ends with an identifier 
+*/ 
+static void addSpaceSeparator(sqlite3_str *pStr){ 
+  if( pStr->nChar && sqlite3IsIdChar(pStr->zText[pStr->nChar-1]) ){ 
+    sqlite3_str_append(pStr, " ", 1); 
+  } 
+} 
+ 
+/* 
+** Compute a normalization of the SQL given by zSql[0..nSql-1].  Return 
+** the normalization in space obtained from sqlite3DbMalloc().  Or return 
+** NULL if anything goes wrong or if zSql is NULL. 
+*/ 
+SQLITE_PRIVATE char *sqlite3Normalize( 
+  Vdbe *pVdbe,       /* VM being reprepared */ 
+  const char *zSql   /* The original SQL string */ 
+){ 
+  sqlite3 *db;       /* The database connection */ 
+  int i;             /* Next unread byte of zSql[] */ 
+  int n;             /* length of current token */ 
+  int tokenType;     /* type of current token */ 
+  int prevType = 0;  /* Previous non-whitespace token */ 
+  int nParen;        /* Number of nested levels of parentheses */ 
+  int iStartIN;      /* Start of RHS of IN operator in z[] */ 
+  int nParenAtIN;    /* Value of nParent at start of RHS of IN operator */ 
   u32 j;             /* Bytes of normalized SQL generated so far */
-  sqlite3_str *pStr; /* The normalized SQL string under construction */
-
-  db = sqlite3VdbeDb(pVdbe);
-  tokenType = -1;
-  nParen = iStartIN = nParenAtIN = 0;
-  pStr = sqlite3_str_new(db);
-  assert( pStr!=0 );  /* sqlite3_str_new() never returns NULL */
-  for(i=0; zSql[i] && pStr->accError==0; i+=n){
-    if( tokenType!=TK_SPACE ){
-      prevType = tokenType;
-    }
-    n = sqlite3GetToken((unsigned char*)zSql+i, &tokenType);
-    if( NEVER(n<=0) ) break;
-    switch( tokenType ){
-      case TK_SPACE: {
-        break;
-      }
-      case TK_NULL: {
-        if( prevType==TK_IS || prevType==TK_NOT ){
-          sqlite3_str_append(pStr, " NULL", 5);
-          break;
-        }
-        /* Fall through */
-      }
-      case TK_STRING:
-      case TK_INTEGER:
-      case TK_FLOAT:
-      case TK_VARIABLE:
-      case TK_BLOB: {
-        sqlite3_str_append(pStr, "?", 1);
-        break;
-      }
-      case TK_LP: {
-        nParen++;
-        if( prevType==TK_IN ){
-          iStartIN = pStr->nChar;
-          nParenAtIN = nParen;
-        }
-        sqlite3_str_append(pStr, "(", 1);
-        break;
-      }
-      case TK_RP: {
-        if( iStartIN>0 && nParen==nParenAtIN ){
+  sqlite3_str *pStr; /* The normalized SQL string under construction */ 
+ 
+  db = sqlite3VdbeDb(pVdbe); 
+  tokenType = -1; 
+  nParen = iStartIN = nParenAtIN = 0; 
+  pStr = sqlite3_str_new(db); 
+  assert( pStr!=0 );  /* sqlite3_str_new() never returns NULL */ 
+  for(i=0; zSql[i] && pStr->accError==0; i+=n){ 
+    if( tokenType!=TK_SPACE ){ 
+      prevType = tokenType; 
+    } 
+    n = sqlite3GetToken((unsigned char*)zSql+i, &tokenType); 
+    if( NEVER(n<=0) ) break; 
+    switch( tokenType ){ 
+      case TK_SPACE: { 
+        break; 
+      } 
+      case TK_NULL: { 
+        if( prevType==TK_IS || prevType==TK_NOT ){ 
+          sqlite3_str_append(pStr, " NULL", 5); 
+          break; 
+        } 
+        /* Fall through */ 
+      } 
+      case TK_STRING: 
+      case TK_INTEGER: 
+      case TK_FLOAT: 
+      case TK_VARIABLE: 
+      case TK_BLOB: { 
+        sqlite3_str_append(pStr, "?", 1); 
+        break; 
+      } 
+      case TK_LP: { 
+        nParen++; 
+        if( prevType==TK_IN ){ 
+          iStartIN = pStr->nChar; 
+          nParenAtIN = nParen; 
+        } 
+        sqlite3_str_append(pStr, "(", 1); 
+        break; 
+      } 
+      case TK_RP: { 
+        if( iStartIN>0 && nParen==nParenAtIN ){ 
           assert( pStr->nChar>=(u32)iStartIN );
-          pStr->nChar = iStartIN+1;
-          sqlite3_str_append(pStr, "?,?,?", 5);
-          iStartIN = 0;
-        }
-        nParen--;
-        sqlite3_str_append(pStr, ")", 1);
-        break;
-      }
-      case TK_ID: {
-        iStartIN = 0;
-        j = pStr->nChar;
-        if( sqlite3Isquote(zSql[i]) ){
-          char *zId = sqlite3DbStrNDup(db, zSql+i, n);
-          int nId;
-          int eType = 0;
-          if( zId==0 ) break;
-          sqlite3Dequote(zId);
-          if( zSql[i]=='"' && sqlite3VdbeUsesDoubleQuotedString(pVdbe, zId) ){
-            sqlite3_str_append(pStr, "?", 1);
-            sqlite3DbFree(db, zId);
-            break;
-          }
-          nId = sqlite3Strlen30(zId);
-          if( sqlite3GetToken((u8*)zId, &eType)==nId && eType==TK_ID ){
-            addSpaceSeparator(pStr);
-            sqlite3_str_append(pStr, zId, nId);
-          }else{
-            sqlite3_str_appendf(pStr, "\"%w\"", zId);
-          }
-          sqlite3DbFree(db, zId);
-        }else{
-          addSpaceSeparator(pStr);
-          sqlite3_str_append(pStr, zSql+i, n);
-        }
-        while( j<pStr->nChar ){
-          pStr->zText[j] = sqlite3Tolower(pStr->zText[j]);
-          j++;
-        }
-        break;
-      }
-      case TK_SELECT: {
-        iStartIN = 0;
-        /* fall through */
-      }
-      default: {
-        if( sqlite3IsIdChar(zSql[i]) ) addSpaceSeparator(pStr);
-        j = pStr->nChar;
-        sqlite3_str_append(pStr, zSql+i, n);
-        while( j<pStr->nChar ){
-          pStr->zText[j] = sqlite3Toupper(pStr->zText[j]);
-          j++;
-        }
-        break;
-      }
-    }
-  }
-  if( tokenType!=TK_SEMI ) sqlite3_str_append(pStr, ";", 1);
-  return sqlite3_str_finish(pStr);
-}
-#endif /* SQLITE_ENABLE_NORMALIZE */
-
+          pStr->nChar = iStartIN+1; 
+          sqlite3_str_append(pStr, "?,?,?", 5); 
+          iStartIN = 0; 
+        } 
+        nParen--; 
+        sqlite3_str_append(pStr, ")", 1); 
+        break; 
+      } 
+      case TK_ID: { 
+        iStartIN = 0; 
+        j = pStr->nChar; 
+        if( sqlite3Isquote(zSql[i]) ){ 
+          char *zId = sqlite3DbStrNDup(db, zSql+i, n); 
+          int nId; 
+          int eType = 0; 
+          if( zId==0 ) break; 
+          sqlite3Dequote(zId); 
+          if( zSql[i]=='"' && sqlite3VdbeUsesDoubleQuotedString(pVdbe, zId) ){ 
+            sqlite3_str_append(pStr, "?", 1); 
+            sqlite3DbFree(db, zId); 
+            break; 
+          } 
+          nId = sqlite3Strlen30(zId); 
+          if( sqlite3GetToken((u8*)zId, &eType)==nId && eType==TK_ID ){ 
+            addSpaceSeparator(pStr); 
+            sqlite3_str_append(pStr, zId, nId); 
+          }else{ 
+            sqlite3_str_appendf(pStr, "\"%w\"", zId); 
+          } 
+          sqlite3DbFree(db, zId); 
+        }else{ 
+          addSpaceSeparator(pStr); 
+          sqlite3_str_append(pStr, zSql+i, n); 
+        } 
+        while( j<pStr->nChar ){ 
+          pStr->zText[j] = sqlite3Tolower(pStr->zText[j]); 
+          j++; 
+        } 
+        break; 
+      } 
+      case TK_SELECT: { 
+        iStartIN = 0; 
+        /* fall through */ 
+      } 
+      default: { 
+        if( sqlite3IsIdChar(zSql[i]) ) addSpaceSeparator(pStr); 
+        j = pStr->nChar; 
+        sqlite3_str_append(pStr, zSql+i, n); 
+        while( j<pStr->nChar ){ 
+          pStr->zText[j] = sqlite3Toupper(pStr->zText[j]); 
+          j++; 
+        } 
+        break; 
+      } 
+    } 
+  } 
+  if( tokenType!=TK_SEMI ) sqlite3_str_append(pStr, ";", 1); 
+  return sqlite3_str_finish(pStr); 
+} 
+#endif /* SQLITE_ENABLE_NORMALIZE */ 
+ 
 /************** End of tokenize.c ********************************************/
 /************** Begin file complete.c ****************************************/
 /*
@@ -166913,10 +166913,10 @@ SQLITE_API int sqlite3_initialize(void){
     }
 #ifndef SQLITE_OMIT_DESERIALIZE
     if( rc==SQLITE_OK ){
-      rc = sqlite3MemdbInit();
-    }
-#endif
-    if( rc==SQLITE_OK ){
+      rc = sqlite3MemdbInit(); 
+    } 
+#endif 
+    if( rc==SQLITE_OK ){ 
       sqlite3PCacheBufferSetup( sqlite3GlobalConfig.pPage,
           sqlite3GlobalConfig.szPage, sqlite3GlobalConfig.nPage);
       sqlite3MemoryBarrier();
@@ -166949,7 +166949,7 @@ SQLITE_API int sqlite3_initialize(void){
 #ifndef NDEBUG
 #ifndef SQLITE_OMIT_FLOATING_POINT
   /* This section of code's only "output" is via assert() statements. */
-  if( rc==SQLITE_OK ){
+  if( rc==SQLITE_OK ){ 
     u64 x = (((u64)1)<<63)-1;
     double y;
     assert(sizeof(x)==8);
@@ -167315,24 +167315,24 @@ SQLITE_API int sqlite3_config(int op, ...){
       break;
     }
 
-#ifdef SQLITE_ENABLE_SORTER_REFERENCES
-    case SQLITE_CONFIG_SORTERREF_SIZE: {
-      int iVal = va_arg(ap, int);
-      if( iVal<0 ){
-        iVal = SQLITE_DEFAULT_SORTERREF_SIZE;
-      }
-      sqlite3GlobalConfig.szSorterRef = (u32)iVal;
-      break;
-    }
-#endif /* SQLITE_ENABLE_SORTER_REFERENCES */
-
+#ifdef SQLITE_ENABLE_SORTER_REFERENCES 
+    case SQLITE_CONFIG_SORTERREF_SIZE: { 
+      int iVal = va_arg(ap, int); 
+      if( iVal<0 ){ 
+        iVal = SQLITE_DEFAULT_SORTERREF_SIZE; 
+      } 
+      sqlite3GlobalConfig.szSorterRef = (u32)iVal; 
+      break; 
+    } 
+#endif /* SQLITE_ENABLE_SORTER_REFERENCES */ 
+ 
 #ifndef SQLITE_OMIT_DESERIALIZE
-    case SQLITE_CONFIG_MEMDB_MAXSIZE: {
-      sqlite3GlobalConfig.mxMemdbSize = va_arg(ap, sqlite3_int64);
-      break;
-    }
+    case SQLITE_CONFIG_MEMDB_MAXSIZE: { 
+      sqlite3GlobalConfig.mxMemdbSize = va_arg(ap, sqlite3_int64); 
+      break; 
+    } 
 #endif /* SQLITE_OMIT_DESERIALIZE */
-
+ 
     default: {
       rc = SQLITE_ERROR;
       break;
@@ -167552,13 +167552,13 @@ SQLITE_API int sqlite3_db_config(sqlite3 *db, int op, ...){
         { SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE,      SQLITE_NoCkptOnClose  },
         { SQLITE_DBCONFIG_ENABLE_QPSG,           SQLITE_EnableQPSG     },
         { SQLITE_DBCONFIG_TRIGGER_EQP,           SQLITE_TriggerEQP     },
-        { SQLITE_DBCONFIG_RESET_DATABASE,        SQLITE_ResetDatabase  },
-        { SQLITE_DBCONFIG_DEFENSIVE,             SQLITE_Defensive      },
-        { SQLITE_DBCONFIG_WRITABLE_SCHEMA,       SQLITE_WriteSchema|
-                                                 SQLITE_NoSchemaError  },
-        { SQLITE_DBCONFIG_LEGACY_ALTER_TABLE,    SQLITE_LegacyAlter    },
-        { SQLITE_DBCONFIG_DQS_DDL,               SQLITE_DqsDDL         },
-        { SQLITE_DBCONFIG_DQS_DML,               SQLITE_DqsDML         },
+        { SQLITE_DBCONFIG_RESET_DATABASE,        SQLITE_ResetDatabase  }, 
+        { SQLITE_DBCONFIG_DEFENSIVE,             SQLITE_Defensive      }, 
+        { SQLITE_DBCONFIG_WRITABLE_SCHEMA,       SQLITE_WriteSchema| 
+                                                 SQLITE_NoSchemaError  }, 
+        { SQLITE_DBCONFIG_LEGACY_ALTER_TABLE,    SQLITE_LegacyAlter    }, 
+        { SQLITE_DBCONFIG_DQS_DDL,               SQLITE_DqsDDL         }, 
+        { SQLITE_DBCONFIG_DQS_DML,               SQLITE_DqsDML         }, 
         { SQLITE_DBCONFIG_LEGACY_FILE_FORMAT,    SQLITE_LegacyFileFmt  },
         { SQLITE_DBCONFIG_TRUSTED_SCHEMA,        SQLITE_TrustedSchema  },
       };
@@ -167568,14 +167568,14 @@ SQLITE_API int sqlite3_db_config(sqlite3 *db, int op, ...){
         if( aFlagOp[i].op==op ){
           int onoff = va_arg(ap, int);
           int *pRes = va_arg(ap, int*);
-          u64 oldFlags = db->flags;
+          u64 oldFlags = db->flags; 
           if( onoff>0 ){
             db->flags |= aFlagOp[i].mask;
           }else if( onoff==0 ){
-            db->flags &= ~(u64)aFlagOp[i].mask;
+            db->flags &= ~(u64)aFlagOp[i].mask; 
           }
           if( oldFlags!=db->flags ){
-            sqlite3ExpirePreparedStatements(db, 0);
+            sqlite3ExpirePreparedStatements(db, 0); 
           }
           if( pRes ){
             *pRes = (db->flags & aFlagOp[i].mask)!=0;
@@ -167596,12 +167596,12 @@ SQLITE_API int sqlite3_db_config(sqlite3 *db, int op, ...){
 ** available.
 */
 static int binCollFunc(
-  void *NotUsed,
+  void *NotUsed, 
   int nKey1, const void *pKey1,
   int nKey2, const void *pKey2
 ){
   int rc, n;
-  UNUSED_PARAMETER(NotUsed);
+  UNUSED_PARAMETER(NotUsed); 
   n = nKey1<nKey2 ? nKey1 : nKey2;
   /* EVIDENCE-OF: R-65033-28449 The built-in BINARY collation compares
   ** strings byte by byte using the memcmp() function from the standard C
@@ -167609,36 +167609,36 @@ static int binCollFunc(
   assert( pKey1 && pKey2 );
   rc = memcmp(pKey1, pKey2, n);
   if( rc==0 ){
-    rc = nKey1 - nKey2;
-  }
-  return rc;
-}
-
-/*
-** This is the collating function named "RTRIM" which is always
-** available.  Ignore trailing spaces.
-*/
-static int rtrimCollFunc(
-  void *pUser,
-  int nKey1, const void *pKey1,
-  int nKey2, const void *pKey2
-){
-  const u8 *pK1 = (const u8*)pKey1;
-  const u8 *pK2 = (const u8*)pKey2;
-  while( nKey1 && pK1[nKey1-1]==' ' ) nKey1--;
-  while( nKey2 && pK2[nKey2-1]==' ' ) nKey2--;
-  return binCollFunc(pUser, nKey1, pKey1, nKey2, pKey2);
-}
-
-/*
-** Return true if CollSeq is the default built-in BINARY.
-*/
-SQLITE_PRIVATE int sqlite3IsBinary(const CollSeq *p){
-  assert( p==0 || p->xCmp!=binCollFunc || strcmp(p->zName,"BINARY")==0 );
-  return p==0 || p->xCmp==binCollFunc;
-}
-
-/*
+    rc = nKey1 - nKey2; 
+  }
+  return rc;
+}
+
+/*
+** This is the collating function named "RTRIM" which is always 
+** available.  Ignore trailing spaces. 
+*/ 
+static int rtrimCollFunc( 
+  void *pUser, 
+  int nKey1, const void *pKey1, 
+  int nKey2, const void *pKey2 
+){ 
+  const u8 *pK1 = (const u8*)pKey1; 
+  const u8 *pK2 = (const u8*)pKey2; 
+  while( nKey1 && pK1[nKey1-1]==' ' ) nKey1--; 
+  while( nKey2 && pK2[nKey2-1]==' ' ) nKey2--; 
+  return binCollFunc(pUser, nKey1, pKey1, nKey2, pKey2); 
+} 
+ 
+/* 
+** Return true if CollSeq is the default built-in BINARY. 
+*/ 
+SQLITE_PRIVATE int sqlite3IsBinary(const CollSeq *p){ 
+  assert( p==0 || p->xCmp!=binCollFunc || strcmp(p->zName,"BINARY")==0 ); 
+  return p==0 || p->xCmp==binCollFunc; 
+} 
+ 
+/* 
 ** Another built-in collating sequence: NOCASE.
 **
 ** This collating sequence is intended to be used for "case independent
@@ -167767,7 +167767,7 @@ static void disconnectAllVtab(sqlite3 *db){
   sqlite3BtreeEnterAll(db);
   for(i=0; i<db->nDb; i++){
     Schema *pSchema = db->aDb[i].pSchema;
-    if( pSchema ){
+    if( pSchema ){ 
       for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){
         Table *pTab = (Table *)sqliteHashData(p);
         if( IsVirtual(pTab) ) sqlite3VtabDisconnect(db, pTab);
@@ -168057,8 +168057,8 @@ SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3 *db, int tripCode){
   sqlite3VtabRollback(db);
   sqlite3EndBenignMalloc();
 
-  if( schemaChange ){
-    sqlite3ExpirePreparedStatements(db, 0);
+  if( schemaChange ){ 
+    sqlite3ExpirePreparedStatements(db, 0); 
     sqlite3ResetAllSchemasOfConnection(db);
   }
   sqlite3BtreeLeaveAll(db);
@@ -168086,7 +168086,7 @@ SQLITE_PRIVATE const char *sqlite3ErrName(int rc){
     switch( rc ){
       case SQLITE_OK:                 zName = "SQLITE_OK";                break;
       case SQLITE_ERROR:              zName = "SQLITE_ERROR";             break;
-      case SQLITE_ERROR_SNAPSHOT:     zName = "SQLITE_ERROR_SNAPSHOT";    break;
+      case SQLITE_ERROR_SNAPSHOT:     zName = "SQLITE_ERROR_SNAPSHOT";    break; 
       case SQLITE_INTERNAL:           zName = "SQLITE_INTERNAL";          break;
       case SQLITE_PERM:               zName = "SQLITE_PERM";              break;
       case SQLITE_ABORT:              zName = "SQLITE_ABORT";             break;
@@ -168223,8 +168223,8 @@ SQLITE_PRIVATE const char *sqlite3ErrStr(int rc){
     /* SQLITE_FORMAT      */ 0,
     /* SQLITE_RANGE       */ "column index out of range",
     /* SQLITE_NOTADB      */ "file is not a database",
-    /* SQLITE_NOTICE      */ "notification message",
-    /* SQLITE_WARNING     */ "warning message",
+    /* SQLITE_NOTICE      */ "notification message", 
+    /* SQLITE_WARNING     */ "warning message", 
   };
   const char *zErr = "unknown error";
   switch( rc ){
@@ -168232,14 +168232,14 @@ SQLITE_PRIVATE const char *sqlite3ErrStr(int rc){
       zErr = "abort due to ROLLBACK";
       break;
     }
-    case SQLITE_ROW: {
-      zErr = "another row available";
-      break;
-    }
-    case SQLITE_DONE: {
-      zErr = "no more rows available";
-      break;
-    }
+    case SQLITE_ROW: { 
+      zErr = "another row available"; 
+      break; 
+    } 
+    case SQLITE_DONE: { 
+      zErr = "no more rows available"; 
+      break; 
+    } 
     default: {
       rc &= 0xff;
       if( ALWAYS(rc>=0) && rc<ArraySize(aMsg) && aMsg[rc]!=0 ){
@@ -168256,24 +168256,24 @@ SQLITE_PRIVATE const char *sqlite3ErrStr(int rc){
 ** again until a timeout value is reached.  The timeout value is
 ** an integer number of milliseconds passed in as the first
 ** argument.
-**
-** Return non-zero to retry the lock.  Return zero to stop trying
-** and cause SQLite to return SQLITE_BUSY.
+** 
+** Return non-zero to retry the lock.  Return zero to stop trying 
+** and cause SQLite to return SQLITE_BUSY. 
 */
 static int sqliteDefaultBusyCallback(
-  void *ptr,               /* Database connection */
+  void *ptr,               /* Database connection */ 
   int count                /* Number of times table has been busy */
 ){
 #if SQLITE_OS_WIN || HAVE_USLEEP
-  /* This case is for systems that have support for sleeping for fractions of
-  ** a second.  Examples:  All windows systems, unix systems with usleep() */
+  /* This case is for systems that have support for sleeping for fractions of 
+  ** a second.  Examples:  All windows systems, unix systems with usleep() */ 
   static const u8 delays[] =
      { 1, 2, 5, 10, 15, 20, 25, 25,  25,  50,  50, 100 };
   static const u8 totals[] =
      { 0, 1, 3,  8, 18, 33, 53, 78, 103, 128, 178, 228 };
 # define NDELAY ArraySize(delays)
   sqlite3 *db = (sqlite3 *)ptr;
-  int tmout = db->busyTimeout;
+  int tmout = db->busyTimeout; 
   int delay, prior;
 
   assert( count>=0 );
@@ -168284,18 +168284,18 @@ static int sqliteDefaultBusyCallback(
     delay = delays[NDELAY-1];
     prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));
   }
-  if( prior + delay > tmout ){
-    delay = tmout - prior;
+  if( prior + delay > tmout ){ 
+    delay = tmout - prior; 
     if( delay<=0 ) return 0;
   }
   sqlite3OsSleep(db->pVfs, delay*1000);
   return 1;
 #else
-  /* This case for unix systems that lack usleep() support.  Sleeping
-  ** must be done in increments of whole seconds */
+  /* This case for unix systems that lack usleep() support.  Sleeping 
+  ** must be done in increments of whole seconds */ 
   sqlite3 *db = (sqlite3 *)ptr;
-  int tmout = ((sqlite3 *)ptr)->busyTimeout;
-  if( (count+1)*1000 > tmout ){
+  int tmout = ((sqlite3 *)ptr)->busyTimeout; 
+  if( (count+1)*1000 > tmout ){ 
     return 0;
   }
   sqlite3OsSleep(db->pVfs, 1000000);
@@ -168306,15 +168306,15 @@ static int sqliteDefaultBusyCallback(
 /*
 ** Invoke the given busy handler.
 **
-** This routine is called when an operation failed to acquire a
-** lock on VFS file pFile.
-**
+** This routine is called when an operation failed to acquire a 
+** lock on VFS file pFile. 
+** 
 ** If this routine returns non-zero, the lock is retried.  If it
 ** returns 0, the operation aborts with an SQLITE_BUSY error.
 */
 SQLITE_PRIVATE int sqlite3InvokeBusyHandler(BusyHandler *p){
   int rc;
-  if( p->xBusyHandler==0 || p->nBusy<0 ) return 0;
+  if( p->xBusyHandler==0 || p->nBusy<0 ) return 0; 
   rc = p->xBusyHandler(p->pBusyArg, p->nBusy);
   if( rc==0 ){
     p->nBusy = -1;
@@ -168337,8 +168337,8 @@ SQLITE_API int sqlite3_busy_handler(
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 #endif
   sqlite3_mutex_enter(db->mutex);
-  db->busyHandler.xBusyHandler = xBusy;
-  db->busyHandler.pBusyArg = pArg;
+  db->busyHandler.xBusyHandler = xBusy; 
+  db->busyHandler.pBusyArg = pArg; 
   db->busyHandler.nBusy = 0;
   db->busyTimeout = 0;
   sqlite3_mutex_leave(db->mutex);
@@ -168387,8 +168387,8 @@ SQLITE_API int sqlite3_busy_timeout(sqlite3 *db, int ms){
   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
 #endif
   if( ms>0 ){
-    sqlite3_busy_handler(db, (int(*)(void*,int))sqliteDefaultBusyCallback,
-                             (void*)db);
+    sqlite3_busy_handler(db, (int(*)(void*,int))sqliteDefaultBusyCallback, 
+                             (void*)db); 
     db->busyTimeout = ms;
   }else{
     sqlite3_busy_handler(db, 0, 0);
@@ -168425,22 +168425,22 @@ SQLITE_PRIVATE int sqlite3CreateFunc(
   void (*xSFunc)(sqlite3_context*,int,sqlite3_value **),
   void (*xStep)(sqlite3_context*,int,sqlite3_value **),
   void (*xFinal)(sqlite3_context*),
-  void (*xValue)(sqlite3_context*),
-  void (*xInverse)(sqlite3_context*,int,sqlite3_value **),
+  void (*xValue)(sqlite3_context*), 
+  void (*xInverse)(sqlite3_context*,int,sqlite3_value **), 
   FuncDestructor *pDestructor
 ){
   FuncDef *p;
   int extraFlags;
 
   assert( sqlite3_mutex_held(db->mutex) );
-  assert( xValue==0 || xSFunc==0 );
-  if( zFunctionName==0                /* Must have a valid name */
-   || (xSFunc!=0 && xFinal!=0)        /* Not both xSFunc and xFinal */
-   || ((xFinal==0)!=(xStep==0))       /* Both or neither of xFinal and xStep */
-   || ((xValue==0)!=(xInverse==0))    /* Both or neither of xValue, xInverse */
-   || (nArg<-1 || nArg>SQLITE_MAX_FUNCTION_ARG)
+  assert( xValue==0 || xSFunc==0 ); 
+  if( zFunctionName==0                /* Must have a valid name */ 
+   || (xSFunc!=0 && xFinal!=0)        /* Not both xSFunc and xFinal */ 
+   || ((xFinal==0)!=(xStep==0))       /* Both or neither of xFinal and xStep */ 
+   || ((xValue==0)!=(xInverse==0))    /* Both or neither of xValue, xInverse */ 
+   || (nArg<-1 || nArg>SQLITE_MAX_FUNCTION_ARG) 
    || (255<sqlite3Strlen30(zFunctionName))
-  ){
+  ){ 
     return SQLITE_MISUSE_BKPT;
   }
 
@@ -168502,14 +168502,14 @@ SQLITE_PRIVATE int sqlite3CreateFunc(
   ** operation to continue but invalidate all precompiled statements.
   */
   p = sqlite3FindFunction(db, zFunctionName, nArg, (u8)enc, 0);
-  if( p && (p->funcFlags & SQLITE_FUNC_ENCMASK)==(u32)enc && p->nArg==nArg ){
+  if( p && (p->funcFlags & SQLITE_FUNC_ENCMASK)==(u32)enc && p->nArg==nArg ){ 
     if( db->nVdbeActive ){
       sqlite3ErrorWithMsg(db, SQLITE_BUSY,
         "unable to delete/modify user-function due to active statements");
       assert( !db->mallocFailed );
       return SQLITE_BUSY;
     }else{
-      sqlite3ExpirePreparedStatements(db, 0);
+      sqlite3ExpirePreparedStatements(db, 0); 
     }
   }else if( xSFunc==0 && xFinal==0 ){
     /* Trying to delete a function that does not exist.  This is a no-op.
@@ -168536,32 +168536,32 @@ SQLITE_PRIVATE int sqlite3CreateFunc(
   testcase( p->funcFlags & SQLITE_DIRECTONLY );
   p->xSFunc = xSFunc ? xSFunc : xStep;
   p->xFinalize = xFinal;
-  p->xValue = xValue;
-  p->xInverse = xInverse;
+  p->xValue = xValue; 
+  p->xInverse = xInverse; 
   p->pUserData = pUserData;
   p->nArg = (u16)nArg;
   return SQLITE_OK;
 }
 
 /*
-** Worker function used by utf-8 APIs that create new functions:
-**
-**    sqlite3_create_function()
-**    sqlite3_create_function_v2()
-**    sqlite3_create_window_function()
+** Worker function used by utf-8 APIs that create new functions: 
+** 
+**    sqlite3_create_function() 
+**    sqlite3_create_function_v2() 
+**    sqlite3_create_window_function() 
 */
-static int createFunctionApi(
+static int createFunctionApi( 
   sqlite3 *db,
   const char *zFunc,
   int nArg,
   int enc,
   void *p,
-  void (*xSFunc)(sqlite3_context*,int,sqlite3_value**),
-  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
+  void (*xSFunc)(sqlite3_context*,int,sqlite3_value**), 
+  void (*xStep)(sqlite3_context*,int,sqlite3_value**), 
   void (*xFinal)(sqlite3_context*),
-  void (*xValue)(sqlite3_context*),
-  void (*xInverse)(sqlite3_context*,int,sqlite3_value**),
-  void(*xDestroy)(void*)
+  void (*xValue)(sqlite3_context*), 
+  void (*xInverse)(sqlite3_context*,int,sqlite3_value**), 
+  void(*xDestroy)(void*) 
 ){
   int rc = SQLITE_ERROR;
   FuncDestructor *pArg = 0;
@@ -168573,23 +168573,23 @@ static int createFunctionApi(
 #endif
   sqlite3_mutex_enter(db->mutex);
   if( xDestroy ){
-    pArg = (FuncDestructor *)sqlite3Malloc(sizeof(FuncDestructor));
+    pArg = (FuncDestructor *)sqlite3Malloc(sizeof(FuncDestructor)); 
     if( !pArg ){
-      sqlite3OomFault(db);
+      sqlite3OomFault(db); 
       xDestroy(p);
       goto out;
     }
-    pArg->nRef = 0;
+    pArg->nRef = 0; 
     pArg->xDestroy = xDestroy;
     pArg->pUserData = p;
   }
   rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p,
-      xSFunc, xStep, xFinal, xValue, xInverse, pArg
-  );
+      xSFunc, xStep, xFinal, xValue, xInverse, pArg 
+  ); 
   if( pArg && pArg->nRef==0 ){
     assert( rc!=SQLITE_OK || (xStep==0 && xFinal==0) );
     xDestroy(p);
-    sqlite3_free(pArg);
+    sqlite3_free(pArg); 
   }
 
  out:
@@ -168598,52 +168598,52 @@ static int createFunctionApi(
   return rc;
 }
 
-/*
-** Create new user functions.
-*/
-SQLITE_API int sqlite3_create_function(
-  sqlite3 *db,
-  const char *zFunc,
-  int nArg,
-  int enc,
-  void *p,
-  void (*xSFunc)(sqlite3_context*,int,sqlite3_value **),
-  void (*xStep)(sqlite3_context*,int,sqlite3_value **),
-  void (*xFinal)(sqlite3_context*)
-){
-  return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep,
-                                    xFinal, 0, 0, 0);
-}
-SQLITE_API int sqlite3_create_function_v2(
-  sqlite3 *db,
-  const char *zFunc,
-  int nArg,
-  int enc,
-  void *p,
-  void (*xSFunc)(sqlite3_context*,int,sqlite3_value **),
-  void (*xStep)(sqlite3_context*,int,sqlite3_value **),
-  void (*xFinal)(sqlite3_context*),
-  void (*xDestroy)(void *)
-){
-  return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep,
-                                    xFinal, 0, 0, xDestroy);
-}
-SQLITE_API int sqlite3_create_window_function(
-  sqlite3 *db,
-  const char *zFunc,
-  int nArg,
-  int enc,
-  void *p,
-  void (*xStep)(sqlite3_context*,int,sqlite3_value **),
-  void (*xFinal)(sqlite3_context*),
-  void (*xValue)(sqlite3_context*),
-  void (*xInverse)(sqlite3_context*,int,sqlite3_value **),
-  void (*xDestroy)(void *)
-){
-  return createFunctionApi(db, zFunc, nArg, enc, p, 0, xStep,
-                                    xFinal, xValue, xInverse, xDestroy);
-}
-
+/* 
+** Create new user functions. 
+*/ 
+SQLITE_API int sqlite3_create_function( 
+  sqlite3 *db, 
+  const char *zFunc, 
+  int nArg, 
+  int enc, 
+  void *p, 
+  void (*xSFunc)(sqlite3_context*,int,sqlite3_value **), 
+  void (*xStep)(sqlite3_context*,int,sqlite3_value **), 
+  void (*xFinal)(sqlite3_context*) 
+){ 
+  return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep, 
+                                    xFinal, 0, 0, 0); 
+} 
+SQLITE_API int sqlite3_create_function_v2( 
+  sqlite3 *db, 
+  const char *zFunc, 
+  int nArg, 
+  int enc, 
+  void *p, 
+  void (*xSFunc)(sqlite3_context*,int,sqlite3_value **), 
+  void (*xStep)(sqlite3_context*,int,sqlite3_value **), 
+  void (*xFinal)(sqlite3_context*), 
+  void (*xDestroy)(void *) 
+){ 
+  return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep, 
+                                    xFinal, 0, 0, xDestroy); 
+} 
+SQLITE_API int sqlite3_create_window_function( 
+  sqlite3 *db, 
+  const char *zFunc, 
+  int nArg, 
+  int enc, 
+  void *p, 
+  void (*xStep)(sqlite3_context*,int,sqlite3_value **), 
+  void (*xFinal)(sqlite3_context*), 
+  void (*xValue)(sqlite3_context*), 
+  void (*xInverse)(sqlite3_context*,int,sqlite3_value **), 
+  void (*xDestroy)(void *) 
+){ 
+  return createFunctionApi(db, zFunc, nArg, enc, p, 0, xStep, 
+                                    xFinal, xValue, xInverse, xDestroy); 
+} 
+ 
 #ifndef SQLITE_OMIT_UTF16
 SQLITE_API int sqlite3_create_function16(
   sqlite3 *db,
@@ -168664,7 +168664,7 @@ SQLITE_API int sqlite3_create_function16(
   sqlite3_mutex_enter(db->mutex);
   assert( !db->mallocFailed );
   zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1, SQLITE_UTF16NATIVE);
-  rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xSFunc,xStep,xFinal,0,0,0);
+  rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xSFunc,xStep,xFinal,0,0,0); 
   sqlite3DbFree(db, zFunc8);
   rc = sqlite3ApiExit(db, rc);
   sqlite3_mutex_leave(db->mutex);
@@ -168674,28 +168674,28 @@ SQLITE_API int sqlite3_create_function16(
 
 
 /*
-** The following is the implementation of an SQL function that always
-** fails with an error message stating that the function is used in the
-** wrong context.  The sqlite3_overload_function() API might construct
-** SQL function that use this routine so that the functions will exist
-** for name resolution but are actually overloaded by the xFindFunction
-** method of virtual tables.
-*/
-static void sqlite3InvalidFunction(
-  sqlite3_context *context,  /* The function calling context */
-  int NotUsed,               /* Number of arguments to the function */
-  sqlite3_value **NotUsed2   /* Value of each argument */
-){
-  const char *zName = (const char*)sqlite3_user_data(context);
-  char *zErr;
-  UNUSED_PARAMETER2(NotUsed, NotUsed2);
-  zErr = sqlite3_mprintf(
-      "unable to use function %s in the requested context", zName);
-  sqlite3_result_error(context, zErr, -1);
-  sqlite3_free(zErr);
-}
-
-/*
+** The following is the implementation of an SQL function that always 
+** fails with an error message stating that the function is used in the 
+** wrong context.  The sqlite3_overload_function() API might construct 
+** SQL function that use this routine so that the functions will exist 
+** for name resolution but are actually overloaded by the xFindFunction 
+** method of virtual tables. 
+*/ 
+static void sqlite3InvalidFunction( 
+  sqlite3_context *context,  /* The function calling context */ 
+  int NotUsed,               /* Number of arguments to the function */ 
+  sqlite3_value **NotUsed2   /* Value of each argument */ 
+){ 
+  const char *zName = (const char*)sqlite3_user_data(context); 
+  char *zErr; 
+  UNUSED_PARAMETER2(NotUsed, NotUsed2); 
+  zErr = sqlite3_mprintf( 
+      "unable to use function %s in the requested context", zName); 
+  sqlite3_result_error(context, zErr, -1); 
+  sqlite3_free(zErr); 
+} 
+ 
+/* 
 ** Declare that a function has been overloaded by a virtual table.
 **
 ** If the function already exists as a regular global function, then
@@ -168712,8 +168712,8 @@ SQLITE_API int sqlite3_overload_function(
   const char *zName,
   int nArg
 ){
-  int rc;
-  char *zCopy;
+  int rc; 
+  char *zCopy; 
 
 #ifdef SQLITE_ENABLE_API_ARMOR
   if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){
@@ -168721,13 +168721,13 @@ SQLITE_API int sqlite3_overload_function(
   }
 #endif
   sqlite3_mutex_enter(db->mutex);
-  rc = sqlite3FindFunction(db, zName, nArg, SQLITE_UTF8, 0)!=0;
+  rc = sqlite3FindFunction(db, zName, nArg, SQLITE_UTF8, 0)!=0; 
   sqlite3_mutex_leave(db->mutex);
-  if( rc ) return SQLITE_OK;
-  zCopy = sqlite3_mprintf(zName);
-  if( zCopy==0 ) return SQLITE_NOMEM;
-  return sqlite3_create_function_v2(db, zName, nArg, SQLITE_UTF8,
-                           zCopy, sqlite3InvalidFunction, 0, 0, sqlite3_free);
+  if( rc ) return SQLITE_OK; 
+  zCopy = sqlite3_mprintf(zName); 
+  if( zCopy==0 ) return SQLITE_NOMEM; 
+  return sqlite3_create_function_v2(db, zName, nArg, SQLITE_UTF8, 
+                           zCopy, sqlite3InvalidFunction, 0, 0, sqlite3_free); 
 }
 
 #ifndef SQLITE_OMIT_TRACE
@@ -168808,8 +168808,8 @@ SQLITE_API void *sqlite3_profile(
   pOld = db->pProfileArg;
   db->xProfile = xProfile;
   db->pProfileArg = pArg;
-  db->mTrace &= SQLITE_TRACE_NONLEGACY_MASK;
-  if( db->xProfile ) db->mTrace |= SQLITE_TRACE_XPROFILE;
+  db->mTrace &= SQLITE_TRACE_NONLEGACY_MASK; 
+  if( db->xProfile ) db->mTrace |= SQLITE_TRACE_XPROFILE; 
   sqlite3_mutex_leave(db->mutex);
   return pOld;
 }
@@ -169193,7 +169193,7 @@ SQLITE_API const char *sqlite3_errmsg(sqlite3 *db){
     z = sqlite3ErrStr(SQLITE_NOMEM_BKPT);
   }else{
     testcase( db->pErr==0 );
-    z = db->errCode ? (char*)sqlite3_value_text(db->pErr) : 0;
+    z = db->errCode ? (char*)sqlite3_value_text(db->pErr) : 0; 
     assert( !db->mallocFailed );
     if( z==0 ){
       z = sqlite3ErrStr(db->errCode);
@@ -169323,7 +169323,7 @@ static int createCollation(
         "unable to delete/modify collation sequence due to active statements");
       return SQLITE_BUSY;
     }
-    sqlite3ExpirePreparedStatements(db, 0);
+    sqlite3ExpirePreparedStatements(db, 0); 
 
     /* If collation sequence pColl was created directly by a call to
     ** sqlite3_create_collation, and not generated by synthCollSeq(),
@@ -169730,10 +169730,10 @@ SQLITE_PRIVATE int sqlite3ParseUri(
   return rc;
 }
 
-/*
+/* 
 ** This routine does the core work of extracting URI parameters from a
 ** database filename for the sqlite3_uri_parameter() interface.
-*/
+*/ 
 static const char *uriParameter(const char *zFilename, const char *zParam){
   zFilename += sqlite3Strlen30(zFilename) + 1;
   while( ALWAYS(zFilename!=0) && zFilename[0] ){
@@ -169741,11 +169741,11 @@ static const char *uriParameter(const char *zFilename, const char *zParam){
     zFilename += sqlite3Strlen30(zFilename) + 1;
     if( x==0 ) return zFilename;
     zFilename += sqlite3Strlen30(zFilename) + 1;
-  }
+  } 
   return 0;
-}
-
+} 
 
+ 
 
 /*
 ** This routine does the work of opening a database on behalf of
@@ -169836,7 +169836,7 @@ static int openDatabase(
   db->nDb = 2;
   db->eOpenState = SQLITE_STATE_BUSY;
   db->aDb = db->aDbStatic;
-  db->lookaside.bDisable = 1;
+  db->lookaside.bDisable = 1; 
   db->lookaside.sz = 0;
 
   assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
@@ -169855,38 +169855,38 @@ static int openDatabase(
   ** SQLITE_TESTCTRL_SORTER_MMAP test-control at runtime. */
   db->nMaxSorterMmap = 0x7FFFFFFF;
 #endif
-  db->flags |= SQLITE_ShortColNames
-                 | SQLITE_EnableTrigger
+  db->flags |= SQLITE_ShortColNames 
+                 | SQLITE_EnableTrigger 
                  | SQLITE_EnableView
-                 | SQLITE_CacheSpill
+                 | SQLITE_CacheSpill 
 #if !defined(SQLITE_TRUSTED_SCHEMA) || SQLITE_TRUSTED_SCHEMA+0!=0
                  | SQLITE_TrustedSchema
 #endif
-/* The SQLITE_DQS compile-time option determines the default settings
-** for SQLITE_DBCONFIG_DQS_DDL and SQLITE_DBCONFIG_DQS_DML.
-**
-**    SQLITE_DQS     SQLITE_DBCONFIG_DQS_DDL    SQLITE_DBCONFIG_DQS_DML
-**    ----------     -----------------------    -----------------------
+/* The SQLITE_DQS compile-time option determines the default settings 
+** for SQLITE_DBCONFIG_DQS_DDL and SQLITE_DBCONFIG_DQS_DML. 
+** 
+**    SQLITE_DQS     SQLITE_DBCONFIG_DQS_DDL    SQLITE_DBCONFIG_DQS_DML 
+**    ----------     -----------------------    ----------------------- 
 **     undefined               on                          on
-**         3                   on                          on
-**         2                   on                         off
-**         1                  off                          on
-**         0                  off                         off
-**
-** Legacy behavior is 3 (double-quoted string literals are allowed anywhere)
-** and so that is the default.  But developers are encouranged to use
-** -DSQLITE_DQS=0 (best) or -DSQLITE_DQS=1 (second choice) if possible.
-*/
-#if !defined(SQLITE_DQS)
-# define SQLITE_DQS 3
-#endif
-#if (SQLITE_DQS&1)==1
-                 | SQLITE_DqsDML
-#endif
-#if (SQLITE_DQS&2)==2
-                 | SQLITE_DqsDDL
-#endif
-
+**         3                   on                          on 
+**         2                   on                         off 
+**         1                  off                          on 
+**         0                  off                         off 
+** 
+** Legacy behavior is 3 (double-quoted string literals are allowed anywhere) 
+** and so that is the default.  But developers are encouranged to use 
+** -DSQLITE_DQS=0 (best) or -DSQLITE_DQS=1 (second choice) if possible. 
+*/ 
+#if !defined(SQLITE_DQS) 
+# define SQLITE_DQS 3 
+#endif 
+#if (SQLITE_DQS&1)==1 
+                 | SQLITE_DqsDML 
+#endif 
+#if (SQLITE_DQS&2)==2 
+                 | SQLITE_DqsDDL 
+#endif 
+ 
 #if !defined(SQLITE_DEFAULT_AUTOMATIC_INDEX) || SQLITE_DEFAULT_AUTOMATIC_INDEX
                  | SQLITE_AutoIndex
 #endif
@@ -169917,9 +169917,9 @@ static int openDatabase(
 #if defined(SQLITE_ENABLE_QPSG)
                  | SQLITE_EnableQPSG
 #endif
-#if defined(SQLITE_DEFAULT_DEFENSIVE)
-                 | SQLITE_Defensive
-#endif
+#if defined(SQLITE_DEFAULT_DEFENSIVE) 
+                 | SQLITE_Defensive 
+#endif 
 #if defined(SQLITE_DEFAULT_LEGACY_ALTER_TABLE)
                  | SQLITE_LegacyAlter
 #endif
@@ -169940,7 +169940,7 @@ static int openDatabase(
   createCollation(db, sqlite3StrBINARY, SQLITE_UTF16BE, 0, binCollFunc, 0);
   createCollation(db, sqlite3StrBINARY, SQLITE_UTF16LE, 0, binCollFunc, 0);
   createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0);
-  createCollation(db, "RTRIM", SQLITE_UTF8, 0, rtrimCollFunc, 0);
+  createCollation(db, "RTRIM", SQLITE_UTF8, 0, rtrimCollFunc, 0); 
   if( db->mallocFailed ){
     goto opendb_out;
   }
@@ -170083,7 +170083,7 @@ opendb_out:
   return rc;
 }
 
-
+ 
 /*
 ** Open a new database handle.
 */
@@ -170514,9 +170514,9 @@ SQLITE_API int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, vo
     }else if( op==SQLITE_FCNTL_JOURNAL_POINTER ){
       *(sqlite3_file**)pArg = sqlite3PagerJrnlFile(pPager);
       rc = SQLITE_OK;
-    }else if( op==SQLITE_FCNTL_DATA_VERSION ){
-      *(unsigned int*)pArg = sqlite3PagerDataVersion(pPager);
-      rc = SQLITE_OK;
+    }else if( op==SQLITE_FCNTL_DATA_VERSION ){ 
+      *(unsigned int*)pArg = sqlite3PagerDataVersion(pPager); 
+      rc = SQLITE_OK; 
     }else if( op==SQLITE_FCNTL_RESERVE_BYTES ){
       int iNew = *(int*)pArg;
       *(int*)pArg = sqlite3BtreeGetRequestedReserve(pBtree);
@@ -170524,7 +170524,7 @@ SQLITE_API int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, vo
         sqlite3BtreeSetPageSize(pBtree, 0, iNew, 0);
       }
       rc = SQLITE_OK;
-    }else{
+    }else{ 
       int nSave = db->busyHandler.nBusy;
       rc = sqlite3OsFileControl(fd, op, pArg);
       db->busyHandler.nBusy = nSave;
@@ -170757,13 +170757,13 @@ SQLITE_API int sqlite3_test_control(int op, ...){
       break;
     }
 
-    /*   sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, int onoff);
+    /*   sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, int onoff); 
     **
-    ** If parameter onoff is non-zero, subsequent calls to localtime()
-    ** and its variants fail. If onoff is zero, undo this setting.
+    ** If parameter onoff is non-zero, subsequent calls to localtime() 
+    ** and its variants fail. If onoff is zero, undo this setting. 
     */
-    case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
-      sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int);
+    case SQLITE_TESTCTRL_LOCALTIME_FAULT: { 
+      sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int); 
       break;
     }
 
@@ -170772,7 +170772,7 @@ SQLITE_API int sqlite3_test_control(int op, ...){
     ** Toggle the ability to use internal functions on or off for
     ** the database connection given in the argument.
     */
-    case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: {
+    case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: { 
       sqlite3 *db = va_arg(ap, sqlite3*);
       db->mDbFlags ^= DBFLAG_InternalFunc;
       break;
@@ -170825,8 +170825,8 @@ SQLITE_API int sqlite3_test_control(int op, ...){
     */
     case SQLITE_TESTCTRL_VDBE_COVERAGE: {
 #ifdef SQLITE_VDBE_COVERAGE
-      typedef void (*branch_callback)(void*,unsigned int,
-                                      unsigned char,unsigned char);
+      typedef void (*branch_callback)(void*,unsigned int, 
+                                      unsigned char,unsigned char); 
       sqlite3GlobalConfig.xVdbeBranch = va_arg(ap,branch_callback);
       sqlite3GlobalConfig.pVdbeBranchArg = va_arg(ap,void*);
 #endif
@@ -170898,22 +170898,22 @@ SQLITE_API int sqlite3_test_control(int op, ...){
       break;
     }
 #endif /* defined(YYCOVERAGE) */
-
-    /*  sqlite3_test_control(SQLITE_TESTCTRL_RESULT_INTREAL, sqlite3_context*);
-    **
-    ** This test-control causes the most recent sqlite3_result_int64() value
-    ** to be interpreted as a MEM_IntReal instead of as an MEM_Int.  Normally,
-    ** MEM_IntReal values only arise during an INSERT operation of integer
-    ** values into a REAL column, so they can be challenging to test.  This
-    ** test-control enables us to write an intreal() SQL function that can
-    ** inject an intreal() value at arbitrary places in an SQL statement,
-    ** for testing purposes.
-    */
-    case SQLITE_TESTCTRL_RESULT_INTREAL: {
-      sqlite3_context *pCtx = va_arg(ap, sqlite3_context*);
-      sqlite3ResultIntReal(pCtx);
-      break;
-    }
+ 
+    /*  sqlite3_test_control(SQLITE_TESTCTRL_RESULT_INTREAL, sqlite3_context*); 
+    ** 
+    ** This test-control causes the most recent sqlite3_result_int64() value 
+    ** to be interpreted as a MEM_IntReal instead of as an MEM_Int.  Normally, 
+    ** MEM_IntReal values only arise during an INSERT operation of integer 
+    ** values into a REAL column, so they can be challenging to test.  This 
+    ** test-control enables us to write an intreal() SQL function that can 
+    ** inject an intreal() value at arbitrary places in an SQL statement, 
+    ** for testing purposes. 
+    */ 
+    case SQLITE_TESTCTRL_RESULT_INTREAL: { 
+      sqlite3_context *pCtx = va_arg(ap, sqlite3_context*); 
+      sqlite3ResultIntReal(pCtx); 
+      break; 
+    } 
 
     /*  sqlite3_test_control(SQLITE_TESTCTRL_SEEK_COUNT,
     **    sqlite3 *db,    // Database connection
@@ -171220,7 +171220,7 @@ SQLITE_API int sqlite3_snapshot_get(
     if( iDb==0 || iDb>1 ){
       Btree *pBt = db->aDb[iDb].pBt;
       if( SQLITE_TXN_WRITE!=sqlite3BtreeTxnState(pBt) ){
-        rc = sqlite3BtreeBeginTrans(pBt, 0, 0);
+        rc = sqlite3BtreeBeginTrans(pBt, 0, 0); 
         if( rc==SQLITE_OK ){
           rc = sqlite3PagerSnapshotGet(sqlite3BtreePager(pBt), ppSnapshot);
         }
@@ -171256,29 +171256,29 @@ SQLITE_API int sqlite3_snapshot_open(
     if( iDb==0 || iDb>1 ){
       Btree *pBt = db->aDb[iDb].pBt;
       if( sqlite3BtreeTxnState(pBt)!=SQLITE_TXN_WRITE ){
-        Pager *pPager = sqlite3BtreePager(pBt);
-        int bUnlock = 0;
+        Pager *pPager = sqlite3BtreePager(pBt); 
+        int bUnlock = 0; 
         if( sqlite3BtreeTxnState(pBt)!=SQLITE_TXN_NONE ){
-          if( db->nVdbeActive==0 ){
-            rc = sqlite3PagerSnapshotCheck(pPager, pSnapshot);
-            if( rc==SQLITE_OK ){
-              bUnlock = 1;
-              rc = sqlite3BtreeCommit(pBt);
-            }
-          }
-        }else{
-          rc = SQLITE_OK;
-        }
-        if( rc==SQLITE_OK ){
-          rc = sqlite3PagerSnapshotOpen(pPager, pSnapshot);
-        }
+          if( db->nVdbeActive==0 ){ 
+            rc = sqlite3PagerSnapshotCheck(pPager, pSnapshot); 
+            if( rc==SQLITE_OK ){ 
+              bUnlock = 1; 
+              rc = sqlite3BtreeCommit(pBt); 
+            } 
+          } 
+        }else{ 
+          rc = SQLITE_OK; 
+        } 
         if( rc==SQLITE_OK ){
-          rc = sqlite3BtreeBeginTrans(pBt, 0, 0);
-          sqlite3PagerSnapshotOpen(pPager, 0);
-        }
-        if( bUnlock ){
-          sqlite3PagerSnapshotUnlock(pPager);
+          rc = sqlite3PagerSnapshotOpen(pPager, pSnapshot); 
         }
+        if( rc==SQLITE_OK ){ 
+          rc = sqlite3BtreeBeginTrans(pBt, 0, 0); 
+          sqlite3PagerSnapshotOpen(pPager, 0); 
+        } 
+        if( bUnlock ){ 
+          sqlite3PagerSnapshotUnlock(pPager); 
+        } 
       }
     }
   }
@@ -171308,7 +171308,7 @@ SQLITE_API int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb){
   if( iDb==0 || iDb>1 ){
     Btree *pBt = db->aDb[iDb].pBt;
     if( SQLITE_TXN_NONE==sqlite3BtreeTxnState(pBt) ){
-      rc = sqlite3BtreeBeginTrans(pBt, 0, 0);
+      rc = sqlite3BtreeBeginTrans(pBt, 0, 0); 
       if( rc==SQLITE_OK ){
         rc = sqlite3PagerSnapshotRecover(sqlite3BtreePager(pBt));
         sqlite3BtreeCommit(pBt);
@@ -172387,8 +172387,8 @@ SQLITE_PRIVATE Fts3HashElem *sqlite3Fts3HashFindElem(const Fts3Hash *, const voi
 */
 #define FTS3_VARINT_MAX 10
 
-#define FTS3_BUFFER_PADDING 8
-
+#define FTS3_BUFFER_PADDING 8 
+ 
 /*
 ** FTS4 virtual tables may maintain multiple indexes - one index of all terms
 ** in the document set and zero or more prefix indexes. All indexes are stored
@@ -172422,18 +172422,18 @@ SQLITE_PRIVATE Fts3HashElem *sqlite3Fts3HashFindElem(const Fts3Hash *, const voi
 #define POS_END     (0)     /* Position-list terminator */
 
 /*
-** The assert_fts3_nc() macro is similar to the assert() macro, except that it
+** The assert_fts3_nc() macro is similar to the assert() macro, except that it 
 ** is used for assert() conditions that are true only if it can be
-** guranteed that the database is not corrupt.
-*/
+** guranteed that the database is not corrupt. 
+*/ 
 #ifdef SQLITE_DEBUG
-SQLITE_API extern int sqlite3_fts3_may_be_corrupt;
-# define assert_fts3_nc(x) assert(sqlite3_fts3_may_be_corrupt || (x))
-#else
-# define assert_fts3_nc(x) assert(x)
-#endif
-
-/*
+SQLITE_API extern int sqlite3_fts3_may_be_corrupt; 
+# define assert_fts3_nc(x) assert(sqlite3_fts3_may_be_corrupt || (x)) 
+#else 
+# define assert_fts3_nc(x) assert(x) 
+#endif 
+ 
+/* 
 ** This section provides definitions to allow the
 ** FTS3 extension to be compiled outside of the
 ** amalgamation.
@@ -172910,7 +172910,7 @@ SQLITE_PRIVATE int sqlite3Fts3ExprParse(sqlite3_tokenizer *, int,
 );
 SQLITE_PRIVATE void sqlite3Fts3ExprFree(Fts3Expr *);
 #ifdef SQLITE_TEST
-SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3 *db, Fts3Hash*);
+SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3 *db, Fts3Hash*); 
 SQLITE_PRIVATE int sqlite3Fts3InitTerm(sqlite3 *db);
 #endif
 SQLITE_PRIVATE void *sqlite3Fts3MallocZero(i64 nByte);
@@ -172971,16 +172971,16 @@ static int fts3EvalStart(Fts3Cursor *pCsr);
 static int fts3TermSegReaderCursor(
     Fts3Cursor *, const char *, int, int, Fts3MultiSegReader **);
 
-/*
-** This variable is set to false when running tests for which the on disk
-** structures should not be corrupt. Otherwise, true. If it is false, extra
-** assert() conditions in the fts3 code are activated - conditions that are
-** only true if it is guaranteed that the fts3 database is not corrupt.
-*/
+/* 
+** This variable is set to false when running tests for which the on disk 
+** structures should not be corrupt. Otherwise, true. If it is false, extra 
+** assert() conditions in the fts3 code are activated - conditions that are 
+** only true if it is guaranteed that the fts3 database is not corrupt. 
+*/ 
 #ifdef SQLITE_DEBUG
-SQLITE_API int sqlite3_fts3_may_be_corrupt = 1;
+SQLITE_API int sqlite3_fts3_may_be_corrupt = 1; 
 #endif
-
+ 
 /*
 ** Write a 64-bit variable-length integer to memory starting at p[0].
 ** The length of data written will be between 1 and FTS3_VARINT_MAX bytes.
@@ -172999,7 +172999,7 @@ SQLITE_PRIVATE int sqlite3Fts3PutVarint(char *p, sqlite_int64 v){
 }
 
 #define GETVARINT_STEP(v, ptr, shift, mask1, mask2, var, ret) \
-  v = (v & mask1) | ( (*(const unsigned char*)(ptr++)) << shift );  \
+  v = (v & mask1) | ( (*(const unsigned char*)(ptr++)) << shift );  \ 
   if( (v & mask2)==0 ){ var = v; return ret; }
 #define GETVARINT_INIT(v, ptr, shift, mask1, mask2, var, ret) \
   v = (*ptr++);                                               \
@@ -173067,21 +173067,21 @@ SQLITE_PRIVATE int sqlite3Fts3GetVarintBounded(
 ** a non-negative 32-bit integer before it is returned.
 */
 SQLITE_PRIVATE int sqlite3Fts3GetVarint32(const char *p, int *pi){
-  const unsigned char *ptr = (const unsigned char*)p;
+  const unsigned char *ptr = (const unsigned char*)p; 
   u32 a;
 
 #ifndef fts3GetVarint32
-  GETVARINT_INIT(a, ptr, 0,  0x00,     0x80, *pi, 1);
+  GETVARINT_INIT(a, ptr, 0,  0x00,     0x80, *pi, 1); 
 #else
-  a = (*ptr++);
+  a = (*ptr++); 
   assert( a & 0x80 );
 #endif
 
-  GETVARINT_STEP(a, ptr, 7,  0x7F,     0x4000, *pi, 2);
-  GETVARINT_STEP(a, ptr, 14, 0x3FFF,   0x200000, *pi, 3);
-  GETVARINT_STEP(a, ptr, 21, 0x1FFFFF, 0x10000000, *pi, 4);
+  GETVARINT_STEP(a, ptr, 7,  0x7F,     0x4000, *pi, 2); 
+  GETVARINT_STEP(a, ptr, 14, 0x3FFF,   0x200000, *pi, 3); 
+  GETVARINT_STEP(a, ptr, 21, 0x1FFFFF, 0x10000000, *pi, 4); 
   a = (a & 0x0FFFFFFF );
-  *pi = (int)(a | ((u32)(*ptr & 0x07) << 28));
+  *pi = (int)(a | ((u32)(*ptr & 0x07) << 28)); 
   assert( 0==(a & 0x80000000) );
   assert( *pi>=0 );
   return 5;
@@ -173253,17 +173253,17 @@ static int fts3DestroyMethod(sqlite3_vtab *pVtab){
 
   /* Drop the shadow tables */
   fts3DbExec(&rc, db,
-    "DROP TABLE IF EXISTS %Q.'%q_segments';"
-    "DROP TABLE IF EXISTS %Q.'%q_segdir';"
-    "DROP TABLE IF EXISTS %Q.'%q_docsize';"
-    "DROP TABLE IF EXISTS %Q.'%q_stat';"
-    "%s DROP TABLE IF EXISTS %Q.'%q_content';",
-    zDb, p->zName,
-    zDb, p->zName,
-    zDb, p->zName,
-    zDb, p->zName,
-    (p->zContentTbl ? "--" : ""), zDb,p->zName
-  );
+    "DROP TABLE IF EXISTS %Q.'%q_segments';" 
+    "DROP TABLE IF EXISTS %Q.'%q_segdir';" 
+    "DROP TABLE IF EXISTS %Q.'%q_docsize';" 
+    "DROP TABLE IF EXISTS %Q.'%q_stat';" 
+    "%s DROP TABLE IF EXISTS %Q.'%q_content';", 
+    zDb, p->zName, 
+    zDb, p->zName, 
+    zDb, p->zName, 
+    zDb, p->zName, 
+    (p->zContentTbl ? "--" : ""), zDb,p->zName 
+  ); 
 
   /* If everything has worked, invoke fts3DisconnectMethod() to free the
   ** memory associated with the Fts3Table structure and return SQLITE_OK.
@@ -173495,10 +173495,10 @@ static void fts3Appendf(
 ** memory.
 */
 static char *fts3QuoteId(char const *zInput){
-  sqlite3_int64 nRet;
+  sqlite3_int64 nRet; 
   char *zRet;
   nRet = 2 + (int)strlen(zInput)*2 + 1;
-  zRet = sqlite3_malloc64(nRet);
+  zRet = sqlite3_malloc64(nRet); 
   if( zRet ){
     int i;
     char *z = zRet;
@@ -173693,7 +173693,7 @@ static int fts3PrefixParameter(
     }
   }
 
-  aIndex = sqlite3_malloc64(sizeof(struct Fts3Index) * nIndex);
+  aIndex = sqlite3_malloc64(sizeof(struct Fts3Index) * nIndex); 
   *apIndex = aIndex;
   if( !aIndex ){
     return SQLITE_NOMEM;
@@ -173772,7 +173772,7 @@ static int fts3ContentColumns(
 
   if( rc==SQLITE_OK ){
     const char **azCol;           /* Output array */
-    sqlite3_int64 nStr = 0;       /* Size of all column names (incl. 0x00) */
+    sqlite3_int64 nStr = 0;       /* Size of all column names (incl. 0x00) */ 
     int nCol;                     /* Number of table columns */
     int i;                        /* Used to iterate through columns */
 
@@ -173782,11 +173782,11 @@ static int fts3ContentColumns(
     nCol = sqlite3_column_count(pStmt);
     for(i=0; i<nCol; i++){
       const char *zCol = sqlite3_column_name(pStmt, i);
-      nStr += strlen(zCol) + 1;
+      nStr += strlen(zCol) + 1; 
     }
 
     /* Allocate and populate the array to return. */
-    azCol = (const char **)sqlite3_malloc64(sizeof(char *) * nCol + nStr);
+    azCol = (const char **)sqlite3_malloc64(sizeof(char *) * nCol + nStr); 
     if( azCol==0 ){
       rc = SQLITE_NOMEM;
     }else{
@@ -173834,7 +173834,7 @@ static int fts3InitVtab(
   Fts3Table *p = 0;               /* Pointer to allocated vtab */
   int rc = SQLITE_OK;             /* Return code */
   int i;                          /* Iterator variable */
-  sqlite3_int64 nByte;            /* Size of allocation used for *p */
+  sqlite3_int64 nByte;            /* Size of allocation used for *p */ 
   int iCol;                       /* Column index */
   int nString = 0;                /* Bytes required to hold all column names */
   int nCol = 0;                   /* Number of columns in the FTS table */
@@ -173868,10 +173868,10 @@ static int fts3InitVtab(
   nName = (int)strlen(argv[2]) + 1;
 
   nByte = sizeof(const char *) * (argc-2);
-  aCol = (const char **)sqlite3_malloc64(nByte);
+  aCol = (const char **)sqlite3_malloc64(nByte); 
   if( aCol ){
     memset((void*)aCol, 0, nByte);
-    azNotindexed = (char **)sqlite3_malloc64(nByte);
+    azNotindexed = (char **)sqlite3_malloc64(nByte); 
   }
   if( azNotindexed ){
     memset(azNotindexed, 0, nByte);
@@ -174066,7 +174066,7 @@ static int fts3InitVtab(
           nName +                              /* zName */
           nDb +                                /* zDb */
           nString;                             /* Space for azColumn strings */
-  p = (Fts3Table*)sqlite3_malloc64(nByte);
+  p = (Fts3Table*)sqlite3_malloc64(nByte); 
   if( p==0 ){
     rc = SQLITE_NOMEM;
     goto fts3_init_out;
@@ -174548,7 +174548,7 @@ static int fts3ScanInteriorNode(
   const char *zCsr = zNode;       /* Cursor to iterate through node */
   const char *zEnd = &zCsr[nNode];/* End of interior node buffer */
   char *zBuffer = 0;              /* Buffer to load terms into */
-  i64 nAlloc = 0;                 /* Size of allocated buffer */
+  i64 nAlloc = 0;                 /* Size of allocated buffer */ 
   int isFirstTerm = 1;            /* True when processing first term on page */
   u64 iChild;                     /* Block id of child node to descend to */
   int nBuffer = 0;                /* Total term size */
@@ -174590,14 +174590,14 @@ static int fts3ScanInteriorNode(
     zCsr += fts3GetVarint32(zCsr, &nSuffix);
 
     assert( nPrefix>=0 && nSuffix>=0 );
-    if( nPrefix>zCsr-zNode || nSuffix>zEnd-zCsr || nSuffix==0 ){
+    if( nPrefix>zCsr-zNode || nSuffix>zEnd-zCsr || nSuffix==0 ){ 
       rc = FTS_CORRUPT_VTAB;
       goto finish_scan;
     }
-    if( (i64)nPrefix+nSuffix>nAlloc ){
+    if( (i64)nPrefix+nSuffix>nAlloc ){ 
       char *zNew;
-      nAlloc = ((i64)nPrefix+nSuffix) * 2;
-      zNew = (char *)sqlite3_realloc64(zBuffer, nAlloc);
+      nAlloc = ((i64)nPrefix+nSuffix) * 2; 
+      zNew = (char *)sqlite3_realloc64(zBuffer, nAlloc); 
       if( !zNew ){
         rc = SQLITE_NOMEM;
         goto finish_scan;
@@ -174874,7 +174874,7 @@ static int fts3PutColNumber(char **pp, int iCol){
 ** updated appropriately.   The caller is responsible for insuring
 ** that there is enough space in *pp to hold the complete output.
 */
-static int fts3PoslistMerge(
+static int fts3PoslistMerge( 
   char **pp,                      /* Output buffer */
   char **pp1,                     /* Left input list */
   char **pp2                      /* Right input list */
@@ -174888,16 +174888,16 @@ static int fts3PoslistMerge(
     int iCol2;         /* The current column index in pp2 */
 
     if( *p1==POS_COLUMN ){
-      fts3GetVarint32(&p1[1], &iCol1);
-      if( iCol1==0 ) return FTS_CORRUPT_VTAB;
-    }
+      fts3GetVarint32(&p1[1], &iCol1); 
+      if( iCol1==0 ) return FTS_CORRUPT_VTAB; 
+    } 
     else if( *p1==POS_END ) iCol1 = 0x7fffffff;
     else iCol1 = 0;
 
-    if( *p2==POS_COLUMN ){
-      fts3GetVarint32(&p2[1], &iCol2);
-      if( iCol2==0 ) return FTS_CORRUPT_VTAB;
-    }
+    if( *p2==POS_COLUMN ){ 
+      fts3GetVarint32(&p2[1], &iCol2); 
+      if( iCol2==0 ) return FTS_CORRUPT_VTAB; 
+    } 
     else if( *p2==POS_END ) iCol2 = 0x7fffffff;
     else iCol2 = 0;
 
@@ -174948,7 +174948,7 @@ static int fts3PoslistMerge(
   *pp = p;
   *pp1 = p1 + 1;
   *pp2 = p2 + 1;
-  return SQLITE_OK;
+  return SQLITE_OK; 
 }
 
 /*
@@ -175015,7 +175015,7 @@ static int fts3PoslistPhraseMerge(
 
       fts3GetDeltaVarint(&p1, &iPos1); iPos1 -= 2;
       fts3GetDeltaVarint(&p2, &iPos2); iPos2 -= 2;
-      if( iPos1<0 || iPos2<0 ) break;
+      if( iPos1<0 || iPos2<0 ) break; 
 
       while( 1 ){
         if( iPos2==iPos1+nToken
@@ -175244,7 +175244,7 @@ static int fts3DoclistOrMerge(
   char *a2, int n2,               /* Second doclist */
   char **paOut, int *pnOut        /* OUT: Malloc'd doclist */
 ){
-  int rc = SQLITE_OK;
+  int rc = SQLITE_OK; 
   sqlite3_int64 i1 = 0;
   sqlite3_int64 i2 = 0;
   sqlite3_int64 iPrev = 0;
@@ -175288,7 +175288,7 @@ static int fts3DoclistOrMerge(
   ** A symetric argument may be made if the doclists are in descending
   ** order.
   */
-  aOut = sqlite3_malloc64((i64)n1+n2+FTS3_VARINT_MAX-1+FTS3_BUFFER_PADDING);
+  aOut = sqlite3_malloc64((i64)n1+n2+FTS3_VARINT_MAX-1+FTS3_BUFFER_PADDING); 
   if( !aOut ) return SQLITE_NOMEM;
 
   p = aOut;
@@ -175299,8 +175299,8 @@ static int fts3DoclistOrMerge(
 
     if( p2 && p1 && iDiff==0 ){
       fts3PutDeltaVarint3(&p, bDescDoclist, &iPrev, &bFirstOut, i1);
-      rc = fts3PoslistMerge(&p, &p1, &p2);
-      if( rc ) break;
+      rc = fts3PoslistMerge(&p, &p1, &p2); 
+      if( rc ) break; 
       fts3GetDeltaVarint3(&p1, pEnd1, bDescDoclist, &i1);
       fts3GetDeltaVarint3(&p2, pEnd2, bDescDoclist, &i2);
     }else if( !p2 || (p1 && iDiff<0) ){
@@ -175316,16 +175316,16 @@ static int fts3DoclistOrMerge(
     assert( (p-aOut)<=((p1?(p1-a1):n1)+(p2?(p2-a2):n2)+FTS3_VARINT_MAX-1) );
   }
 
-  if( rc!=SQLITE_OK ){
-    sqlite3_free(aOut);
-    p = aOut = 0;
-  }else{
-    assert( (p-aOut)<=n1+n2+FTS3_VARINT_MAX-1 );
-    memset(&aOut[(p-aOut)], 0, FTS3_BUFFER_PADDING);
-  }
+  if( rc!=SQLITE_OK ){ 
+    sqlite3_free(aOut); 
+    p = aOut = 0; 
+  }else{ 
+    assert( (p-aOut)<=n1+n2+FTS3_VARINT_MAX-1 ); 
+    memset(&aOut[(p-aOut)], 0, FTS3_BUFFER_PADDING); 
+  } 
   *paOut = aOut;
   *pnOut = (int)(p-aOut);
-  return rc;
+  return rc; 
 }
 
 /*
@@ -175360,7 +175360,7 @@ static int fts3DoclistPhraseMerge(
 
   assert( nDist>0 );
   if( bDescDoclist ){
-    aOut = sqlite3_malloc64((sqlite3_int64)*pnRight + FTS3_VARINT_MAX);
+    aOut = sqlite3_malloc64((sqlite3_int64)*pnRight + FTS3_VARINT_MAX); 
     if( aOut==0 ) return SQLITE_NOMEM;
   }else{
     aOut = aRight;
@@ -175544,7 +175544,7 @@ static int fts3TermSelectMerge(
     pTS->anOutput[0] = nDoclist;
     if( pTS->aaOutput[0] ){
       memcpy(pTS->aaOutput[0], aDoclist, nDoclist);
-      memset(&pTS->aaOutput[0][nDoclist], 0, FTS3_VARINT_MAX);
+      memset(&pTS->aaOutput[0][nDoclist], 0, FTS3_VARINT_MAX); 
     }else{
       return SQLITE_NOMEM;
     }
@@ -175596,8 +175596,8 @@ static int fts3SegReaderCursorAppend(
 ){
   if( (pCsr->nSegment%16)==0 ){
     Fts3SegReader **apNew;
-    sqlite3_int64 nByte = (pCsr->nSegment + 16)*sizeof(Fts3SegReader*);
-    apNew = (Fts3SegReader **)sqlite3_realloc64(pCsr->apSegment, nByte);
+    sqlite3_int64 nByte = (pCsr->nSegment + 16)*sizeof(Fts3SegReader*); 
+    apNew = (Fts3SegReader **)sqlite3_realloc64(pCsr->apSegment, nByte); 
     if( !apNew ){
       sqlite3Fts3SegReaderFree(pNew);
       return SQLITE_NOMEM;
@@ -175661,7 +175661,7 @@ static int fts3SegReaderCursor(
 
       /* If zTerm is not NULL, and this segment is not stored entirely on its
       ** root node, the range of leaves scanned can be reduced. Do this. */
-      if( iStartBlock && zTerm && zRoot ){
+      if( iStartBlock && zTerm && zRoot ){ 
         sqlite3_int64 *pi = (isPrefix ? &iLeavesEndBlock : 0);
         rc = fts3SelectLeaf(p, zTerm, nTerm, zRoot, nRoot, &iStartBlock, pi);
         if( rc!=SQLITE_OK ) goto finished;
@@ -176580,7 +176580,7 @@ static int fts3SavepointMethod(sqlite3_vtab *pVtab, int iSavepoint){
   int rc = SQLITE_OK;
   UNUSED_PARAMETER(iSavepoint);
   assert( ((Fts3Table *)pVtab)->inTransaction );
-  assert( ((Fts3Table *)pVtab)->mxSavepoint <= iSavepoint );
+  assert( ((Fts3Table *)pVtab)->mxSavepoint <= iSavepoint ); 
   TESTONLY( ((Fts3Table *)pVtab)->mxSavepoint = iSavepoint );
   if( ((Fts3Table *)pVtab)->bIgnoreSavepoint==0 ){
     rc = fts3SyncMethod(pVtab);
@@ -176617,23 +176617,23 @@ static int fts3RollbackToMethod(sqlite3_vtab *pVtab, int iSavepoint){
   return SQLITE_OK;
 }
 
-/*
-** Return true if zName is the extension on one of the shadow tables used
-** by this module.
-*/
-static int fts3ShadowName(const char *zName){
-  static const char *azName[] = {
+/* 
+** Return true if zName is the extension on one of the shadow tables used 
+** by this module. 
+*/ 
+static int fts3ShadowName(const char *zName){ 
+  static const char *azName[] = { 
     "content", "docsize", "segdir", "segments", "stat",
-  };
-  unsigned int i;
-  for(i=0; i<sizeof(azName)/sizeof(azName[0]); i++){
-    if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
-  }
-  return 0;
-}
-
+  }; 
+  unsigned int i; 
+  for(i=0; i<sizeof(azName)/sizeof(azName[0]); i++){ 
+    if( sqlite3_stricmp(zName, azName[i])==0 ) return 1; 
+  } 
+  return 0; 
+} 
+ 
 static const sqlite3_module fts3Module = {
-  /* iVersion      */ 3,
+  /* iVersion      */ 3, 
   /* xCreate       */ fts3CreateMethod,
   /* xConnect      */ fts3ConnectMethod,
   /* xBestIndex    */ fts3BestIndexMethod,
@@ -176656,7 +176656,7 @@ static const sqlite3_module fts3Module = {
   /* xSavepoint    */ fts3SavepointMethod,
   /* xRelease      */ fts3ReleaseMethod,
   /* xRollbackTo   */ fts3RollbackToMethod,
-  /* xShadowName   */ fts3ShadowName,
+  /* xShadowName   */ fts3ShadowName, 
 };
 
 /*
@@ -176750,7 +176750,7 @@ SQLITE_PRIVATE int sqlite3Fts3Init(sqlite3 *db){
 
 #ifdef SQLITE_TEST
   if( rc==SQLITE_OK ){
-    rc = sqlite3Fts3ExprInitTestInterface(db, pHash);
+    rc = sqlite3Fts3ExprInitTestInterface(db, pHash); 
   }
 #endif
 
@@ -176937,7 +176937,7 @@ static int fts3EvalPhraseLoad(
   return rc;
 }
 
-#ifndef SQLITE_DISABLE_FTS4_DEFERRED
+#ifndef SQLITE_DISABLE_FTS4_DEFERRED 
 /*
 ** This function is called on each phrase after the position lists for
 ** any deferred tokens have been loaded into memory. It updates the phrases
@@ -177041,7 +177041,7 @@ static int fts3EvalDeferredPhrase(Fts3Cursor *pCsr, Fts3Phrase *pPhrase){
 
   return SQLITE_OK;
 }
-#endif /* SQLITE_DISABLE_FTS4_DEFERRED */
+#endif /* SQLITE_DISABLE_FTS4_DEFERRED */ 
 
 /*
 ** Maximum number of tokens a phrase may have to be considered for the
@@ -177387,10 +177387,10 @@ static int fts3EvalIncrPhraseNext(
       if( bEof==0 ){
         int nList = 0;
         int nByte = a[p->nToken-1].nList;
-        char *aDoclist = sqlite3_malloc(nByte+FTS3_BUFFER_PADDING);
+        char *aDoclist = sqlite3_malloc(nByte+FTS3_BUFFER_PADDING); 
         if( !aDoclist ) return SQLITE_NOMEM;
         memcpy(aDoclist, a[p->nToken-1].pList, nByte+1);
-        memset(&aDoclist[nByte], 0, FTS3_BUFFER_PADDING);
+        memset(&aDoclist[nByte], 0, FTS3_BUFFER_PADDING); 
 
         for(i=0; i<(p->nToken-1); i++){
           if( a[i].bIgnore==0 ){
@@ -177781,7 +177781,7 @@ static int fts3EvalStart(Fts3Cursor *pCsr){
 #ifndef SQLITE_DISABLE_FTS4_DEFERRED
   if( rc==SQLITE_OK && nToken>1 && pTab->bFts4 ){
     Fts3TokenAndCost *aTC;
-    aTC = (Fts3TokenAndCost *)sqlite3_malloc64(
+    aTC = (Fts3TokenAndCost *)sqlite3_malloc64( 
         sizeof(Fts3TokenAndCost) * nToken
       + sizeof(Fts3Expr *) * nOr * 2
     );
@@ -178095,7 +178095,7 @@ static int fts3EvalNearTest(Fts3Expr *pExpr, int *pRc){
    && (pExpr->pParent==0 || pExpr->pParent->eType!=FTSQUERY_NEAR)
   ){
     Fts3Expr *p;
-    sqlite3_int64 nTmp = 0;       /* Bytes of temp space */
+    sqlite3_int64 nTmp = 0;       /* Bytes of temp space */ 
     char *aTmp;                   /* Temp space for PoslistNearMerge() */
 
     /* Allocate temporary working space. */
@@ -178104,7 +178104,7 @@ static int fts3EvalNearTest(Fts3Expr *pExpr, int *pRc){
       nTmp += p->pRight->pPhrase->doclist.nList;
     }
     nTmp += p->pPhrase->doclist.nList;
-    aTmp = sqlite3_malloc64(nTmp*2);
+    aTmp = sqlite3_malloc64(nTmp*2); 
     if( !aTmp ){
       *pRc = SQLITE_NOMEM;
       res = 0;
@@ -178377,14 +178377,14 @@ static void fts3EvalRestart(
 ** found in Fts3Expr.pPhrase->doclist.pList for each of the phrase
 ** expression nodes.
 */
-static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){
+static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){ 
   if( pExpr ){
     Fts3Phrase *pPhrase = pExpr->pPhrase;
     if( pPhrase && pPhrase->doclist.pList ){
       int iCol = 0;
       char *p = pPhrase->doclist.pList;
 
-      do{
+      do{ 
         u8 c = 0;
         int iCnt = 0;
         while( 0xFE & (*p | c) ){
@@ -178400,11 +178400,11 @@ static void fts3EvalUpdateCounts(Fts3Expr *pExpr, int nCol){
         if( *p==0x00 ) break;
         p++;
         p += fts3GetVarint32(p, &iCol);
-      }while( iCol<nCol );
+      }while( iCol<nCol ); 
     }
 
-    fts3EvalUpdateCounts(pExpr->pLeft, nCol);
-    fts3EvalUpdateCounts(pExpr->pRight, nCol);
+    fts3EvalUpdateCounts(pExpr->pLeft, nCol); 
+    fts3EvalUpdateCounts(pExpr->pRight, nCol); 
   }
 }
 
@@ -178448,7 +178448,7 @@ static int fts3EvalGatherStats(
     for(p=pRoot; p; p=p->pLeft){
       Fts3Expr *pE = (p->eType==FTSQUERY_PHRASE?p:p->pRight);
       assert( pE->aMI==0 );
-      pE->aMI = (u32 *)sqlite3_malloc64(pTab->nColumn * 3 * sizeof(u32));
+      pE->aMI = (u32 *)sqlite3_malloc64(pTab->nColumn * 3 * sizeof(u32)); 
       if( !pE->aMI ) return SQLITE_NOMEM;
       memset(pE->aMI, 0, pTab->nColumn * 3 * sizeof(u32));
     }
@@ -178474,7 +178474,7 @@ static int fts3EvalGatherStats(
       );
 
       if( rc==SQLITE_OK && pCsr->isEof==0 ){
-        fts3EvalUpdateCounts(pRoot, pTab->nColumn);
+        fts3EvalUpdateCounts(pRoot, pTab->nColumn); 
       }
     }
 
@@ -178828,7 +178828,7 @@ static int fts3auxConnectMethod(
   char const *zFts3;              /* Name of fts3 table */
   int nDb;                        /* Result of strlen(zDb) */
   int nFts3;                      /* Result of strlen(zFts3) */
-  sqlite3_int64 nByte;            /* Bytes of space to allocate here */
+  sqlite3_int64 nByte;            /* Bytes of space to allocate here */ 
   int rc;                         /* value returned by declare_vtab() */
   Fts3auxTable *p;                /* Virtual table object to return */
 
@@ -178860,7 +178860,7 @@ static int fts3auxConnectMethod(
   if( rc!=SQLITE_OK ) return rc;
 
   nByte = sizeof(Fts3auxTable) + sizeof(Fts3Table) + nDb + nFts3 + 2;
-  p = (Fts3auxTable *)sqlite3_malloc64(nByte);
+  p = (Fts3auxTable *)sqlite3_malloc64(nByte); 
   if( !p ) return SQLITE_NOMEM;
   memset(p, 0, nByte);
 
@@ -179184,14 +179184,14 @@ static int fts3auxFilterMethod(
     if( zStr ){
       pCsr->filter.zTerm = sqlite3_mprintf("%s", zStr);
       if( pCsr->filter.zTerm==0 ) return SQLITE_NOMEM;
-      pCsr->filter.nTerm = (int)strlen(pCsr->filter.zTerm);
+      pCsr->filter.nTerm = (int)strlen(pCsr->filter.zTerm); 
     }
   }
 
   if( iLe>=0 ){
     pCsr->zStop = sqlite3_mprintf("%s", sqlite3_value_text(apVal[iLe]));
     if( pCsr->zStop==0 ) return SQLITE_NOMEM;
-    pCsr->nStop = (int)strlen(pCsr->zStop);
+    pCsr->nStop = (int)strlen(pCsr->zStop); 
   }
 
   if( iLangid>=0 ){
@@ -179306,8 +179306,8 @@ SQLITE_PRIVATE int sqlite3Fts3InitAux(sqlite3 *db){
      0,                           /* xRename       */
      0,                           /* xSavepoint    */
      0,                           /* xRelease      */
-     0,                           /* xRollbackTo   */
-     0                            /* xShadowName   */
+     0,                           /* xRollbackTo   */ 
+     0                            /* xShadowName   */ 
   };
   int rc;                         /* Return code */
 
@@ -179444,7 +179444,7 @@ static int fts3isspace(char c){
 ** return NULL.
 */
 SQLITE_PRIVATE void *sqlite3Fts3MallocZero(sqlite3_int64 nByte){
-  void *pRet = sqlite3_malloc64(nByte);
+  void *pRet = sqlite3_malloc64(nByte); 
   if( pRet ) memset(pRet, 0, nByte);
   return pRet;
 }
@@ -179519,7 +179519,7 @@ static int getNextToken(
   if( rc==SQLITE_OK ){
     const char *zToken;
     int nToken = 0, iStart = 0, iEnd = 0, iPosition = 0;
-    sqlite3_int64 nByte;                    /* total space to allocate */
+    sqlite3_int64 nByte;                    /* total space to allocate */ 
 
     rc = pModule->xNext(pCursor, &zToken, &nToken, &iStart, &iEnd, &iPosition);
     if( rc==SQLITE_OK ){
@@ -179573,8 +179573,8 @@ static int getNextToken(
 ** Enlarge a memory allocation.  If an out-of-memory allocation occurs,
 ** then free the old allocation.
 */
-static void *fts3ReallocOrFree(void *pOrig, sqlite3_int64 nNew){
-  void *pRet = sqlite3_realloc64(pOrig, nNew);
+static void *fts3ReallocOrFree(void *pOrig, sqlite3_int64 nNew){ 
+  void *pRet = sqlite3_realloc64(pOrig, nNew); 
   if( !pRet ){
     sqlite3_free(pOrig);
   }
@@ -180118,7 +180118,7 @@ static int fts3ExprBalance(Fts3Expr **pp, int nMaxDepth){
   if( rc==SQLITE_OK ){
     if( (eType==FTSQUERY_AND || eType==FTSQUERY_OR) ){
       Fts3Expr **apLeaf;
-      apLeaf = (Fts3Expr **)sqlite3_malloc64(sizeof(Fts3Expr *) * nMaxDepth);
+      apLeaf = (Fts3Expr **)sqlite3_malloc64(sizeof(Fts3Expr *) * nMaxDepth); 
       if( 0==apLeaf ){
         rc = SQLITE_NOMEM;
       }else{
@@ -180497,8 +180497,8 @@ static char *exprToString(Fts3Expr *pExpr, char *zBuf){
 **
 **   SELECT fts3_exprtest('simple', 'Bill col2:Bloggs', 'col1', 'col2');
 */
-static void fts3ExprTestCommon(
-  int bRebalance,
+static void fts3ExprTestCommon( 
+  int bRebalance, 
   sqlite3_context *context,
   int argc,
   sqlite3_value **argv
@@ -180512,9 +180512,9 @@ static void fts3ExprTestCommon(
   int ii;
   Fts3Expr *pExpr;
   char *zBuf = 0;
-  Fts3Hash *pHash = (Fts3Hash*)sqlite3_user_data(context);
-  const char *zTokenizer = 0;
-  char *zErr = 0;
+  Fts3Hash *pHash = (Fts3Hash*)sqlite3_user_data(context); 
+  const char *zTokenizer = 0; 
+  char *zErr = 0; 
 
   if( argc<3 ){
     sqlite3_result_error(context,
@@ -180523,22 +180523,22 @@ static void fts3ExprTestCommon(
     return;
   }
 
-  zTokenizer = (const char*)sqlite3_value_text(argv[0]);
-  rc = sqlite3Fts3InitTokenizer(pHash, zTokenizer, &pTokenizer, &zErr);
-  if( rc!=SQLITE_OK ){
-    if( rc==SQLITE_NOMEM ){
-      sqlite3_result_error_nomem(context);
-    }else{
-      sqlite3_result_error(context, zErr, -1);
-    }
-    sqlite3_free(zErr);
-    return;
+  zTokenizer = (const char*)sqlite3_value_text(argv[0]); 
+  rc = sqlite3Fts3InitTokenizer(pHash, zTokenizer, &pTokenizer, &zErr); 
+  if( rc!=SQLITE_OK ){ 
+    if( rc==SQLITE_NOMEM ){ 
+      sqlite3_result_error_nomem(context); 
+    }else{ 
+      sqlite3_result_error(context, zErr, -1); 
+    } 
+    sqlite3_free(zErr); 
+    return; 
   }
 
   zExpr = (const char *)sqlite3_value_text(argv[1]);
   nExpr = sqlite3_value_bytes(argv[1]);
   nCol = argc-2;
-  azCol = (char **)sqlite3_malloc64(nCol*sizeof(char *));
+  azCol = (char **)sqlite3_malloc64(nCol*sizeof(char *)); 
   if( !azCol ){
     sqlite3_result_error_nomem(context);
     goto exprtest_out;
@@ -180547,7 +180547,7 @@ static void fts3ExprTestCommon(
     azCol[ii] = (char *)sqlite3_value_text(argv[ii+2]);
   }
 
-  if( bRebalance ){
+  if( bRebalance ){ 
     char *zDummy = 0;
     rc = sqlite3Fts3ExprParse(
         pTokenizer, 0, azCol, 0, nCol, nCol, zExpr, nExpr, &pExpr, &zDummy
@@ -180573,38 +180573,38 @@ static void fts3ExprTestCommon(
   sqlite3Fts3ExprFree(pExpr);
 
 exprtest_out:
-  if( pTokenizer ){
-    rc = pTokenizer->pModule->xDestroy(pTokenizer);
+  if( pTokenizer ){ 
+    rc = pTokenizer->pModule->xDestroy(pTokenizer); 
   }
   sqlite3_free(azCol);
 }
 
-static void fts3ExprTest(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  fts3ExprTestCommon(0, context, argc, argv);
-}
-static void fts3ExprTestRebalance(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  fts3ExprTestCommon(1, context, argc, argv);
-}
-
+static void fts3ExprTest( 
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  fts3ExprTestCommon(0, context, argc, argv); 
+} 
+static void fts3ExprTestRebalance( 
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  fts3ExprTestCommon(1, context, argc, argv); 
+} 
+ 
 /*
 ** Register the query expression parser test function fts3_exprtest()
 ** with database connection db.
 */
-SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3 *db, Fts3Hash *pHash){
+SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3 *db, Fts3Hash *pHash){ 
   int rc = sqlite3_create_function(
-      db, "fts3_exprtest", -1, SQLITE_UTF8, (void*)pHash, fts3ExprTest, 0, 0
+      db, "fts3_exprtest", -1, SQLITE_UTF8, (void*)pHash, fts3ExprTest, 0, 0 
   );
   if( rc==SQLITE_OK ){
     rc = sqlite3_create_function(db, "fts3_exprtest_rebalance",
-        -1, SQLITE_UTF8, (void*)pHash, fts3ExprTestRebalance, 0, 0
+        -1, SQLITE_UTF8, (void*)pHash, fts3ExprTestRebalance, 0, 0 
     );
   }
   return rc;
@@ -180652,8 +180652,8 @@ SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3 *db, Fts3Hash *pHash
 /*
 ** Malloc and Free functions
 */
-static void *fts3HashMalloc(sqlite3_int64 n){
-  void *p = sqlite3_malloc64(n);
+static void *fts3HashMalloc(sqlite3_int64 n){ 
+  void *p = sqlite3_malloc64(n); 
   if( p ){
     memset(p, 0, n);
   }
@@ -181747,7 +181747,7 @@ static void fts3TokenizerFunc(
   nName = sqlite3_value_bytes(argv[0])+1;
 
   if( argc==2 ){
-    if( fts3TokenizerEnabled(context) || sqlite3_value_frombind(argv[1]) ){
+    if( fts3TokenizerEnabled(context) || sqlite3_value_frombind(argv[1]) ){ 
       void *pOld;
       int n = sqlite3_value_bytes(argv[1]);
       if( zName==0 || n!=sizeof(pPtr) ){
@@ -181774,9 +181774,9 @@ static void fts3TokenizerFunc(
       return;
     }
   }
-  if( fts3TokenizerEnabled(context) || sqlite3_value_frombind(argv[0]) ){
-    sqlite3_result_blob(context, (void *)&pPtr, sizeof(pPtr), SQLITE_TRANSIENT);
-  }
+  if( fts3TokenizerEnabled(context) || sqlite3_value_frombind(argv[0]) ){ 
+    sqlite3_result_blob(context, (void *)&pPtr, sizeof(pPtr), SQLITE_TRANSIENT); 
+  } 
 }
 
 SQLITE_PRIVATE int sqlite3Fts3IsIdChar(char c){
@@ -181864,8 +181864,8 @@ SQLITE_PRIVATE int sqlite3Fts3InitTokenizer(
     int iArg = 0;
     z = &z[n+1];
     while( z<zEnd && (NULL!=(z = (char *)sqlite3Fts3NextToken(z, &n))) ){
-      sqlite3_int64 nNew = sizeof(char *)*(iArg+1);
-      char const **aNew = (const char **)sqlite3_realloc64((void *)aArg, nNew);
+      sqlite3_int64 nNew = sizeof(char *)*(iArg+1); 
+      char const **aNew = (const char **)sqlite3_realloc64((void *)aArg, nNew); 
       if( !aNew ){
         sqlite3_free(zCopy);
         sqlite3_free((void *)aArg);
@@ -182550,7 +182550,7 @@ static int fts3tokDequoteArray(
       nByte += (int)(strlen(argv[i]) + 1);
     }
 
-    *pazDequote = azDequote = sqlite3_malloc64(sizeof(char *)*argc + nByte);
+    *pazDequote = azDequote = sqlite3_malloc64(sizeof(char *)*argc + nByte); 
     if( azDequote==0 ){
       rc = SQLITE_NOMEM;
     }else{
@@ -182775,7 +182775,7 @@ static int fts3tokFilterMethod(
   if( idxNum==1 ){
     const char *zByte = (const char *)sqlite3_value_text(apVal[0]);
     int nByte = sqlite3_value_bytes(apVal[0]);
-    pCsr->zInput = sqlite3_malloc64(nByte+1);
+    pCsr->zInput = sqlite3_malloc64(nByte+1); 
     if( pCsr->zInput==0 ){
       rc = SQLITE_NOMEM;
     }else{
@@ -182872,8 +182872,8 @@ SQLITE_PRIVATE int sqlite3Fts3InitTok(sqlite3 *db, Fts3Hash *pHash){
      0,                           /* xRename       */
      0,                           /* xSavepoint    */
      0,                           /* xRelease      */
-     0,                           /* xRollbackTo   */
-     0                            /* xShadowName   */
+     0,                           /* xRollbackTo   */ 
+     0                            /* xShadowName   */ 
   };
   int rc;                         /* Return code */
 
@@ -183285,12 +183285,12 @@ static int fts3SqlStmt(
 
   pStmt = p->aStmt[eStmt];
   if( !pStmt ){
-    int f = SQLITE_PREPARE_PERSISTENT|SQLITE_PREPARE_NO_VTAB;
+    int f = SQLITE_PREPARE_PERSISTENT|SQLITE_PREPARE_NO_VTAB; 
     char *zSql;
     if( eStmt==SQL_CONTENT_INSERT ){
       zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName, p->zWriteExprlist);
     }else if( eStmt==SQL_SELECT_CONTENT_BY_ROWID ){
-      f &= ~SQLITE_PREPARE_NO_VTAB;
+      f &= ~SQLITE_PREPARE_NO_VTAB; 
       zSql = sqlite3_mprintf(azSql[eStmt], p->zReadExprlist);
     }else{
       zSql = sqlite3_mprintf(azSql[eStmt], p->zDb, p->zName);
@@ -183298,7 +183298,7 @@ static int fts3SqlStmt(
     if( !zSql ){
       rc = SQLITE_NOMEM;
     }else{
-      rc = sqlite3_prepare_v3(p->db, zSql, -1, f, &pStmt, NULL);
+      rc = sqlite3_prepare_v3(p->db, zSql, -1, f, &pStmt, NULL); 
       sqlite3_free(zSql);
       assert( rc==SQLITE_OK || pStmt==0 );
       p->aStmt[eStmt] = pStmt;
@@ -183456,7 +183456,7 @@ static sqlite3_int64 getAbsoluteLevel(
   int iLevel                      /* Level of segments */
 ){
   sqlite3_int64 iBase;            /* First absolute level for iLangid/iIndex */
-  assert_fts3_nc( iLangid>=0 );
+  assert_fts3_nc( iLangid>=0 ); 
   assert( p->nIndex>0 );
   assert( iIndex>=0 && iIndex<p->nIndex );
 
@@ -184249,9 +184249,9 @@ static int fts3SegReaderNext(
 
     /* If iCurrentBlock>=iLeafEndBlock, this is an EOF condition. All leaf
     ** blocks have already been traversed.  */
-#ifdef CORRUPT_DB
-    assert( pReader->iCurrentBlock<=pReader->iLeafEndBlock || CORRUPT_DB );
-#endif
+#ifdef CORRUPT_DB 
+    assert( pReader->iCurrentBlock<=pReader->iLeafEndBlock || CORRUPT_DB ); 
+#endif 
     if( pReader->iCurrentBlock>=pReader->iLeafEndBlock ){
       return SQLITE_OK;
     }
@@ -184279,18 +184279,18 @@ static int fts3SegReaderNext(
   pNext += fts3GetVarint32(pNext, &nPrefix);
   pNext += fts3GetVarint32(pNext, &nSuffix);
   if( nSuffix<=0
-   || (&pReader->aNode[pReader->nNode] - pNext)<nSuffix
+   || (&pReader->aNode[pReader->nNode] - pNext)<nSuffix 
    || nPrefix>pReader->nTerm
   ){
     return FTS_CORRUPT_VTAB;
   }
 
-  /* Both nPrefix and nSuffix were read by fts3GetVarint32() and so are
-  ** between 0 and 0x7FFFFFFF. But the sum of the two may cause integer
-  ** overflow - hence the (i64) casts.  */
-  if( (i64)nPrefix+nSuffix>(i64)pReader->nTermAlloc ){
-    i64 nNew = ((i64)nPrefix+nSuffix)*2;
-    char *zNew = sqlite3_realloc64(pReader->zTerm, nNew);
+  /* Both nPrefix and nSuffix were read by fts3GetVarint32() and so are 
+  ** between 0 and 0x7FFFFFFF. But the sum of the two may cause integer 
+  ** overflow - hence the (i64) casts.  */ 
+  if( (i64)nPrefix+nSuffix>(i64)pReader->nTermAlloc ){ 
+    i64 nNew = ((i64)nPrefix+nSuffix)*2; 
+    char *zNew = sqlite3_realloc64(pReader->zTerm, nNew); 
     if( !zNew ){
       return SQLITE_NOMEM;
     }
@@ -184312,7 +184312,7 @@ static int fts3SegReaderNext(
   ** b-tree node. And that the final byte of the doclist is 0x00. If either
   ** of these statements is untrue, then the data structure is corrupt.
   */
-  if( pReader->nDoclist > pReader->nNode-(pReader->aDoclist-pReader->aNode)
+  if( pReader->nDoclist > pReader->nNode-(pReader->aDoclist-pReader->aNode) 
    || (pReader->nPopulate==0 && pReader->aDoclist[pReader->nDoclist-1])
    || pReader->nDoclist==0
   ){
@@ -184511,13 +184511,13 @@ SQLITE_PRIVATE int sqlite3Fts3SegReaderNew(
   Fts3SegReader *pReader;         /* Newly allocated SegReader object */
   int nExtra = 0;                 /* Bytes to allocate segment root node */
 
-  assert( zRoot!=0 || nRoot==0 );
-#ifdef CORRUPT_DB
-  assert( zRoot!=0 || CORRUPT_DB );
-#endif
-
+  assert( zRoot!=0 || nRoot==0 ); 
+#ifdef CORRUPT_DB 
+  assert( zRoot!=0 || CORRUPT_DB ); 
+#endif 
+ 
   if( iStartLeaf==0 ){
-    if( iEndLeaf!=0 ) return FTS_CORRUPT_VTAB;
+    if( iEndLeaf!=0 ) return FTS_CORRUPT_VTAB; 
     nExtra = nRoot + FTS3_NODE_PADDING;
   }
 
@@ -184537,7 +184537,7 @@ SQLITE_PRIVATE int sqlite3Fts3SegReaderNew(
     pReader->aNode = (char *)&pReader[1];
     pReader->rootOnly = 1;
     pReader->nNode = nRoot;
-    if( nRoot ) memcpy(pReader->aNode, zRoot, nRoot);
+    if( nRoot ) memcpy(pReader->aNode, zRoot, nRoot); 
     memset(&pReader->aNode[nRoot], 0, FTS3_NODE_PADDING);
   }else{
     pReader->iCurrentBlock = iStartLeaf-1;
@@ -184652,9 +184652,9 @@ SQLITE_PRIVATE int sqlite3Fts3SegReaderPending(
   }
 
   if( nElem>0 ){
-    sqlite3_int64 nByte;
-    nByte = sizeof(Fts3SegReader) + (nElem+1)*sizeof(Fts3HashElem *);
-    pReader = (Fts3SegReader *)sqlite3_malloc64(nByte);
+    sqlite3_int64 nByte; 
+    nByte = sizeof(Fts3SegReader) + (nElem+1)*sizeof(Fts3HashElem *); 
+    pReader = (Fts3SegReader *)sqlite3_malloc64(nByte); 
     if( !pReader ){
       rc = SQLITE_NOMEM;
     }else{
@@ -184821,7 +184821,7 @@ static int fts3WriteSegment(
     sqlite3_bind_blob(pStmt, 2, z, n, SQLITE_STATIC);
     sqlite3_step(pStmt);
     rc = sqlite3_reset(pStmt);
-    sqlite3_bind_null(pStmt, 2);
+    sqlite3_bind_null(pStmt, 2); 
   }
   return rc;
 }
@@ -184878,7 +184878,7 @@ static int fts3WriteSegdir(
     sqlite3_bind_blob(pStmt, 6, zRoot, nRoot, SQLITE_STATIC);
     sqlite3_step(pStmt);
     rc = sqlite3_reset(pStmt);
-    sqlite3_bind_null(pStmt, 6);
+    sqlite3_bind_null(pStmt, 6); 
   }
   return rc;
 }
@@ -185164,10 +185164,10 @@ static int fts3SegWriterAdd(
   nSuffix = nTerm-nPrefix;
 
   /* If nSuffix is zero or less, then zTerm/nTerm must be a prefix of
-  ** pWriter->zTerm/pWriter->nTerm. i.e. must be equal to or less than when
-  ** compared with BINARY collation. This indicates corruption.  */
-  if( nSuffix<=0 ) return FTS_CORRUPT_VTAB;
-
+  ** pWriter->zTerm/pWriter->nTerm. i.e. must be equal to or less than when 
+  ** compared with BINARY collation. This indicates corruption.  */ 
+  if( nSuffix<=0 ) return FTS_CORRUPT_VTAB; 
+ 
   /* Figure out how many bytes are required by this new entry */
   nReq = sqlite3Fts3VarintLen(nPrefix) +    /* varint containing prefix size */
     sqlite3Fts3VarintLen(nSuffix) +         /* varint containing suffix size */
@@ -185528,14 +185528,14 @@ static void fts3ColumnFilter(
 
     nList -= (int)(p - pList);
     pList = p;
-    if( nList<=0 ){
+    if( nList<=0 ){ 
       break;
     }
     p = &pList[1];
     p += fts3GetVarint32(p, &iCurrent);
   }
 
-  if( bZero && (pEnd - &pList[nList])>0){
+  if( bZero && (pEnd - &pList[nList])>0){ 
     memset(&pList[nList], 0, pEnd - &pList[nList]);
   }
   *ppList = pList;
@@ -186156,10 +186156,10 @@ static int fts3SegmentMerge(
   if( rc!=SQLITE_OK ) goto finished;
 
   assert( csr.nSegment>0 );
-  assert_fts3_nc( iNewLevel>=getAbsoluteLevel(p, iLangid, iIndex, 0) );
+  assert_fts3_nc( iNewLevel>=getAbsoluteLevel(p, iLangid, iIndex, 0) ); 
   assert_fts3_nc(
     iNewLevel<getAbsoluteLevel(p, iLangid, iIndex,FTS3_SEGDIR_MAXLEVEL)
-  );
+  ); 
 
   memset(&filter, 0, sizeof(Fts3SegFilter));
   filter.flags = FTS3_SEGMENT_REQUIRE_POS;
@@ -186258,16 +186258,16 @@ static void fts3DecodeIntArray(
   const char *zBuf,  /* The BLOB containing the varints */
   int nBuf           /* size of the BLOB */
 ){
-  int i = 0;
-  if( nBuf && (zBuf[nBuf-1]&0x80)==0 ){
-    int j;
-    for(i=j=0; i<N && j<nBuf; i++){
-      sqlite3_int64 x;
-      j += sqlite3Fts3GetVarint(&zBuf[j], &x);
-      a[i] = (u32)(x & 0xffffffff);
-    }
+  int i = 0; 
+  if( nBuf && (zBuf[nBuf-1]&0x80)==0 ){ 
+    int j; 
+    for(i=j=0; i<N && j<nBuf; i++){ 
+      sqlite3_int64 x; 
+      j += sqlite3Fts3GetVarint(&zBuf[j], &x); 
+      a[i] = (u32)(x & 0xffffffff); 
+    } 
   }
-  while( i<N ) a[i++] = 0;
+  while( i<N ) a[i++] = 0; 
 }
 
 /*
@@ -186286,7 +186286,7 @@ static void fts3InsertDocsize(
   int rc;                  /* Result code from subfunctions */
 
   if( *pRC ) return;
-  pBlob = sqlite3_malloc64( 10*(sqlite3_int64)p->nColumn );
+  pBlob = sqlite3_malloc64( 10*(sqlite3_int64)p->nColumn ); 
   if( pBlob==0 ){
     *pRC = SQLITE_NOMEM;
     return;
@@ -186336,7 +186336,7 @@ static void fts3UpdateDocTotals(
   const int nStat = p->nColumn+2;
 
   if( *pRC ) return;
-  a = sqlite3_malloc64( (sizeof(u32)+10)*(sqlite3_int64)nStat );
+  a = sqlite3_malloc64( (sizeof(u32)+10)*(sqlite3_int64)nStat ); 
   if( a==0 ){
     *pRC = SQLITE_NOMEM;
     return;
@@ -186387,7 +186387,7 @@ static void fts3UpdateDocTotals(
   sqlite3_bind_blob(pStmt, 2, pBlob, nBlob, SQLITE_STATIC);
   sqlite3_step(pStmt);
   *pRC = sqlite3_reset(pStmt);
-  sqlite3_bind_null(pStmt, 2);
+  sqlite3_bind_null(pStmt, 2); 
   sqlite3_free(a);
 }
 
@@ -186459,8 +186459,8 @@ static int fts3DoRebuild(Fts3Table *p){
     }
 
     if( rc==SQLITE_OK ){
-      sqlite3_int64 nByte = sizeof(u32) * ((sqlite3_int64)p->nColumn+1)*3;
-      aSz = (u32 *)sqlite3_malloc64(nByte);
+      sqlite3_int64 nByte = sizeof(u32) * ((sqlite3_int64)p->nColumn+1)*3; 
+      aSz = (u32 *)sqlite3_malloc64(nByte); 
       if( aSz==0 ){
         rc = SQLITE_NOMEM;
       }else{
@@ -186526,12 +186526,12 @@ static int fts3IncrmergeCsr(
 ){
   int rc;                         /* Return Code */
   sqlite3_stmt *pStmt = 0;        /* Statement used to read %_segdir entry */
-  sqlite3_int64 nByte;            /* Bytes allocated at pCsr->apSegment[] */
+  sqlite3_int64 nByte;            /* Bytes allocated at pCsr->apSegment[] */ 
 
   /* Allocate space for the Fts3MultiSegReader.aCsr[] array */
   memset(pCsr, 0, sizeof(*pCsr));
   nByte = sizeof(Fts3SegReader *) * nSeg;
-  pCsr->apSegment = (Fts3SegReader **)sqlite3_malloc64(nByte);
+  pCsr->apSegment = (Fts3SegReader **)sqlite3_malloc64(nByte); 
 
   if( pCsr->apSegment==0 ){
     rc = SQLITE_NOMEM;
@@ -186674,9 +186674,9 @@ static int nodeReaderNext(NodeReader *p){
     }
     p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &nSuffix);
 
-    if( nPrefix>p->term.n || nSuffix>p->nNode-p->iOff || nSuffix==0 ){
-      return FTS_CORRUPT_VTAB;
-    }
+    if( nPrefix>p->term.n || nSuffix>p->nNode-p->iOff || nSuffix==0 ){ 
+      return FTS_CORRUPT_VTAB; 
+    } 
     blobGrowBuffer(&p->term, nPrefix+nSuffix, &rc);
     if( rc==SQLITE_OK && ALWAYS(p->term.a!=0) ){
       memcpy(&p->term.a[nPrefix], &p->aNode[p->iOff], nSuffix);
@@ -186684,16 +186684,16 @@ static int nodeReaderNext(NodeReader *p){
       p->iOff += nSuffix;
       if( p->iChild==0 ){
         p->iOff += fts3GetVarint32(&p->aNode[p->iOff], &p->nDoclist);
-        if( (p->nNode-p->iOff)<p->nDoclist ){
-          return FTS_CORRUPT_VTAB;
-        }
+        if( (p->nNode-p->iOff)<p->nDoclist ){ 
+          return FTS_CORRUPT_VTAB; 
+        } 
         p->aDoclist = &p->aNode[p->iOff];
         p->iOff += p->nDoclist;
       }
     }
   }
 
-  assert_fts3_nc( p->iOff<=p->nNode );
+  assert_fts3_nc( p->iOff<=p->nNode ); 
   return rc;
 }
 
@@ -186855,7 +186855,7 @@ static int fts3AppendToNode(
   /* Node must have already been started. There must be a doclist for a
   ** leaf node, and there must not be a doclist for an internal node.  */
   assert( pNode->n>0 );
-  assert_fts3_nc( (pNode->a[0]=='\0')==(aDoclist!=0) );
+  assert_fts3_nc( (pNode->a[0]=='\0')==(aDoclist!=0) ); 
 
   blobGrowBuffer(pPrev, nTerm, &rc);
   if( rc!=SQLITE_OK ) return rc;
@@ -187217,12 +187217,12 @@ static int fts3IncrmergeLoad(
       pNode = &pWriter->aNodeWriter[nHeight];
       pNode->iBlock = pWriter->iStart + pWriter->nLeafEst*nHeight;
       blobGrowBuffer(&pNode->block,
-          MAX(nRoot, p->nNodeSize)+FTS3_NODE_PADDING, &rc
-      );
+          MAX(nRoot, p->nNodeSize)+FTS3_NODE_PADDING, &rc 
+      ); 
       if( rc==SQLITE_OK ){
         memcpy(pNode->block.a, aRoot, nRoot);
         pNode->block.n = nRoot;
-        memset(&pNode->block.a[nRoot], 0, FTS3_NODE_PADDING);
+        memset(&pNode->block.a[nRoot], 0, FTS3_NODE_PADDING); 
       }
 
       for(i=nHeight; i>=0 && rc==SQLITE_OK; i--){
@@ -187231,29 +187231,29 @@ static int fts3IncrmergeLoad(
 
         if( pNode->block.a){
           rc = nodeReaderInit(&reader, pNode->block.a, pNode->block.n);
-          while( reader.aNode && rc==SQLITE_OK ) rc = nodeReaderNext(&reader);
-          blobGrowBuffer(&pNode->key, reader.term.n, &rc);
-          if( rc==SQLITE_OK ){
+          while( reader.aNode && rc==SQLITE_OK ) rc = nodeReaderNext(&reader); 
+          blobGrowBuffer(&pNode->key, reader.term.n, &rc); 
+          if( rc==SQLITE_OK ){ 
             assert_fts3_nc( reader.term.n>0 || reader.aNode==0 );
             if( reader.term.n>0 ){
               memcpy(pNode->key.a, reader.term.a, reader.term.n);
             }
-            pNode->key.n = reader.term.n;
-            if( i>0 ){
-              char *aBlock = 0;
-              int nBlock = 0;
-              pNode = &pWriter->aNodeWriter[i-1];
-              pNode->iBlock = reader.iChild;
+            pNode->key.n = reader.term.n; 
+            if( i>0 ){ 
+              char *aBlock = 0; 
+              int nBlock = 0; 
+              pNode = &pWriter->aNodeWriter[i-1]; 
+              pNode->iBlock = reader.iChild; 
               rc = sqlite3Fts3ReadBlock(p, reader.iChild, &aBlock, &nBlock,0);
               blobGrowBuffer(&pNode->block,
-                  MAX(nBlock, p->nNodeSize)+FTS3_NODE_PADDING, &rc
+                  MAX(nBlock, p->nNodeSize)+FTS3_NODE_PADDING, &rc 
                   );
-              if( rc==SQLITE_OK ){
-                memcpy(pNode->block.a, aBlock, nBlock);
-                pNode->block.n = nBlock;
-                memset(&pNode->block.a[nBlock], 0, FTS3_NODE_PADDING);
-              }
-              sqlite3_free(aBlock);
+              if( rc==SQLITE_OK ){ 
+                memcpy(pNode->block.a, aBlock, nBlock); 
+                pNode->block.n = nBlock; 
+                memset(&pNode->block.a[nBlock], 0, FTS3_NODE_PADDING); 
+              } 
+              sqlite3_free(aBlock); 
             }
           }
         }
@@ -187497,11 +187497,11 @@ static int fts3TruncateNode(
   NodeReader reader;              /* Reader object */
   Blob prev = {0, 0, 0};          /* Previous term written to new node */
   int rc = SQLITE_OK;             /* Return code */
-  int bLeaf;                       /* True for a leaf node */
-
-  if( nNode<1 ) return FTS_CORRUPT_VTAB;
-  bLeaf = aNode[0]=='\0';
+  int bLeaf;                       /* True for a leaf node */ 
 
+  if( nNode<1 ) return FTS_CORRUPT_VTAB; 
+  bLeaf = aNode[0]=='\0'; 
+ 
   /* Allocate required output space */
   blobGrowBuffer(pNew, nNode, &rc);
   if( rc!=SQLITE_OK ) return rc;
@@ -187611,7 +187611,7 @@ static int fts3TruncateSegment(
       sqlite3_bind_int(pChomp, 4, iIdx);
       sqlite3_step(pChomp);
       rc = sqlite3_reset(pChomp);
-      sqlite3_bind_null(pChomp, 2);
+      sqlite3_bind_null(pChomp, 2); 
     }
   }
 
@@ -187691,7 +187691,7 @@ static int fts3IncrmergeHintStore(Fts3Table *p, Blob *pHint){
     sqlite3_bind_blob(pReplace, 2, pHint->a, pHint->n, SQLITE_STATIC);
     sqlite3_step(pReplace);
     rc = sqlite3_reset(pReplace);
-    sqlite3_bind_null(pReplace, 2);
+    sqlite3_bind_null(pReplace, 2); 
   }
 
   return rc;
@@ -188573,7 +188573,7 @@ SQLITE_PRIVATE int sqlite3Fts3UpdateMethod(
   }
 
   /* Allocate space to hold the change in document sizes */
-  aSzDel = sqlite3_malloc64(sizeof(aSzDel[0])*((sqlite3_int64)p->nColumn+1)*2);
+  aSzDel = sqlite3_malloc64(sizeof(aSzDel[0])*((sqlite3_int64)p->nColumn+1)*2); 
   if( aSzDel==0 ){
     rc = SQLITE_NOMEM;
     goto update_out;
@@ -188648,7 +188648,7 @@ SQLITE_PRIVATE int sqlite3Fts3UpdateMethod(
         rc = FTS_CORRUPT_VTAB;
       }
     }
-    if( rc==SQLITE_OK ){
+    if( rc==SQLITE_OK ){ 
       rc = fts3PendingTermsDocid(p, 0, iLangid, *pRowid);
     }
     if( rc==SQLITE_OK ){
@@ -188831,18 +188831,18 @@ struct StrBuffer {
 /*
 ** Allocate a two-slot MatchinfoBuffer object.
 */
-static MatchinfoBuffer *fts3MIBufferNew(size_t nElem, const char *zMatchinfo){
+static MatchinfoBuffer *fts3MIBufferNew(size_t nElem, const char *zMatchinfo){ 
   MatchinfoBuffer *pRet;
-  sqlite3_int64 nByte = sizeof(u32) * (2*(sqlite3_int64)nElem + 1)
-                           + sizeof(MatchinfoBuffer);
-  sqlite3_int64 nStr = strlen(zMatchinfo);
+  sqlite3_int64 nByte = sizeof(u32) * (2*(sqlite3_int64)nElem + 1) 
+                           + sizeof(MatchinfoBuffer); 
+  sqlite3_int64 nStr = strlen(zMatchinfo); 
 
   pRet = sqlite3Fts3MallocZero(nByte + nStr+1);
   if( pRet ){
     pRet->aMatchinfo[0] = (u8*)(&pRet->aMatchinfo[1]) - (u8*)pRet;
-    pRet->aMatchinfo[1+nElem] = pRet->aMatchinfo[0]
-                                      + sizeof(u32)*((int)nElem+1);
-    pRet->nElem = (int)nElem;
+    pRet->aMatchinfo[1+nElem] = pRet->aMatchinfo[0] 
+                                      + sizeof(u32)*((int)nElem+1); 
+    pRet->nElem = (int)nElem; 
     pRet->zMatchinfo = ((char*)pRet) + nByte;
     memcpy(pRet->zMatchinfo, zMatchinfo, nStr+1);
     pRet->aRef[0] = 1;
@@ -188882,7 +188882,7 @@ static void (*fts3MIBufferAlloc(MatchinfoBuffer *p, u32 **paOut))(void*){
     aOut = &p->aMatchinfo[p->nElem+2];
     xRet = fts3MIBufferFree;
   }else{
-    aOut = (u32*)sqlite3_malloc64(p->nElem * sizeof(u32));
+    aOut = (u32*)sqlite3_malloc64(p->nElem * sizeof(u32)); 
     if( aOut ){
       xRet = sqlite3_free;
       if( p->bGlobal ) memcpy(aOut, &p->aMatchinfo[1], p->nElem*sizeof(u32));
@@ -189133,11 +189133,11 @@ static void fts3SnippetDetails(
       char *pCsr = pPhrase->pTail;
       i64 iCsr = pPhrase->iTail;
 
-      while( iCsr<(iStart+pIter->nSnippet) && iCsr>=iStart ){
+      while( iCsr<(iStart+pIter->nSnippet) && iCsr>=iStart ){ 
         int j;
         u64 mPhrase = (u64)1 << (i%64);
         u64 mPos = (u64)1 << (iCsr - iStart);
-        assert( iCsr>=iStart && (iCsr - iStart)<=64 );
+        assert( iCsr>=iStart && (iCsr - iStart)<=64 ); 
         assert( i>=0 );
         if( (mCover|mCovered)&mPhrase ){
           iScore++;
@@ -189180,14 +189180,14 @@ static int fts3SnippetFindPositions(Fts3Expr *pExpr, int iPhrase, void *ctx){
     i64 iFirst = 0;
     pPhrase->pList = pCsr;
     fts3GetDeltaPosition(&pCsr, &iFirst);
-    if( iFirst<0 ){
-      rc = FTS_CORRUPT_VTAB;
-    }else{
-      pPhrase->pHead = pCsr;
-      pPhrase->pTail = pCsr;
-      pPhrase->iHead = iFirst;
-      pPhrase->iTail = iFirst;
-    }
+    if( iFirst<0 ){ 
+      rc = FTS_CORRUPT_VTAB; 
+    }else{ 
+      pPhrase->pHead = pCsr; 
+      pPhrase->pTail = pCsr; 
+      pPhrase->iHead = iFirst; 
+      pPhrase->iTail = iFirst; 
+    } 
   }else{
     assert( rc!=SQLITE_OK || (
        pPhrase->pList==0 && pPhrase->pHead==0 && pPhrase->pTail==0
@@ -189224,7 +189224,7 @@ static int fts3BestSnippet(
   int rc;                         /* Return Code */
   int nList;                      /* Number of phrases in expression */
   SnippetIter sIter;              /* Iterates through snippet candidates */
-  sqlite3_int64 nByte;            /* Number of bytes of space to allocate */
+  sqlite3_int64 nByte;            /* Number of bytes of space to allocate */ 
   int iBestScore = -1;            /* Best snippet score found so far */
   int i;                          /* Loop counter */
 
@@ -189311,8 +189311,8 @@ static int fts3StringAppend(
   ** appended data.
   */
   if( pStr->n+nAppend+1>=pStr->nAlloc ){
-    sqlite3_int64 nAlloc = pStr->nAlloc+(sqlite3_int64)nAppend+100;
-    char *zNew = sqlite3_realloc64(pStr->z, nAlloc);
+    sqlite3_int64 nAlloc = pStr->nAlloc+(sqlite3_int64)nAppend+100; 
+    char *zNew = sqlite3_realloc64(pStr->z, nAlloc); 
     if( !zNew ){
       return SQLITE_NOMEM;
     }
@@ -189367,7 +189367,7 @@ static int fts3SnippetShift(
 
     for(nLeft=0; !(hlmask & ((u64)1 << nLeft)); nLeft++);
     for(nRight=0; !(hlmask & ((u64)1 << (nSnippet-1-nRight))); nRight++);
-    assert( (nSnippet-1-nRight)<=63 && (nSnippet-1-nRight)>=0 );
+    assert( (nSnippet-1-nRight)<=63 && (nSnippet-1-nRight)>=0 ); 
     nDesired = (nLeft-nRight)/2;
 
     /* Ideally, the start of the snippet should be pushed forward in the
@@ -189560,7 +189560,7 @@ static int fts3ColumnlistCount(char **ppCollist){
 /*
 ** This function gathers 'y' or 'b' data for a single phrase.
 */
-static int fts3ExprLHits(
+static int fts3ExprLHits( 
   Fts3Expr *pExpr,                /* Phrase expression node */
   MatchInfo *p                    /* Matchinfo context */
 ){
@@ -189590,29 +189590,29 @@ static int fts3ExprLHits(
     if( *pIter!=0x01 ) break;
     pIter++;
     pIter += fts3GetVarint32(pIter, &iCol);
-    if( iCol>=p->nCol ) return FTS_CORRUPT_VTAB;
+    if( iCol>=p->nCol ) return FTS_CORRUPT_VTAB; 
   }
-  return SQLITE_OK;
+  return SQLITE_OK; 
 }
 
 /*
 ** Gather the results for matchinfo directives 'y' and 'b'.
 */
-static int fts3ExprLHitGather(
+static int fts3ExprLHitGather( 
   Fts3Expr *pExpr,
   MatchInfo *p
 ){
-  int rc = SQLITE_OK;
+  int rc = SQLITE_OK; 
   assert( (pExpr->pLeft==0)==(pExpr->pRight==0) );
   if( pExpr->bEof==0 && pExpr->iDocid==p->pCursor->iPrevId ){
     if( pExpr->pLeft ){
-      rc = fts3ExprLHitGather(pExpr->pLeft, p);
-      if( rc==SQLITE_OK ) rc = fts3ExprLHitGather(pExpr->pRight, p);
+      rc = fts3ExprLHitGather(pExpr->pLeft, p); 
+      if( rc==SQLITE_OK ) rc = fts3ExprLHitGather(pExpr->pRight, p); 
     }else{
-      rc = fts3ExprLHits(pExpr, p);
+      rc = fts3ExprLHits(pExpr, p); 
     }
   }
-  return rc;
+  return rc; 
 }
 
 /*
@@ -189702,8 +189702,8 @@ static int fts3MatchinfoCheck(
   return SQLITE_ERROR;
 }
 
-static size_t fts3MatchinfoSize(MatchInfo *pInfo, char cArg){
-  size_t nVal;                      /* Number of integers output by cArg */
+static size_t fts3MatchinfoSize(MatchInfo *pInfo, char cArg){ 
+  size_t nVal;                      /* Number of integers output by cArg */ 
 
   switch( cArg ){
     case FTS3_MATCHINFO_NDOC:
@@ -189843,7 +189843,7 @@ static int fts3MatchinfoLcs(Fts3Cursor *pCsr, MatchInfo *pInfo){
   int i;
   int iCol;
   int nToken = 0;
-  int rc = SQLITE_OK;
+  int rc = SQLITE_OK; 
 
   /* Allocate and populate the array of LcsIterator objects. The array
   ** contains one element for each matchable phrase in the query.
@@ -189865,14 +189865,14 @@ static int fts3MatchinfoLcs(Fts3Cursor *pCsr, MatchInfo *pInfo){
     for(i=0; i<pInfo->nPhrase; i++){
       LcsIterator *pIt = &aIter[i];
       rc = sqlite3Fts3EvalPhrasePoslist(pCsr, pIt->pExpr, iCol, &pIt->pRead);
-      if( rc!=SQLITE_OK ) goto matchinfo_lcs_out;
+      if( rc!=SQLITE_OK ) goto matchinfo_lcs_out; 
       if( pIt->pRead ){
         pIt->iPos = pIt->iPosOffset;
-        fts3LcsIteratorAdvance(pIt);
-        if( pIt->pRead==0 ){
-          rc = FTS_CORRUPT_VTAB;
-          goto matchinfo_lcs_out;
-        }
+        fts3LcsIteratorAdvance(pIt); 
+        if( pIt->pRead==0 ){ 
+          rc = FTS_CORRUPT_VTAB; 
+          goto matchinfo_lcs_out; 
+        } 
         nLive++;
       }
     }
@@ -189904,9 +189904,9 @@ static int fts3MatchinfoLcs(Fts3Cursor *pCsr, MatchInfo *pInfo){
     pInfo->aMatchinfo[iCol] = nLcs;
   }
 
- matchinfo_lcs_out:
+ matchinfo_lcs_out: 
   sqlite3_free(aIter);
-  return rc;
+  return rc; 
 }
 
 /*
@@ -190010,9 +190010,9 @@ static int fts3MatchinfoValues(
 
       case FTS3_MATCHINFO_LHITS_BM:
       case FTS3_MATCHINFO_LHITS: {
-        size_t nZero = fts3MatchinfoSize(pInfo, zArg[i]) * sizeof(u32);
+        size_t nZero = fts3MatchinfoSize(pInfo, zArg[i]) * sizeof(u32); 
         memset(pInfo->aMatchinfo, 0, nZero);
-        rc = fts3ExprLHitGather(pCsr->pExpr, pInfo);
+        rc = fts3ExprLHitGather(pCsr->pExpr, pInfo); 
         break;
       }
 
@@ -190079,7 +190079,7 @@ static void fts3GetMatchinfo(
   ** initialize those elements that are constant for every row.
   */
   if( pCsr->pMIBuffer==0 ){
-    size_t nMatchinfo = 0;        /* Number of u32 elements in match-info */
+    size_t nMatchinfo = 0;        /* Number of u32 elements in match-info */ 
     int i;                        /* Used to iterate through zArg */
 
     /* Determine the number of phrases in the query */
@@ -190164,10 +190164,10 @@ SQLITE_PRIVATE void sqlite3Fts3Snippet(
     return;
   }
 
-  /* Limit the snippet length to 64 tokens. */
-  if( nToken<-64 ) nToken = -64;
-  if( nToken>+64 ) nToken = +64;
-
+  /* Limit the snippet length to 64 tokens. */ 
+  if( nToken<-64 ) nToken = -64; 
+  if( nToken>+64 ) nToken = +64; 
+ 
   for(nSnippet=1; 1; nSnippet++){
 
     int iSnip;                    /* Loop counter 0..nSnippet-1 */
@@ -190269,7 +190269,7 @@ static int fts3ExprTermOffsetInit(Fts3Expr *pExpr, int iPhrase, void *ctx){
   nTerm = pExpr->pPhrase->nToken;
   if( pList ){
     fts3GetDeltaPosition(&pList, &iPos);
-    assert_fts3_nc( iPos>=0 );
+    assert_fts3_nc( iPos>=0 ); 
   }
 
   for(iTerm=0; iTerm<nTerm; iTerm++){
@@ -190379,7 +190379,7 @@ SQLITE_PRIVATE void sqlite3Fts3Offsets(
         /* All offsets for this column have been gathered. */
         rc = SQLITE_DONE;
       }else{
-        assert_fts3_nc( iCurrent<=iMinPos );
+        assert_fts3_nc( iCurrent<=iMinPos ); 
         if( 0==(0xFE&*pTerm->pList) ){
           pTerm->pList = 0;
         }else{
@@ -190535,7 +190535,7 @@ typedef struct unicode_cursor unicode_cursor;
 
 struct unicode_tokenizer {
   sqlite3_tokenizer base;
-  int eRemoveDiacritic;
+  int eRemoveDiacritic; 
   int nException;
   int *aiException;
 };
@@ -190608,7 +190608,7 @@ static int unicodeAddExceptions(
     int *aNew;                    /* New aiException[] array */
     int nNew;                     /* Number of valid entries in array aNew[] */
 
-    aNew = sqlite3_realloc64(p->aiException,(p->nException+nEntry)*sizeof(int));
+    aNew = sqlite3_realloc64(p->aiException,(p->nException+nEntry)*sizeof(int)); 
     if( aNew==0 ) return SQLITE_NOMEM;
     nNew = p->nException;
 
@@ -190680,21 +190680,21 @@ static int unicodeCreate(
   pNew = (unicode_tokenizer *) sqlite3_malloc(sizeof(unicode_tokenizer));
   if( pNew==NULL ) return SQLITE_NOMEM;
   memset(pNew, 0, sizeof(unicode_tokenizer));
-  pNew->eRemoveDiacritic = 1;
+  pNew->eRemoveDiacritic = 1; 
 
   for(i=0; rc==SQLITE_OK && i<nArg; i++){
     const char *z = azArg[i];
     int n = (int)strlen(z);
 
     if( n==19 && memcmp("remove_diacritics=1", z, 19)==0 ){
-      pNew->eRemoveDiacritic = 1;
+      pNew->eRemoveDiacritic = 1; 
     }
     else if( n==19 && memcmp("remove_diacritics=0", z, 19)==0 ){
-      pNew->eRemoveDiacritic = 0;
-    }
-    else if( n==19 && memcmp("remove_diacritics=2", z, 19)==0 ){
-      pNew->eRemoveDiacritic = 2;
+      pNew->eRemoveDiacritic = 0; 
     }
+    else if( n==19 && memcmp("remove_diacritics=2", z, 19)==0 ){ 
+      pNew->eRemoveDiacritic = 2; 
+    } 
     else if( n>=11 && memcmp("tokenchars=", z, 11)==0 ){
       rc = unicodeAddExceptions(pNew, 1, &z[11], n-11);
     }
@@ -190798,7 +190798,7 @@ static int unicodeNext(
 
     /* Grow the output buffer if required. */
     if( (zOut-pCsr->zToken)>=(pCsr->nAlloc-4) ){
-      char *zNew = sqlite3_realloc64(pCsr->zToken, pCsr->nAlloc+64);
+      char *zNew = sqlite3_realloc64(pCsr->zToken, pCsr->nAlloc+64); 
       if( !zNew ) return SQLITE_NOMEM;
       zOut = &zNew[zOut - pCsr->zToken];
       pCsr->zToken = zNew;
@@ -190807,7 +190807,7 @@ static int unicodeNext(
 
     /* Write the folded case of the last character read to the output */
     zEnd = z;
-    iOut = sqlite3FtsUnicodeFold((int)iCode, p->eRemoveDiacritic);
+    iOut = sqlite3FtsUnicodeFold((int)iCode, p->eRemoveDiacritic); 
     if( iOut ){
       WRITE_UTF8(zOut, iOut);
     }
@@ -190852,7 +190852,7 @@ SQLITE_PRIVATE void sqlite3Fts3UnicodeTokenizer(sqlite3_tokenizer_module const *
 /************** End of fts3_unicode.c ****************************************/
 /************** Begin file fts3_unicode2.c ***********************************/
 /*
-** 2012-05-25
+** 2012-05-25 
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
@@ -191012,7 +191012,7 @@ SQLITE_PRIVATE int sqlite3FtsUnicodeIsalnum(int c){
 ** E"). The resuls of passing a codepoint that corresponds to an
 ** uppercase letter are undefined.
 */
-static int remove_diacritic(int c, int bComplex){
+static int remove_diacritic(int c, int bComplex){ 
   unsigned short aDia[] = {
         0,  1797,  1848,  1859,  1891,  1928,  1940,  1995,
      2024,  2040,  2060,  2110,  2168,  2206,  2264,  2286,
@@ -191031,8 +191031,8 @@ static int remove_diacritic(int c, int bComplex){
     62830, 62890, 62924, 62974, 63032, 63050, 63082, 63118,
     63182, 63242, 63274, 63310, 63368, 63390,
   };
-#define HIBIT ((unsigned char)0x80)
-  unsigned char aChar[] = {
+#define HIBIT ((unsigned char)0x80) 
+  unsigned char aChar[] = { 
     '\0',      'a',       'c',       'e',       'i',       'n',
     'o',       'u',       'y',       'y',       'a',       'c',
     'd',       'e',       'e',       'g',       'h',       'i',
@@ -191070,8 +191070,8 @@ static int remove_diacritic(int c, int bComplex){
     }
   }
   assert( key>=aDia[iRes] );
-  if( bComplex==0 && (aChar[iRes] & 0x80) ) return c;
-  return (c > (aDia[iRes]>>3) + (aDia[iRes]&0x07)) ? c : ((int)aChar[iRes] & 0x7F);
+  if( bComplex==0 && (aChar[iRes] & 0x80) ) return c; 
+  return (c > (aDia[iRes]>>3) + (aDia[iRes]&0x07)) ? c : ((int)aChar[iRes] & 0x7F); 
 }
 
 
@@ -191084,8 +191084,8 @@ SQLITE_PRIVATE int sqlite3FtsUnicodeIsdiacritic(int c){
   unsigned int mask1 = 0x000361F8;
   if( c<768 || c>817 ) return 0;
   return (c < 768+32) ?
-      (mask0 & ((unsigned int)1 << (c-768))) :
-      (mask1 & ((unsigned int)1 << (c-768-32)));
+      (mask0 & ((unsigned int)1 << (c-768))) : 
+      (mask1 & ((unsigned int)1 << (c-768-32))); 
 }
 
 
@@ -191098,7 +191098,7 @@ SQLITE_PRIVATE int sqlite3FtsUnicodeIsdiacritic(int c){
 ** The results are undefined if the value passed to this function
 ** is less than zero.
 */
-SQLITE_PRIVATE int sqlite3FtsUnicodeFold(int c, int eRemoveDiacritic){
+SQLITE_PRIVATE int sqlite3FtsUnicodeFold(int c, int eRemoveDiacritic){ 
   /* Each entry in the following array defines a rule for folding a range
   ** of codepoints to lower case. The rule applies to a range of nRange
   ** codepoints starting at codepoint iCode.
@@ -191221,9 +191221,9 @@ SQLITE_PRIVATE int sqlite3FtsUnicodeFold(int c, int eRemoveDiacritic){
       assert( ret>0 );
     }
 
-    if( eRemoveDiacritic ){
-      ret = remove_diacritic(ret, eRemoveDiacritic==2);
-    }
+    if( eRemoveDiacritic ){ 
+      ret = remove_diacritic(ret, eRemoveDiacritic==2); 
+    } 
   }
 
   else if( c>=66560 && c<66600 ){
@@ -191236,105 +191236,105 @@ SQLITE_PRIVATE int sqlite3FtsUnicodeFold(int c, int eRemoveDiacritic){
 #endif /* !defined(SQLITE_DISABLE_FTS3_UNICODE) */
 
 /************** End of fts3_unicode2.c ***************************************/
-/************** Begin file json1.c *******************************************/
-/*
-** 2015-08-12
-**
-** 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 SQLite extension implements JSON functions.  The interface is
-** modeled after MySQL JSON functions:
-**
-**     https://dev.mysql.com/doc/refman/5.7/en/json.html
-**
-** For the time being, all JSON is stored as pure text.  (We might add
-** a JSONB type in the future which stores a binary encoding of JSON in
-** a BLOB, but there is no support for JSONB in the current implementation.
-** This implementation parses JSON text at 250 MB/s, so it is hard to see
-** how JSONB might improve on that.)
-*/
-#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_JSON1)
-#if !defined(SQLITEINT_H)
-/* #include "sqlite3ext.h" */
-#endif
-SQLITE_EXTENSION_INIT1
-/* #include <assert.h> */
-/* #include <string.h> */
-/* #include <stdlib.h> */
-/* #include <stdarg.h> */
-
-/* Mark a function parameter as unused, to suppress nuisance compiler
-** warnings. */
-#ifndef UNUSED_PARAM
-# define UNUSED_PARAM(X)  (void)(X)
-#endif
-
-#ifndef LARGEST_INT64
-# define LARGEST_INT64  (0xffffffff|(((sqlite3_int64)0x7fffffff)<<32))
-# define SMALLEST_INT64 (((sqlite3_int64)-1) - LARGEST_INT64)
-#endif
-
+/************** Begin file json1.c *******************************************/ 
+/* 
+** 2015-08-12 
+** 
+** 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 SQLite extension implements JSON functions.  The interface is 
+** modeled after MySQL JSON functions: 
+** 
+**     https://dev.mysql.com/doc/refman/5.7/en/json.html 
+** 
+** For the time being, all JSON is stored as pure text.  (We might add 
+** a JSONB type in the future which stores a binary encoding of JSON in 
+** a BLOB, but there is no support for JSONB in the current implementation. 
+** This implementation parses JSON text at 250 MB/s, so it is hard to see 
+** how JSONB might improve on that.) 
+*/ 
+#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_JSON1) 
+#if !defined(SQLITEINT_H) 
+/* #include "sqlite3ext.h" */ 
+#endif 
+SQLITE_EXTENSION_INIT1 
+/* #include <assert.h> */ 
+/* #include <string.h> */ 
+/* #include <stdlib.h> */ 
+/* #include <stdarg.h> */ 
+ 
+/* Mark a function parameter as unused, to suppress nuisance compiler 
+** warnings. */ 
+#ifndef UNUSED_PARAM 
+# define UNUSED_PARAM(X)  (void)(X) 
+#endif 
+ 
+#ifndef LARGEST_INT64 
+# define LARGEST_INT64  (0xffffffff|(((sqlite3_int64)0x7fffffff)<<32)) 
+# define SMALLEST_INT64 (((sqlite3_int64)-1) - LARGEST_INT64) 
+#endif 
+ 
 #ifndef deliberate_fall_through
 # define deliberate_fall_through
 #endif
 
-/*
-** Versions of isspace(), isalnum() and isdigit() to which it is safe
-** to pass signed char values.
-*/
-#ifdef sqlite3Isdigit
-   /* Use the SQLite core versions if this routine is part of the
-   ** SQLite amalgamation */
-#  define safe_isdigit(x)  sqlite3Isdigit(x)
-#  define safe_isalnum(x)  sqlite3Isalnum(x)
-#  define safe_isxdigit(x) sqlite3Isxdigit(x)
-#else
-   /* Use the standard library for separate compilation */
-#include <ctype.h>  /* amalgamator: keep */
-#  define safe_isdigit(x)  isdigit((unsigned char)(x))
-#  define safe_isalnum(x)  isalnum((unsigned char)(x))
-#  define safe_isxdigit(x) isxdigit((unsigned char)(x))
-#endif
-
-/*
-** Growing our own isspace() routine this way is twice as fast as
-** the library isspace() function, resulting in a 7% overall performance
-** increase for the parser.  (Ubuntu14.10 gcc 4.8.4 x64 with -Os).
-*/
-static const char jsonIsSpace[] = {
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 1, 1, 0, 0, 1, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  1, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-};
-#define safe_isspace(x) (jsonIsSpace[(unsigned char)x])
-
-#ifndef SQLITE_AMALGAMATION
-  /* Unsigned integer types.  These are already defined in the sqliteInt.h,
-  ** but the definitions need to be repeated for separate compilation. */
-  typedef sqlite3_uint64 u64;
-  typedef unsigned int u32;
-  typedef unsigned short int u16;
-  typedef unsigned char u8;
+/* 
+** Versions of isspace(), isalnum() and isdigit() to which it is safe 
+** to pass signed char values. 
+*/ 
+#ifdef sqlite3Isdigit 
+   /* Use the SQLite core versions if this routine is part of the 
+   ** SQLite amalgamation */ 
+#  define safe_isdigit(x)  sqlite3Isdigit(x) 
+#  define safe_isalnum(x)  sqlite3Isalnum(x) 
+#  define safe_isxdigit(x) sqlite3Isxdigit(x) 
+#else 
+   /* Use the standard library for separate compilation */ 
+#include <ctype.h>  /* amalgamator: keep */ 
+#  define safe_isdigit(x)  isdigit((unsigned char)(x)) 
+#  define safe_isalnum(x)  isalnum((unsigned char)(x)) 
+#  define safe_isxdigit(x) isxdigit((unsigned char)(x)) 
+#endif 
+ 
+/* 
+** Growing our own isspace() routine this way is twice as fast as 
+** the library isspace() function, resulting in a 7% overall performance 
+** increase for the parser.  (Ubuntu14.10 gcc 4.8.4 x64 with -Os). 
+*/ 
+static const char jsonIsSpace[] = { 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 1, 1, 0, 0, 1, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  1, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+}; 
+#define safe_isspace(x) (jsonIsSpace[(unsigned char)x]) 
+ 
+#ifndef SQLITE_AMALGAMATION 
+  /* Unsigned integer types.  These are already defined in the sqliteInt.h, 
+  ** but the definitions need to be repeated for separate compilation. */ 
+  typedef sqlite3_uint64 u64; 
+  typedef unsigned int u32; 
+  typedef unsigned short int u16; 
+  typedef unsigned char u8; 
 # if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST)
 #   define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS 1
 # endif
@@ -191349,13 +191349,13 @@ static const char jsonIsSpace[] = {
 #   define NEVER(X)       (X)
 # endif
 # define testcase(X)
-#endif
+#endif 
 #if !defined(SQLITE_DEBUG) && !defined(SQLITE_COVERAGE_TEST)
 #  define VVA(X)
 #else
 #  define VVA(X) X
 #endif
-
+ 
 /*
 ** Some of the testcase() macros in this file are problematic for gcov
 ** in that they generate false-miss errors randomly.  This is a gcov problem,
@@ -191364,444 +191364,444 @@ static const char jsonIsSpace[] = {
 */
 #define json_testcase(X)
 
-/* Objects */
-typedef struct JsonString JsonString;
-typedef struct JsonNode JsonNode;
-typedef struct JsonParse JsonParse;
-
-/* An instance of this object represents a JSON string
-** under construction.  Really, this is a generic string accumulator
-** that can be and is used to create strings other than JSON.
-*/
-struct JsonString {
-  sqlite3_context *pCtx;   /* Function context - put error messages here */
-  char *zBuf;              /* Append JSON content here */
-  u64 nAlloc;              /* Bytes of storage available in zBuf[] */
-  u64 nUsed;               /* Bytes of zBuf[] currently used */
-  u8 bStatic;              /* True if zBuf is static space */
-  u8 bErr;                 /* True if an error has been encountered */
-  char zSpace[100];        /* Initial static space */
-};
-
-/* JSON type values
-*/
-#define JSON_NULL     0
-#define JSON_TRUE     1
-#define JSON_FALSE    2
-#define JSON_INT      3
-#define JSON_REAL     4
-#define JSON_STRING   5
-#define JSON_ARRAY    6
-#define JSON_OBJECT   7
-
-/* The "subtype" set for JSON values */
-#define JSON_SUBTYPE  74    /* Ascii for "J" */
-
-/*
-** Names of the various JSON types:
-*/
-static const char * const jsonType[] = {
-  "null", "true", "false", "integer", "real", "text", "array", "object"
-};
-
-/* Bit values for the JsonNode.jnFlag field
-*/
-#define JNODE_RAW     0x01         /* Content is raw, not JSON encoded */
-#define JNODE_ESCAPE  0x02         /* Content is text with \ escapes */
-#define JNODE_REMOVE  0x04         /* Do not output */
-#define JNODE_REPLACE 0x08         /* Replace with JsonNode.u.iReplace */
-#define JNODE_PATCH   0x10         /* Patch with JsonNode.u.pPatch */
-#define JNODE_APPEND  0x20         /* More ARRAY/OBJECT entries at u.iAppend */
-#define JNODE_LABEL   0x40         /* Is a label of an object */
-
-
-/* A single node of parsed JSON
-*/
-struct JsonNode {
-  u8 eType;              /* One of the JSON_ type values */
-  u8 jnFlags;            /* JNODE flags */
+/* Objects */ 
+typedef struct JsonString JsonString; 
+typedef struct JsonNode JsonNode; 
+typedef struct JsonParse JsonParse; 
+ 
+/* An instance of this object represents a JSON string 
+** under construction.  Really, this is a generic string accumulator 
+** that can be and is used to create strings other than JSON. 
+*/ 
+struct JsonString { 
+  sqlite3_context *pCtx;   /* Function context - put error messages here */ 
+  char *zBuf;              /* Append JSON content here */ 
+  u64 nAlloc;              /* Bytes of storage available in zBuf[] */ 
+  u64 nUsed;               /* Bytes of zBuf[] currently used */ 
+  u8 bStatic;              /* True if zBuf is static space */ 
+  u8 bErr;                 /* True if an error has been encountered */ 
+  char zSpace[100];        /* Initial static space */ 
+}; 
+ 
+/* JSON type values 
+*/ 
+#define JSON_NULL     0 
+#define JSON_TRUE     1 
+#define JSON_FALSE    2 
+#define JSON_INT      3 
+#define JSON_REAL     4 
+#define JSON_STRING   5 
+#define JSON_ARRAY    6 
+#define JSON_OBJECT   7 
+ 
+/* The "subtype" set for JSON values */ 
+#define JSON_SUBTYPE  74    /* Ascii for "J" */ 
+ 
+/* 
+** Names of the various JSON types: 
+*/ 
+static const char * const jsonType[] = { 
+  "null", "true", "false", "integer", "real", "text", "array", "object" 
+}; 
+ 
+/* Bit values for the JsonNode.jnFlag field 
+*/ 
+#define JNODE_RAW     0x01         /* Content is raw, not JSON encoded */ 
+#define JNODE_ESCAPE  0x02         /* Content is text with \ escapes */ 
+#define JNODE_REMOVE  0x04         /* Do not output */ 
+#define JNODE_REPLACE 0x08         /* Replace with JsonNode.u.iReplace */ 
+#define JNODE_PATCH   0x10         /* Patch with JsonNode.u.pPatch */ 
+#define JNODE_APPEND  0x20         /* More ARRAY/OBJECT entries at u.iAppend */ 
+#define JNODE_LABEL   0x40         /* Is a label of an object */ 
+ 
+ 
+/* A single node of parsed JSON 
+*/ 
+struct JsonNode { 
+  u8 eType;              /* One of the JSON_ type values */ 
+  u8 jnFlags;            /* JNODE flags */ 
   u8 eU;                 /* Which union element to use */
-  u32 n;                 /* Bytes of content, or number of sub-nodes */
-  union {
+  u32 n;                 /* Bytes of content, or number of sub-nodes */ 
+  union { 
     const char *zJContent; /* 1: Content for INT, REAL, and STRING */
     u32 iAppend;           /* 2: More terms for ARRAY and OBJECT */
     u32 iKey;              /* 3: Key for ARRAY objects in json_tree() */
     u32 iReplace;          /* 4: Replacement content for JNODE_REPLACE */
     JsonNode *pPatch;      /* 5: Node chain of patch for JNODE_PATCH */
-  } u;
-};
-
-/* A completely parsed JSON string
-*/
-struct JsonParse {
-  u32 nNode;         /* Number of slots of aNode[] used */
-  u32 nAlloc;        /* Number of slots of aNode[] allocated */
-  JsonNode *aNode;   /* Array of nodes containing the parse */
-  const char *zJson; /* Original JSON string */
-  u32 *aUp;          /* Index of parent of each node */
-  u8 oom;            /* Set to true if out of memory */
-  u8 nErr;           /* Number of errors seen */
-  u16 iDepth;        /* Nesting depth */
-  int nJson;         /* Length of the zJson string in bytes */
-  u32 iHold;         /* Replace cache line with the lowest iHold value */
-};
-
-/*
-** Maximum nesting depth of JSON for this implementation.
-**
-** This limit is needed to avoid a stack overflow in the recursive
-** descent parser.  A depth of 2000 is far deeper than any sane JSON
-** should go.
-*/
-#define JSON_MAX_DEPTH  2000
-
-/**************************************************************************
-** Utility routines for dealing with JsonString objects
-**************************************************************************/
-
-/* Set the JsonString object to an empty string
-*/
-static void jsonZero(JsonString *p){
-  p->zBuf = p->zSpace;
-  p->nAlloc = sizeof(p->zSpace);
-  p->nUsed = 0;
-  p->bStatic = 1;
-}
-
-/* Initialize the JsonString object
-*/
-static void jsonInit(JsonString *p, sqlite3_context *pCtx){
-  p->pCtx = pCtx;
-  p->bErr = 0;
-  jsonZero(p);
-}
-
-
-/* Free all allocated memory and reset the JsonString object back to its
-** initial state.
-*/
-static void jsonReset(JsonString *p){
-  if( !p->bStatic ) sqlite3_free(p->zBuf);
-  jsonZero(p);
-}
-
-
+  } u; 
+}; 
+ 
+/* A completely parsed JSON string 
+*/ 
+struct JsonParse { 
+  u32 nNode;         /* Number of slots of aNode[] used */ 
+  u32 nAlloc;        /* Number of slots of aNode[] allocated */ 
+  JsonNode *aNode;   /* Array of nodes containing the parse */ 
+  const char *zJson; /* Original JSON string */ 
+  u32 *aUp;          /* Index of parent of each node */ 
+  u8 oom;            /* Set to true if out of memory */ 
+  u8 nErr;           /* Number of errors seen */ 
+  u16 iDepth;        /* Nesting depth */ 
+  int nJson;         /* Length of the zJson string in bytes */ 
+  u32 iHold;         /* Replace cache line with the lowest iHold value */ 
+}; 
+ 
+/* 
+** Maximum nesting depth of JSON for this implementation. 
+** 
+** This limit is needed to avoid a stack overflow in the recursive 
+** descent parser.  A depth of 2000 is far deeper than any sane JSON 
+** should go. 
+*/ 
+#define JSON_MAX_DEPTH  2000 
+ 
+/************************************************************************** 
+** Utility routines for dealing with JsonString objects 
+**************************************************************************/ 
+ 
+/* Set the JsonString object to an empty string 
+*/ 
+static void jsonZero(JsonString *p){ 
+  p->zBuf = p->zSpace; 
+  p->nAlloc = sizeof(p->zSpace); 
+  p->nUsed = 0; 
+  p->bStatic = 1; 
+} 
+ 
+/* Initialize the JsonString object 
+*/ 
+static void jsonInit(JsonString *p, sqlite3_context *pCtx){ 
+  p->pCtx = pCtx; 
+  p->bErr = 0; 
+  jsonZero(p); 
+} 
+ 
+ 
+/* Free all allocated memory and reset the JsonString object back to its 
+** initial state. 
+*/ 
+static void jsonReset(JsonString *p){ 
+  if( !p->bStatic ) sqlite3_free(p->zBuf); 
+  jsonZero(p); 
+} 
+ 
+ 
 /* Report an out-of-memory (OOM) condition
-*/
-static void jsonOom(JsonString *p){
-  p->bErr = 1;
-  sqlite3_result_error_nomem(p->pCtx);
-  jsonReset(p);
-}
-
-/* Enlarge pJson->zBuf so that it can hold at least N more bytes.
-** Return zero on success.  Return non-zero on an OOM error
-*/
-static int jsonGrow(JsonString *p, u32 N){
-  u64 nTotal = N<p->nAlloc ? p->nAlloc*2 : p->nAlloc+N+10;
-  char *zNew;
-  if( p->bStatic ){
-    if( p->bErr ) return 1;
-    zNew = sqlite3_malloc64(nTotal);
-    if( zNew==0 ){
-      jsonOom(p);
-      return SQLITE_NOMEM;
-    }
-    memcpy(zNew, p->zBuf, (size_t)p->nUsed);
-    p->zBuf = zNew;
-    p->bStatic = 0;
-  }else{
-    zNew = sqlite3_realloc64(p->zBuf, nTotal);
-    if( zNew==0 ){
-      jsonOom(p);
-      return SQLITE_NOMEM;
-    }
-    p->zBuf = zNew;
-  }
-  p->nAlloc = nTotal;
-  return SQLITE_OK;
-}
-
-/* Append N bytes from zIn onto the end of the JsonString string.
-*/
-static void jsonAppendRaw(JsonString *p, const char *zIn, u32 N){
+*/ 
+static void jsonOom(JsonString *p){ 
+  p->bErr = 1; 
+  sqlite3_result_error_nomem(p->pCtx); 
+  jsonReset(p); 
+} 
+ 
+/* Enlarge pJson->zBuf so that it can hold at least N more bytes. 
+** Return zero on success.  Return non-zero on an OOM error 
+*/ 
+static int jsonGrow(JsonString *p, u32 N){ 
+  u64 nTotal = N<p->nAlloc ? p->nAlloc*2 : p->nAlloc+N+10; 
+  char *zNew; 
+  if( p->bStatic ){ 
+    if( p->bErr ) return 1; 
+    zNew = sqlite3_malloc64(nTotal); 
+    if( zNew==0 ){ 
+      jsonOom(p); 
+      return SQLITE_NOMEM; 
+    } 
+    memcpy(zNew, p->zBuf, (size_t)p->nUsed); 
+    p->zBuf = zNew; 
+    p->bStatic = 0; 
+  }else{ 
+    zNew = sqlite3_realloc64(p->zBuf, nTotal); 
+    if( zNew==0 ){ 
+      jsonOom(p); 
+      return SQLITE_NOMEM; 
+    } 
+    p->zBuf = zNew; 
+  } 
+  p->nAlloc = nTotal; 
+  return SQLITE_OK; 
+} 
+ 
+/* Append N bytes from zIn onto the end of the JsonString string. 
+*/ 
+static void jsonAppendRaw(JsonString *p, const char *zIn, u32 N){ 
   if( N==0 ) return;
-  if( (N+p->nUsed >= p->nAlloc) && jsonGrow(p,N)!=0 ) return;
-  memcpy(p->zBuf+p->nUsed, zIn, N);
-  p->nUsed += N;
-}
-
-/* Append formatted text (not to exceed N bytes) to the JsonString.
-*/
-static void jsonPrintf(int N, JsonString *p, const char *zFormat, ...){
-  va_list ap;
-  if( (p->nUsed + N >= p->nAlloc) && jsonGrow(p, N) ) return;
-  va_start(ap, zFormat);
-  sqlite3_vsnprintf(N, p->zBuf+p->nUsed, zFormat, ap);
-  va_end(ap);
-  p->nUsed += (int)strlen(p->zBuf+p->nUsed);
-}
-
-/* Append a single character
-*/
-static void jsonAppendChar(JsonString *p, char c){
-  if( p->nUsed>=p->nAlloc && jsonGrow(p,1)!=0 ) return;
-  p->zBuf[p->nUsed++] = c;
-}
-
-/* Append a comma separator to the output buffer, if the previous
-** character is not '[' or '{'.
-*/
-static void jsonAppendSeparator(JsonString *p){
-  char c;
-  if( p->nUsed==0 ) return;
-  c = p->zBuf[p->nUsed-1];
-  if( c!='[' && c!='{' ) jsonAppendChar(p, ',');
-}
-
-/* Append the N-byte string in zIn to the end of the JsonString string
-** under construction.  Enclose the string in "..." and escape
-** any double-quotes or backslash characters contained within the
-** string.
-*/
-static void jsonAppendString(JsonString *p, const char *zIn, u32 N){
-  u32 i;
+  if( (N+p->nUsed >= p->nAlloc) && jsonGrow(p,N)!=0 ) return; 
+  memcpy(p->zBuf+p->nUsed, zIn, N); 
+  p->nUsed += N; 
+} 
+ 
+/* Append formatted text (not to exceed N bytes) to the JsonString. 
+*/ 
+static void jsonPrintf(int N, JsonString *p, const char *zFormat, ...){ 
+  va_list ap; 
+  if( (p->nUsed + N >= p->nAlloc) && jsonGrow(p, N) ) return; 
+  va_start(ap, zFormat); 
+  sqlite3_vsnprintf(N, p->zBuf+p->nUsed, zFormat, ap); 
+  va_end(ap); 
+  p->nUsed += (int)strlen(p->zBuf+p->nUsed); 
+} 
+ 
+/* Append a single character 
+*/ 
+static void jsonAppendChar(JsonString *p, char c){ 
+  if( p->nUsed>=p->nAlloc && jsonGrow(p,1)!=0 ) return; 
+  p->zBuf[p->nUsed++] = c; 
+} 
+ 
+/* Append a comma separator to the output buffer, if the previous 
+** character is not '[' or '{'. 
+*/ 
+static void jsonAppendSeparator(JsonString *p){ 
+  char c; 
+  if( p->nUsed==0 ) return; 
+  c = p->zBuf[p->nUsed-1]; 
+  if( c!='[' && c!='{' ) jsonAppendChar(p, ','); 
+} 
+ 
+/* Append the N-byte string in zIn to the end of the JsonString string 
+** under construction.  Enclose the string in "..." and escape 
+** any double-quotes or backslash characters contained within the 
+** string. 
+*/ 
+static void jsonAppendString(JsonString *p, const char *zIn, u32 N){ 
+  u32 i; 
   if( zIn==0 || ((N+p->nUsed+2 >= p->nAlloc) && jsonGrow(p,N+2)!=0) ) return;
-  p->zBuf[p->nUsed++] = '"';
-  for(i=0; i<N; i++){
-    unsigned char c = ((unsigned const char*)zIn)[i];
-    if( c=='"' || c=='\\' ){
-      json_simple_escape:
-      if( (p->nUsed+N+3-i > p->nAlloc) && jsonGrow(p,N+3-i)!=0 ) return;
-      p->zBuf[p->nUsed++] = '\\';
-    }else if( c<=0x1f ){
-      static const char aSpecial[] = {
-         0, 0, 0, 0, 0, 0, 0, 0, 'b', 't', 'n', 0, 'f', 'r', 0, 0,
-         0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0, 0,   0,   0, 0, 0
-      };
-      assert( sizeof(aSpecial)==32 );
-      assert( aSpecial['\b']=='b' );
-      assert( aSpecial['\f']=='f' );
-      assert( aSpecial['\n']=='n' );
-      assert( aSpecial['\r']=='r' );
-      assert( aSpecial['\t']=='t' );
-      if( aSpecial[c] ){
-        c = aSpecial[c];
-        goto json_simple_escape;
-      }
-      if( (p->nUsed+N+7+i > p->nAlloc) && jsonGrow(p,N+7-i)!=0 ) return;
-      p->zBuf[p->nUsed++] = '\\';
-      p->zBuf[p->nUsed++] = 'u';
-      p->zBuf[p->nUsed++] = '0';
-      p->zBuf[p->nUsed++] = '0';
-      p->zBuf[p->nUsed++] = '0' + (c>>4);
-      c = "0123456789abcdef"[c&0xf];
-    }
-    p->zBuf[p->nUsed++] = c;
-  }
-  p->zBuf[p->nUsed++] = '"';
-  assert( p->nUsed<p->nAlloc );
-}
-
-/*
+  p->zBuf[p->nUsed++] = '"'; 
+  for(i=0; i<N; i++){ 
+    unsigned char c = ((unsigned const char*)zIn)[i]; 
+    if( c=='"' || c=='\\' ){ 
+      json_simple_escape: 
+      if( (p->nUsed+N+3-i > p->nAlloc) && jsonGrow(p,N+3-i)!=0 ) return; 
+      p->zBuf[p->nUsed++] = '\\'; 
+    }else if( c<=0x1f ){ 
+      static const char aSpecial[] = { 
+         0, 0, 0, 0, 0, 0, 0, 0, 'b', 't', 'n', 0, 'f', 'r', 0, 0, 
+         0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0, 0,   0,   0, 0, 0 
+      }; 
+      assert( sizeof(aSpecial)==32 ); 
+      assert( aSpecial['\b']=='b' ); 
+      assert( aSpecial['\f']=='f' ); 
+      assert( aSpecial['\n']=='n' ); 
+      assert( aSpecial['\r']=='r' ); 
+      assert( aSpecial['\t']=='t' ); 
+      if( aSpecial[c] ){ 
+        c = aSpecial[c]; 
+        goto json_simple_escape; 
+      } 
+      if( (p->nUsed+N+7+i > p->nAlloc) && jsonGrow(p,N+7-i)!=0 ) return; 
+      p->zBuf[p->nUsed++] = '\\'; 
+      p->zBuf[p->nUsed++] = 'u'; 
+      p->zBuf[p->nUsed++] = '0'; 
+      p->zBuf[p->nUsed++] = '0'; 
+      p->zBuf[p->nUsed++] = '0' + (c>>4); 
+      c = "0123456789abcdef"[c&0xf]; 
+    } 
+    p->zBuf[p->nUsed++] = c; 
+  } 
+  p->zBuf[p->nUsed++] = '"'; 
+  assert( p->nUsed<p->nAlloc ); 
+} 
+ 
+/* 
 ** Append a function parameter value to the JSON string under
-** construction.
-*/
-static void jsonAppendValue(
-  JsonString *p,                 /* Append to this JSON string */
-  sqlite3_value *pValue          /* Value to append */
-){
-  switch( sqlite3_value_type(pValue) ){
-    case SQLITE_NULL: {
-      jsonAppendRaw(p, "null", 4);
-      break;
-    }
-    case SQLITE_INTEGER:
-    case SQLITE_FLOAT: {
-      const char *z = (const char*)sqlite3_value_text(pValue);
-      u32 n = (u32)sqlite3_value_bytes(pValue);
-      jsonAppendRaw(p, z, n);
-      break;
-    }
-    case SQLITE_TEXT: {
-      const char *z = (const char*)sqlite3_value_text(pValue);
-      u32 n = (u32)sqlite3_value_bytes(pValue);
-      if( sqlite3_value_subtype(pValue)==JSON_SUBTYPE ){
-        jsonAppendRaw(p, z, n);
-      }else{
-        jsonAppendString(p, z, n);
-      }
-      break;
-    }
-    default: {
-      if( p->bErr==0 ){
-        sqlite3_result_error(p->pCtx, "JSON cannot hold BLOB values", -1);
-        p->bErr = 2;
-        jsonReset(p);
-      }
-      break;
-    }
-  }
-}
-
-
-/* Make the JSON in p the result of the SQL function.
-*/
-static void jsonResult(JsonString *p){
-  if( p->bErr==0 ){
+** construction. 
+*/ 
+static void jsonAppendValue( 
+  JsonString *p,                 /* Append to this JSON string */ 
+  sqlite3_value *pValue          /* Value to append */ 
+){ 
+  switch( sqlite3_value_type(pValue) ){ 
+    case SQLITE_NULL: { 
+      jsonAppendRaw(p, "null", 4); 
+      break; 
+    } 
+    case SQLITE_INTEGER: 
+    case SQLITE_FLOAT: { 
+      const char *z = (const char*)sqlite3_value_text(pValue); 
+      u32 n = (u32)sqlite3_value_bytes(pValue); 
+      jsonAppendRaw(p, z, n); 
+      break; 
+    } 
+    case SQLITE_TEXT: { 
+      const char *z = (const char*)sqlite3_value_text(pValue); 
+      u32 n = (u32)sqlite3_value_bytes(pValue); 
+      if( sqlite3_value_subtype(pValue)==JSON_SUBTYPE ){ 
+        jsonAppendRaw(p, z, n); 
+      }else{ 
+        jsonAppendString(p, z, n); 
+      } 
+      break; 
+    } 
+    default: { 
+      if( p->bErr==0 ){ 
+        sqlite3_result_error(p->pCtx, "JSON cannot hold BLOB values", -1); 
+        p->bErr = 2; 
+        jsonReset(p); 
+      } 
+      break; 
+    } 
+  } 
+} 
+ 
+ 
+/* Make the JSON in p the result of the SQL function. 
+*/ 
+static void jsonResult(JsonString *p){ 
+  if( p->bErr==0 ){ 
     sqlite3_result_text64(p->pCtx, p->zBuf, p->nUsed,
-                          p->bStatic ? SQLITE_TRANSIENT : sqlite3_free,
-                          SQLITE_UTF8);
-    jsonZero(p);
-  }
-  assert( p->bStatic );
-}
-
-/**************************************************************************
-** Utility routines for dealing with JsonNode and JsonParse objects
-**************************************************************************/
-
-/*
-** Return the number of consecutive JsonNode slots need to represent
-** the parsed JSON at pNode.  The minimum answer is 1.  For ARRAY and
-** OBJECT types, the number might be larger.
-**
-** Appended elements are not counted.  The value returned is the number
-** by which the JsonNode counter should increment in order to go to the
-** next peer value.
-*/
-static u32 jsonNodeSize(JsonNode *pNode){
-  return pNode->eType>=JSON_ARRAY ? pNode->n+1 : 1;
-}
-
-/*
-** Reclaim all memory allocated by a JsonParse object.  But do not
-** delete the JsonParse object itself.
-*/
-static void jsonParseReset(JsonParse *pParse){
-  sqlite3_free(pParse->aNode);
-  pParse->aNode = 0;
-  pParse->nNode = 0;
-  pParse->nAlloc = 0;
-  sqlite3_free(pParse->aUp);
-  pParse->aUp = 0;
-}
-
-/*
-** Free a JsonParse object that was obtained from sqlite3_malloc().
-*/
-static void jsonParseFree(JsonParse *pParse){
-  jsonParseReset(pParse);
-  sqlite3_free(pParse);
-}
-
-/*
-** Convert the JsonNode pNode into a pure JSON string and
-** append to pOut.  Subsubstructure is also included.  Return
-** the number of JsonNode objects that are encoded.
-*/
-static void jsonRenderNode(
-  JsonNode *pNode,               /* The node to render */
-  JsonString *pOut,              /* Write JSON here */
-  sqlite3_value **aReplace       /* Replacement values */
-){
+                          p->bStatic ? SQLITE_TRANSIENT : sqlite3_free, 
+                          SQLITE_UTF8); 
+    jsonZero(p); 
+  } 
+  assert( p->bStatic ); 
+} 
+ 
+/************************************************************************** 
+** Utility routines for dealing with JsonNode and JsonParse objects 
+**************************************************************************/ 
+ 
+/* 
+** Return the number of consecutive JsonNode slots need to represent 
+** the parsed JSON at pNode.  The minimum answer is 1.  For ARRAY and 
+** OBJECT types, the number might be larger. 
+** 
+** Appended elements are not counted.  The value returned is the number 
+** by which the JsonNode counter should increment in order to go to the 
+** next peer value. 
+*/ 
+static u32 jsonNodeSize(JsonNode *pNode){ 
+  return pNode->eType>=JSON_ARRAY ? pNode->n+1 : 1; 
+} 
+ 
+/* 
+** Reclaim all memory allocated by a JsonParse object.  But do not 
+** delete the JsonParse object itself. 
+*/ 
+static void jsonParseReset(JsonParse *pParse){ 
+  sqlite3_free(pParse->aNode); 
+  pParse->aNode = 0; 
+  pParse->nNode = 0; 
+  pParse->nAlloc = 0; 
+  sqlite3_free(pParse->aUp); 
+  pParse->aUp = 0; 
+} 
+ 
+/* 
+** Free a JsonParse object that was obtained from sqlite3_malloc(). 
+*/ 
+static void jsonParseFree(JsonParse *pParse){ 
+  jsonParseReset(pParse); 
+  sqlite3_free(pParse); 
+} 
+ 
+/* 
+** Convert the JsonNode pNode into a pure JSON string and 
+** append to pOut.  Subsubstructure is also included.  Return 
+** the number of JsonNode objects that are encoded. 
+*/ 
+static void jsonRenderNode( 
+  JsonNode *pNode,               /* The node to render */ 
+  JsonString *pOut,              /* Write JSON here */ 
+  sqlite3_value **aReplace       /* Replacement values */ 
+){ 
   assert( pNode!=0 );
-  if( pNode->jnFlags & (JNODE_REPLACE|JNODE_PATCH) ){
+  if( pNode->jnFlags & (JNODE_REPLACE|JNODE_PATCH) ){ 
     if( (pNode->jnFlags & JNODE_REPLACE)!=0 && ALWAYS(aReplace!=0) ){
       assert( pNode->eU==4 );
-      jsonAppendValue(pOut, aReplace[pNode->u.iReplace]);
-      return;
-    }
+      jsonAppendValue(pOut, aReplace[pNode->u.iReplace]); 
+      return; 
+    } 
     assert( pNode->eU==5 );
-    pNode = pNode->u.pPatch;
-  }
-  switch( pNode->eType ){
-    default: {
-      assert( pNode->eType==JSON_NULL );
-      jsonAppendRaw(pOut, "null", 4);
-      break;
-    }
-    case JSON_TRUE: {
-      jsonAppendRaw(pOut, "true", 4);
-      break;
-    }
-    case JSON_FALSE: {
-      jsonAppendRaw(pOut, "false", 5);
-      break;
-    }
-    case JSON_STRING: {
-      if( pNode->jnFlags & JNODE_RAW ){
+    pNode = pNode->u.pPatch; 
+  } 
+  switch( pNode->eType ){ 
+    default: { 
+      assert( pNode->eType==JSON_NULL ); 
+      jsonAppendRaw(pOut, "null", 4); 
+      break; 
+    } 
+    case JSON_TRUE: { 
+      jsonAppendRaw(pOut, "true", 4); 
+      break; 
+    } 
+    case JSON_FALSE: { 
+      jsonAppendRaw(pOut, "false", 5); 
+      break; 
+    } 
+    case JSON_STRING: { 
+      if( pNode->jnFlags & JNODE_RAW ){ 
         assert( pNode->eU==1 );
-        jsonAppendString(pOut, pNode->u.zJContent, pNode->n);
-        break;
-      }
+        jsonAppendString(pOut, pNode->u.zJContent, pNode->n); 
+        break; 
+      } 
       /* no break */ deliberate_fall_through
-    }
-    case JSON_REAL:
-    case JSON_INT: {
+    } 
+    case JSON_REAL: 
+    case JSON_INT: { 
       assert( pNode->eU==1 );
-      jsonAppendRaw(pOut, pNode->u.zJContent, pNode->n);
-      break;
-    }
-    case JSON_ARRAY: {
-      u32 j = 1;
-      jsonAppendChar(pOut, '[');
-      for(;;){
-        while( j<=pNode->n ){
-          if( (pNode[j].jnFlags & JNODE_REMOVE)==0 ){
-            jsonAppendSeparator(pOut);
-            jsonRenderNode(&pNode[j], pOut, aReplace);
-          }
-          j += jsonNodeSize(&pNode[j]);
-        }
-        if( (pNode->jnFlags & JNODE_APPEND)==0 ) break;
+      jsonAppendRaw(pOut, pNode->u.zJContent, pNode->n); 
+      break; 
+    } 
+    case JSON_ARRAY: { 
+      u32 j = 1; 
+      jsonAppendChar(pOut, '['); 
+      for(;;){ 
+        while( j<=pNode->n ){ 
+          if( (pNode[j].jnFlags & JNODE_REMOVE)==0 ){ 
+            jsonAppendSeparator(pOut); 
+            jsonRenderNode(&pNode[j], pOut, aReplace); 
+          } 
+          j += jsonNodeSize(&pNode[j]); 
+        } 
+        if( (pNode->jnFlags & JNODE_APPEND)==0 ) break; 
         assert( pNode->eU==2 );
-        pNode = &pNode[pNode->u.iAppend];
-        j = 1;
-      }
-      jsonAppendChar(pOut, ']');
-      break;
-    }
-    case JSON_OBJECT: {
-      u32 j = 1;
-      jsonAppendChar(pOut, '{');
-      for(;;){
-        while( j<=pNode->n ){
-          if( (pNode[j+1].jnFlags & JNODE_REMOVE)==0 ){
-            jsonAppendSeparator(pOut);
-            jsonRenderNode(&pNode[j], pOut, aReplace);
-            jsonAppendChar(pOut, ':');
-            jsonRenderNode(&pNode[j+1], pOut, aReplace);
-          }
-          j += 1 + jsonNodeSize(&pNode[j+1]);
-        }
-        if( (pNode->jnFlags & JNODE_APPEND)==0 ) break;
+        pNode = &pNode[pNode->u.iAppend]; 
+        j = 1; 
+      } 
+      jsonAppendChar(pOut, ']'); 
+      break; 
+    } 
+    case JSON_OBJECT: { 
+      u32 j = 1; 
+      jsonAppendChar(pOut, '{'); 
+      for(;;){ 
+        while( j<=pNode->n ){ 
+          if( (pNode[j+1].jnFlags & JNODE_REMOVE)==0 ){ 
+            jsonAppendSeparator(pOut); 
+            jsonRenderNode(&pNode[j], pOut, aReplace); 
+            jsonAppendChar(pOut, ':'); 
+            jsonRenderNode(&pNode[j+1], pOut, aReplace); 
+          } 
+          j += 1 + jsonNodeSize(&pNode[j+1]); 
+        } 
+        if( (pNode->jnFlags & JNODE_APPEND)==0 ) break; 
         assert( pNode->eU==2 );
-        pNode = &pNode[pNode->u.iAppend];
-        j = 1;
-      }
-      jsonAppendChar(pOut, '}');
-      break;
-    }
-  }
-}
-
-/*
-** Return a JsonNode and all its descendents as a JSON string.
-*/
-static void jsonReturnJson(
-  JsonNode *pNode,            /* Node to return */
-  sqlite3_context *pCtx,      /* Return value for this function */
-  sqlite3_value **aReplace    /* Array of replacement values */
-){
-  JsonString s;
-  jsonInit(&s, pCtx);
-  jsonRenderNode(pNode, &s, aReplace);
-  jsonResult(&s);
-  sqlite3_result_subtype(pCtx, JSON_SUBTYPE);
-}
-
-/*
+        pNode = &pNode[pNode->u.iAppend]; 
+        j = 1; 
+      } 
+      jsonAppendChar(pOut, '}'); 
+      break; 
+    } 
+  } 
+} 
+ 
+/* 
+** Return a JsonNode and all its descendents as a JSON string. 
+*/ 
+static void jsonReturnJson( 
+  JsonNode *pNode,            /* Node to return */ 
+  sqlite3_context *pCtx,      /* Return value for this function */ 
+  sqlite3_value **aReplace    /* Array of replacement values */ 
+){ 
+  JsonString s; 
+  jsonInit(&s, pCtx); 
+  jsonRenderNode(pNode, &s, aReplace); 
+  jsonResult(&s); 
+  sqlite3_result_subtype(pCtx, JSON_SUBTYPE); 
+} 
+ 
+/* 
 ** Translate a single byte of Hex into an integer.
 ** This routine only works if h really is a valid hexadecimal
 ** character:  0..9a..fA..F
@@ -191833,116 +191833,116 @@ static u32 jsonHexToInt4(const char *z){
 }
 
 /*
-** Make the JsonNode the return value of the function.
-*/
-static void jsonReturn(
-  JsonNode *pNode,            /* Node to return */
-  sqlite3_context *pCtx,      /* Return value for this function */
-  sqlite3_value **aReplace    /* Array of replacement values */
-){
-  switch( pNode->eType ){
-    default: {
-      assert( pNode->eType==JSON_NULL );
-      sqlite3_result_null(pCtx);
-      break;
-    }
-    case JSON_TRUE: {
-      sqlite3_result_int(pCtx, 1);
-      break;
-    }
-    case JSON_FALSE: {
-      sqlite3_result_int(pCtx, 0);
-      break;
-    }
-    case JSON_INT: {
-      sqlite3_int64 i = 0;
+** Make the JsonNode the return value of the function. 
+*/ 
+static void jsonReturn( 
+  JsonNode *pNode,            /* Node to return */ 
+  sqlite3_context *pCtx,      /* Return value for this function */ 
+  sqlite3_value **aReplace    /* Array of replacement values */ 
+){ 
+  switch( pNode->eType ){ 
+    default: { 
+      assert( pNode->eType==JSON_NULL ); 
+      sqlite3_result_null(pCtx); 
+      break; 
+    } 
+    case JSON_TRUE: { 
+      sqlite3_result_int(pCtx, 1); 
+      break; 
+    } 
+    case JSON_FALSE: { 
+      sqlite3_result_int(pCtx, 0); 
+      break; 
+    } 
+    case JSON_INT: { 
+      sqlite3_int64 i = 0; 
       const char *z;
       assert( pNode->eU==1 );
       z = pNode->u.zJContent;
-      if( z[0]=='-' ){ z++; }
-      while( z[0]>='0' && z[0]<='9' ){
-        unsigned v = *(z++) - '0';
-        if( i>=LARGEST_INT64/10 ){
-          if( i>LARGEST_INT64/10 ) goto int_as_real;
-          if( z[0]>='0' && z[0]<='9' ) goto int_as_real;
-          if( v==9 ) goto int_as_real;
-          if( v==8 ){
-            if( pNode->u.zJContent[0]=='-' ){
-              sqlite3_result_int64(pCtx, SMALLEST_INT64);
-              goto int_done;
-            }else{
-              goto int_as_real;
-            }
-          }
-        }
-        i = i*10 + v;
-      }
-      if( pNode->u.zJContent[0]=='-' ){ i = -i; }
-      sqlite3_result_int64(pCtx, i);
-      int_done:
-      break;
+      if( z[0]=='-' ){ z++; } 
+      while( z[0]>='0' && z[0]<='9' ){ 
+        unsigned v = *(z++) - '0'; 
+        if( i>=LARGEST_INT64/10 ){ 
+          if( i>LARGEST_INT64/10 ) goto int_as_real; 
+          if( z[0]>='0' && z[0]<='9' ) goto int_as_real; 
+          if( v==9 ) goto int_as_real; 
+          if( v==8 ){ 
+            if( pNode->u.zJContent[0]=='-' ){ 
+              sqlite3_result_int64(pCtx, SMALLEST_INT64); 
+              goto int_done; 
+            }else{ 
+              goto int_as_real; 
+            } 
+          } 
+        } 
+        i = i*10 + v; 
+      } 
+      if( pNode->u.zJContent[0]=='-' ){ i = -i; } 
+      sqlite3_result_int64(pCtx, i); 
+      int_done: 
+      break; 
       int_as_real: ; /* no break */ deliberate_fall_through
-    }
-    case JSON_REAL: {
-      double r;
-#ifdef SQLITE_AMALGAMATION
+    } 
+    case JSON_REAL: { 
+      double r; 
+#ifdef SQLITE_AMALGAMATION 
       const char *z;
       assert( pNode->eU==1 );
       z = pNode->u.zJContent;
-      sqlite3AtoF(z, &r, sqlite3Strlen30(z), SQLITE_UTF8);
-#else
+      sqlite3AtoF(z, &r, sqlite3Strlen30(z), SQLITE_UTF8); 
+#else 
       assert( pNode->eU==1 );
-      r = strtod(pNode->u.zJContent, 0);
-#endif
-      sqlite3_result_double(pCtx, r);
-      break;
-    }
-    case JSON_STRING: {
-#if 0 /* Never happens because JNODE_RAW is only set by json_set(),
-      ** json_insert() and json_replace() and those routines do not
-      ** call jsonReturn() */
-      if( pNode->jnFlags & JNODE_RAW ){
+      r = strtod(pNode->u.zJContent, 0); 
+#endif 
+      sqlite3_result_double(pCtx, r); 
+      break; 
+    } 
+    case JSON_STRING: { 
+#if 0 /* Never happens because JNODE_RAW is only set by json_set(), 
+      ** json_insert() and json_replace() and those routines do not 
+      ** call jsonReturn() */ 
+      if( pNode->jnFlags & JNODE_RAW ){ 
         assert( pNode->eU==1 );
-        sqlite3_result_text(pCtx, pNode->u.zJContent, pNode->n,
-                            SQLITE_TRANSIENT);
+        sqlite3_result_text(pCtx, pNode->u.zJContent, pNode->n, 
+                            SQLITE_TRANSIENT); 
       }else
-#endif
-      assert( (pNode->jnFlags & JNODE_RAW)==0 );
-      if( (pNode->jnFlags & JNODE_ESCAPE)==0 ){
-        /* JSON formatted without any backslash-escapes */
+#endif 
+      assert( (pNode->jnFlags & JNODE_RAW)==0 ); 
+      if( (pNode->jnFlags & JNODE_ESCAPE)==0 ){ 
+        /* JSON formatted without any backslash-escapes */ 
         assert( pNode->eU==1 );
-        sqlite3_result_text(pCtx, pNode->u.zJContent+1, pNode->n-2,
-                            SQLITE_TRANSIENT);
-      }else{
-        /* Translate JSON formatted string into raw text */
-        u32 i;
-        u32 n = pNode->n;
+        sqlite3_result_text(pCtx, pNode->u.zJContent+1, pNode->n-2, 
+                            SQLITE_TRANSIENT); 
+      }else{ 
+        /* Translate JSON formatted string into raw text */ 
+        u32 i; 
+        u32 n = pNode->n; 
         const char *z;
-        char *zOut;
-        u32 j;
+        char *zOut; 
+        u32 j; 
         assert( pNode->eU==1 );
         z = pNode->u.zJContent;
-        zOut = sqlite3_malloc( n+1 );
-        if( zOut==0 ){
-          sqlite3_result_error_nomem(pCtx);
-          break;
-        }
-        for(i=1, j=0; i<n-1; i++){
-          char c = z[i];
-          if( c!='\\' ){
-            zOut[j++] = c;
-          }else{
-            c = z[++i];
-            if( c=='u' ){
+        zOut = sqlite3_malloc( n+1 ); 
+        if( zOut==0 ){ 
+          sqlite3_result_error_nomem(pCtx); 
+          break; 
+        } 
+        for(i=1, j=0; i<n-1; i++){ 
+          char c = z[i]; 
+          if( c!='\\' ){ 
+            zOut[j++] = c; 
+          }else{ 
+            c = z[++i]; 
+            if( c=='u' ){ 
               u32 v = jsonHexToInt4(z+i+1);
               i += 4;
-              if( v==0 ) break;
-              if( v<=0x7f ){
-                zOut[j++] = (char)v;
-              }else if( v<=0x7ff ){
-                zOut[j++] = (char)(0xc0 | (v>>6));
-                zOut[j++] = 0x80 | (v&0x3f);
-              }else{
+              if( v==0 ) break; 
+              if( v<=0x7f ){ 
+                zOut[j++] = (char)v; 
+              }else if( v<=0x7ff ){ 
+                zOut[j++] = (char)(0xc0 | (v>>6)); 
+                zOut[j++] = 0x80 | (v&0x3f); 
+              }else{ 
                 u32 vlo;
                 if( (v&0xfc00)==0xd800
                   && i<n-6
@@ -191962,521 +191962,521 @@ static void jsonReturn(
                   zOut[j++] = 0x80 | ((v>>6)&0x3f);
                   zOut[j++] = 0x80 | (v&0x3f);
                 }
-              }
-            }else{
-              if( c=='b' ){
-                c = '\b';
-              }else if( c=='f' ){
-                c = '\f';
-              }else if( c=='n' ){
-                c = '\n';
-              }else if( c=='r' ){
-                c = '\r';
-              }else if( c=='t' ){
-                c = '\t';
-              }
-              zOut[j++] = c;
-            }
-          }
-        }
-        zOut[j] = 0;
-        sqlite3_result_text(pCtx, zOut, j, sqlite3_free);
-      }
-      break;
-    }
-    case JSON_ARRAY:
-    case JSON_OBJECT: {
-      jsonReturnJson(pNode, pCtx, aReplace);
-      break;
-    }
-  }
-}
-
-/* Forward reference */
-static int jsonParseAddNode(JsonParse*,u32,u32,const char*);
-
-/*
-** A macro to hint to the compiler that a function should not be
-** inlined.
-*/
-#if defined(__GNUC__)
-#  define JSON_NOINLINE  __attribute__((noinline))
-#elif defined(_MSC_VER) && _MSC_VER>=1310
-#  define JSON_NOINLINE  __declspec(noinline)
-#else
-#  define JSON_NOINLINE
-#endif
-
-
-static JSON_NOINLINE int jsonParseAddNodeExpand(
-  JsonParse *pParse,        /* Append the node to this object */
-  u32 eType,                /* Node type */
-  u32 n,                    /* Content size or sub-node count */
-  const char *zContent      /* Content */
-){
-  u32 nNew;
-  JsonNode *pNew;
-  assert( pParse->nNode>=pParse->nAlloc );
-  if( pParse->oom ) return -1;
-  nNew = pParse->nAlloc*2 + 10;
-  pNew = sqlite3_realloc64(pParse->aNode, sizeof(JsonNode)*nNew);
-  if( pNew==0 ){
-    pParse->oom = 1;
-    return -1;
-  }
-  pParse->nAlloc = nNew;
-  pParse->aNode = pNew;
-  assert( pParse->nNode<pParse->nAlloc );
-  return jsonParseAddNode(pParse, eType, n, zContent);
-}
-
-/*
-** Create a new JsonNode instance based on the arguments and append that
-** instance to the JsonParse.  Return the index in pParse->aNode[] of the
-** new node, or -1 if a memory allocation fails.
-*/
-static int jsonParseAddNode(
-  JsonParse *pParse,        /* Append the node to this object */
-  u32 eType,                /* Node type */
-  u32 n,                    /* Content size or sub-node count */
-  const char *zContent      /* Content */
-){
-  JsonNode *p;
+              } 
+            }else{ 
+              if( c=='b' ){ 
+                c = '\b'; 
+              }else if( c=='f' ){ 
+                c = '\f'; 
+              }else if( c=='n' ){ 
+                c = '\n'; 
+              }else if( c=='r' ){ 
+                c = '\r'; 
+              }else if( c=='t' ){ 
+                c = '\t'; 
+              } 
+              zOut[j++] = c; 
+            } 
+          } 
+        } 
+        zOut[j] = 0; 
+        sqlite3_result_text(pCtx, zOut, j, sqlite3_free); 
+      } 
+      break; 
+    } 
+    case JSON_ARRAY: 
+    case JSON_OBJECT: { 
+      jsonReturnJson(pNode, pCtx, aReplace); 
+      break; 
+    } 
+  } 
+} 
+ 
+/* Forward reference */ 
+static int jsonParseAddNode(JsonParse*,u32,u32,const char*); 
+ 
+/* 
+** A macro to hint to the compiler that a function should not be 
+** inlined. 
+*/ 
+#if defined(__GNUC__) 
+#  define JSON_NOINLINE  __attribute__((noinline)) 
+#elif defined(_MSC_VER) && _MSC_VER>=1310 
+#  define JSON_NOINLINE  __declspec(noinline) 
+#else 
+#  define JSON_NOINLINE 
+#endif 
+ 
+ 
+static JSON_NOINLINE int jsonParseAddNodeExpand( 
+  JsonParse *pParse,        /* Append the node to this object */ 
+  u32 eType,                /* Node type */ 
+  u32 n,                    /* Content size or sub-node count */ 
+  const char *zContent      /* Content */ 
+){ 
+  u32 nNew; 
+  JsonNode *pNew; 
+  assert( pParse->nNode>=pParse->nAlloc ); 
+  if( pParse->oom ) return -1; 
+  nNew = pParse->nAlloc*2 + 10; 
+  pNew = sqlite3_realloc64(pParse->aNode, sizeof(JsonNode)*nNew); 
+  if( pNew==0 ){ 
+    pParse->oom = 1; 
+    return -1; 
+  } 
+  pParse->nAlloc = nNew; 
+  pParse->aNode = pNew; 
+  assert( pParse->nNode<pParse->nAlloc ); 
+  return jsonParseAddNode(pParse, eType, n, zContent); 
+} 
+ 
+/* 
+** Create a new JsonNode instance based on the arguments and append that 
+** instance to the JsonParse.  Return the index in pParse->aNode[] of the 
+** new node, or -1 if a memory allocation fails. 
+*/ 
+static int jsonParseAddNode( 
+  JsonParse *pParse,        /* Append the node to this object */ 
+  u32 eType,                /* Node type */ 
+  u32 n,                    /* Content size or sub-node count */ 
+  const char *zContent      /* Content */ 
+){ 
+  JsonNode *p; 
   if( pParse->aNode==0 || pParse->nNode>=pParse->nAlloc ){
-    return jsonParseAddNodeExpand(pParse, eType, n, zContent);
-  }
-  p = &pParse->aNode[pParse->nNode];
-  p->eType = (u8)eType;
-  p->jnFlags = 0;
+    return jsonParseAddNodeExpand(pParse, eType, n, zContent); 
+  } 
+  p = &pParse->aNode[pParse->nNode]; 
+  p->eType = (u8)eType; 
+  p->jnFlags = 0; 
   VVA( p->eU = zContent ? 1 : 0 );
-  p->n = n;
-  p->u.zJContent = zContent;
-  return pParse->nNode++;
-}
-
-/*
-** Return true if z[] begins with 4 (or more) hexadecimal digits
-*/
-static int jsonIs4Hex(const char *z){
-  int i;
-  for(i=0; i<4; i++) if( !safe_isxdigit(z[i]) ) return 0;
-  return 1;
-}
-
-/*
-** Parse a single JSON value which begins at pParse->zJson[i].  Return the
-** index of the first character past the end of the value parsed.
-**
-** Return negative for a syntax error.  Special cases:  return -2 if the
-** first non-whitespace character is '}' and return -3 if the first
-** non-whitespace character is ']'.
-*/
-static int jsonParseValue(JsonParse *pParse, u32 i){
-  char c;
-  u32 j;
-  int iThis;
-  int x;
-  JsonNode *pNode;
-  const char *z = pParse->zJson;
-  while( safe_isspace(z[i]) ){ i++; }
-  if( (c = z[i])=='{' ){
-    /* Parse object */
-    iThis = jsonParseAddNode(pParse, JSON_OBJECT, 0, 0);
-    if( iThis<0 ) return -1;
-    for(j=i+1;;j++){
-      while( safe_isspace(z[j]) ){ j++; }
-      if( ++pParse->iDepth > JSON_MAX_DEPTH ) return -1;
-      x = jsonParseValue(pParse, j);
-      if( x<0 ){
-        pParse->iDepth--;
-        if( x==(-2) && pParse->nNode==(u32)iThis+1 ) return j+1;
-        return -1;
-      }
-      if( pParse->oom ) return -1;
-      pNode = &pParse->aNode[pParse->nNode-1];
-      if( pNode->eType!=JSON_STRING ) return -1;
-      pNode->jnFlags |= JNODE_LABEL;
-      j = x;
-      while( safe_isspace(z[j]) ){ j++; }
-      if( z[j]!=':' ) return -1;
-      j++;
-      x = jsonParseValue(pParse, j);
-      pParse->iDepth--;
-      if( x<0 ) return -1;
-      j = x;
-      while( safe_isspace(z[j]) ){ j++; }
-      c = z[j];
-      if( c==',' ) continue;
-      if( c!='}' ) return -1;
-      break;
-    }
-    pParse->aNode[iThis].n = pParse->nNode - (u32)iThis - 1;
-    return j+1;
-  }else if( c=='[' ){
-    /* Parse array */
-    iThis = jsonParseAddNode(pParse, JSON_ARRAY, 0, 0);
-    if( iThis<0 ) return -1;
+  p->n = n; 
+  p->u.zJContent = zContent; 
+  return pParse->nNode++; 
+} 
+ 
+/* 
+** Return true if z[] begins with 4 (or more) hexadecimal digits 
+*/ 
+static int jsonIs4Hex(const char *z){ 
+  int i; 
+  for(i=0; i<4; i++) if( !safe_isxdigit(z[i]) ) return 0; 
+  return 1; 
+} 
+ 
+/* 
+** Parse a single JSON value which begins at pParse->zJson[i].  Return the 
+** index of the first character past the end of the value parsed. 
+** 
+** Return negative for a syntax error.  Special cases:  return -2 if the 
+** first non-whitespace character is '}' and return -3 if the first 
+** non-whitespace character is ']'. 
+*/ 
+static int jsonParseValue(JsonParse *pParse, u32 i){ 
+  char c; 
+  u32 j; 
+  int iThis; 
+  int x; 
+  JsonNode *pNode; 
+  const char *z = pParse->zJson; 
+  while( safe_isspace(z[i]) ){ i++; } 
+  if( (c = z[i])=='{' ){ 
+    /* Parse object */ 
+    iThis = jsonParseAddNode(pParse, JSON_OBJECT, 0, 0); 
+    if( iThis<0 ) return -1; 
+    for(j=i+1;;j++){ 
+      while( safe_isspace(z[j]) ){ j++; } 
+      if( ++pParse->iDepth > JSON_MAX_DEPTH ) return -1; 
+      x = jsonParseValue(pParse, j); 
+      if( x<0 ){ 
+        pParse->iDepth--; 
+        if( x==(-2) && pParse->nNode==(u32)iThis+1 ) return j+1; 
+        return -1; 
+      } 
+      if( pParse->oom ) return -1; 
+      pNode = &pParse->aNode[pParse->nNode-1]; 
+      if( pNode->eType!=JSON_STRING ) return -1; 
+      pNode->jnFlags |= JNODE_LABEL; 
+      j = x; 
+      while( safe_isspace(z[j]) ){ j++; } 
+      if( z[j]!=':' ) return -1; 
+      j++; 
+      x = jsonParseValue(pParse, j); 
+      pParse->iDepth--; 
+      if( x<0 ) return -1; 
+      j = x; 
+      while( safe_isspace(z[j]) ){ j++; } 
+      c = z[j]; 
+      if( c==',' ) continue; 
+      if( c!='}' ) return -1; 
+      break; 
+    } 
+    pParse->aNode[iThis].n = pParse->nNode - (u32)iThis - 1; 
+    return j+1; 
+  }else if( c=='[' ){ 
+    /* Parse array */ 
+    iThis = jsonParseAddNode(pParse, JSON_ARRAY, 0, 0); 
+    if( iThis<0 ) return -1; 
     memset(&pParse->aNode[iThis].u, 0, sizeof(pParse->aNode[iThis].u));
-    for(j=i+1;;j++){
-      while( safe_isspace(z[j]) ){ j++; }
-      if( ++pParse->iDepth > JSON_MAX_DEPTH ) return -1;
-      x = jsonParseValue(pParse, j);
-      pParse->iDepth--;
-      if( x<0 ){
-        if( x==(-3) && pParse->nNode==(u32)iThis+1 ) return j+1;
-        return -1;
-      }
-      j = x;
-      while( safe_isspace(z[j]) ){ j++; }
-      c = z[j];
-      if( c==',' ) continue;
-      if( c!=']' ) return -1;
-      break;
-    }
-    pParse->aNode[iThis].n = pParse->nNode - (u32)iThis - 1;
-    return j+1;
-  }else if( c=='"' ){
-    /* Parse string */
-    u8 jnFlags = 0;
-    j = i+1;
-    for(;;){
-      c = z[j];
-      if( (c & ~0x1f)==0 ){
-        /* Control characters are not allowed in strings */
-        return -1;
-      }
-      if( c=='\\' ){
-        c = z[++j];
-        if( c=='"' || c=='\\' || c=='/' || c=='b' || c=='f'
-           || c=='n' || c=='r' || c=='t'
-           || (c=='u' && jsonIs4Hex(z+j+1)) ){
-          jnFlags = JNODE_ESCAPE;
-        }else{
-          return -1;
-        }
-      }else if( c=='"' ){
-        break;
-      }
-      j++;
-    }
-    jsonParseAddNode(pParse, JSON_STRING, j+1-i, &z[i]);
-    if( !pParse->oom ) pParse->aNode[pParse->nNode-1].jnFlags = jnFlags;
-    return j+1;
-  }else if( c=='n'
-         && strncmp(z+i,"null",4)==0
-         && !safe_isalnum(z[i+4]) ){
-    jsonParseAddNode(pParse, JSON_NULL, 0, 0);
-    return i+4;
-  }else if( c=='t'
-         && strncmp(z+i,"true",4)==0
-         && !safe_isalnum(z[i+4]) ){
-    jsonParseAddNode(pParse, JSON_TRUE, 0, 0);
-    return i+4;
-  }else if( c=='f'
-         && strncmp(z+i,"false",5)==0
-         && !safe_isalnum(z[i+5]) ){
-    jsonParseAddNode(pParse, JSON_FALSE, 0, 0);
-    return i+5;
-  }else if( c=='-' || (c>='0' && c<='9') ){
-    /* Parse number */
-    u8 seenDP = 0;
-    u8 seenE = 0;
-    assert( '-' < '0' );
-    if( c<='0' ){
-      j = c=='-' ? i+1 : i;
-      if( z[j]=='0' && z[j+1]>='0' && z[j+1]<='9' ) return -1;
-    }
-    j = i+1;
-    for(;; j++){
-      c = z[j];
-      if( c>='0' && c<='9' ) continue;
-      if( c=='.' ){
-        if( z[j-1]=='-' ) return -1;
-        if( seenDP ) return -1;
-        seenDP = 1;
-        continue;
-      }
-      if( c=='e' || c=='E' ){
-        if( z[j-1]<'0' ) return -1;
-        if( seenE ) return -1;
-        seenDP = seenE = 1;
-        c = z[j+1];
-        if( c=='+' || c=='-' ){
-          j++;
-          c = z[j+1];
-        }
-        if( c<'0' || c>'9' ) return -1;
-        continue;
-      }
-      break;
-    }
-    if( z[j-1]<'0' ) return -1;
-    jsonParseAddNode(pParse, seenDP ? JSON_REAL : JSON_INT,
-                        j - i, &z[i]);
-    return j;
-  }else if( c=='}' ){
-    return -2;  /* End of {...} */
-  }else if( c==']' ){
-    return -3;  /* End of [...] */
-  }else if( c==0 ){
-    return 0;   /* End of file */
-  }else{
-    return -1;  /* Syntax error */
-  }
-}
-
-/*
-** Parse a complete JSON string.  Return 0 on success or non-zero if there
-** are any errors.  If an error occurs, free all memory associated with
-** pParse.
-**
-** pParse is uninitialized when this routine is called.
-*/
-static int jsonParse(
-  JsonParse *pParse,           /* Initialize and fill this JsonParse object */
-  sqlite3_context *pCtx,       /* Report errors here */
-  const char *zJson            /* Input JSON text to be parsed */
-){
-  int i;
-  memset(pParse, 0, sizeof(*pParse));
-  if( zJson==0 ) return 1;
-  pParse->zJson = zJson;
-  i = jsonParseValue(pParse, 0);
-  if( pParse->oom ) i = -1;
-  if( i>0 ){
-    assert( pParse->iDepth==0 );
-    while( safe_isspace(zJson[i]) ) i++;
-    if( zJson[i] ) i = -1;
-  }
-  if( i<=0 ){
-    if( pCtx!=0 ){
-      if( pParse->oom ){
-        sqlite3_result_error_nomem(pCtx);
-      }else{
-        sqlite3_result_error(pCtx, "malformed JSON", -1);
-      }
-    }
-    jsonParseReset(pParse);
-    return 1;
-  }
-  return 0;
-}
-
-/* Mark node i of pParse as being a child of iParent.  Call recursively
-** to fill in all the descendants of node i.
-*/
-static void jsonParseFillInParentage(JsonParse *pParse, u32 i, u32 iParent){
-  JsonNode *pNode = &pParse->aNode[i];
-  u32 j;
-  pParse->aUp[i] = iParent;
-  switch( pNode->eType ){
-    case JSON_ARRAY: {
-      for(j=1; j<=pNode->n; j += jsonNodeSize(pNode+j)){
-        jsonParseFillInParentage(pParse, i+j, i);
-      }
-      break;
-    }
-    case JSON_OBJECT: {
-      for(j=1; j<=pNode->n; j += jsonNodeSize(pNode+j+1)+1){
-        pParse->aUp[i+j] = i;
-        jsonParseFillInParentage(pParse, i+j+1, i);
-      }
-      break;
-    }
-    default: {
-      break;
-    }
-  }
-}
-
-/*
-** Compute the parentage of all nodes in a completed parse.
-*/
-static int jsonParseFindParents(JsonParse *pParse){
-  u32 *aUp;
-  assert( pParse->aUp==0 );
-  aUp = pParse->aUp = sqlite3_malloc64( sizeof(u32)*pParse->nNode );
-  if( aUp==0 ){
-    pParse->oom = 1;
-    return SQLITE_NOMEM;
-  }
-  jsonParseFillInParentage(pParse, 0, 0);
-  return SQLITE_OK;
-}
-
-/*
-** Magic number used for the JSON parse cache in sqlite3_get_auxdata()
-*/
-#define JSON_CACHE_ID  (-429938)  /* First cache entry */
-#define JSON_CACHE_SZ  4          /* Max number of cache entries */
-
-/*
-** Obtain a complete parse of the JSON found in the first argument
-** of the argv array.  Use the sqlite3_get_auxdata() cache for this
-** parse if it is available.  If the cache is not available or if it
-** is no longer valid, parse the JSON again and return the new parse,
-** and also register the new parse so that it will be available for
-** future sqlite3_get_auxdata() calls.
-*/
-static JsonParse *jsonParseCached(
-  sqlite3_context *pCtx,
-  sqlite3_value **argv,
-  sqlite3_context *pErrCtx
-){
-  const char *zJson = (const char*)sqlite3_value_text(argv[0]);
-  int nJson = sqlite3_value_bytes(argv[0]);
-  JsonParse *p;
-  JsonParse *pMatch = 0;
-  int iKey;
-  int iMinKey = 0;
-  u32 iMinHold = 0xffffffff;
-  u32 iMaxHold = 0;
-  if( zJson==0 ) return 0;
-  for(iKey=0; iKey<JSON_CACHE_SZ; iKey++){
-    p = (JsonParse*)sqlite3_get_auxdata(pCtx, JSON_CACHE_ID+iKey);
-    if( p==0 ){
-      iMinKey = iKey;
-      break;
-    }
-    if( pMatch==0
-     && p->nJson==nJson
-     && memcmp(p->zJson,zJson,nJson)==0
-    ){
-      p->nErr = 0;
-      pMatch = p;
-    }else if( p->iHold<iMinHold ){
-      iMinHold = p->iHold;
-      iMinKey = iKey;
-    }
-    if( p->iHold>iMaxHold ){
-      iMaxHold = p->iHold;
-    }
-  }
-  if( pMatch ){
-    pMatch->nErr = 0;
-    pMatch->iHold = iMaxHold+1;
-    return pMatch;
-  }
-  p = sqlite3_malloc64( sizeof(*p) + nJson + 1 );
-  if( p==0 ){
-    sqlite3_result_error_nomem(pCtx);
-    return 0;
-  }
-  memset(p, 0, sizeof(*p));
-  p->zJson = (char*)&p[1];
-  memcpy((char*)p->zJson, zJson, nJson+1);
-  if( jsonParse(p, pErrCtx, p->zJson) ){
-    sqlite3_free(p);
-    return 0;
-  }
-  p->nJson = nJson;
-  p->iHold = iMaxHold+1;
-  sqlite3_set_auxdata(pCtx, JSON_CACHE_ID+iMinKey, p,
-                      (void(*)(void*))jsonParseFree);
-  return (JsonParse*)sqlite3_get_auxdata(pCtx, JSON_CACHE_ID+iMinKey);
-}
-
-/*
-** Compare the OBJECT label at pNode against zKey,nKey.  Return true on
-** a match.
-*/
-static int jsonLabelCompare(JsonNode *pNode, const char *zKey, u32 nKey){
+    for(j=i+1;;j++){ 
+      while( safe_isspace(z[j]) ){ j++; } 
+      if( ++pParse->iDepth > JSON_MAX_DEPTH ) return -1; 
+      x = jsonParseValue(pParse, j); 
+      pParse->iDepth--; 
+      if( x<0 ){ 
+        if( x==(-3) && pParse->nNode==(u32)iThis+1 ) return j+1; 
+        return -1; 
+      } 
+      j = x; 
+      while( safe_isspace(z[j]) ){ j++; } 
+      c = z[j]; 
+      if( c==',' ) continue; 
+      if( c!=']' ) return -1; 
+      break; 
+    } 
+    pParse->aNode[iThis].n = pParse->nNode - (u32)iThis - 1; 
+    return j+1; 
+  }else if( c=='"' ){ 
+    /* Parse string */ 
+    u8 jnFlags = 0; 
+    j = i+1; 
+    for(;;){ 
+      c = z[j]; 
+      if( (c & ~0x1f)==0 ){ 
+        /* Control characters are not allowed in strings */ 
+        return -1; 
+      } 
+      if( c=='\\' ){ 
+        c = z[++j]; 
+        if( c=='"' || c=='\\' || c=='/' || c=='b' || c=='f' 
+           || c=='n' || c=='r' || c=='t' 
+           || (c=='u' && jsonIs4Hex(z+j+1)) ){ 
+          jnFlags = JNODE_ESCAPE; 
+        }else{ 
+          return -1; 
+        } 
+      }else if( c=='"' ){ 
+        break; 
+      } 
+      j++; 
+    } 
+    jsonParseAddNode(pParse, JSON_STRING, j+1-i, &z[i]); 
+    if( !pParse->oom ) pParse->aNode[pParse->nNode-1].jnFlags = jnFlags; 
+    return j+1; 
+  }else if( c=='n' 
+         && strncmp(z+i,"null",4)==0 
+         && !safe_isalnum(z[i+4]) ){ 
+    jsonParseAddNode(pParse, JSON_NULL, 0, 0); 
+    return i+4; 
+  }else if( c=='t' 
+         && strncmp(z+i,"true",4)==0 
+         && !safe_isalnum(z[i+4]) ){ 
+    jsonParseAddNode(pParse, JSON_TRUE, 0, 0); 
+    return i+4; 
+  }else if( c=='f' 
+         && strncmp(z+i,"false",5)==0 
+         && !safe_isalnum(z[i+5]) ){ 
+    jsonParseAddNode(pParse, JSON_FALSE, 0, 0); 
+    return i+5; 
+  }else if( c=='-' || (c>='0' && c<='9') ){ 
+    /* Parse number */ 
+    u8 seenDP = 0; 
+    u8 seenE = 0; 
+    assert( '-' < '0' ); 
+    if( c<='0' ){ 
+      j = c=='-' ? i+1 : i; 
+      if( z[j]=='0' && z[j+1]>='0' && z[j+1]<='9' ) return -1; 
+    } 
+    j = i+1; 
+    for(;; j++){ 
+      c = z[j]; 
+      if( c>='0' && c<='9' ) continue; 
+      if( c=='.' ){ 
+        if( z[j-1]=='-' ) return -1; 
+        if( seenDP ) return -1; 
+        seenDP = 1; 
+        continue; 
+      } 
+      if( c=='e' || c=='E' ){ 
+        if( z[j-1]<'0' ) return -1; 
+        if( seenE ) return -1; 
+        seenDP = seenE = 1; 
+        c = z[j+1]; 
+        if( c=='+' || c=='-' ){ 
+          j++; 
+          c = z[j+1]; 
+        } 
+        if( c<'0' || c>'9' ) return -1; 
+        continue; 
+      } 
+      break; 
+    } 
+    if( z[j-1]<'0' ) return -1; 
+    jsonParseAddNode(pParse, seenDP ? JSON_REAL : JSON_INT, 
+                        j - i, &z[i]); 
+    return j; 
+  }else if( c=='}' ){ 
+    return -2;  /* End of {...} */ 
+  }else if( c==']' ){ 
+    return -3;  /* End of [...] */ 
+  }else if( c==0 ){ 
+    return 0;   /* End of file */ 
+  }else{ 
+    return -1;  /* Syntax error */ 
+  } 
+} 
+ 
+/* 
+** Parse a complete JSON string.  Return 0 on success or non-zero if there 
+** are any errors.  If an error occurs, free all memory associated with 
+** pParse. 
+** 
+** pParse is uninitialized when this routine is called. 
+*/ 
+static int jsonParse( 
+  JsonParse *pParse,           /* Initialize and fill this JsonParse object */ 
+  sqlite3_context *pCtx,       /* Report errors here */ 
+  const char *zJson            /* Input JSON text to be parsed */ 
+){ 
+  int i; 
+  memset(pParse, 0, sizeof(*pParse)); 
+  if( zJson==0 ) return 1; 
+  pParse->zJson = zJson; 
+  i = jsonParseValue(pParse, 0); 
+  if( pParse->oom ) i = -1; 
+  if( i>0 ){ 
+    assert( pParse->iDepth==0 ); 
+    while( safe_isspace(zJson[i]) ) i++; 
+    if( zJson[i] ) i = -1; 
+  } 
+  if( i<=0 ){ 
+    if( pCtx!=0 ){ 
+      if( pParse->oom ){ 
+        sqlite3_result_error_nomem(pCtx); 
+      }else{ 
+        sqlite3_result_error(pCtx, "malformed JSON", -1); 
+      } 
+    } 
+    jsonParseReset(pParse); 
+    return 1; 
+  } 
+  return 0; 
+} 
+ 
+/* Mark node i of pParse as being a child of iParent.  Call recursively 
+** to fill in all the descendants of node i. 
+*/ 
+static void jsonParseFillInParentage(JsonParse *pParse, u32 i, u32 iParent){ 
+  JsonNode *pNode = &pParse->aNode[i]; 
+  u32 j; 
+  pParse->aUp[i] = iParent; 
+  switch( pNode->eType ){ 
+    case JSON_ARRAY: { 
+      for(j=1; j<=pNode->n; j += jsonNodeSize(pNode+j)){ 
+        jsonParseFillInParentage(pParse, i+j, i); 
+      } 
+      break; 
+    } 
+    case JSON_OBJECT: { 
+      for(j=1; j<=pNode->n; j += jsonNodeSize(pNode+j+1)+1){ 
+        pParse->aUp[i+j] = i; 
+        jsonParseFillInParentage(pParse, i+j+1, i); 
+      } 
+      break; 
+    } 
+    default: { 
+      break; 
+    } 
+  } 
+} 
+ 
+/* 
+** Compute the parentage of all nodes in a completed parse. 
+*/ 
+static int jsonParseFindParents(JsonParse *pParse){ 
+  u32 *aUp; 
+  assert( pParse->aUp==0 ); 
+  aUp = pParse->aUp = sqlite3_malloc64( sizeof(u32)*pParse->nNode ); 
+  if( aUp==0 ){ 
+    pParse->oom = 1; 
+    return SQLITE_NOMEM; 
+  } 
+  jsonParseFillInParentage(pParse, 0, 0); 
+  return SQLITE_OK; 
+} 
+ 
+/* 
+** Magic number used for the JSON parse cache in sqlite3_get_auxdata() 
+*/ 
+#define JSON_CACHE_ID  (-429938)  /* First cache entry */ 
+#define JSON_CACHE_SZ  4          /* Max number of cache entries */ 
+ 
+/* 
+** Obtain a complete parse of the JSON found in the first argument 
+** of the argv array.  Use the sqlite3_get_auxdata() cache for this 
+** parse if it is available.  If the cache is not available or if it 
+** is no longer valid, parse the JSON again and return the new parse, 
+** and also register the new parse so that it will be available for 
+** future sqlite3_get_auxdata() calls. 
+*/ 
+static JsonParse *jsonParseCached( 
+  sqlite3_context *pCtx, 
+  sqlite3_value **argv, 
+  sqlite3_context *pErrCtx 
+){ 
+  const char *zJson = (const char*)sqlite3_value_text(argv[0]); 
+  int nJson = sqlite3_value_bytes(argv[0]); 
+  JsonParse *p; 
+  JsonParse *pMatch = 0; 
+  int iKey; 
+  int iMinKey = 0; 
+  u32 iMinHold = 0xffffffff; 
+  u32 iMaxHold = 0; 
+  if( zJson==0 ) return 0; 
+  for(iKey=0; iKey<JSON_CACHE_SZ; iKey++){ 
+    p = (JsonParse*)sqlite3_get_auxdata(pCtx, JSON_CACHE_ID+iKey); 
+    if( p==0 ){ 
+      iMinKey = iKey; 
+      break; 
+    } 
+    if( pMatch==0 
+     && p->nJson==nJson 
+     && memcmp(p->zJson,zJson,nJson)==0 
+    ){ 
+      p->nErr = 0; 
+      pMatch = p; 
+    }else if( p->iHold<iMinHold ){ 
+      iMinHold = p->iHold; 
+      iMinKey = iKey; 
+    } 
+    if( p->iHold>iMaxHold ){ 
+      iMaxHold = p->iHold; 
+    } 
+  } 
+  if( pMatch ){ 
+    pMatch->nErr = 0; 
+    pMatch->iHold = iMaxHold+1; 
+    return pMatch; 
+  } 
+  p = sqlite3_malloc64( sizeof(*p) + nJson + 1 ); 
+  if( p==0 ){ 
+    sqlite3_result_error_nomem(pCtx); 
+    return 0; 
+  } 
+  memset(p, 0, sizeof(*p)); 
+  p->zJson = (char*)&p[1]; 
+  memcpy((char*)p->zJson, zJson, nJson+1); 
+  if( jsonParse(p, pErrCtx, p->zJson) ){ 
+    sqlite3_free(p); 
+    return 0; 
+  } 
+  p->nJson = nJson; 
+  p->iHold = iMaxHold+1; 
+  sqlite3_set_auxdata(pCtx, JSON_CACHE_ID+iMinKey, p, 
+                      (void(*)(void*))jsonParseFree); 
+  return (JsonParse*)sqlite3_get_auxdata(pCtx, JSON_CACHE_ID+iMinKey); 
+} 
+ 
+/* 
+** Compare the OBJECT label at pNode against zKey,nKey.  Return true on 
+** a match. 
+*/ 
+static int jsonLabelCompare(JsonNode *pNode, const char *zKey, u32 nKey){ 
   assert( pNode->eU==1 );
-  if( pNode->jnFlags & JNODE_RAW ){
-    if( pNode->n!=nKey ) return 0;
-    return strncmp(pNode->u.zJContent, zKey, nKey)==0;
-  }else{
-    if( pNode->n!=nKey+2 ) return 0;
-    return strncmp(pNode->u.zJContent+1, zKey, nKey)==0;
-  }
-}
-
-/* forward declaration */
-static JsonNode *jsonLookupAppend(JsonParse*,const char*,int*,const char**);
-
-/*
-** Search along zPath to find the node specified.  Return a pointer
-** to that node, or NULL if zPath is malformed or if there is no such
-** node.
-**
-** If pApnd!=0, then try to append new nodes to complete zPath if it is
-** possible to do so and if no existing node corresponds to zPath.  If
-** new nodes are appended *pApnd is set to 1.
-*/
-static JsonNode *jsonLookupStep(
-  JsonParse *pParse,      /* The JSON to search */
-  u32 iRoot,              /* Begin the search at this node */
-  const char *zPath,      /* The path to search */
-  int *pApnd,             /* Append nodes to complete path if not NULL */
-  const char **pzErr      /* Make *pzErr point to any syntax error in zPath */
-){
-  u32 i, j, nKey;
-  const char *zKey;
-  JsonNode *pRoot = &pParse->aNode[iRoot];
-  if( zPath[0]==0 ) return pRoot;
+  if( pNode->jnFlags & JNODE_RAW ){ 
+    if( pNode->n!=nKey ) return 0; 
+    return strncmp(pNode->u.zJContent, zKey, nKey)==0; 
+  }else{ 
+    if( pNode->n!=nKey+2 ) return 0; 
+    return strncmp(pNode->u.zJContent+1, zKey, nKey)==0; 
+  } 
+} 
+ 
+/* forward declaration */ 
+static JsonNode *jsonLookupAppend(JsonParse*,const char*,int*,const char**); 
+ 
+/* 
+** Search along zPath to find the node specified.  Return a pointer 
+** to that node, or NULL if zPath is malformed or if there is no such 
+** node. 
+** 
+** If pApnd!=0, then try to append new nodes to complete zPath if it is 
+** possible to do so and if no existing node corresponds to zPath.  If 
+** new nodes are appended *pApnd is set to 1. 
+*/ 
+static JsonNode *jsonLookupStep( 
+  JsonParse *pParse,      /* The JSON to search */ 
+  u32 iRoot,              /* Begin the search at this node */ 
+  const char *zPath,      /* The path to search */ 
+  int *pApnd,             /* Append nodes to complete path if not NULL */ 
+  const char **pzErr      /* Make *pzErr point to any syntax error in zPath */ 
+){ 
+  u32 i, j, nKey; 
+  const char *zKey; 
+  JsonNode *pRoot = &pParse->aNode[iRoot]; 
+  if( zPath[0]==0 ) return pRoot; 
   if( pRoot->jnFlags & JNODE_REPLACE ) return 0;
-  if( zPath[0]=='.' ){
-    if( pRoot->eType!=JSON_OBJECT ) return 0;
-    zPath++;
-    if( zPath[0]=='"' ){
-      zKey = zPath + 1;
-      for(i=1; zPath[i] && zPath[i]!='"'; i++){}
-      nKey = i-1;
-      if( zPath[i] ){
-        i++;
-      }else{
-        *pzErr = zPath;
-        return 0;
-      }
-    }else{
-      zKey = zPath;
-      for(i=0; zPath[i] && zPath[i]!='.' && zPath[i]!='['; i++){}
-      nKey = i;
-    }
-    if( nKey==0 ){
-      *pzErr = zPath;
-      return 0;
-    }
-    j = 1;
-    for(;;){
-      while( j<=pRoot->n ){
-        if( jsonLabelCompare(pRoot+j, zKey, nKey) ){
-          return jsonLookupStep(pParse, iRoot+j+1, &zPath[i], pApnd, pzErr);
-        }
-        j++;
-        j += jsonNodeSize(&pRoot[j]);
-      }
-      if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break;
+  if( zPath[0]=='.' ){ 
+    if( pRoot->eType!=JSON_OBJECT ) return 0; 
+    zPath++; 
+    if( zPath[0]=='"' ){ 
+      zKey = zPath + 1; 
+      for(i=1; zPath[i] && zPath[i]!='"'; i++){} 
+      nKey = i-1; 
+      if( zPath[i] ){ 
+        i++; 
+      }else{ 
+        *pzErr = zPath; 
+        return 0; 
+      } 
+    }else{ 
+      zKey = zPath; 
+      for(i=0; zPath[i] && zPath[i]!='.' && zPath[i]!='['; i++){} 
+      nKey = i; 
+    } 
+    if( nKey==0 ){ 
+      *pzErr = zPath; 
+      return 0; 
+    } 
+    j = 1; 
+    for(;;){ 
+      while( j<=pRoot->n ){ 
+        if( jsonLabelCompare(pRoot+j, zKey, nKey) ){ 
+          return jsonLookupStep(pParse, iRoot+j+1, &zPath[i], pApnd, pzErr); 
+        } 
+        j++; 
+        j += jsonNodeSize(&pRoot[j]); 
+      } 
+      if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break; 
       assert( pRoot->eU==2 );
-      iRoot += pRoot->u.iAppend;
-      pRoot = &pParse->aNode[iRoot];
-      j = 1;
-    }
-    if( pApnd ){
-      u32 iStart, iLabel;
-      JsonNode *pNode;
-      iStart = jsonParseAddNode(pParse, JSON_OBJECT, 2, 0);
-      iLabel = jsonParseAddNode(pParse, JSON_STRING, nKey, zKey);
-      zPath += i;
-      pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr);
-      if( pParse->oom ) return 0;
-      if( pNode ){
-        pRoot = &pParse->aNode[iRoot];
+      iRoot += pRoot->u.iAppend; 
+      pRoot = &pParse->aNode[iRoot]; 
+      j = 1; 
+    } 
+    if( pApnd ){ 
+      u32 iStart, iLabel; 
+      JsonNode *pNode; 
+      iStart = jsonParseAddNode(pParse, JSON_OBJECT, 2, 0); 
+      iLabel = jsonParseAddNode(pParse, JSON_STRING, nKey, zKey); 
+      zPath += i; 
+      pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr); 
+      if( pParse->oom ) return 0; 
+      if( pNode ){ 
+        pRoot = &pParse->aNode[iRoot]; 
         assert( pRoot->eU==0 );
-        pRoot->u.iAppend = iStart - iRoot;
-        pRoot->jnFlags |= JNODE_APPEND;
+        pRoot->u.iAppend = iStart - iRoot; 
+        pRoot->jnFlags |= JNODE_APPEND; 
         VVA( pRoot->eU = 2 );
-        pParse->aNode[iLabel].jnFlags |= JNODE_RAW;
-      }
-      return pNode;
-    }
+        pParse->aNode[iLabel].jnFlags |= JNODE_RAW; 
+      } 
+      return pNode; 
+    } 
   }else if( zPath[0]=='[' ){
-    i = 0;
-    j = 1;
-    while( safe_isdigit(zPath[j]) ){
-      i = i*10 + zPath[j] - '0';
-      j++;
-    }
+    i = 0; 
+    j = 1; 
+    while( safe_isdigit(zPath[j]) ){ 
+      i = i*10 + zPath[j] - '0'; 
+      j++; 
+    } 
     if( j<2 || zPath[j]!=']' ){
       if( zPath[1]=='#' ){
         JsonNode *pBase = pRoot;
@@ -192512,780 +192512,780 @@ static JsonNode *jsonLookupStep(
         *pzErr = zPath;
         return 0;
       }
-    }
+    } 
     if( pRoot->eType!=JSON_ARRAY ) return 0;
-    zPath += j + 1;
-    j = 1;
-    for(;;){
-      while( j<=pRoot->n && (i>0 || (pRoot[j].jnFlags & JNODE_REMOVE)!=0) ){
-        if( (pRoot[j].jnFlags & JNODE_REMOVE)==0 ) i--;
-        j += jsonNodeSize(&pRoot[j]);
-      }
-      if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break;
+    zPath += j + 1; 
+    j = 1; 
+    for(;;){ 
+      while( j<=pRoot->n && (i>0 || (pRoot[j].jnFlags & JNODE_REMOVE)!=0) ){ 
+        if( (pRoot[j].jnFlags & JNODE_REMOVE)==0 ) i--; 
+        j += jsonNodeSize(&pRoot[j]); 
+      } 
+      if( (pRoot->jnFlags & JNODE_APPEND)==0 ) break; 
       assert( pRoot->eU==2 );
-      iRoot += pRoot->u.iAppend;
-      pRoot = &pParse->aNode[iRoot];
-      j = 1;
-    }
-    if( j<=pRoot->n ){
-      return jsonLookupStep(pParse, iRoot+j, zPath, pApnd, pzErr);
-    }
-    if( i==0 && pApnd ){
-      u32 iStart;
-      JsonNode *pNode;
-      iStart = jsonParseAddNode(pParse, JSON_ARRAY, 1, 0);
-      pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr);
-      if( pParse->oom ) return 0;
-      if( pNode ){
-        pRoot = &pParse->aNode[iRoot];
+      iRoot += pRoot->u.iAppend; 
+      pRoot = &pParse->aNode[iRoot]; 
+      j = 1; 
+    } 
+    if( j<=pRoot->n ){ 
+      return jsonLookupStep(pParse, iRoot+j, zPath, pApnd, pzErr); 
+    } 
+    if( i==0 && pApnd ){ 
+      u32 iStart; 
+      JsonNode *pNode; 
+      iStart = jsonParseAddNode(pParse, JSON_ARRAY, 1, 0); 
+      pNode = jsonLookupAppend(pParse, zPath, pApnd, pzErr); 
+      if( pParse->oom ) return 0; 
+      if( pNode ){ 
+        pRoot = &pParse->aNode[iRoot]; 
         assert( pRoot->eU==0 );
-        pRoot->u.iAppend = iStart - iRoot;
-        pRoot->jnFlags |= JNODE_APPEND;
+        pRoot->u.iAppend = iStart - iRoot; 
+        pRoot->jnFlags |= JNODE_APPEND; 
         VVA( pRoot->eU = 2 );
-      }
-      return pNode;
-    }
-  }else{
-    *pzErr = zPath;
-  }
-  return 0;
-}
-
-/*
-** Append content to pParse that will complete zPath.  Return a pointer
-** to the inserted node, or return NULL if the append fails.
-*/
-static JsonNode *jsonLookupAppend(
-  JsonParse *pParse,     /* Append content to the JSON parse */
-  const char *zPath,     /* Description of content to append */
-  int *pApnd,            /* Set this flag to 1 */
-  const char **pzErr     /* Make this point to any syntax error */
-){
-  *pApnd = 1;
-  if( zPath[0]==0 ){
-    jsonParseAddNode(pParse, JSON_NULL, 0, 0);
-    return pParse->oom ? 0 : &pParse->aNode[pParse->nNode-1];
-  }
-  if( zPath[0]=='.' ){
-    jsonParseAddNode(pParse, JSON_OBJECT, 0, 0);
-  }else if( strncmp(zPath,"[0]",3)==0 ){
-    jsonParseAddNode(pParse, JSON_ARRAY, 0, 0);
-  }else{
-    return 0;
-  }
-  if( pParse->oom ) return 0;
-  return jsonLookupStep(pParse, pParse->nNode-1, zPath, pApnd, pzErr);
-}
-
-/*
-** Return the text of a syntax error message on a JSON path.  Space is
-** obtained from sqlite3_malloc().
-*/
-static char *jsonPathSyntaxError(const char *zErr){
-  return sqlite3_mprintf("JSON path error near '%q'", zErr);
-}
-
-/*
-** Do a node lookup using zPath.  Return a pointer to the node on success.
-** Return NULL if not found or if there is an error.
-**
-** On an error, write an error message into pCtx and increment the
-** pParse->nErr counter.
-**
-** If pApnd!=NULL then try to append missing nodes and set *pApnd = 1 if
-** nodes are appended.
-*/
-static JsonNode *jsonLookup(
-  JsonParse *pParse,      /* The JSON to search */
-  const char *zPath,      /* The path to search */
-  int *pApnd,             /* Append nodes to complete path if not NULL */
-  sqlite3_context *pCtx   /* Report errors here, if not NULL */
-){
-  const char *zErr = 0;
-  JsonNode *pNode = 0;
-  char *zMsg;
-
-  if( zPath==0 ) return 0;
-  if( zPath[0]!='$' ){
-    zErr = zPath;
-    goto lookup_err;
-  }
-  zPath++;
-  pNode = jsonLookupStep(pParse, 0, zPath, pApnd, &zErr);
-  if( zErr==0 ) return pNode;
-
-lookup_err:
-  pParse->nErr++;
-  assert( zErr!=0 && pCtx!=0 );
-  zMsg = jsonPathSyntaxError(zErr);
-  if( zMsg ){
-    sqlite3_result_error(pCtx, zMsg, -1);
-    sqlite3_free(zMsg);
-  }else{
-    sqlite3_result_error_nomem(pCtx);
-  }
-  return 0;
-}
-
-
-/*
-** Report the wrong number of arguments for json_insert(), json_replace()
-** or json_set().
-*/
-static void jsonWrongNumArgs(
-  sqlite3_context *pCtx,
-  const char *zFuncName
-){
-  char *zMsg = sqlite3_mprintf("json_%s() needs an odd number of arguments",
-                               zFuncName);
-  sqlite3_result_error(pCtx, zMsg, -1);
+      } 
+      return pNode; 
+    } 
+  }else{ 
+    *pzErr = zPath; 
+  } 
+  return 0; 
+} 
+ 
+/* 
+** Append content to pParse that will complete zPath.  Return a pointer 
+** to the inserted node, or return NULL if the append fails. 
+*/ 
+static JsonNode *jsonLookupAppend( 
+  JsonParse *pParse,     /* Append content to the JSON parse */ 
+  const char *zPath,     /* Description of content to append */ 
+  int *pApnd,            /* Set this flag to 1 */ 
+  const char **pzErr     /* Make this point to any syntax error */ 
+){ 
+  *pApnd = 1; 
+  if( zPath[0]==0 ){ 
+    jsonParseAddNode(pParse, JSON_NULL, 0, 0); 
+    return pParse->oom ? 0 : &pParse->aNode[pParse->nNode-1]; 
+  } 
+  if( zPath[0]=='.' ){ 
+    jsonParseAddNode(pParse, JSON_OBJECT, 0, 0); 
+  }else if( strncmp(zPath,"[0]",3)==0 ){ 
+    jsonParseAddNode(pParse, JSON_ARRAY, 0, 0); 
+  }else{ 
+    return 0; 
+  } 
+  if( pParse->oom ) return 0; 
+  return jsonLookupStep(pParse, pParse->nNode-1, zPath, pApnd, pzErr); 
+} 
+ 
+/* 
+** Return the text of a syntax error message on a JSON path.  Space is 
+** obtained from sqlite3_malloc(). 
+*/ 
+static char *jsonPathSyntaxError(const char *zErr){ 
+  return sqlite3_mprintf("JSON path error near '%q'", zErr); 
+} 
+ 
+/* 
+** Do a node lookup using zPath.  Return a pointer to the node on success. 
+** Return NULL if not found or if there is an error. 
+** 
+** On an error, write an error message into pCtx and increment the 
+** pParse->nErr counter. 
+** 
+** If pApnd!=NULL then try to append missing nodes and set *pApnd = 1 if 
+** nodes are appended. 
+*/ 
+static JsonNode *jsonLookup( 
+  JsonParse *pParse,      /* The JSON to search */ 
+  const char *zPath,      /* The path to search */ 
+  int *pApnd,             /* Append nodes to complete path if not NULL */ 
+  sqlite3_context *pCtx   /* Report errors here, if not NULL */ 
+){ 
+  const char *zErr = 0; 
+  JsonNode *pNode = 0; 
+  char *zMsg; 
+ 
+  if( zPath==0 ) return 0; 
+  if( zPath[0]!='$' ){ 
+    zErr = zPath; 
+    goto lookup_err; 
+  } 
+  zPath++; 
+  pNode = jsonLookupStep(pParse, 0, zPath, pApnd, &zErr); 
+  if( zErr==0 ) return pNode; 
+ 
+lookup_err: 
+  pParse->nErr++; 
+  assert( zErr!=0 && pCtx!=0 ); 
+  zMsg = jsonPathSyntaxError(zErr); 
+  if( zMsg ){ 
+    sqlite3_result_error(pCtx, zMsg, -1); 
+    sqlite3_free(zMsg); 
+  }else{ 
+    sqlite3_result_error_nomem(pCtx); 
+  } 
+  return 0; 
+} 
+ 
+ 
+/* 
+** Report the wrong number of arguments for json_insert(), json_replace() 
+** or json_set(). 
+*/ 
+static void jsonWrongNumArgs( 
+  sqlite3_context *pCtx, 
+  const char *zFuncName 
+){ 
+  char *zMsg = sqlite3_mprintf("json_%s() needs an odd number of arguments", 
+                               zFuncName); 
+  sqlite3_result_error(pCtx, zMsg, -1); 
   sqlite3_free(zMsg);
-}
-
-/*
-** Mark all NULL entries in the Object passed in as JNODE_REMOVE.
-*/
-static void jsonRemoveAllNulls(JsonNode *pNode){
-  int i, n;
-  assert( pNode->eType==JSON_OBJECT );
-  n = pNode->n;
-  for(i=2; i<=n; i += jsonNodeSize(&pNode[i])+1){
-    switch( pNode[i].eType ){
-      case JSON_NULL:
-        pNode[i].jnFlags |= JNODE_REMOVE;
-        break;
-      case JSON_OBJECT:
-        jsonRemoveAllNulls(&pNode[i]);
-        break;
-    }
-  }
-}
-
-
-/****************************************************************************
-** SQL functions used for testing and debugging
-****************************************************************************/
-
-#ifdef SQLITE_DEBUG
-/*
-** The json_parse(JSON) function returns a string which describes
-** a parse of the JSON provided.  Or it returns NULL if JSON is not
-** well-formed.
-*/
-static void jsonParseFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonString s;       /* Output string - not real JSON */
-  JsonParse x;        /* The parse */
-  u32 i;
-
-  assert( argc==1 );
-  if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
-  jsonParseFindParents(&x);
-  jsonInit(&s, ctx);
-  for(i=0; i<x.nNode; i++){
-    const char *zType;
-    if( x.aNode[i].jnFlags & JNODE_LABEL ){
-      assert( x.aNode[i].eType==JSON_STRING );
-      zType = "label";
-    }else{
-      zType = jsonType[x.aNode[i].eType];
-    }
-    jsonPrintf(100, &s,"node %3u: %7s n=%-4d up=%-4d",
-               i, zType, x.aNode[i].n, x.aUp[i]);
+} 
+ 
+/* 
+** Mark all NULL entries in the Object passed in as JNODE_REMOVE. 
+*/ 
+static void jsonRemoveAllNulls(JsonNode *pNode){ 
+  int i, n; 
+  assert( pNode->eType==JSON_OBJECT ); 
+  n = pNode->n; 
+  for(i=2; i<=n; i += jsonNodeSize(&pNode[i])+1){ 
+    switch( pNode[i].eType ){ 
+      case JSON_NULL: 
+        pNode[i].jnFlags |= JNODE_REMOVE; 
+        break; 
+      case JSON_OBJECT: 
+        jsonRemoveAllNulls(&pNode[i]); 
+        break; 
+    } 
+  } 
+} 
+ 
+ 
+/**************************************************************************** 
+** SQL functions used for testing and debugging 
+****************************************************************************/ 
+ 
+#ifdef SQLITE_DEBUG 
+/* 
+** The json_parse(JSON) function returns a string which describes 
+** a parse of the JSON provided.  Or it returns NULL if JSON is not 
+** well-formed. 
+*/ 
+static void jsonParseFunc( 
+  sqlite3_context *ctx, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  JsonString s;       /* Output string - not real JSON */ 
+  JsonParse x;        /* The parse */ 
+  u32 i; 
+ 
+  assert( argc==1 ); 
+  if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; 
+  jsonParseFindParents(&x); 
+  jsonInit(&s, ctx); 
+  for(i=0; i<x.nNode; i++){ 
+    const char *zType; 
+    if( x.aNode[i].jnFlags & JNODE_LABEL ){ 
+      assert( x.aNode[i].eType==JSON_STRING ); 
+      zType = "label"; 
+    }else{ 
+      zType = jsonType[x.aNode[i].eType]; 
+    } 
+    jsonPrintf(100, &s,"node %3u: %7s n=%-4d up=%-4d", 
+               i, zType, x.aNode[i].n, x.aUp[i]); 
     assert( x.aNode[i].eU==0 || x.aNode[i].eU==1 );
-    if( x.aNode[i].u.zJContent!=0 ){
+    if( x.aNode[i].u.zJContent!=0 ){ 
       assert( x.aNode[i].eU==1 );
-      jsonAppendRaw(&s, " ", 1);
-      jsonAppendRaw(&s, x.aNode[i].u.zJContent, x.aNode[i].n);
+      jsonAppendRaw(&s, " ", 1); 
+      jsonAppendRaw(&s, x.aNode[i].u.zJContent, x.aNode[i].n); 
     }else{
       assert( x.aNode[i].eU==0 );
-    }
-    jsonAppendRaw(&s, "\n", 1);
-  }
-  jsonParseReset(&x);
-  jsonResult(&s);
-}
-
-/*
-** The json_test1(JSON) function return true (1) if the input is JSON
-** text generated by another json function.  It returns (0) if the input
-** is not known to be JSON.
-*/
-static void jsonTest1Func(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  UNUSED_PARAM(argc);
-  sqlite3_result_int(ctx, sqlite3_value_subtype(argv[0])==JSON_SUBTYPE);
-}
-#endif /* SQLITE_DEBUG */
-
-/****************************************************************************
-** Scalar SQL function implementations
-****************************************************************************/
-
-/*
-** Implementation of the json_QUOTE(VALUE) function.  Return a JSON value
+    } 
+    jsonAppendRaw(&s, "\n", 1); 
+  } 
+  jsonParseReset(&x); 
+  jsonResult(&s); 
+} 
+ 
+/* 
+** The json_test1(JSON) function return true (1) if the input is JSON 
+** text generated by another json function.  It returns (0) if the input 
+** is not known to be JSON. 
+*/ 
+static void jsonTest1Func( 
+  sqlite3_context *ctx, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  UNUSED_PARAM(argc); 
+  sqlite3_result_int(ctx, sqlite3_value_subtype(argv[0])==JSON_SUBTYPE); 
+} 
+#endif /* SQLITE_DEBUG */ 
+ 
+/**************************************************************************** 
+** Scalar SQL function implementations 
+****************************************************************************/ 
+ 
+/* 
+** Implementation of the json_QUOTE(VALUE) function.  Return a JSON value 
 ** corresponding to the SQL value input.  Mostly this means putting
-** double-quotes around strings and returning the unquoted string "null"
-** when given a NULL input.
-*/
-static void jsonQuoteFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonString jx;
-  UNUSED_PARAM(argc);
-
-  jsonInit(&jx, ctx);
-  jsonAppendValue(&jx, argv[0]);
-  jsonResult(&jx);
-  sqlite3_result_subtype(ctx, JSON_SUBTYPE);
-}
-
-/*
-** Implementation of the json_array(VALUE,...) function.  Return a JSON
-** array that contains all values given in arguments.  Or if any argument
-** is a BLOB, throw an error.
-*/
-static void jsonArrayFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  int i;
-  JsonString jx;
-
-  jsonInit(&jx, ctx);
-  jsonAppendChar(&jx, '[');
-  for(i=0; i<argc; i++){
-    jsonAppendSeparator(&jx);
-    jsonAppendValue(&jx, argv[i]);
-  }
-  jsonAppendChar(&jx, ']');
-  jsonResult(&jx);
-  sqlite3_result_subtype(ctx, JSON_SUBTYPE);
-}
-
-
-/*
-** json_array_length(JSON)
-** json_array_length(JSON, PATH)
-**
+** double-quotes around strings and returning the unquoted string "null" 
+** when given a NULL input. 
+*/ 
+static void jsonQuoteFunc( 
+  sqlite3_context *ctx, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  JsonString jx; 
+  UNUSED_PARAM(argc); 
+ 
+  jsonInit(&jx, ctx); 
+  jsonAppendValue(&jx, argv[0]); 
+  jsonResult(&jx); 
+  sqlite3_result_subtype(ctx, JSON_SUBTYPE); 
+} 
+ 
+/* 
+** Implementation of the json_array(VALUE,...) function.  Return a JSON 
+** array that contains all values given in arguments.  Or if any argument 
+** is a BLOB, throw an error. 
+*/ 
+static void jsonArrayFunc( 
+  sqlite3_context *ctx, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  int i; 
+  JsonString jx; 
+ 
+  jsonInit(&jx, ctx); 
+  jsonAppendChar(&jx, '['); 
+  for(i=0; i<argc; i++){ 
+    jsonAppendSeparator(&jx); 
+    jsonAppendValue(&jx, argv[i]); 
+  } 
+  jsonAppendChar(&jx, ']'); 
+  jsonResult(&jx); 
+  sqlite3_result_subtype(ctx, JSON_SUBTYPE); 
+} 
+ 
+ 
+/* 
+** json_array_length(JSON) 
+** json_array_length(JSON, PATH) 
+** 
 ** Return the number of elements in the top-level JSON array.
-** Return 0 if the input is not a well-formed JSON array.
-*/
-static void jsonArrayLengthFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonParse *p;          /* The parse */
-  sqlite3_int64 n = 0;
-  u32 i;
-  JsonNode *pNode;
-
-  p = jsonParseCached(ctx, argv, ctx);
-  if( p==0 ) return;
-  assert( p->nNode );
-  if( argc==2 ){
-    const char *zPath = (const char*)sqlite3_value_text(argv[1]);
-    pNode = jsonLookup(p, zPath, 0, ctx);
-  }else{
-    pNode = p->aNode;
-  }
-  if( pNode==0 ){
-    return;
-  }
-  if( pNode->eType==JSON_ARRAY ){
-    assert( (pNode->jnFlags & JNODE_APPEND)==0 );
-    for(i=1; i<=pNode->n; n++){
-      i += jsonNodeSize(&pNode[i]);
-    }
-  }
-  sqlite3_result_int64(ctx, n);
-}
-
-/*
-** json_extract(JSON, PATH, ...)
-**
-** Return the element described by PATH.  Return NULL if there is no
-** PATH element.  If there are multiple PATHs, then return a JSON array
-** with the result from each path.  Throw an error if the JSON or any PATH
-** is malformed.
-*/
-static void jsonExtractFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonParse *p;          /* The parse */
-  JsonNode *pNode;
-  const char *zPath;
-  JsonString jx;
-  int i;
-
-  if( argc<2 ) return;
-  p = jsonParseCached(ctx, argv, ctx);
-  if( p==0 ) return;
-  jsonInit(&jx, ctx);
-  jsonAppendChar(&jx, '[');
-  for(i=1; i<argc; i++){
-    zPath = (const char*)sqlite3_value_text(argv[i]);
-    pNode = jsonLookup(p, zPath, 0, ctx);
-    if( p->nErr ) break;
-    if( argc>2 ){
-      jsonAppendSeparator(&jx);
-      if( pNode ){
-        jsonRenderNode(pNode, &jx, 0);
-      }else{
-        jsonAppendRaw(&jx, "null", 4);
-      }
-    }else if( pNode ){
-      jsonReturn(pNode, ctx, 0);
-    }
-  }
-  if( argc>2 && i==argc ){
-    jsonAppendChar(&jx, ']');
-    jsonResult(&jx);
-    sqlite3_result_subtype(ctx, JSON_SUBTYPE);
-  }
-  jsonReset(&jx);
-}
-
-/* This is the RFC 7396 MergePatch algorithm.
-*/
-static JsonNode *jsonMergePatch(
-  JsonParse *pParse,   /* The JSON parser that contains the TARGET */
-  u32 iTarget,         /* Node of the TARGET in pParse */
-  JsonNode *pPatch     /* The PATCH */
-){
-  u32 i, j;
-  u32 iRoot;
-  JsonNode *pTarget;
-  if( pPatch->eType!=JSON_OBJECT ){
-    return pPatch;
-  }
-  assert( iTarget>=0 && iTarget<pParse->nNode );
-  pTarget = &pParse->aNode[iTarget];
-  assert( (pPatch->jnFlags & JNODE_APPEND)==0 );
-  if( pTarget->eType!=JSON_OBJECT ){
-    jsonRemoveAllNulls(pPatch);
-    return pPatch;
-  }
-  iRoot = iTarget;
-  for(i=1; i<pPatch->n; i += jsonNodeSize(&pPatch[i+1])+1){
-    u32 nKey;
-    const char *zKey;
-    assert( pPatch[i].eType==JSON_STRING );
-    assert( pPatch[i].jnFlags & JNODE_LABEL );
+** Return 0 if the input is not a well-formed JSON array. 
+*/ 
+static void jsonArrayLengthFunc( 
+  sqlite3_context *ctx, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  JsonParse *p;          /* The parse */ 
+  sqlite3_int64 n = 0; 
+  u32 i; 
+  JsonNode *pNode; 
+ 
+  p = jsonParseCached(ctx, argv, ctx); 
+  if( p==0 ) return; 
+  assert( p->nNode ); 
+  if( argc==2 ){ 
+    const char *zPath = (const char*)sqlite3_value_text(argv[1]); 
+    pNode = jsonLookup(p, zPath, 0, ctx); 
+  }else{ 
+    pNode = p->aNode; 
+  } 
+  if( pNode==0 ){ 
+    return; 
+  } 
+  if( pNode->eType==JSON_ARRAY ){ 
+    assert( (pNode->jnFlags & JNODE_APPEND)==0 ); 
+    for(i=1; i<=pNode->n; n++){ 
+      i += jsonNodeSize(&pNode[i]); 
+    } 
+  } 
+  sqlite3_result_int64(ctx, n); 
+} 
+ 
+/* 
+** json_extract(JSON, PATH, ...) 
+** 
+** Return the element described by PATH.  Return NULL if there is no 
+** PATH element.  If there are multiple PATHs, then return a JSON array 
+** with the result from each path.  Throw an error if the JSON or any PATH 
+** is malformed. 
+*/ 
+static void jsonExtractFunc( 
+  sqlite3_context *ctx, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  JsonParse *p;          /* The parse */ 
+  JsonNode *pNode; 
+  const char *zPath; 
+  JsonString jx; 
+  int i; 
+ 
+  if( argc<2 ) return; 
+  p = jsonParseCached(ctx, argv, ctx); 
+  if( p==0 ) return; 
+  jsonInit(&jx, ctx); 
+  jsonAppendChar(&jx, '['); 
+  for(i=1; i<argc; i++){ 
+    zPath = (const char*)sqlite3_value_text(argv[i]); 
+    pNode = jsonLookup(p, zPath, 0, ctx); 
+    if( p->nErr ) break; 
+    if( argc>2 ){ 
+      jsonAppendSeparator(&jx); 
+      if( pNode ){ 
+        jsonRenderNode(pNode, &jx, 0); 
+      }else{ 
+        jsonAppendRaw(&jx, "null", 4); 
+      } 
+    }else if( pNode ){ 
+      jsonReturn(pNode, ctx, 0); 
+    } 
+  } 
+  if( argc>2 && i==argc ){ 
+    jsonAppendChar(&jx, ']'); 
+    jsonResult(&jx); 
+    sqlite3_result_subtype(ctx, JSON_SUBTYPE); 
+  } 
+  jsonReset(&jx); 
+} 
+ 
+/* This is the RFC 7396 MergePatch algorithm. 
+*/ 
+static JsonNode *jsonMergePatch( 
+  JsonParse *pParse,   /* The JSON parser that contains the TARGET */ 
+  u32 iTarget,         /* Node of the TARGET in pParse */ 
+  JsonNode *pPatch     /* The PATCH */ 
+){ 
+  u32 i, j; 
+  u32 iRoot; 
+  JsonNode *pTarget; 
+  if( pPatch->eType!=JSON_OBJECT ){ 
+    return pPatch; 
+  } 
+  assert( iTarget>=0 && iTarget<pParse->nNode ); 
+  pTarget = &pParse->aNode[iTarget]; 
+  assert( (pPatch->jnFlags & JNODE_APPEND)==0 ); 
+  if( pTarget->eType!=JSON_OBJECT ){ 
+    jsonRemoveAllNulls(pPatch); 
+    return pPatch; 
+  } 
+  iRoot = iTarget; 
+  for(i=1; i<pPatch->n; i += jsonNodeSize(&pPatch[i+1])+1){ 
+    u32 nKey; 
+    const char *zKey; 
+    assert( pPatch[i].eType==JSON_STRING ); 
+    assert( pPatch[i].jnFlags & JNODE_LABEL ); 
     assert( pPatch[i].eU==1 );
-    nKey = pPatch[i].n;
-    zKey = pPatch[i].u.zJContent;
-    assert( (pPatch[i].jnFlags & JNODE_RAW)==0 );
-    for(j=1; j<pTarget->n; j += jsonNodeSize(&pTarget[j+1])+1 ){
-      assert( pTarget[j].eType==JSON_STRING );
-      assert( pTarget[j].jnFlags & JNODE_LABEL );
-      assert( (pPatch[i].jnFlags & JNODE_RAW)==0 );
-      if( pTarget[j].n==nKey && strncmp(pTarget[j].u.zJContent,zKey,nKey)==0 ){
-        if( pTarget[j+1].jnFlags & (JNODE_REMOVE|JNODE_PATCH) ) break;
-        if( pPatch[i+1].eType==JSON_NULL ){
-          pTarget[j+1].jnFlags |= JNODE_REMOVE;
-        }else{
-          JsonNode *pNew = jsonMergePatch(pParse, iTarget+j+1, &pPatch[i+1]);
-          if( pNew==0 ) return 0;
-          pTarget = &pParse->aNode[iTarget];
-          if( pNew!=&pTarget[j+1] ){
+    nKey = pPatch[i].n; 
+    zKey = pPatch[i].u.zJContent; 
+    assert( (pPatch[i].jnFlags & JNODE_RAW)==0 ); 
+    for(j=1; j<pTarget->n; j += jsonNodeSize(&pTarget[j+1])+1 ){ 
+      assert( pTarget[j].eType==JSON_STRING ); 
+      assert( pTarget[j].jnFlags & JNODE_LABEL ); 
+      assert( (pPatch[i].jnFlags & JNODE_RAW)==0 ); 
+      if( pTarget[j].n==nKey && strncmp(pTarget[j].u.zJContent,zKey,nKey)==0 ){ 
+        if( pTarget[j+1].jnFlags & (JNODE_REMOVE|JNODE_PATCH) ) break; 
+        if( pPatch[i+1].eType==JSON_NULL ){ 
+          pTarget[j+1].jnFlags |= JNODE_REMOVE; 
+        }else{ 
+          JsonNode *pNew = jsonMergePatch(pParse, iTarget+j+1, &pPatch[i+1]); 
+          if( pNew==0 ) return 0; 
+          pTarget = &pParse->aNode[iTarget]; 
+          if( pNew!=&pTarget[j+1] ){ 
             assert( pTarget[j+1].eU==0
                  || pTarget[j+1].eU==1
                  || pTarget[j+1].eU==2 );
             testcase( pTarget[j+1].eU==1 );
             testcase( pTarget[j+1].eU==2 );
             VVA( pTarget[j+1].eU = 5 );
-            pTarget[j+1].u.pPatch = pNew;
-            pTarget[j+1].jnFlags |= JNODE_PATCH;
-          }
-        }
-        break;
-      }
-    }
-    if( j>=pTarget->n && pPatch[i+1].eType!=JSON_NULL ){
-      int iStart, iPatch;
-      iStart = jsonParseAddNode(pParse, JSON_OBJECT, 2, 0);
-      jsonParseAddNode(pParse, JSON_STRING, nKey, zKey);
-      iPatch = jsonParseAddNode(pParse, JSON_TRUE, 0, 0);
-      if( pParse->oom ) return 0;
-      jsonRemoveAllNulls(pPatch);
-      pTarget = &pParse->aNode[iTarget];
+            pTarget[j+1].u.pPatch = pNew; 
+            pTarget[j+1].jnFlags |= JNODE_PATCH; 
+          } 
+        } 
+        break; 
+      } 
+    } 
+    if( j>=pTarget->n && pPatch[i+1].eType!=JSON_NULL ){ 
+      int iStart, iPatch; 
+      iStart = jsonParseAddNode(pParse, JSON_OBJECT, 2, 0); 
+      jsonParseAddNode(pParse, JSON_STRING, nKey, zKey); 
+      iPatch = jsonParseAddNode(pParse, JSON_TRUE, 0, 0); 
+      if( pParse->oom ) return 0; 
+      jsonRemoveAllNulls(pPatch); 
+      pTarget = &pParse->aNode[iTarget]; 
       assert( pParse->aNode[iRoot].eU==0 || pParse->aNode[iRoot].eU==2 );
       testcase( pParse->aNode[iRoot].eU==2 );
-      pParse->aNode[iRoot].jnFlags |= JNODE_APPEND;
+      pParse->aNode[iRoot].jnFlags |= JNODE_APPEND; 
       VVA( pParse->aNode[iRoot].eU = 2 );
-      pParse->aNode[iRoot].u.iAppend = iStart - iRoot;
-      iRoot = iStart;
+      pParse->aNode[iRoot].u.iAppend = iStart - iRoot; 
+      iRoot = iStart; 
       assert( pParse->aNode[iPatch].eU==0 );
       VVA( pParse->aNode[iPatch].eU = 5 );
-      pParse->aNode[iPatch].jnFlags |= JNODE_PATCH;
-      pParse->aNode[iPatch].u.pPatch = &pPatch[i+1];
-    }
-  }
-  return pTarget;
-}
-
-/*
-** Implementation of the json_mergepatch(JSON1,JSON2) function.  Return a JSON
-** object that is the result of running the RFC 7396 MergePatch() algorithm
-** on the two arguments.
-*/
-static void jsonPatchFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonParse x;     /* The JSON that is being patched */
-  JsonParse y;     /* The patch */
-  JsonNode *pResult;   /* The result of the merge */
-
-  UNUSED_PARAM(argc);
-  if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
-  if( jsonParse(&y, ctx, (const char*)sqlite3_value_text(argv[1])) ){
-    jsonParseReset(&x);
-    return;
-  }
-  pResult = jsonMergePatch(&x, 0, y.aNode);
-  assert( pResult!=0 || x.oom );
-  if( pResult ){
-    jsonReturnJson(pResult, ctx, 0);
-  }else{
-    sqlite3_result_error_nomem(ctx);
-  }
-  jsonParseReset(&x);
-  jsonParseReset(&y);
-}
-
-
-/*
-** Implementation of the json_object(NAME,VALUE,...) function.  Return a JSON
-** object that contains all name/value given in arguments.  Or if any name
-** is not a string or if any value is a BLOB, throw an error.
-*/
-static void jsonObjectFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  int i;
-  JsonString jx;
-  const char *z;
-  u32 n;
-
-  if( argc&1 ){
-    sqlite3_result_error(ctx, "json_object() requires an even number "
-                                  "of arguments", -1);
-    return;
-  }
-  jsonInit(&jx, ctx);
-  jsonAppendChar(&jx, '{');
-  for(i=0; i<argc; i+=2){
-    if( sqlite3_value_type(argv[i])!=SQLITE_TEXT ){
-      sqlite3_result_error(ctx, "json_object() labels must be TEXT", -1);
-      jsonReset(&jx);
-      return;
-    }
-    jsonAppendSeparator(&jx);
-    z = (const char*)sqlite3_value_text(argv[i]);
-    n = (u32)sqlite3_value_bytes(argv[i]);
-    jsonAppendString(&jx, z, n);
-    jsonAppendChar(&jx, ':');
-    jsonAppendValue(&jx, argv[i+1]);
-  }
-  jsonAppendChar(&jx, '}');
-  jsonResult(&jx);
-  sqlite3_result_subtype(ctx, JSON_SUBTYPE);
-}
-
-
-/*
-** json_remove(JSON, PATH, ...)
-**
-** Remove the named elements from JSON and return the result.  malformed
-** JSON or PATH arguments result in an error.
-*/
-static void jsonRemoveFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonParse x;          /* The parse */
-  JsonNode *pNode;
-  const char *zPath;
-  u32 i;
-
-  if( argc<1 ) return;
-  if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
-  assert( x.nNode );
-  for(i=1; i<(u32)argc; i++){
-    zPath = (const char*)sqlite3_value_text(argv[i]);
-    if( zPath==0 ) goto remove_done;
-    pNode = jsonLookup(&x, zPath, 0, ctx);
-    if( x.nErr ) goto remove_done;
-    if( pNode ) pNode->jnFlags |= JNODE_REMOVE;
-  }
-  if( (x.aNode[0].jnFlags & JNODE_REMOVE)==0 ){
-    jsonReturnJson(x.aNode, ctx, 0);
-  }
-remove_done:
-  jsonParseReset(&x);
-}
-
-/*
-** json_replace(JSON, PATH, VALUE, ...)
-**
-** Replace the value at PATH with VALUE.  If PATH does not already exist,
-** this routine is a no-op.  If JSON or PATH is malformed, throw an error.
-*/
-static void jsonReplaceFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonParse x;          /* The parse */
-  JsonNode *pNode;
-  const char *zPath;
-  u32 i;
-
-  if( argc<1 ) return;
-  if( (argc&1)==0 ) {
-    jsonWrongNumArgs(ctx, "replace");
-    return;
-  }
-  if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
-  assert( x.nNode );
-  for(i=1; i<(u32)argc; i+=2){
-    zPath = (const char*)sqlite3_value_text(argv[i]);
-    pNode = jsonLookup(&x, zPath, 0, ctx);
-    if( x.nErr ) goto replace_err;
-    if( pNode ){
+      pParse->aNode[iPatch].jnFlags |= JNODE_PATCH; 
+      pParse->aNode[iPatch].u.pPatch = &pPatch[i+1]; 
+    } 
+  } 
+  return pTarget; 
+} 
+ 
+/* 
+** Implementation of the json_mergepatch(JSON1,JSON2) function.  Return a JSON 
+** object that is the result of running the RFC 7396 MergePatch() algorithm 
+** on the two arguments. 
+*/ 
+static void jsonPatchFunc( 
+  sqlite3_context *ctx, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  JsonParse x;     /* The JSON that is being patched */ 
+  JsonParse y;     /* The patch */ 
+  JsonNode *pResult;   /* The result of the merge */ 
+ 
+  UNUSED_PARAM(argc); 
+  if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; 
+  if( jsonParse(&y, ctx, (const char*)sqlite3_value_text(argv[1])) ){ 
+    jsonParseReset(&x); 
+    return; 
+  } 
+  pResult = jsonMergePatch(&x, 0, y.aNode); 
+  assert( pResult!=0 || x.oom ); 
+  if( pResult ){ 
+    jsonReturnJson(pResult, ctx, 0); 
+  }else{ 
+    sqlite3_result_error_nomem(ctx); 
+  } 
+  jsonParseReset(&x); 
+  jsonParseReset(&y); 
+} 
+ 
+ 
+/* 
+** Implementation of the json_object(NAME,VALUE,...) function.  Return a JSON 
+** object that contains all name/value given in arguments.  Or if any name 
+** is not a string or if any value is a BLOB, throw an error. 
+*/ 
+static void jsonObjectFunc( 
+  sqlite3_context *ctx, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  int i; 
+  JsonString jx; 
+  const char *z; 
+  u32 n; 
+ 
+  if( argc&1 ){ 
+    sqlite3_result_error(ctx, "json_object() requires an even number " 
+                                  "of arguments", -1); 
+    return; 
+  } 
+  jsonInit(&jx, ctx); 
+  jsonAppendChar(&jx, '{'); 
+  for(i=0; i<argc; i+=2){ 
+    if( sqlite3_value_type(argv[i])!=SQLITE_TEXT ){ 
+      sqlite3_result_error(ctx, "json_object() labels must be TEXT", -1); 
+      jsonReset(&jx); 
+      return; 
+    } 
+    jsonAppendSeparator(&jx); 
+    z = (const char*)sqlite3_value_text(argv[i]); 
+    n = (u32)sqlite3_value_bytes(argv[i]); 
+    jsonAppendString(&jx, z, n); 
+    jsonAppendChar(&jx, ':'); 
+    jsonAppendValue(&jx, argv[i+1]); 
+  } 
+  jsonAppendChar(&jx, '}'); 
+  jsonResult(&jx); 
+  sqlite3_result_subtype(ctx, JSON_SUBTYPE); 
+} 
+ 
+ 
+/* 
+** json_remove(JSON, PATH, ...) 
+** 
+** Remove the named elements from JSON and return the result.  malformed 
+** JSON or PATH arguments result in an error. 
+*/ 
+static void jsonRemoveFunc( 
+  sqlite3_context *ctx, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  JsonParse x;          /* The parse */ 
+  JsonNode *pNode; 
+  const char *zPath; 
+  u32 i; 
+ 
+  if( argc<1 ) return; 
+  if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; 
+  assert( x.nNode ); 
+  for(i=1; i<(u32)argc; i++){ 
+    zPath = (const char*)sqlite3_value_text(argv[i]); 
+    if( zPath==0 ) goto remove_done; 
+    pNode = jsonLookup(&x, zPath, 0, ctx); 
+    if( x.nErr ) goto remove_done; 
+    if( pNode ) pNode->jnFlags |= JNODE_REMOVE; 
+  } 
+  if( (x.aNode[0].jnFlags & JNODE_REMOVE)==0 ){ 
+    jsonReturnJson(x.aNode, ctx, 0); 
+  } 
+remove_done: 
+  jsonParseReset(&x); 
+} 
+ 
+/* 
+** json_replace(JSON, PATH, VALUE, ...) 
+** 
+** Replace the value at PATH with VALUE.  If PATH does not already exist, 
+** this routine is a no-op.  If JSON or PATH is malformed, throw an error. 
+*/ 
+static void jsonReplaceFunc( 
+  sqlite3_context *ctx, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  JsonParse x;          /* The parse */ 
+  JsonNode *pNode; 
+  const char *zPath; 
+  u32 i; 
+ 
+  if( argc<1 ) return; 
+  if( (argc&1)==0 ) { 
+    jsonWrongNumArgs(ctx, "replace"); 
+    return; 
+  } 
+  if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; 
+  assert( x.nNode ); 
+  for(i=1; i<(u32)argc; i+=2){ 
+    zPath = (const char*)sqlite3_value_text(argv[i]); 
+    pNode = jsonLookup(&x, zPath, 0, ctx); 
+    if( x.nErr ) goto replace_err; 
+    if( pNode ){ 
       assert( pNode->eU==0 || pNode->eU==1 || pNode->eU==4 );
       json_testcase( pNode->eU!=0 && pNode->eU!=1 );
-      pNode->jnFlags |= (u8)JNODE_REPLACE;
+      pNode->jnFlags |= (u8)JNODE_REPLACE; 
       VVA( pNode->eU =  4 );
-      pNode->u.iReplace = i + 1;
-    }
-  }
-  if( x.aNode[0].jnFlags & JNODE_REPLACE ){
+      pNode->u.iReplace = i + 1; 
+    } 
+  } 
+  if( x.aNode[0].jnFlags & JNODE_REPLACE ){ 
     assert( x.aNode[0].eU==4 );
-    sqlite3_result_value(ctx, argv[x.aNode[0].u.iReplace]);
-  }else{
-    jsonReturnJson(x.aNode, ctx, argv);
-  }
-replace_err:
-  jsonParseReset(&x);
-}
-
-/*
-** json_set(JSON, PATH, VALUE, ...)
-**
-** Set the value at PATH to VALUE.  Create the PATH if it does not already
-** exist.  Overwrite existing values that do exist.
-** If JSON or PATH is malformed, throw an error.
-**
-** json_insert(JSON, PATH, VALUE, ...)
-**
-** Create PATH and initialize it to VALUE.  If PATH already exists, this
-** routine is a no-op.  If JSON or PATH is malformed, throw an error.
-*/
-static void jsonSetFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonParse x;          /* The parse */
-  JsonNode *pNode;
-  const char *zPath;
-  u32 i;
-  int bApnd;
-  int bIsSet = *(int*)sqlite3_user_data(ctx);
-
-  if( argc<1 ) return;
-  if( (argc&1)==0 ) {
-    jsonWrongNumArgs(ctx, bIsSet ? "set" : "insert");
-    return;
-  }
-  if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return;
-  assert( x.nNode );
-  for(i=1; i<(u32)argc; i+=2){
-    zPath = (const char*)sqlite3_value_text(argv[i]);
-    bApnd = 0;
-    pNode = jsonLookup(&x, zPath, &bApnd, ctx);
-    if( x.oom ){
-      sqlite3_result_error_nomem(ctx);
-      goto jsonSetDone;
-    }else if( x.nErr ){
-      goto jsonSetDone;
-    }else if( pNode && (bApnd || bIsSet) ){
+    sqlite3_result_value(ctx, argv[x.aNode[0].u.iReplace]); 
+  }else{ 
+    jsonReturnJson(x.aNode, ctx, argv); 
+  } 
+replace_err: 
+  jsonParseReset(&x); 
+} 
+ 
+/* 
+** json_set(JSON, PATH, VALUE, ...) 
+** 
+** Set the value at PATH to VALUE.  Create the PATH if it does not already 
+** exist.  Overwrite existing values that do exist. 
+** If JSON or PATH is malformed, throw an error. 
+** 
+** json_insert(JSON, PATH, VALUE, ...) 
+** 
+** Create PATH and initialize it to VALUE.  If PATH already exists, this 
+** routine is a no-op.  If JSON or PATH is malformed, throw an error. 
+*/ 
+static void jsonSetFunc( 
+  sqlite3_context *ctx, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  JsonParse x;          /* The parse */ 
+  JsonNode *pNode; 
+  const char *zPath; 
+  u32 i; 
+  int bApnd; 
+  int bIsSet = *(int*)sqlite3_user_data(ctx); 
+ 
+  if( argc<1 ) return; 
+  if( (argc&1)==0 ) { 
+    jsonWrongNumArgs(ctx, bIsSet ? "set" : "insert"); 
+    return; 
+  } 
+  if( jsonParse(&x, ctx, (const char*)sqlite3_value_text(argv[0])) ) return; 
+  assert( x.nNode ); 
+  for(i=1; i<(u32)argc; i+=2){ 
+    zPath = (const char*)sqlite3_value_text(argv[i]); 
+    bApnd = 0; 
+    pNode = jsonLookup(&x, zPath, &bApnd, ctx); 
+    if( x.oom ){ 
+      sqlite3_result_error_nomem(ctx); 
+      goto jsonSetDone; 
+    }else if( x.nErr ){ 
+      goto jsonSetDone; 
+    }else if( pNode && (bApnd || bIsSet) ){ 
       json_testcase( pNode->eU!=0 && pNode->eU!=1 && pNode->eU!=4 );
       assert( pNode->eU!=3 || pNode->eU!=5 );
       VVA( pNode->eU = 4 );
-      pNode->jnFlags |= (u8)JNODE_REPLACE;
-      pNode->u.iReplace = i + 1;
-    }
-  }
-  if( x.aNode[0].jnFlags & JNODE_REPLACE ){
+      pNode->jnFlags |= (u8)JNODE_REPLACE; 
+      pNode->u.iReplace = i + 1; 
+    } 
+  } 
+  if( x.aNode[0].jnFlags & JNODE_REPLACE ){ 
     assert( x.aNode[0].eU==4 );
-    sqlite3_result_value(ctx, argv[x.aNode[0].u.iReplace]);
-  }else{
-    jsonReturnJson(x.aNode, ctx, argv);
-  }
-jsonSetDone:
-  jsonParseReset(&x);
-}
-
-/*
-** json_type(JSON)
-** json_type(JSON, PATH)
-**
-** Return the top-level "type" of a JSON string.  Throw an error if
-** either the JSON or PATH inputs are not well-formed.
-*/
-static void jsonTypeFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonParse *p;          /* The parse */
-  const char *zPath;
-  JsonNode *pNode;
-
-  p = jsonParseCached(ctx, argv, ctx);
-  if( p==0 ) return;
-  if( argc==2 ){
-    zPath = (const char*)sqlite3_value_text(argv[1]);
-    pNode = jsonLookup(p, zPath, 0, ctx);
-  }else{
-    pNode = p->aNode;
-  }
-  if( pNode ){
-    sqlite3_result_text(ctx, jsonType[pNode->eType], -1, SQLITE_STATIC);
-  }
-}
-
-/*
-** json_valid(JSON)
-**
-** Return 1 if JSON is a well-formed JSON string according to RFC-7159.
-** Return 0 otherwise.
-*/
-static void jsonValidFunc(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonParse *p;          /* The parse */
-  UNUSED_PARAM(argc);
-  p = jsonParseCached(ctx, argv, 0);
-  sqlite3_result_int(ctx, p!=0);
-}
-
-
-/****************************************************************************
-** Aggregate SQL function implementations
-****************************************************************************/
-/*
-** json_group_array(VALUE)
-**
-** Return a JSON array composed of all values in the aggregate.
-*/
-static void jsonArrayStep(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonString *pStr;
-  UNUSED_PARAM(argc);
-  pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr));
-  if( pStr ){
-    if( pStr->zBuf==0 ){
-      jsonInit(pStr, ctx);
-      jsonAppendChar(pStr, '[');
+    sqlite3_result_value(ctx, argv[x.aNode[0].u.iReplace]); 
+  }else{ 
+    jsonReturnJson(x.aNode, ctx, argv); 
+  } 
+jsonSetDone: 
+  jsonParseReset(&x); 
+} 
+ 
+/* 
+** json_type(JSON) 
+** json_type(JSON, PATH) 
+** 
+** Return the top-level "type" of a JSON string.  Throw an error if 
+** either the JSON or PATH inputs are not well-formed. 
+*/ 
+static void jsonTypeFunc( 
+  sqlite3_context *ctx, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  JsonParse *p;          /* The parse */ 
+  const char *zPath; 
+  JsonNode *pNode; 
+ 
+  p = jsonParseCached(ctx, argv, ctx); 
+  if( p==0 ) return; 
+  if( argc==2 ){ 
+    zPath = (const char*)sqlite3_value_text(argv[1]); 
+    pNode = jsonLookup(p, zPath, 0, ctx); 
+  }else{ 
+    pNode = p->aNode; 
+  } 
+  if( pNode ){ 
+    sqlite3_result_text(ctx, jsonType[pNode->eType], -1, SQLITE_STATIC); 
+  } 
+} 
+ 
+/* 
+** json_valid(JSON) 
+** 
+** Return 1 if JSON is a well-formed JSON string according to RFC-7159. 
+** Return 0 otherwise. 
+*/ 
+static void jsonValidFunc( 
+  sqlite3_context *ctx, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  JsonParse *p;          /* The parse */ 
+  UNUSED_PARAM(argc); 
+  p = jsonParseCached(ctx, argv, 0); 
+  sqlite3_result_int(ctx, p!=0); 
+} 
+ 
+ 
+/**************************************************************************** 
+** Aggregate SQL function implementations 
+****************************************************************************/ 
+/* 
+** json_group_array(VALUE) 
+** 
+** Return a JSON array composed of all values in the aggregate. 
+*/ 
+static void jsonArrayStep( 
+  sqlite3_context *ctx, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  JsonString *pStr; 
+  UNUSED_PARAM(argc); 
+  pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr)); 
+  if( pStr ){ 
+    if( pStr->zBuf==0 ){ 
+      jsonInit(pStr, ctx); 
+      jsonAppendChar(pStr, '['); 
     }else if( pStr->nUsed>1 ){
-      jsonAppendChar(pStr, ',');
-    }
-    pStr->pCtx = ctx;
-    jsonAppendValue(pStr, argv[0]);
-  }
-}
-static void jsonArrayCompute(sqlite3_context *ctx, int isFinal){
-  JsonString *pStr;
-  pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0);
-  if( pStr ){
+      jsonAppendChar(pStr, ','); 
+    } 
     pStr->pCtx = ctx;
-    jsonAppendChar(pStr, ']');
-    if( pStr->bErr ){
-      if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx);
-      assert( pStr->bStatic );
-    }else if( isFinal ){
-      sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed,
-                          pStr->bStatic ? SQLITE_TRANSIENT : sqlite3_free);
-      pStr->bStatic = 1;
-    }else{
-      sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, SQLITE_TRANSIENT);
-      pStr->nUsed--;
-    }
-  }else{
-    sqlite3_result_text(ctx, "[]", 2, SQLITE_STATIC);
-  }
-  sqlite3_result_subtype(ctx, JSON_SUBTYPE);
-}
-static void jsonArrayValue(sqlite3_context *ctx){
-  jsonArrayCompute(ctx, 0);
-}
-static void jsonArrayFinal(sqlite3_context *ctx){
-  jsonArrayCompute(ctx, 1);
-}
-
-#ifndef SQLITE_OMIT_WINDOWFUNC
-/*
-** This method works for both json_group_array() and json_group_object().
-** It works by removing the first element of the group by searching forward
-** to the first comma (",") that is not within a string and deleting all
-** text through that comma.
-*/
-static void jsonGroupInverse(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
+    jsonAppendValue(pStr, argv[0]); 
+  } 
+} 
+static void jsonArrayCompute(sqlite3_context *ctx, int isFinal){ 
+  JsonString *pStr; 
+  pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0); 
+  if( pStr ){ 
+    pStr->pCtx = ctx; 
+    jsonAppendChar(pStr, ']'); 
+    if( pStr->bErr ){ 
+      if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx); 
+      assert( pStr->bStatic ); 
+    }else if( isFinal ){ 
+      sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, 
+                          pStr->bStatic ? SQLITE_TRANSIENT : sqlite3_free); 
+      pStr->bStatic = 1; 
+    }else{ 
+      sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, SQLITE_TRANSIENT); 
+      pStr->nUsed--; 
+    } 
+  }else{ 
+    sqlite3_result_text(ctx, "[]", 2, SQLITE_STATIC); 
+  } 
+  sqlite3_result_subtype(ctx, JSON_SUBTYPE); 
+} 
+static void jsonArrayValue(sqlite3_context *ctx){ 
+  jsonArrayCompute(ctx, 0); 
+} 
+static void jsonArrayFinal(sqlite3_context *ctx){ 
+  jsonArrayCompute(ctx, 1); 
+} 
+ 
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+/* 
+** This method works for both json_group_array() and json_group_object(). 
+** It works by removing the first element of the group by searching forward 
+** to the first comma (",") that is not within a string and deleting all 
+** text through that comma. 
+*/ 
+static void jsonGroupInverse( 
+  sqlite3_context *ctx, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
   unsigned int i;
-  int inStr = 0;
+  int inStr = 0; 
   int nNest = 0;
-  char *z;
+  char *z; 
   char c;
-  JsonString *pStr;
-  UNUSED_PARAM(argc);
-  UNUSED_PARAM(argv);
-  pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0);
-#ifdef NEVER
-  /* pStr is always non-NULL since jsonArrayStep() or jsonObjectStep() will
-  ** always have been called to initalize it */
-  if( NEVER(!pStr) ) return;
-#endif
-  z = pStr->zBuf;
+  JsonString *pStr; 
+  UNUSED_PARAM(argc); 
+  UNUSED_PARAM(argv); 
+  pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0); 
+#ifdef NEVER 
+  /* pStr is always non-NULL since jsonArrayStep() or jsonObjectStep() will 
+  ** always have been called to initalize it */ 
+  if( NEVER(!pStr) ) return; 
+#endif 
+  z = pStr->zBuf; 
   for(i=1; i<pStr->nUsed && ((c = z[i])!=',' || inStr || nNest); i++){
     if( c=='"' ){
-      inStr = !inStr;
+      inStr = !inStr; 
     }else if( c=='\\' ){
-      i++;
+      i++; 
     }else if( !inStr ){
       if( c=='{' || c=='[' ) nNest++;
       if( c=='}' || c==']' ) nNest--;
-    }
-  }
+    } 
+  } 
   if( i<pStr->nUsed ){
     pStr->nUsed -= i;
     memmove(&z[1], &z[i+1], (size_t)pStr->nUsed-1);
@@ -193293,673 +193293,673 @@ static void jsonGroupInverse(
   }else{
     pStr->nUsed = 1;
   }
-}
-#else
-# define jsonGroupInverse 0
-#endif
-
-
-/*
-** json_group_obj(NAME,VALUE)
-**
-** Return a JSON object composed of all names and values in the aggregate.
-*/
-static void jsonObjectStep(
-  sqlite3_context *ctx,
-  int argc,
-  sqlite3_value **argv
-){
-  JsonString *pStr;
-  const char *z;
-  u32 n;
-  UNUSED_PARAM(argc);
-  pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr));
-  if( pStr ){
-    if( pStr->zBuf==0 ){
-      jsonInit(pStr, ctx);
-      jsonAppendChar(pStr, '{');
+} 
+#else 
+# define jsonGroupInverse 0 
+#endif 
+ 
+ 
+/* 
+** json_group_obj(NAME,VALUE) 
+** 
+** Return a JSON object composed of all names and values in the aggregate. 
+*/ 
+static void jsonObjectStep( 
+  sqlite3_context *ctx, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  JsonString *pStr; 
+  const char *z; 
+  u32 n; 
+  UNUSED_PARAM(argc); 
+  pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr)); 
+  if( pStr ){ 
+    if( pStr->zBuf==0 ){ 
+      jsonInit(pStr, ctx); 
+      jsonAppendChar(pStr, '{'); 
     }else if( pStr->nUsed>1 ){
-      jsonAppendChar(pStr, ',');
-    }
+      jsonAppendChar(pStr, ','); 
+    } 
     pStr->pCtx = ctx;
-    z = (const char*)sqlite3_value_text(argv[0]);
-    n = (u32)sqlite3_value_bytes(argv[0]);
-    jsonAppendString(pStr, z, n);
-    jsonAppendChar(pStr, ':');
-    jsonAppendValue(pStr, argv[1]);
-  }
-}
-static void jsonObjectCompute(sqlite3_context *ctx, int isFinal){
-  JsonString *pStr;
-  pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0);
-  if( pStr ){
-    jsonAppendChar(pStr, '}');
-    if( pStr->bErr ){
-      if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx);
-      assert( pStr->bStatic );
-    }else if( isFinal ){
-      sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed,
-                          pStr->bStatic ? SQLITE_TRANSIENT : sqlite3_free);
-      pStr->bStatic = 1;
-    }else{
-      sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, SQLITE_TRANSIENT);
-      pStr->nUsed--;
-    }
-  }else{
-    sqlite3_result_text(ctx, "{}", 2, SQLITE_STATIC);
-  }
-  sqlite3_result_subtype(ctx, JSON_SUBTYPE);
-}
-static void jsonObjectValue(sqlite3_context *ctx){
-  jsonObjectCompute(ctx, 0);
-}
-static void jsonObjectFinal(sqlite3_context *ctx){
-  jsonObjectCompute(ctx, 1);
-}
-
-
-
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-/****************************************************************************
-** The json_each virtual table
-****************************************************************************/
-typedef struct JsonEachCursor JsonEachCursor;
-struct JsonEachCursor {
-  sqlite3_vtab_cursor base;  /* Base class - must be first */
-  u32 iRowid;                /* The rowid */
-  u32 iBegin;                /* The first node of the scan */
-  u32 i;                     /* Index in sParse.aNode[] of current row */
-  u32 iEnd;                  /* EOF when i equals or exceeds this value */
-  u8 eType;                  /* Type of top-level element */
-  u8 bRecursive;             /* True for json_tree().  False for json_each() */
-  char *zJson;               /* Input JSON */
-  char *zRoot;               /* Path by which to filter zJson */
-  JsonParse sParse;          /* Parse of the input JSON */
-};
-
-/* Constructor for the json_each virtual table */
-static int jsonEachConnect(
-  sqlite3 *db,
-  void *pAux,
-  int argc, const char *const*argv,
-  sqlite3_vtab **ppVtab,
-  char **pzErr
-){
-  sqlite3_vtab *pNew;
-  int rc;
-
-/* Column numbers */
-#define JEACH_KEY     0
-#define JEACH_VALUE   1
-#define JEACH_TYPE    2
-#define JEACH_ATOM    3
-#define JEACH_ID      4
-#define JEACH_PARENT  5
-#define JEACH_FULLKEY 6
-#define JEACH_PATH    7
-/* The xBestIndex method assumes that the JSON and ROOT columns are
-** the last two columns in the table.  Should this ever changes, be
-** sure to update the xBestIndex method. */
-#define JEACH_JSON    8
-#define JEACH_ROOT    9
-
-  UNUSED_PARAM(pzErr);
-  UNUSED_PARAM(argv);
-  UNUSED_PARAM(argc);
-  UNUSED_PARAM(pAux);
+    z = (const char*)sqlite3_value_text(argv[0]); 
+    n = (u32)sqlite3_value_bytes(argv[0]); 
+    jsonAppendString(pStr, z, n); 
+    jsonAppendChar(pStr, ':'); 
+    jsonAppendValue(pStr, argv[1]); 
+  } 
+} 
+static void jsonObjectCompute(sqlite3_context *ctx, int isFinal){ 
+  JsonString *pStr; 
+  pStr = (JsonString*)sqlite3_aggregate_context(ctx, 0); 
+  if( pStr ){ 
+    jsonAppendChar(pStr, '}'); 
+    if( pStr->bErr ){ 
+      if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx); 
+      assert( pStr->bStatic ); 
+    }else if( isFinal ){ 
+      sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, 
+                          pStr->bStatic ? SQLITE_TRANSIENT : sqlite3_free); 
+      pStr->bStatic = 1; 
+    }else{ 
+      sqlite3_result_text(ctx, pStr->zBuf, (int)pStr->nUsed, SQLITE_TRANSIENT); 
+      pStr->nUsed--; 
+    } 
+  }else{ 
+    sqlite3_result_text(ctx, "{}", 2, SQLITE_STATIC); 
+  } 
+  sqlite3_result_subtype(ctx, JSON_SUBTYPE); 
+} 
+static void jsonObjectValue(sqlite3_context *ctx){ 
+  jsonObjectCompute(ctx, 0); 
+} 
+static void jsonObjectFinal(sqlite3_context *ctx){ 
+  jsonObjectCompute(ctx, 1); 
+} 
+ 
+ 
+ 
+#ifndef SQLITE_OMIT_VIRTUALTABLE 
+/**************************************************************************** 
+** The json_each virtual table 
+****************************************************************************/ 
+typedef struct JsonEachCursor JsonEachCursor; 
+struct JsonEachCursor { 
+  sqlite3_vtab_cursor base;  /* Base class - must be first */ 
+  u32 iRowid;                /* The rowid */ 
+  u32 iBegin;                /* The first node of the scan */ 
+  u32 i;                     /* Index in sParse.aNode[] of current row */ 
+  u32 iEnd;                  /* EOF when i equals or exceeds this value */ 
+  u8 eType;                  /* Type of top-level element */ 
+  u8 bRecursive;             /* True for json_tree().  False for json_each() */ 
+  char *zJson;               /* Input JSON */ 
+  char *zRoot;               /* Path by which to filter zJson */ 
+  JsonParse sParse;          /* Parse of the input JSON */ 
+}; 
+ 
+/* Constructor for the json_each virtual table */ 
+static int jsonEachConnect( 
+  sqlite3 *db, 
+  void *pAux, 
+  int argc, const char *const*argv, 
+  sqlite3_vtab **ppVtab, 
+  char **pzErr 
+){ 
+  sqlite3_vtab *pNew; 
+  int rc; 
+ 
+/* Column numbers */ 
+#define JEACH_KEY     0 
+#define JEACH_VALUE   1 
+#define JEACH_TYPE    2 
+#define JEACH_ATOM    3 
+#define JEACH_ID      4 
+#define JEACH_PARENT  5 
+#define JEACH_FULLKEY 6 
+#define JEACH_PATH    7 
+/* The xBestIndex method assumes that the JSON and ROOT columns are 
+** the last two columns in the table.  Should this ever changes, be 
+** sure to update the xBestIndex method. */ 
+#define JEACH_JSON    8 
+#define JEACH_ROOT    9 
+ 
+  UNUSED_PARAM(pzErr); 
+  UNUSED_PARAM(argv); 
+  UNUSED_PARAM(argc); 
+  UNUSED_PARAM(pAux); 
   rc = sqlite3_declare_vtab(db,
-     "CREATE TABLE x(key,value,type,atom,id,parent,fullkey,path,"
-                    "json HIDDEN,root HIDDEN)");
-  if( rc==SQLITE_OK ){
-    pNew = *ppVtab = sqlite3_malloc( sizeof(*pNew) );
-    if( pNew==0 ) return SQLITE_NOMEM;
-    memset(pNew, 0, sizeof(*pNew));
+     "CREATE TABLE x(key,value,type,atom,id,parent,fullkey,path," 
+                    "json HIDDEN,root HIDDEN)"); 
+  if( rc==SQLITE_OK ){ 
+    pNew = *ppVtab = sqlite3_malloc( sizeof(*pNew) ); 
+    if( pNew==0 ) return SQLITE_NOMEM; 
+    memset(pNew, 0, sizeof(*pNew)); 
     sqlite3_vtab_config(db, SQLITE_VTAB_INNOCUOUS);
-  }
-  return rc;
-}
-
-/* destructor for json_each virtual table */
-static int jsonEachDisconnect(sqlite3_vtab *pVtab){
-  sqlite3_free(pVtab);
-  return SQLITE_OK;
-}
-
-/* constructor for a JsonEachCursor object for json_each(). */
-static int jsonEachOpenEach(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){
-  JsonEachCursor *pCur;
-
-  UNUSED_PARAM(p);
-  pCur = sqlite3_malloc( sizeof(*pCur) );
-  if( pCur==0 ) return SQLITE_NOMEM;
-  memset(pCur, 0, sizeof(*pCur));
-  *ppCursor = &pCur->base;
-  return SQLITE_OK;
-}
-
-/* constructor for a JsonEachCursor object for json_tree(). */
-static int jsonEachOpenTree(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){
-  int rc = jsonEachOpenEach(p, ppCursor);
-  if( rc==SQLITE_OK ){
-    JsonEachCursor *pCur = (JsonEachCursor*)*ppCursor;
-    pCur->bRecursive = 1;
-  }
-  return rc;
-}
-
-/* Reset a JsonEachCursor back to its original state.  Free any memory
-** held. */
-static void jsonEachCursorReset(JsonEachCursor *p){
-  sqlite3_free(p->zJson);
-  sqlite3_free(p->zRoot);
-  jsonParseReset(&p->sParse);
-  p->iRowid = 0;
-  p->i = 0;
-  p->iEnd = 0;
-  p->eType = 0;
-  p->zJson = 0;
-  p->zRoot = 0;
-}
-
-/* Destructor for a jsonEachCursor object */
-static int jsonEachClose(sqlite3_vtab_cursor *cur){
-  JsonEachCursor *p = (JsonEachCursor*)cur;
-  jsonEachCursorReset(p);
-  sqlite3_free(cur);
-  return SQLITE_OK;
-}
-
-/* Return TRUE if the jsonEachCursor object has been advanced off the end
-** of the JSON object */
-static int jsonEachEof(sqlite3_vtab_cursor *cur){
-  JsonEachCursor *p = (JsonEachCursor*)cur;
-  return p->i >= p->iEnd;
-}
-
-/* Advance the cursor to the next element for json_tree() */
-static int jsonEachNext(sqlite3_vtab_cursor *cur){
-  JsonEachCursor *p = (JsonEachCursor*)cur;
-  if( p->bRecursive ){
-    if( p->sParse.aNode[p->i].jnFlags & JNODE_LABEL ) p->i++;
-    p->i++;
-    p->iRowid++;
-    if( p->i<p->iEnd ){
-      u32 iUp = p->sParse.aUp[p->i];
-      JsonNode *pUp = &p->sParse.aNode[iUp];
-      p->eType = pUp->eType;
-      if( pUp->eType==JSON_ARRAY ){
+  } 
+  return rc; 
+} 
+ 
+/* destructor for json_each virtual table */ 
+static int jsonEachDisconnect(sqlite3_vtab *pVtab){ 
+  sqlite3_free(pVtab); 
+  return SQLITE_OK; 
+} 
+ 
+/* constructor for a JsonEachCursor object for json_each(). */ 
+static int jsonEachOpenEach(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ 
+  JsonEachCursor *pCur; 
+ 
+  UNUSED_PARAM(p); 
+  pCur = sqlite3_malloc( sizeof(*pCur) ); 
+  if( pCur==0 ) return SQLITE_NOMEM; 
+  memset(pCur, 0, sizeof(*pCur)); 
+  *ppCursor = &pCur->base; 
+  return SQLITE_OK; 
+} 
+ 
+/* constructor for a JsonEachCursor object for json_tree(). */ 
+static int jsonEachOpenTree(sqlite3_vtab *p, sqlite3_vtab_cursor **ppCursor){ 
+  int rc = jsonEachOpenEach(p, ppCursor); 
+  if( rc==SQLITE_OK ){ 
+    JsonEachCursor *pCur = (JsonEachCursor*)*ppCursor; 
+    pCur->bRecursive = 1; 
+  } 
+  return rc; 
+} 
+ 
+/* Reset a JsonEachCursor back to its original state.  Free any memory 
+** held. */ 
+static void jsonEachCursorReset(JsonEachCursor *p){ 
+  sqlite3_free(p->zJson); 
+  sqlite3_free(p->zRoot); 
+  jsonParseReset(&p->sParse); 
+  p->iRowid = 0; 
+  p->i = 0; 
+  p->iEnd = 0; 
+  p->eType = 0; 
+  p->zJson = 0; 
+  p->zRoot = 0; 
+} 
+ 
+/* Destructor for a jsonEachCursor object */ 
+static int jsonEachClose(sqlite3_vtab_cursor *cur){ 
+  JsonEachCursor *p = (JsonEachCursor*)cur; 
+  jsonEachCursorReset(p); 
+  sqlite3_free(cur); 
+  return SQLITE_OK; 
+} 
+ 
+/* Return TRUE if the jsonEachCursor object has been advanced off the end 
+** of the JSON object */ 
+static int jsonEachEof(sqlite3_vtab_cursor *cur){ 
+  JsonEachCursor *p = (JsonEachCursor*)cur; 
+  return p->i >= p->iEnd; 
+} 
+ 
+/* Advance the cursor to the next element for json_tree() */ 
+static int jsonEachNext(sqlite3_vtab_cursor *cur){ 
+  JsonEachCursor *p = (JsonEachCursor*)cur; 
+  if( p->bRecursive ){ 
+    if( p->sParse.aNode[p->i].jnFlags & JNODE_LABEL ) p->i++; 
+    p->i++; 
+    p->iRowid++; 
+    if( p->i<p->iEnd ){ 
+      u32 iUp = p->sParse.aUp[p->i]; 
+      JsonNode *pUp = &p->sParse.aNode[iUp]; 
+      p->eType = pUp->eType; 
+      if( pUp->eType==JSON_ARRAY ){ 
         assert( pUp->eU==0 || pUp->eU==3 );
         json_testcase( pUp->eU==3 );
         VVA( pUp->eU = 3 );
-        if( iUp==p->i-1 ){
-          pUp->u.iKey = 0;
-        }else{
-          pUp->u.iKey++;
-        }
-      }
-    }
-  }else{
-    switch( p->eType ){
-      case JSON_ARRAY: {
-        p->i += jsonNodeSize(&p->sParse.aNode[p->i]);
-        p->iRowid++;
-        break;
-      }
-      case JSON_OBJECT: {
-        p->i += 1 + jsonNodeSize(&p->sParse.aNode[p->i+1]);
-        p->iRowid++;
-        break;
-      }
-      default: {
-        p->i = p->iEnd;
-        break;
-      }
-    }
-  }
-  return SQLITE_OK;
-}
-
-/* Append the name of the path for element i to pStr
-*/
-static void jsonEachComputePath(
-  JsonEachCursor *p,       /* The cursor */
-  JsonString *pStr,        /* Write the path here */
-  u32 i                    /* Path to this element */
-){
-  JsonNode *pNode, *pUp;
-  u32 iUp;
-  if( i==0 ){
-    jsonAppendChar(pStr, '$');
-    return;
-  }
-  iUp = p->sParse.aUp[i];
-  jsonEachComputePath(p, pStr, iUp);
-  pNode = &p->sParse.aNode[i];
-  pUp = &p->sParse.aNode[iUp];
-  if( pUp->eType==JSON_ARRAY ){
+        if( iUp==p->i-1 ){ 
+          pUp->u.iKey = 0; 
+        }else{ 
+          pUp->u.iKey++; 
+        } 
+      } 
+    } 
+  }else{ 
+    switch( p->eType ){ 
+      case JSON_ARRAY: { 
+        p->i += jsonNodeSize(&p->sParse.aNode[p->i]); 
+        p->iRowid++; 
+        break; 
+      } 
+      case JSON_OBJECT: { 
+        p->i += 1 + jsonNodeSize(&p->sParse.aNode[p->i+1]); 
+        p->iRowid++; 
+        break; 
+      } 
+      default: { 
+        p->i = p->iEnd; 
+        break; 
+      } 
+    } 
+  } 
+  return SQLITE_OK; 
+} 
+ 
+/* Append the name of the path for element i to pStr 
+*/ 
+static void jsonEachComputePath( 
+  JsonEachCursor *p,       /* The cursor */ 
+  JsonString *pStr,        /* Write the path here */ 
+  u32 i                    /* Path to this element */ 
+){ 
+  JsonNode *pNode, *pUp; 
+  u32 iUp; 
+  if( i==0 ){ 
+    jsonAppendChar(pStr, '$'); 
+    return; 
+  } 
+  iUp = p->sParse.aUp[i]; 
+  jsonEachComputePath(p, pStr, iUp); 
+  pNode = &p->sParse.aNode[i]; 
+  pUp = &p->sParse.aNode[iUp]; 
+  if( pUp->eType==JSON_ARRAY ){ 
     assert( pUp->eU==3 || (pUp->eU==0 && pUp->u.iKey==0) );
     testcase( pUp->eU==0 );
-    jsonPrintf(30, pStr, "[%d]", pUp->u.iKey);
-  }else{
-    assert( pUp->eType==JSON_OBJECT );
-    if( (pNode->jnFlags & JNODE_LABEL)==0 ) pNode--;
-    assert( pNode->eType==JSON_STRING );
-    assert( pNode->jnFlags & JNODE_LABEL );
+    jsonPrintf(30, pStr, "[%d]", pUp->u.iKey); 
+  }else{ 
+    assert( pUp->eType==JSON_OBJECT ); 
+    if( (pNode->jnFlags & JNODE_LABEL)==0 ) pNode--; 
+    assert( pNode->eType==JSON_STRING ); 
+    assert( pNode->jnFlags & JNODE_LABEL ); 
     assert( pNode->eU==1 );
-    jsonPrintf(pNode->n+1, pStr, ".%.*s", pNode->n-2, pNode->u.zJContent+1);
-  }
-}
-
-/* Return the value of a column */
-static int jsonEachColumn(
-  sqlite3_vtab_cursor *cur,   /* The cursor */
-  sqlite3_context *ctx,       /* First argument to sqlite3_result_...() */
-  int i                       /* Which column to return */
-){
-  JsonEachCursor *p = (JsonEachCursor*)cur;
-  JsonNode *pThis = &p->sParse.aNode[p->i];
-  switch( i ){
-    case JEACH_KEY: {
-      if( p->i==0 ) break;
-      if( p->eType==JSON_OBJECT ){
-        jsonReturn(pThis, ctx, 0);
-      }else if( p->eType==JSON_ARRAY ){
-        u32 iKey;
-        if( p->bRecursive ){
-          if( p->iRowid==0 ) break;
+    jsonPrintf(pNode->n+1, pStr, ".%.*s", pNode->n-2, pNode->u.zJContent+1); 
+  } 
+} 
+ 
+/* Return the value of a column */ 
+static int jsonEachColumn( 
+  sqlite3_vtab_cursor *cur,   /* The cursor */ 
+  sqlite3_context *ctx,       /* First argument to sqlite3_result_...() */ 
+  int i                       /* Which column to return */ 
+){ 
+  JsonEachCursor *p = (JsonEachCursor*)cur; 
+  JsonNode *pThis = &p->sParse.aNode[p->i]; 
+  switch( i ){ 
+    case JEACH_KEY: { 
+      if( p->i==0 ) break; 
+      if( p->eType==JSON_OBJECT ){ 
+        jsonReturn(pThis, ctx, 0); 
+      }else if( p->eType==JSON_ARRAY ){ 
+        u32 iKey; 
+        if( p->bRecursive ){ 
+          if( p->iRowid==0 ) break; 
           assert( p->sParse.aNode[p->sParse.aUp[p->i]].eU==3 );
-          iKey = p->sParse.aNode[p->sParse.aUp[p->i]].u.iKey;
-        }else{
-          iKey = p->iRowid;
-        }
-        sqlite3_result_int64(ctx, (sqlite3_int64)iKey);
-      }
-      break;
-    }
-    case JEACH_VALUE: {
-      if( pThis->jnFlags & JNODE_LABEL ) pThis++;
-      jsonReturn(pThis, ctx, 0);
-      break;
-    }
-    case JEACH_TYPE: {
-      if( pThis->jnFlags & JNODE_LABEL ) pThis++;
-      sqlite3_result_text(ctx, jsonType[pThis->eType], -1, SQLITE_STATIC);
-      break;
-    }
-    case JEACH_ATOM: {
-      if( pThis->jnFlags & JNODE_LABEL ) pThis++;
-      if( pThis->eType>=JSON_ARRAY ) break;
-      jsonReturn(pThis, ctx, 0);
-      break;
-    }
-    case JEACH_ID: {
+          iKey = p->sParse.aNode[p->sParse.aUp[p->i]].u.iKey; 
+        }else{ 
+          iKey = p->iRowid; 
+        } 
+        sqlite3_result_int64(ctx, (sqlite3_int64)iKey); 
+      } 
+      break; 
+    } 
+    case JEACH_VALUE: { 
+      if( pThis->jnFlags & JNODE_LABEL ) pThis++; 
+      jsonReturn(pThis, ctx, 0); 
+      break; 
+    } 
+    case JEACH_TYPE: { 
+      if( pThis->jnFlags & JNODE_LABEL ) pThis++; 
+      sqlite3_result_text(ctx, jsonType[pThis->eType], -1, SQLITE_STATIC); 
+      break; 
+    } 
+    case JEACH_ATOM: { 
+      if( pThis->jnFlags & JNODE_LABEL ) pThis++; 
+      if( pThis->eType>=JSON_ARRAY ) break; 
+      jsonReturn(pThis, ctx, 0); 
+      break; 
+    } 
+    case JEACH_ID: { 
       sqlite3_result_int64(ctx,
-         (sqlite3_int64)p->i + ((pThis->jnFlags & JNODE_LABEL)!=0));
-      break;
-    }
-    case JEACH_PARENT: {
-      if( p->i>p->iBegin && p->bRecursive ){
-        sqlite3_result_int64(ctx, (sqlite3_int64)p->sParse.aUp[p->i]);
-      }
-      break;
-    }
-    case JEACH_FULLKEY: {
-      JsonString x;
-      jsonInit(&x, ctx);
-      if( p->bRecursive ){
-        jsonEachComputePath(p, &x, p->i);
-      }else{
-        if( p->zRoot ){
-          jsonAppendRaw(&x, p->zRoot, (int)strlen(p->zRoot));
-        }else{
-          jsonAppendChar(&x, '$');
-        }
-        if( p->eType==JSON_ARRAY ){
-          jsonPrintf(30, &x, "[%d]", p->iRowid);
-        }else if( p->eType==JSON_OBJECT ){
+         (sqlite3_int64)p->i + ((pThis->jnFlags & JNODE_LABEL)!=0)); 
+      break; 
+    } 
+    case JEACH_PARENT: { 
+      if( p->i>p->iBegin && p->bRecursive ){ 
+        sqlite3_result_int64(ctx, (sqlite3_int64)p->sParse.aUp[p->i]); 
+      } 
+      break; 
+    } 
+    case JEACH_FULLKEY: { 
+      JsonString x; 
+      jsonInit(&x, ctx); 
+      if( p->bRecursive ){ 
+        jsonEachComputePath(p, &x, p->i); 
+      }else{ 
+        if( p->zRoot ){ 
+          jsonAppendRaw(&x, p->zRoot, (int)strlen(p->zRoot)); 
+        }else{ 
+          jsonAppendChar(&x, '$'); 
+        } 
+        if( p->eType==JSON_ARRAY ){ 
+          jsonPrintf(30, &x, "[%d]", p->iRowid); 
+        }else if( p->eType==JSON_OBJECT ){ 
           assert( pThis->eU==1 );
-          jsonPrintf(pThis->n, &x, ".%.*s", pThis->n-2, pThis->u.zJContent+1);
-        }
-      }
-      jsonResult(&x);
-      break;
-    }
-    case JEACH_PATH: {
-      if( p->bRecursive ){
-        JsonString x;
-        jsonInit(&x, ctx);
-        jsonEachComputePath(p, &x, p->sParse.aUp[p->i]);
-        jsonResult(&x);
-        break;
-      }
-      /* For json_each() path and root are the same so fall through
-      ** into the root case */
+          jsonPrintf(pThis->n, &x, ".%.*s", pThis->n-2, pThis->u.zJContent+1); 
+        } 
+      } 
+      jsonResult(&x); 
+      break; 
+    } 
+    case JEACH_PATH: { 
+      if( p->bRecursive ){ 
+        JsonString x; 
+        jsonInit(&x, ctx); 
+        jsonEachComputePath(p, &x, p->sParse.aUp[p->i]); 
+        jsonResult(&x); 
+        break; 
+      } 
+      /* For json_each() path and root are the same so fall through 
+      ** into the root case */ 
       /* no break */ deliberate_fall_through
-    }
-    default: {
-      const char *zRoot = p->zRoot;
-      if( zRoot==0 ) zRoot = "$";
-      sqlite3_result_text(ctx, zRoot, -1, SQLITE_STATIC);
-      break;
-    }
-    case JEACH_JSON: {
-      assert( i==JEACH_JSON );
-      sqlite3_result_text(ctx, p->sParse.zJson, -1, SQLITE_STATIC);
-      break;
-    }
-  }
-  return SQLITE_OK;
-}
-
-/* Return the current rowid value */
-static int jsonEachRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
-  JsonEachCursor *p = (JsonEachCursor*)cur;
-  *pRowid = p->iRowid;
-  return SQLITE_OK;
-}
-
-/* The query strategy is to look for an equality constraint on the json
-** column.  Without such a constraint, the table cannot operate.  idxNum is
-** 1 if the constraint is found, 3 if the constraint and zRoot are found,
-** and 0 otherwise.
-*/
-static int jsonEachBestIndex(
-  sqlite3_vtab *tab,
-  sqlite3_index_info *pIdxInfo
-){
-  int i;                     /* Loop counter or computed array index */
-  int aIdx[2];               /* Index of constraints for JSON and ROOT */
-  int unusableMask = 0;      /* Mask of unusable JSON and ROOT constraints */
-  int idxMask = 0;           /* Mask of usable == constraints JSON and ROOT */
-  const struct sqlite3_index_constraint *pConstraint;
-
-  /* This implementation assumes that JSON and ROOT are the last two
-  ** columns in the table */
-  assert( JEACH_ROOT == JEACH_JSON+1 );
-  UNUSED_PARAM(tab);
-  aIdx[0] = aIdx[1] = -1;
-  pConstraint = pIdxInfo->aConstraint;
-  for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){
-    int iCol;
-    int iMask;
-    if( pConstraint->iColumn < JEACH_JSON ) continue;
-    iCol = pConstraint->iColumn - JEACH_JSON;
-    assert( iCol==0 || iCol==1 );
+    } 
+    default: { 
+      const char *zRoot = p->zRoot; 
+      if( zRoot==0 ) zRoot = "$"; 
+      sqlite3_result_text(ctx, zRoot, -1, SQLITE_STATIC); 
+      break; 
+    } 
+    case JEACH_JSON: { 
+      assert( i==JEACH_JSON ); 
+      sqlite3_result_text(ctx, p->sParse.zJson, -1, SQLITE_STATIC); 
+      break; 
+    } 
+  } 
+  return SQLITE_OK; 
+} 
+ 
+/* Return the current rowid value */ 
+static int jsonEachRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){ 
+  JsonEachCursor *p = (JsonEachCursor*)cur; 
+  *pRowid = p->iRowid; 
+  return SQLITE_OK; 
+} 
+ 
+/* The query strategy is to look for an equality constraint on the json 
+** column.  Without such a constraint, the table cannot operate.  idxNum is 
+** 1 if the constraint is found, 3 if the constraint and zRoot are found, 
+** and 0 otherwise. 
+*/ 
+static int jsonEachBestIndex( 
+  sqlite3_vtab *tab, 
+  sqlite3_index_info *pIdxInfo 
+){ 
+  int i;                     /* Loop counter or computed array index */ 
+  int aIdx[2];               /* Index of constraints for JSON and ROOT */ 
+  int unusableMask = 0;      /* Mask of unusable JSON and ROOT constraints */ 
+  int idxMask = 0;           /* Mask of usable == constraints JSON and ROOT */ 
+  const struct sqlite3_index_constraint *pConstraint; 
+ 
+  /* This implementation assumes that JSON and ROOT are the last two 
+  ** columns in the table */ 
+  assert( JEACH_ROOT == JEACH_JSON+1 ); 
+  UNUSED_PARAM(tab); 
+  aIdx[0] = aIdx[1] = -1; 
+  pConstraint = pIdxInfo->aConstraint; 
+  for(i=0; i<pIdxInfo->nConstraint; i++, pConstraint++){ 
+    int iCol; 
+    int iMask; 
+    if( pConstraint->iColumn < JEACH_JSON ) continue; 
+    iCol = pConstraint->iColumn - JEACH_JSON; 
+    assert( iCol==0 || iCol==1 ); 
     testcase( iCol==0 );
-    iMask = 1 << iCol;
-    if( pConstraint->usable==0 ){
-      unusableMask |= iMask;
-    }else if( pConstraint->op==SQLITE_INDEX_CONSTRAINT_EQ ){
-      aIdx[iCol] = i;
-      idxMask |= iMask;
-    }
-  }
-  if( (unusableMask & ~idxMask)!=0 ){
-    /* If there are any unusable constraints on JSON or ROOT, then reject
-    ** this entire plan */
-    return SQLITE_CONSTRAINT;
-  }
-  if( aIdx[0]<0 ){
-    /* No JSON input.  Leave estimatedCost at the huge value that it was
-    ** initialized to to discourage the query planner from selecting this
-    ** plan. */
-    pIdxInfo->idxNum = 0;
-  }else{
-    pIdxInfo->estimatedCost = 1.0;
-    i = aIdx[0];
-    pIdxInfo->aConstraintUsage[i].argvIndex = 1;
-    pIdxInfo->aConstraintUsage[i].omit = 1;
-    if( aIdx[1]<0 ){
-      pIdxInfo->idxNum = 1;  /* Only JSON supplied.  Plan 1 */
-    }else{
-      i = aIdx[1];
-      pIdxInfo->aConstraintUsage[i].argvIndex = 2;
-      pIdxInfo->aConstraintUsage[i].omit = 1;
-      pIdxInfo->idxNum = 3;  /* Both JSON and ROOT are supplied.  Plan 3 */
-    }
-  }
-  return SQLITE_OK;
-}
-
-/* Start a search on a new JSON string */
-static int jsonEachFilter(
-  sqlite3_vtab_cursor *cur,
-  int idxNum, const char *idxStr,
-  int argc, sqlite3_value **argv
-){
-  JsonEachCursor *p = (JsonEachCursor*)cur;
-  const char *z;
-  const char *zRoot = 0;
-  sqlite3_int64 n;
-
-  UNUSED_PARAM(idxStr);
-  UNUSED_PARAM(argc);
-  jsonEachCursorReset(p);
-  if( idxNum==0 ) return SQLITE_OK;
-  z = (const char*)sqlite3_value_text(argv[0]);
-  if( z==0 ) return SQLITE_OK;
-  n = sqlite3_value_bytes(argv[0]);
-  p->zJson = sqlite3_malloc64( n+1 );
-  if( p->zJson==0 ) return SQLITE_NOMEM;
-  memcpy(p->zJson, z, (size_t)n+1);
-  if( jsonParse(&p->sParse, 0, p->zJson) ){
-    int rc = SQLITE_NOMEM;
-    if( p->sParse.oom==0 ){
-      sqlite3_free(cur->pVtab->zErrMsg);
-      cur->pVtab->zErrMsg = sqlite3_mprintf("malformed JSON");
-      if( cur->pVtab->zErrMsg ) rc = SQLITE_ERROR;
-    }
-    jsonEachCursorReset(p);
-    return rc;
-  }else if( p->bRecursive && jsonParseFindParents(&p->sParse) ){
-    jsonEachCursorReset(p);
-    return SQLITE_NOMEM;
-  }else{
-    JsonNode *pNode = 0;
-    if( idxNum==3 ){
-      const char *zErr = 0;
-      zRoot = (const char*)sqlite3_value_text(argv[1]);
-      if( zRoot==0 ) return SQLITE_OK;
-      n = sqlite3_value_bytes(argv[1]);
-      p->zRoot = sqlite3_malloc64( n+1 );
-      if( p->zRoot==0 ) return SQLITE_NOMEM;
-      memcpy(p->zRoot, zRoot, (size_t)n+1);
-      if( zRoot[0]!='$' ){
-        zErr = zRoot;
-      }else{
-        pNode = jsonLookupStep(&p->sParse, 0, p->zRoot+1, 0, &zErr);
-      }
-      if( zErr ){
-        sqlite3_free(cur->pVtab->zErrMsg);
-        cur->pVtab->zErrMsg = jsonPathSyntaxError(zErr);
-        jsonEachCursorReset(p);
-        return cur->pVtab->zErrMsg ? SQLITE_ERROR : SQLITE_NOMEM;
-      }else if( pNode==0 ){
-        return SQLITE_OK;
-      }
-    }else{
-      pNode = p->sParse.aNode;
-    }
-    p->iBegin = p->i = (int)(pNode - p->sParse.aNode);
-    p->eType = pNode->eType;
-    if( p->eType>=JSON_ARRAY ){
+    iMask = 1 << iCol; 
+    if( pConstraint->usable==0 ){ 
+      unusableMask |= iMask; 
+    }else if( pConstraint->op==SQLITE_INDEX_CONSTRAINT_EQ ){ 
+      aIdx[iCol] = i; 
+      idxMask |= iMask; 
+    } 
+  } 
+  if( (unusableMask & ~idxMask)!=0 ){ 
+    /* If there are any unusable constraints on JSON or ROOT, then reject 
+    ** this entire plan */ 
+    return SQLITE_CONSTRAINT; 
+  } 
+  if( aIdx[0]<0 ){ 
+    /* No JSON input.  Leave estimatedCost at the huge value that it was 
+    ** initialized to to discourage the query planner from selecting this 
+    ** plan. */ 
+    pIdxInfo->idxNum = 0; 
+  }else{ 
+    pIdxInfo->estimatedCost = 1.0; 
+    i = aIdx[0]; 
+    pIdxInfo->aConstraintUsage[i].argvIndex = 1; 
+    pIdxInfo->aConstraintUsage[i].omit = 1; 
+    if( aIdx[1]<0 ){ 
+      pIdxInfo->idxNum = 1;  /* Only JSON supplied.  Plan 1 */ 
+    }else{ 
+      i = aIdx[1]; 
+      pIdxInfo->aConstraintUsage[i].argvIndex = 2; 
+      pIdxInfo->aConstraintUsage[i].omit = 1; 
+      pIdxInfo->idxNum = 3;  /* Both JSON and ROOT are supplied.  Plan 3 */ 
+    } 
+  } 
+  return SQLITE_OK; 
+} 
+ 
+/* Start a search on a new JSON string */ 
+static int jsonEachFilter( 
+  sqlite3_vtab_cursor *cur, 
+  int idxNum, const char *idxStr, 
+  int argc, sqlite3_value **argv 
+){ 
+  JsonEachCursor *p = (JsonEachCursor*)cur; 
+  const char *z; 
+  const char *zRoot = 0; 
+  sqlite3_int64 n; 
+ 
+  UNUSED_PARAM(idxStr); 
+  UNUSED_PARAM(argc); 
+  jsonEachCursorReset(p); 
+  if( idxNum==0 ) return SQLITE_OK; 
+  z = (const char*)sqlite3_value_text(argv[0]); 
+  if( z==0 ) return SQLITE_OK; 
+  n = sqlite3_value_bytes(argv[0]); 
+  p->zJson = sqlite3_malloc64( n+1 ); 
+  if( p->zJson==0 ) return SQLITE_NOMEM; 
+  memcpy(p->zJson, z, (size_t)n+1); 
+  if( jsonParse(&p->sParse, 0, p->zJson) ){ 
+    int rc = SQLITE_NOMEM; 
+    if( p->sParse.oom==0 ){ 
+      sqlite3_free(cur->pVtab->zErrMsg); 
+      cur->pVtab->zErrMsg = sqlite3_mprintf("malformed JSON"); 
+      if( cur->pVtab->zErrMsg ) rc = SQLITE_ERROR; 
+    } 
+    jsonEachCursorReset(p); 
+    return rc; 
+  }else if( p->bRecursive && jsonParseFindParents(&p->sParse) ){ 
+    jsonEachCursorReset(p); 
+    return SQLITE_NOMEM; 
+  }else{ 
+    JsonNode *pNode = 0; 
+    if( idxNum==3 ){ 
+      const char *zErr = 0; 
+      zRoot = (const char*)sqlite3_value_text(argv[1]); 
+      if( zRoot==0 ) return SQLITE_OK; 
+      n = sqlite3_value_bytes(argv[1]); 
+      p->zRoot = sqlite3_malloc64( n+1 ); 
+      if( p->zRoot==0 ) return SQLITE_NOMEM; 
+      memcpy(p->zRoot, zRoot, (size_t)n+1); 
+      if( zRoot[0]!='$' ){ 
+        zErr = zRoot; 
+      }else{ 
+        pNode = jsonLookupStep(&p->sParse, 0, p->zRoot+1, 0, &zErr); 
+      } 
+      if( zErr ){ 
+        sqlite3_free(cur->pVtab->zErrMsg); 
+        cur->pVtab->zErrMsg = jsonPathSyntaxError(zErr); 
+        jsonEachCursorReset(p); 
+        return cur->pVtab->zErrMsg ? SQLITE_ERROR : SQLITE_NOMEM; 
+      }else if( pNode==0 ){ 
+        return SQLITE_OK; 
+      } 
+    }else{ 
+      pNode = p->sParse.aNode; 
+    } 
+    p->iBegin = p->i = (int)(pNode - p->sParse.aNode); 
+    p->eType = pNode->eType; 
+    if( p->eType>=JSON_ARRAY ){ 
       assert( pNode->eU==0 );
       VVA( pNode->eU = 3 );
-      pNode->u.iKey = 0;
-      p->iEnd = p->i + pNode->n + 1;
-      if( p->bRecursive ){
-        p->eType = p->sParse.aNode[p->sParse.aUp[p->i]].eType;
-        if( p->i>0 && (p->sParse.aNode[p->i-1].jnFlags & JNODE_LABEL)!=0 ){
-          p->i--;
-        }
-      }else{
-        p->i++;
-      }
-    }else{
-      p->iEnd = p->i+1;
-    }
-  }
-  return SQLITE_OK;
-}
-
-/* The methods of the json_each virtual table */
-static sqlite3_module jsonEachModule = {
-  0,                         /* iVersion */
-  0,                         /* xCreate */
-  jsonEachConnect,           /* xConnect */
-  jsonEachBestIndex,         /* xBestIndex */
-  jsonEachDisconnect,        /* xDisconnect */
-  0,                         /* xDestroy */
-  jsonEachOpenEach,          /* xOpen - open a cursor */
-  jsonEachClose,             /* xClose - close a cursor */
-  jsonEachFilter,            /* xFilter - configure scan constraints */
-  jsonEachNext,              /* xNext - advance a cursor */
-  jsonEachEof,               /* xEof - check for end of scan */
-  jsonEachColumn,            /* xColumn - read data */
-  jsonEachRowid,             /* xRowid - read data */
-  0,                         /* xUpdate */
-  0,                         /* xBegin */
-  0,                         /* xSync */
-  0,                         /* xCommit */
-  0,                         /* xRollback */
-  0,                         /* xFindMethod */
-  0,                         /* xRename */
-  0,                         /* xSavepoint */
-  0,                         /* xRelease */
-  0,                         /* xRollbackTo */
-  0                          /* xShadowName */
-};
-
-/* The methods of the json_tree virtual table. */
-static sqlite3_module jsonTreeModule = {
-  0,                         /* iVersion */
-  0,                         /* xCreate */
-  jsonEachConnect,           /* xConnect */
-  jsonEachBestIndex,         /* xBestIndex */
-  jsonEachDisconnect,        /* xDisconnect */
-  0,                         /* xDestroy */
-  jsonEachOpenTree,          /* xOpen - open a cursor */
-  jsonEachClose,             /* xClose - close a cursor */
-  jsonEachFilter,            /* xFilter - configure scan constraints */
-  jsonEachNext,              /* xNext - advance a cursor */
-  jsonEachEof,               /* xEof - check for end of scan */
-  jsonEachColumn,            /* xColumn - read data */
-  jsonEachRowid,             /* xRowid - read data */
-  0,                         /* xUpdate */
-  0,                         /* xBegin */
-  0,                         /* xSync */
-  0,                         /* xCommit */
-  0,                         /* xRollback */
-  0,                         /* xFindMethod */
-  0,                         /* xRename */
-  0,                         /* xSavepoint */
-  0,                         /* xRelease */
-  0,                         /* xRollbackTo */
-  0                          /* xShadowName */
-};
-#endif /* SQLITE_OMIT_VIRTUALTABLE */
-
-/****************************************************************************
-** The following routines are the only publically visible identifiers in this
-** file.  Call the following routines in order to register the various SQL
-** functions and the virtual table implemented by this file.
-****************************************************************************/
-
-SQLITE_PRIVATE int sqlite3Json1Init(sqlite3 *db){
-  int rc = SQLITE_OK;
-  unsigned int i;
-  static const struct {
-     const char *zName;
-     int nArg;
-     int flag;
-     void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
-  } aFunc[] = {
-    { "json",                 1, 0,   jsonRemoveFunc        },
-    { "json_array",          -1, 0,   jsonArrayFunc         },
-    { "json_array_length",    1, 0,   jsonArrayLengthFunc   },
-    { "json_array_length",    2, 0,   jsonArrayLengthFunc   },
-    { "json_extract",        -1, 0,   jsonExtractFunc       },
-    { "json_insert",         -1, 0,   jsonSetFunc           },
-    { "json_object",         -1, 0,   jsonObjectFunc        },
-    { "json_patch",           2, 0,   jsonPatchFunc         },
-    { "json_quote",           1, 0,   jsonQuoteFunc         },
-    { "json_remove",         -1, 0,   jsonRemoveFunc        },
-    { "json_replace",        -1, 0,   jsonReplaceFunc       },
-    { "json_set",            -1, 1,   jsonSetFunc           },
-    { "json_type",            1, 0,   jsonTypeFunc          },
-    { "json_type",            2, 0,   jsonTypeFunc          },
-    { "json_valid",           1, 0,   jsonValidFunc         },
-
-#if SQLITE_DEBUG
-    /* DEBUG and TESTING functions */
-    { "json_parse",           1, 0,   jsonParseFunc         },
-    { "json_test1",           1, 0,   jsonTest1Func         },
-#endif
-  };
-  static const struct {
-     const char *zName;
-     int nArg;
-     void (*xStep)(sqlite3_context*,int,sqlite3_value**);
-     void (*xFinal)(sqlite3_context*);
-     void (*xValue)(sqlite3_context*);
-  } aAgg[] = {
-    { "json_group_array",     1,
-      jsonArrayStep,   jsonArrayFinal,  jsonArrayValue  },
-    { "json_group_object",    2,
-      jsonObjectStep,  jsonObjectFinal, jsonObjectValue },
-  };
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-  static const struct {
-     const char *zName;
-     sqlite3_module *pModule;
-  } aMod[] = {
-    { "json_each",            &jsonEachModule               },
-    { "json_tree",            &jsonTreeModule               },
-  };
-#endif
+      pNode->u.iKey = 0; 
+      p->iEnd = p->i + pNode->n + 1; 
+      if( p->bRecursive ){ 
+        p->eType = p->sParse.aNode[p->sParse.aUp[p->i]].eType; 
+        if( p->i>0 && (p->sParse.aNode[p->i-1].jnFlags & JNODE_LABEL)!=0 ){ 
+          p->i--; 
+        } 
+      }else{ 
+        p->i++; 
+      } 
+    }else{ 
+      p->iEnd = p->i+1; 
+    } 
+  } 
+  return SQLITE_OK; 
+} 
+ 
+/* The methods of the json_each virtual table */ 
+static sqlite3_module jsonEachModule = { 
+  0,                         /* iVersion */ 
+  0,                         /* xCreate */ 
+  jsonEachConnect,           /* xConnect */ 
+  jsonEachBestIndex,         /* xBestIndex */ 
+  jsonEachDisconnect,        /* xDisconnect */ 
+  0,                         /* xDestroy */ 
+  jsonEachOpenEach,          /* xOpen - open a cursor */ 
+  jsonEachClose,             /* xClose - close a cursor */ 
+  jsonEachFilter,            /* xFilter - configure scan constraints */ 
+  jsonEachNext,              /* xNext - advance a cursor */ 
+  jsonEachEof,               /* xEof - check for end of scan */ 
+  jsonEachColumn,            /* xColumn - read data */ 
+  jsonEachRowid,             /* xRowid - read data */ 
+  0,                         /* xUpdate */ 
+  0,                         /* xBegin */ 
+  0,                         /* xSync */ 
+  0,                         /* xCommit */ 
+  0,                         /* xRollback */ 
+  0,                         /* xFindMethod */ 
+  0,                         /* xRename */ 
+  0,                         /* xSavepoint */ 
+  0,                         /* xRelease */ 
+  0,                         /* xRollbackTo */ 
+  0                          /* xShadowName */ 
+}; 
+ 
+/* The methods of the json_tree virtual table. */ 
+static sqlite3_module jsonTreeModule = { 
+  0,                         /* iVersion */ 
+  0,                         /* xCreate */ 
+  jsonEachConnect,           /* xConnect */ 
+  jsonEachBestIndex,         /* xBestIndex */ 
+  jsonEachDisconnect,        /* xDisconnect */ 
+  0,                         /* xDestroy */ 
+  jsonEachOpenTree,          /* xOpen - open a cursor */ 
+  jsonEachClose,             /* xClose - close a cursor */ 
+  jsonEachFilter,            /* xFilter - configure scan constraints */ 
+  jsonEachNext,              /* xNext - advance a cursor */ 
+  jsonEachEof,               /* xEof - check for end of scan */ 
+  jsonEachColumn,            /* xColumn - read data */ 
+  jsonEachRowid,             /* xRowid - read data */ 
+  0,                         /* xUpdate */ 
+  0,                         /* xBegin */ 
+  0,                         /* xSync */ 
+  0,                         /* xCommit */ 
+  0,                         /* xRollback */ 
+  0,                         /* xFindMethod */ 
+  0,                         /* xRename */ 
+  0,                         /* xSavepoint */ 
+  0,                         /* xRelease */ 
+  0,                         /* xRollbackTo */ 
+  0                          /* xShadowName */ 
+}; 
+#endif /* SQLITE_OMIT_VIRTUALTABLE */ 
+ 
+/**************************************************************************** 
+** The following routines are the only publically visible identifiers in this 
+** file.  Call the following routines in order to register the various SQL 
+** functions and the virtual table implemented by this file. 
+****************************************************************************/ 
+ 
+SQLITE_PRIVATE int sqlite3Json1Init(sqlite3 *db){ 
+  int rc = SQLITE_OK; 
+  unsigned int i; 
+  static const struct { 
+     const char *zName; 
+     int nArg; 
+     int flag; 
+     void (*xFunc)(sqlite3_context*,int,sqlite3_value**); 
+  } aFunc[] = { 
+    { "json",                 1, 0,   jsonRemoveFunc        }, 
+    { "json_array",          -1, 0,   jsonArrayFunc         }, 
+    { "json_array_length",    1, 0,   jsonArrayLengthFunc   }, 
+    { "json_array_length",    2, 0,   jsonArrayLengthFunc   }, 
+    { "json_extract",        -1, 0,   jsonExtractFunc       }, 
+    { "json_insert",         -1, 0,   jsonSetFunc           }, 
+    { "json_object",         -1, 0,   jsonObjectFunc        }, 
+    { "json_patch",           2, 0,   jsonPatchFunc         }, 
+    { "json_quote",           1, 0,   jsonQuoteFunc         }, 
+    { "json_remove",         -1, 0,   jsonRemoveFunc        }, 
+    { "json_replace",        -1, 0,   jsonReplaceFunc       }, 
+    { "json_set",            -1, 1,   jsonSetFunc           }, 
+    { "json_type",            1, 0,   jsonTypeFunc          }, 
+    { "json_type",            2, 0,   jsonTypeFunc          }, 
+    { "json_valid",           1, 0,   jsonValidFunc         }, 
+ 
+#if SQLITE_DEBUG 
+    /* DEBUG and TESTING functions */ 
+    { "json_parse",           1, 0,   jsonParseFunc         }, 
+    { "json_test1",           1, 0,   jsonTest1Func         }, 
+#endif 
+  }; 
+  static const struct { 
+     const char *zName; 
+     int nArg; 
+     void (*xStep)(sqlite3_context*,int,sqlite3_value**); 
+     void (*xFinal)(sqlite3_context*); 
+     void (*xValue)(sqlite3_context*); 
+  } aAgg[] = { 
+    { "json_group_array",     1, 
+      jsonArrayStep,   jsonArrayFinal,  jsonArrayValue  }, 
+    { "json_group_object",    2, 
+      jsonObjectStep,  jsonObjectFinal, jsonObjectValue }, 
+  }; 
+#ifndef SQLITE_OMIT_VIRTUALTABLE 
+  static const struct { 
+     const char *zName; 
+     sqlite3_module *pModule; 
+  } aMod[] = { 
+    { "json_each",            &jsonEachModule               }, 
+    { "json_tree",            &jsonTreeModule               }, 
+  }; 
+#endif 
   static const int enc =
        SQLITE_UTF8 |
        SQLITE_DETERMINISTIC |
        SQLITE_INNOCUOUS;
-  for(i=0; i<sizeof(aFunc)/sizeof(aFunc[0]) && rc==SQLITE_OK; i++){
+  for(i=0; i<sizeof(aFunc)/sizeof(aFunc[0]) && rc==SQLITE_OK; i++){ 
     rc = sqlite3_create_function(db, aFunc[i].zName, aFunc[i].nArg, enc,
-                                 (void*)&aFunc[i].flag,
-                                 aFunc[i].xFunc, 0, 0);
-  }
-#ifndef SQLITE_OMIT_WINDOWFUNC
-  for(i=0; i<sizeof(aAgg)/sizeof(aAgg[0]) && rc==SQLITE_OK; i++){
-    rc = sqlite3_create_window_function(db, aAgg[i].zName, aAgg[i].nArg,
+                                 (void*)&aFunc[i].flag, 
+                                 aFunc[i].xFunc, 0, 0); 
+  } 
+#ifndef SQLITE_OMIT_WINDOWFUNC 
+  for(i=0; i<sizeof(aAgg)/sizeof(aAgg[0]) && rc==SQLITE_OK; i++){ 
+    rc = sqlite3_create_window_function(db, aAgg[i].zName, aAgg[i].nArg, 
                                  SQLITE_SUBTYPE | enc, 0,
-                                 aAgg[i].xStep, aAgg[i].xFinal,
-                                 aAgg[i].xValue, jsonGroupInverse, 0);
-  }
-#endif
-#ifndef SQLITE_OMIT_VIRTUALTABLE
-  for(i=0; i<sizeof(aMod)/sizeof(aMod[0]) && rc==SQLITE_OK; i++){
-    rc = sqlite3_create_module(db, aMod[i].zName, aMod[i].pModule, 0);
-  }
-#endif
-  return rc;
-}
-
-
-#ifndef SQLITE_CORE
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-SQLITE_API int sqlite3_json_init(
+                                 aAgg[i].xStep, aAgg[i].xFinal, 
+                                 aAgg[i].xValue, jsonGroupInverse, 0); 
+  } 
+#endif 
+#ifndef SQLITE_OMIT_VIRTUALTABLE 
+  for(i=0; i<sizeof(aMod)/sizeof(aMod[0]) && rc==SQLITE_OK; i++){ 
+    rc = sqlite3_create_module(db, aMod[i].zName, aMod[i].pModule, 0); 
+  } 
+#endif 
+  return rc; 
+} 
+ 
+ 
+#ifndef SQLITE_CORE 
+#ifdef _WIN32 
+__declspec(dllexport) 
+#endif 
+SQLITE_API int sqlite3_json_init( 
   sqlite3 *db,
   char **pzErrMsg,
-  const sqlite3_api_routines *pApi
-){
-  SQLITE_EXTENSION_INIT2(pApi);
-  (void)pzErrMsg;  /* Unused parameter */
-  return sqlite3Json1Init(db);
-}
-#endif
-#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_JSON1) */
-
-/************** End of json1.c ***********************************************/
+  const sqlite3_api_routines *pApi 
+){ 
+  SQLITE_EXTENSION_INIT2(pApi); 
+  (void)pzErrMsg;  /* Unused parameter */ 
+  return sqlite3Json1Init(db); 
+} 
+#endif 
+#endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_JSON1) */ 
+ 
+/************** End of json1.c ***********************************************/ 
 /************** Begin file rtree.c *******************************************/
 /*
 ** 2001 September 15
@@ -193987,15 +193987,15 @@ SQLITE_API int sqlite3_json_init(
 **
 **   CREATE TABLE %_node(nodeno INTEGER PRIMARY KEY, data BLOB)
 **   CREATE TABLE %_parent(nodeno INTEGER PRIMARY KEY, parentnode INTEGER)
-**   CREATE TABLE %_rowid(rowid INTEGER PRIMARY KEY, nodeno INTEGER, ...)
+**   CREATE TABLE %_rowid(rowid INTEGER PRIMARY KEY, nodeno INTEGER, ...) 
 **
 ** The data for each node of the r-tree structure is stored in the %_node
 ** table. For each node that is not the root node of the r-tree, there is
 ** an entry in the %_parent table associating the node with its parent.
 ** And for each row of data in the table, there is an entry in the %_rowid
 ** table that maps from the entries rowid to the id of the node that it
-** is stored on.  If the r-tree contains auxiliary columns, those are stored
-** on the end of the %_rowid table.
+** is stored on.  If the r-tree contains auxiliary columns, those are stored 
+** on the end of the %_rowid table. 
 **
 ** The root node of an r-tree always exists, even if the r-tree table is
 ** empty. The nodeno of the root node is always 1. All other nodes in the
@@ -194038,15 +194038,15 @@ typedef sqlite3_uint64 u64;
 typedef unsigned char u8;
 typedef unsigned short u16;
 typedef unsigned int u32;
-#if !defined(NDEBUG) && !defined(SQLITE_DEBUG)
-# define NDEBUG 1
-#endif
-#if defined(NDEBUG) && defined(SQLITE_DEBUG)
-# undef NDEBUG
+#if !defined(NDEBUG) && !defined(SQLITE_DEBUG) 
+# define NDEBUG 1 
 #endif
+#if defined(NDEBUG) && defined(SQLITE_DEBUG) 
+# undef NDEBUG 
+#endif 
 #if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST)
 # define SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS 1
-#endif
+#endif 
 #if defined(SQLITE_OMIT_AUXILIARY_SAFETY_CHECKS)
 # define ALWAYS(X)      (1)
 # define NEVER(X)       (0)
@@ -194059,11 +194059,11 @@ typedef unsigned int u32;
 #endif
 #endif /* !defined(SQLITE_AMALGAMATION) */
 
-/* #include <string.h> */
-/* #include <stdio.h> */
-/* #include <assert.h> */
+/* #include <string.h> */ 
+/* #include <stdio.h> */ 
+/* #include <assert.h> */ 
 /* #include <stdlib.h> */
-
+ 
 /*  The following macro is used to suppress compiler warnings.
 */
 #ifndef UNUSED_PARAMETER
@@ -194083,9 +194083,9 @@ typedef struct RtreeSearchPoint RtreeSearchPoint;
 /* The rtree may have between 1 and RTREE_MAX_DIMENSIONS dimensions. */
 #define RTREE_MAX_DIMENSIONS 5
 
-/* Maximum number of auxiliary columns */
-#define RTREE_MAX_AUX_COLUMN 100
-
+/* Maximum number of auxiliary columns */ 
+#define RTREE_MAX_AUX_COLUMN 100 
+ 
 /* Size of hash table Rtree.aHash. This hash table is not expected to
 ** ever contain very many entries, so a fixed number of buckets is
 ** used.
@@ -194114,21 +194114,21 @@ struct Rtree {
   u8 eCoordType;              /* RTREE_COORD_REAL32 or RTREE_COORD_INT32 */
   u8 nBytesPerCell;           /* Bytes consumed per cell */
   u8 inWrTrans;               /* True if inside write transaction */
-  u8 nAux;                    /* # of auxiliary columns in %_rowid */
+  u8 nAux;                    /* # of auxiliary columns in %_rowid */ 
 #ifdef SQLITE_ENABLE_GEOPOLY
-  u8 nAuxNotNull;             /* Number of initial not-null aux columns */
-#endif
-#ifdef SQLITE_DEBUG
-  u8 bCorrupt;                /* Shadow table corruption detected */
+  u8 nAuxNotNull;             /* Number of initial not-null aux columns */ 
 #endif
+#ifdef SQLITE_DEBUG 
+  u8 bCorrupt;                /* Shadow table corruption detected */ 
+#endif 
   int iDepth;                 /* Current depth of the r-tree structure */
   char *zDb;                  /* Name of database containing r-tree table */
   char *zName;                /* Name of r-tree table */
   u32 nBusy;                  /* Current number of users of this structure */
   i64 nRowEst;                /* Estimated number of rows in this table */
   u32 nCursor;                /* Number of open cursors */
-  u32 nNodeRef;               /* Number RtreeNodes with positive nRef */
-  char *zReadAuxSql;          /* SQL for statement to read aux data */
+  u32 nNodeRef;               /* Number RtreeNodes with positive nRef */ 
+  char *zReadAuxSql;          /* SQL for statement to read aux data */ 
 
   /* List of nodes removed during a CondenseTree operation. List is
   ** linked together via the pointer normally used for hash chains -
@@ -194155,9 +194155,9 @@ struct Rtree {
   sqlite3_stmt *pWriteParent;
   sqlite3_stmt *pDeleteParent;
 
-  /* Statement for writing to the "aux:" fields, if there are any */
-  sqlite3_stmt *pWriteAux;
-
+  /* Statement for writing to the "aux:" fields, if there are any */ 
+  sqlite3_stmt *pWriteAux; 
+ 
   RtreeNode *aHash[HASHSIZE]; /* Hash table of in-memory nodes. */
 };
 
@@ -194181,15 +194181,15 @@ struct Rtree {
 #endif
 
 /*
-** Set the Rtree.bCorrupt flag
-*/
-#ifdef SQLITE_DEBUG
-# define RTREE_IS_CORRUPT(X) ((X)->bCorrupt = 1)
-#else
-# define RTREE_IS_CORRUPT(X)
-#endif
-
-/*
+** Set the Rtree.bCorrupt flag 
+*/ 
+#ifdef SQLITE_DEBUG 
+# define RTREE_IS_CORRUPT(X) ((X)->bCorrupt = 1) 
+#else 
+# define RTREE_IS_CORRUPT(X) 
+#endif 
+ 
+/* 
 ** When doing a search of an r-tree, instances of the following structure
 ** record intermediate results from the tree walk.
 **
@@ -194243,7 +194243,7 @@ struct RtreeCursor {
   sqlite3_vtab_cursor base;         /* Base class.  Must be first */
   u8 atEOF;                         /* True if at end of search */
   u8 bPoint;                        /* True if sPoint is valid */
-  u8 bAuxValid;                     /* True if pReadAux is valid */
+  u8 bAuxValid;                     /* True if pReadAux is valid */ 
   int iStrategy;                    /* Copy of idxNum search parameter */
   int nConstraint;                  /* Number of entries in aConstraint */
   RtreeConstraint *aConstraint;     /* Search constraints. */
@@ -194251,7 +194251,7 @@ struct RtreeCursor {
   int nPoint;                       /* Number of slots used in aPoint[] */
   int mxLevel;                      /* iLevel value for root of the tree */
   RtreeSearchPoint *aPoint;         /* Priority queue for search points */
-  sqlite3_stmt *pReadAux;           /* Statement to read aux-data */
+  sqlite3_stmt *pReadAux;           /* Statement to read aux-data */ 
   RtreeSearchPoint sPoint;          /* Cached next search point */
   RtreeNode *aNode[RTREE_CACHE_SZ]; /* Rtree node cache */
   u32 anQueue[RTREE_MAX_DEPTH+1];   /* Number of queued entries by iLevel */
@@ -194566,7 +194566,7 @@ static int writeInt64(u8 *p, i64 i){
 */
 static void nodeReference(RtreeNode *p){
   if( p ){
-    assert( p->nRef>0 );
+    assert( p->nRef>0 ); 
     p->nRef++;
   }
 }
@@ -194583,8 +194583,8 @@ static void nodeZero(Rtree *pRtree, RtreeNode *p){
 ** Given a node number iNode, return the corresponding key to use
 ** in the Rtree.aHash table.
 */
-static unsigned int nodeHash(i64 iNode){
-  return ((unsigned)iNode) % HASHSIZE;
+static unsigned int nodeHash(i64 iNode){ 
+  return ((unsigned)iNode) % HASHSIZE; 
 }
 
 /*
@@ -194629,12 +194629,12 @@ static void nodeHashDelete(Rtree *pRtree, RtreeNode *pNode){
 */
 static RtreeNode *nodeNew(Rtree *pRtree, RtreeNode *pParent){
   RtreeNode *pNode;
-  pNode = (RtreeNode *)sqlite3_malloc64(sizeof(RtreeNode) + pRtree->iNodeSize);
+  pNode = (RtreeNode *)sqlite3_malloc64(sizeof(RtreeNode) + pRtree->iNodeSize); 
   if( pNode ){
     memset(pNode, 0, sizeof(RtreeNode) + pRtree->iNodeSize);
     pNode->zData = (u8 *)&pNode[1];
     pNode->nRef = 1;
-    pRtree->nNodeRef++;
+    pRtree->nNodeRef++; 
     pNode->pParent = pParent;
     pNode->isDirty = 1;
     nodeReference(pParent);
@@ -194668,7 +194668,7 @@ static int nodeAcquire(
   /* Check if the requested node is already in the hash table. If so,
   ** increase its reference count and return it.
   */
-  if( (pNode = nodeHashLookup(pRtree, iNode))!=0 ){
+  if( (pNode = nodeHashLookup(pRtree, iNode))!=0 ){ 
     if( pParent && pParent!=pNode->pParent ){
       RTREE_IS_CORRUPT(pRtree);
       return SQLITE_CORRUPT_VTAB;
@@ -194700,19 +194700,19 @@ static int nodeAcquire(
     *ppNode = 0;
     /* If unable to open an sqlite3_blob on the desired row, that can only
     ** be because the shadow tables hold erroneous data. */
-    if( rc==SQLITE_ERROR ){
-      rc = SQLITE_CORRUPT_VTAB;
-      RTREE_IS_CORRUPT(pRtree);
-    }
+    if( rc==SQLITE_ERROR ){ 
+      rc = SQLITE_CORRUPT_VTAB; 
+      RTREE_IS_CORRUPT(pRtree); 
+    } 
   }else if( pRtree->iNodeSize==sqlite3_blob_bytes(pRtree->pNodeBlob) ){
-    pNode = (RtreeNode *)sqlite3_malloc64(sizeof(RtreeNode)+pRtree->iNodeSize);
+    pNode = (RtreeNode *)sqlite3_malloc64(sizeof(RtreeNode)+pRtree->iNodeSize); 
     if( !pNode ){
       rc = SQLITE_NOMEM;
     }else{
       pNode->pParent = pParent;
       pNode->zData = (u8 *)&pNode[1];
       pNode->nRef = 1;
-      pRtree->nNodeRef++;
+      pRtree->nNodeRef++; 
       pNode->iNode = iNode;
       pNode->isDirty = 0;
       pNode->pNext = 0;
@@ -194731,7 +194731,7 @@ static int nodeAcquire(
     pRtree->iDepth = readInt16(pNode->zData);
     if( pRtree->iDepth>RTREE_MAX_DEPTH ){
       rc = SQLITE_CORRUPT_VTAB;
-      RTREE_IS_CORRUPT(pRtree);
+      RTREE_IS_CORRUPT(pRtree); 
     }
   }
 
@@ -194742,24 +194742,24 @@ static int nodeAcquire(
   if( pNode && rc==SQLITE_OK ){
     if( NCELL(pNode)>((pRtree->iNodeSize-4)/pRtree->nBytesPerCell) ){
       rc = SQLITE_CORRUPT_VTAB;
-      RTREE_IS_CORRUPT(pRtree);
+      RTREE_IS_CORRUPT(pRtree); 
     }
   }
 
   if( rc==SQLITE_OK ){
     if( pNode!=0 ){
-      nodeReference(pParent);
+      nodeReference(pParent); 
       nodeHashInsert(pRtree, pNode);
     }else{
       rc = SQLITE_CORRUPT_VTAB;
-      RTREE_IS_CORRUPT(pRtree);
+      RTREE_IS_CORRUPT(pRtree); 
     }
     *ppNode = pNode;
   }else{
-    if( pNode ){
-      pRtree->nNodeRef--;
-      sqlite3_free(pNode);
-    }
+    if( pNode ){ 
+      pRtree->nNodeRef--; 
+      sqlite3_free(pNode); 
+    } 
     *ppNode = 0;
   }
 
@@ -194839,7 +194839,7 @@ static int nodeWrite(Rtree *pRtree, RtreeNode *pNode){
     sqlite3_step(p);
     pNode->isDirty = 0;
     rc = sqlite3_reset(p);
-    sqlite3_bind_null(p, 2);
+    sqlite3_bind_null(p, 2); 
     if( pNode->iNode==0 && rc==SQLITE_OK ){
       pNode->iNode = sqlite3_last_insert_rowid(pRtree->db);
       nodeHashInsert(pRtree, pNode);
@@ -194856,10 +194856,10 @@ static int nodeRelease(Rtree *pRtree, RtreeNode *pNode){
   int rc = SQLITE_OK;
   if( pNode ){
     assert( pNode->nRef>0 );
-    assert( pRtree->nNodeRef>0 );
+    assert( pRtree->nNodeRef>0 ); 
     pNode->nRef--;
     if( pNode->nRef==0 ){
-      pRtree->nNodeRef--;
+      pRtree->nNodeRef--; 
       if( pNode->iNode==1 ){
         pRtree->iDepth = -1;
       }
@@ -194976,9 +194976,9 @@ static void rtreeRelease(Rtree *pRtree){
   pRtree->nBusy--;
   if( pRtree->nBusy==0 ){
     pRtree->inWrTrans = 0;
-    assert( pRtree->nCursor==0 );
+    assert( pRtree->nCursor==0 ); 
     nodeBlobReset(pRtree);
-    assert( pRtree->nNodeRef==0 || pRtree->bCorrupt );
+    assert( pRtree->nNodeRef==0 || pRtree->bCorrupt ); 
     sqlite3_finalize(pRtree->pWriteNode);
     sqlite3_finalize(pRtree->pDeleteNode);
     sqlite3_finalize(pRtree->pReadRowid);
@@ -194987,8 +194987,8 @@ static void rtreeRelease(Rtree *pRtree){
     sqlite3_finalize(pRtree->pReadParent);
     sqlite3_finalize(pRtree->pWriteParent);
     sqlite3_finalize(pRtree->pDeleteParent);
-    sqlite3_finalize(pRtree->pWriteAux);
-    sqlite3_free(pRtree->zReadAuxSql);
+    sqlite3_finalize(pRtree->pWriteAux); 
+    sqlite3_free(pRtree->zReadAuxSql); 
     sqlite3_free(pRtree);
   }
 }
@@ -195037,7 +195037,7 @@ static int rtreeOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
   Rtree *pRtree = (Rtree *)pVTab;
   RtreeCursor *pCsr;
 
-  pCsr = (RtreeCursor *)sqlite3_malloc64(sizeof(RtreeCursor));
+  pCsr = (RtreeCursor *)sqlite3_malloc64(sizeof(RtreeCursor)); 
   if( pCsr ){
     memset(pCsr, 0, sizeof(RtreeCursor));
     pCsr->base.pVtab = pVTab;
@@ -195086,7 +195086,7 @@ static int rtreeClose(sqlite3_vtab_cursor *cur){
   RtreeCursor *pCsr = (RtreeCursor *)cur;
   assert( pRtree->nCursor>0 );
   resetCursor(pCsr);
-  sqlite3_finalize(pCsr->pReadAux);
+  sqlite3_finalize(pCsr->pReadAux); 
   sqlite3_free(pCsr);
   pRtree->nCursor--;
   nodeBlobReset(pRtree);
@@ -195332,7 +195332,7 @@ static int nodeRowidIndex(
       return SQLITE_OK;
     }
   }
-  RTREE_IS_CORRUPT(pRtree);
+  RTREE_IS_CORRUPT(pRtree); 
   return SQLITE_CORRUPT_VTAB;
 }
 
@@ -195427,7 +195427,7 @@ static RtreeSearchPoint *rtreeEnqueue(
   RtreeSearchPoint *pNew;
   if( pCur->nPoint>=pCur->nPointAlloc ){
     int nNew = pCur->nPointAlloc*2 + 8;
-    pNew = sqlite3_realloc64(pCur->aPoint, nNew*sizeof(pCur->aPoint[0]));
+    pNew = sqlite3_realloc64(pCur->aPoint, nNew*sizeof(pCur->aPoint[0])); 
     if( pNew==0 ) return 0;
     pCur->aPoint = pNew;
     pCur->nPointAlloc = nNew;
@@ -195474,7 +195474,7 @@ static RtreeSearchPoint *rtreeSearchPointNew(
       if( ALWAYS(ii<RTREE_CACHE_SZ) ){
         assert( pCur->aNode[ii]==0 );
         pCur->aNode[ii] = pCur->aNode[0];
-      }else{
+      }else{ 
         nodeRelease(RTREE_OF_CURSOR(pCur), pCur->aNode[0]);
       }
       pCur->aNode[0] = 0;
@@ -195656,10 +195656,10 @@ static int rtreeNext(sqlite3_vtab_cursor *pVtabCursor){
 
   /* Move to the next entry that matches the configured constraints. */
   RTREE_QUEUE_TRACE(pCsr, "POP-Nx:");
-  if( pCsr->bAuxValid ){
-    pCsr->bAuxValid = 0;
-    sqlite3_reset(pCsr->pReadAux);
-  }
+  if( pCsr->bAuxValid ){ 
+    pCsr->bAuxValid = 0; 
+    sqlite3_reset(pCsr->pReadAux); 
+  } 
   rtreeSearchPointPop(pCsr);
   rc = rtreeStepToLeaf(pCsr);
   return rc;
@@ -195694,7 +195694,7 @@ static int rtreeColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
   if( NEVER(p==0) ) return SQLITE_OK;
   if( i==0 ){
     sqlite3_result_int64(ctx, nodeGetRowid(pRtree, pNode, p->iCell));
-  }else if( i<=pRtree->nDim2 ){
+  }else if( i<=pRtree->nDim2 ){ 
     nodeGetCoord(pRtree, pNode, p->iCell, i-1, &c);
 #ifndef SQLITE_RTREE_INT_ONLY
     if( pRtree->eCoordType==RTREE_COORD_REAL32 ){
@@ -195705,26 +195705,26 @@ static int rtreeColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
       assert( pRtree->eCoordType==RTREE_COORD_INT32 );
       sqlite3_result_int(ctx, c.i);
     }
-  }else{
-    if( !pCsr->bAuxValid ){
-      if( pCsr->pReadAux==0 ){
-        rc = sqlite3_prepare_v3(pRtree->db, pRtree->zReadAuxSql, -1, 0,
-                                &pCsr->pReadAux, 0);
-        if( rc ) return rc;
-      }
+  }else{ 
+    if( !pCsr->bAuxValid ){ 
+      if( pCsr->pReadAux==0 ){ 
+        rc = sqlite3_prepare_v3(pRtree->db, pRtree->zReadAuxSql, -1, 0, 
+                                &pCsr->pReadAux, 0); 
+        if( rc ) return rc; 
+      } 
       sqlite3_bind_int64(pCsr->pReadAux, 1,
-          nodeGetRowid(pRtree, pNode, p->iCell));
-      rc = sqlite3_step(pCsr->pReadAux);
-      if( rc==SQLITE_ROW ){
-        pCsr->bAuxValid = 1;
-      }else{
-        sqlite3_reset(pCsr->pReadAux);
-        if( rc==SQLITE_DONE ) rc = SQLITE_OK;
-        return rc;
-      }
-    }
-    sqlite3_result_value(ctx,
-         sqlite3_column_value(pCsr->pReadAux, i - pRtree->nDim2 + 1));
+          nodeGetRowid(pRtree, pNode, p->iCell)); 
+      rc = sqlite3_step(pCsr->pReadAux); 
+      if( rc==SQLITE_ROW ){ 
+        pCsr->bAuxValid = 1; 
+      }else{ 
+        sqlite3_reset(pCsr->pReadAux); 
+        if( rc==SQLITE_DONE ) rc = SQLITE_OK; 
+        return rc; 
+      } 
+    } 
+    sqlite3_result_value(ctx, 
+         sqlite3_column_value(pCsr->pReadAux, i - pRtree->nDim2 + 1)); 
   }
   return SQLITE_OK;
 }
@@ -195843,7 +195843,7 @@ static int rtreeFilter(
     */
     rc = nodeAcquire(pRtree, 1, 0, &pRoot);
     if( rc==SQLITE_OK && argc>0 ){
-      pCsr->aConstraint = sqlite3_malloc64(sizeof(RtreeConstraint)*argc);
+      pCsr->aConstraint = sqlite3_malloc64(sizeof(RtreeConstraint)*argc); 
       pCsr->nConstraint = argc;
       if( !pCsr->aConstraint ){
         rc = SQLITE_NOMEM;
@@ -195991,30 +195991,30 @@ static int rtreeBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
       */
       pIdxInfo->estimatedCost = 30.0;
       pIdxInfo->estimatedRows = 1;
-      pIdxInfo->idxFlags = SQLITE_INDEX_SCAN_UNIQUE;
+      pIdxInfo->idxFlags = SQLITE_INDEX_SCAN_UNIQUE; 
       return SQLITE_OK;
     }
 
-    if( p->usable
-    && ((p->iColumn>0 && p->iColumn<=pRtree->nDim2)
-        || p->op==SQLITE_INDEX_CONSTRAINT_MATCH)
-    ){
+    if( p->usable 
+    && ((p->iColumn>0 && p->iColumn<=pRtree->nDim2) 
+        || p->op==SQLITE_INDEX_CONSTRAINT_MATCH) 
+    ){ 
       u8 op;
       switch( p->op ){
-        case SQLITE_INDEX_CONSTRAINT_EQ:    op = RTREE_EQ;    break;
-        case SQLITE_INDEX_CONSTRAINT_GT:    op = RTREE_GT;    break;
-        case SQLITE_INDEX_CONSTRAINT_LE:    op = RTREE_LE;    break;
-        case SQLITE_INDEX_CONSTRAINT_LT:    op = RTREE_LT;    break;
-        case SQLITE_INDEX_CONSTRAINT_GE:    op = RTREE_GE;    break;
-        case SQLITE_INDEX_CONSTRAINT_MATCH: op = RTREE_MATCH; break;
-        default:                            op = 0;           break;
-      }
-      if( op ){
-        zIdxStr[iIdx++] = op;
-        zIdxStr[iIdx++] = (char)(p->iColumn - 1 + '0');
-        pIdxInfo->aConstraintUsage[ii].argvIndex = (iIdx/2);
-        pIdxInfo->aConstraintUsage[ii].omit = 1;
+        case SQLITE_INDEX_CONSTRAINT_EQ:    op = RTREE_EQ;    break; 
+        case SQLITE_INDEX_CONSTRAINT_GT:    op = RTREE_GT;    break; 
+        case SQLITE_INDEX_CONSTRAINT_LE:    op = RTREE_LE;    break; 
+        case SQLITE_INDEX_CONSTRAINT_LT:    op = RTREE_LT;    break; 
+        case SQLITE_INDEX_CONSTRAINT_GE:    op = RTREE_GE;    break; 
+        case SQLITE_INDEX_CONSTRAINT_MATCH: op = RTREE_MATCH; break; 
+        default:                            op = 0;           break; 
       }
+      if( op ){ 
+        zIdxStr[iIdx++] = op; 
+        zIdxStr[iIdx++] = (char)(p->iColumn - 1 + '0'); 
+        pIdxInfo->aConstraintUsage[ii].argvIndex = (iIdx/2); 
+        pIdxInfo->aConstraintUsage[ii].omit = 1; 
+      } 
     }
   }
 
@@ -196050,11 +196050,11 @@ static RtreeDValue cellArea(Rtree *pRtree, RtreeCell *p){
 #endif
   {
     switch( pRtree->nDim ){
-      case 5:  area  = (i64)p->aCoord[9].i - (i64)p->aCoord[8].i;
-      case 4:  area *= (i64)p->aCoord[7].i - (i64)p->aCoord[6].i;
-      case 3:  area *= (i64)p->aCoord[5].i - (i64)p->aCoord[4].i;
-      case 2:  area *= (i64)p->aCoord[3].i - (i64)p->aCoord[2].i;
-      default: area *= (i64)p->aCoord[1].i - (i64)p->aCoord[0].i;
+      case 5:  area  = (i64)p->aCoord[9].i - (i64)p->aCoord[8].i; 
+      case 4:  area *= (i64)p->aCoord[7].i - (i64)p->aCoord[6].i; 
+      case 3:  area *= (i64)p->aCoord[5].i - (i64)p->aCoord[4].i; 
+      case 2:  area *= (i64)p->aCoord[3].i - (i64)p->aCoord[2].i; 
+      default: area *= (i64)p->aCoord[1].i - (i64)p->aCoord[0].i; 
     }
   }
   return area;
@@ -196223,7 +196223,7 @@ static int AdjustTree(
   RtreeCell *pCell                  /* This cell was just inserted */
 ){
   RtreeNode *p = pNode;
-  int cnt = 0;
+  int cnt = 0; 
   int rc;
   while( p->pParent ){
     RtreeNode *pParent = p->pParent;
@@ -196232,7 +196232,7 @@ static int AdjustTree(
 
     cnt++;
     if( NEVER(cnt>100) ){
-      RTREE_IS_CORRUPT(pRtree);
+      RTREE_IS_CORRUPT(pRtree); 
       return SQLITE_CORRUPT_VTAB;
     }
     rc = nodeParentIndex(pRtree, p, &iCell);
@@ -196434,9 +196434,9 @@ static int splitNodeStartree(
   int iBestSplit = 0;
   RtreeDValue fBestMargin = RTREE_ZERO;
 
-  sqlite3_int64 nByte = (pRtree->nDim+1)*(sizeof(int*)+nCell*sizeof(int));
+  sqlite3_int64 nByte = (pRtree->nDim+1)*(sizeof(int*)+nCell*sizeof(int)); 
 
-  aaSorted = (int **)sqlite3_malloc64(nByte);
+  aaSorted = (int **)sqlite3_malloc64(nByte); 
   if( !aaSorted ){
     return SQLITE_NOMEM;
   }
@@ -196562,7 +196562,7 @@ static int SplitNode(
   /* Allocate an array and populate it with a copy of pCell and
   ** all cells from node pLeft. Then zero the original node.
   */
-  aCell = sqlite3_malloc64((sizeof(RtreeCell)+sizeof(int))*(nCell+1));
+  aCell = sqlite3_malloc64((sizeof(RtreeCell)+sizeof(int))*(nCell+1)); 
   if( !aCell ){
     rc = SQLITE_NOMEM;
     goto splitnode_out;
@@ -196585,7 +196585,7 @@ static int SplitNode(
   }else{
     pLeft = pNode;
     pRight = nodeNew(pRtree, pLeft->pParent);
-    pLeft->nRef++;
+    pLeft->nRef++; 
   }
 
   if( !pLeft || !pRight ){
@@ -196711,10 +196711,10 @@ static int fixLeafParent(Rtree *pRtree, RtreeNode *pLeaf){
     }
     rc = sqlite3_reset(pRtree->pReadParent);
     if( rc==SQLITE_OK ) rc = rc2;
-    if( rc==SQLITE_OK && !pChild->pParent ){
-      RTREE_IS_CORRUPT(pRtree);
-      rc = SQLITE_CORRUPT_VTAB;
-    }
+    if( rc==SQLITE_OK && !pChild->pParent ){ 
+      RTREE_IS_CORRUPT(pRtree); 
+      rc = SQLITE_CORRUPT_VTAB; 
+    } 
     pChild = pChild->pParent;
   }
   return rc;
@@ -196855,7 +196855,7 @@ static int Reinsert(
   /* Allocate the buffers used by this operation. The allocation is
   ** relinquished before this function returns.
   */
-  aCell = (RtreeCell *)sqlite3_malloc64(n * (
+  aCell = (RtreeCell *)sqlite3_malloc64(n * ( 
     sizeof(RtreeCell)     +         /* aCell array */
     sizeof(int)           +         /* aOrder array */
     sizeof(int)           +         /* aSpare array */
@@ -196999,7 +196999,7 @@ static int reinsertNodeContent(Rtree *pRtree, RtreeNode *pNode){
 /*
 ** Select a currently unused rowid for a new r-tree record.
 */
-static int rtreeNewRowid(Rtree *pRtree, i64 *piRowid){
+static int rtreeNewRowid(Rtree *pRtree, i64 *piRowid){ 
   int rc;
   sqlite3_bind_null(pRtree->pWriteRowid, 1);
   sqlite3_bind_null(pRtree->pWriteRowid, 2);
@@ -197029,12 +197029,12 @@ static int rtreeDeleteRowid(Rtree *pRtree, sqlite3_int64 iDelete){
     rc = findLeafNode(pRtree, iDelete, &pLeaf, 0);
   }
 
-#ifdef CORRUPT_DB
-  assert( pLeaf!=0 || rc!=SQLITE_OK || CORRUPT_DB );
-#endif
-
+#ifdef CORRUPT_DB 
+  assert( pLeaf!=0 || rc!=SQLITE_OK || CORRUPT_DB ); 
+#endif 
+ 
   /* Delete the cell in question from the leaf node. */
-  if( rc==SQLITE_OK && pLeaf ){
+  if( rc==SQLITE_OK && pLeaf ){ 
     int rc2;
     rc = nodeRowidIndex(pRtree, pLeaf, iDelete, &iCell);
     if( rc==SQLITE_OK ){
@@ -197084,7 +197084,7 @@ static int rtreeDeleteRowid(Rtree *pRtree, sqlite3_int64 iDelete){
       rc = reinsertNodeContent(pRtree, pLeaf);
     }
     pRtree->pDeleted = pLeaf->pNext;
-    pRtree->nNodeRef--;
+    pRtree->nNodeRef--; 
     sqlite3_free(pLeaf);
   }
 
@@ -197189,12 +197189,12 @@ static int rtreeUpdate(
   RtreeCell cell;                 /* New cell to insert if nData>1 */
   int bHaveRowid = 0;             /* Set to 1 after new rowid is determined */
 
-  if( pRtree->nNodeRef ){
-    /* Unable to write to the btree while another cursor is reading from it,
-    ** since the write might do a rebalance which would disrupt the read
-    ** cursor. */
-    return SQLITE_LOCKED_VTAB;
-  }
+  if( pRtree->nNodeRef ){ 
+    /* Unable to write to the btree while another cursor is reading from it, 
+    ** since the write might do a rebalance which would disrupt the read 
+    ** cursor. */ 
+    return SQLITE_LOCKED_VTAB; 
+  } 
   rtreeReference(pRtree);
   assert(nData>=1);
 
@@ -197213,10 +197213,10 @@ static int rtreeUpdate(
   */
   if( nData>1 ){
     int ii;
-    int nn = nData - 4;
+    int nn = nData - 4; 
 
-    if( nn > pRtree->nDim2 ) nn = pRtree->nDim2;
-    /* Populate the cell.aCoord[] array. The first coordinate is aData[3].
+    if( nn > pRtree->nDim2 ) nn = pRtree->nDim2; 
+    /* Populate the cell.aCoord[] array. The first coordinate is aData[3]. 
     **
     ** NB: nData can only be less than nDim*2+3 if the rtree is mis-declared
     ** with "column" that are interpreted as table constraints.
@@ -197227,9 +197227,9 @@ static int rtreeUpdate(
 
 #ifndef SQLITE_RTREE_INT_ONLY
     if( pRtree->eCoordType==RTREE_COORD_REAL32 ){
-      for(ii=0; ii<nn; ii+=2){
-        cell.aCoord[ii].f = rtreeValueDown(aData[ii+3]);
-        cell.aCoord[ii+1].f = rtreeValueUp(aData[ii+4]);
+      for(ii=0; ii<nn; ii+=2){ 
+        cell.aCoord[ii].f = rtreeValueDown(aData[ii+3]); 
+        cell.aCoord[ii+1].f = rtreeValueUp(aData[ii+4]); 
         if( cell.aCoord[ii].f>cell.aCoord[ii+1].f ){
           rc = rtreeConstraintError(pRtree, ii+1);
           goto constraint;
@@ -197238,9 +197238,9 @@ static int rtreeUpdate(
     }else
 #endif
     {
-      for(ii=0; ii<nn; ii+=2){
-        cell.aCoord[ii].i = sqlite3_value_int(aData[ii+3]);
-        cell.aCoord[ii+1].i = sqlite3_value_int(aData[ii+4]);
+      for(ii=0; ii<nn; ii+=2){ 
+        cell.aCoord[ii].i = sqlite3_value_int(aData[ii+3]); 
+        cell.aCoord[ii+1].i = sqlite3_value_int(aData[ii+4]); 
         if( cell.aCoord[ii].i>cell.aCoord[ii+1].i ){
           rc = rtreeConstraintError(pRtree, ii+1);
           goto constraint;
@@ -197250,10 +197250,10 @@ static int rtreeUpdate(
 
     /* If a rowid value was supplied, check if it is already present in
     ** the table. If so, the constraint has failed. */
-    if( sqlite3_value_type(aData[2])!=SQLITE_NULL ){
-      cell.iRowid = sqlite3_value_int64(aData[2]);
-      if( sqlite3_value_type(aData[0])==SQLITE_NULL
-       || sqlite3_value_int64(aData[0])!=cell.iRowid
+    if( sqlite3_value_type(aData[2])!=SQLITE_NULL ){ 
+      cell.iRowid = sqlite3_value_int64(aData[2]); 
+      if( sqlite3_value_type(aData[0])==SQLITE_NULL 
+       || sqlite3_value_int64(aData[0])!=cell.iRowid 
       ){
         int steprc;
         sqlite3_bind_int64(pRtree->pReadRowid, 1, cell.iRowid);
@@ -197272,16 +197272,16 @@ static int rtreeUpdate(
     }
   }
 
-  /* If aData[0] is not an SQL NULL value, it is the rowid of a
+  /* If aData[0] is not an SQL NULL value, it is the rowid of a 
   ** record to delete from the r-tree table. The following block does
   ** just that.
   */
-  if( sqlite3_value_type(aData[0])!=SQLITE_NULL ){
-    rc = rtreeDeleteRowid(pRtree, sqlite3_value_int64(aData[0]));
+  if( sqlite3_value_type(aData[0])!=SQLITE_NULL ){ 
+    rc = rtreeDeleteRowid(pRtree, sqlite3_value_int64(aData[0])); 
   }
 
-  /* If the aData[] array contains more than one element, elements
-  ** (aData[2]..aData[argc-1]) contain a new record to insert into
+  /* If the aData[] array contains more than one element, elements 
+  ** (aData[2]..aData[argc-1]) contain a new record to insert into 
   ** the r-tree structure.
   */
   if( rc==SQLITE_OK && nData>1 ){
@@ -197290,7 +197290,7 @@ static int rtreeUpdate(
 
     /* Figure out the rowid of the new row. */
     if( bHaveRowid==0 ){
-      rc = rtreeNewRowid(pRtree, &cell.iRowid);
+      rc = rtreeNewRowid(pRtree, &cell.iRowid); 
     }
     *pRowid = cell.iRowid;
 
@@ -197306,16 +197306,16 @@ static int rtreeUpdate(
         rc = rc2;
       }
     }
-    if( rc==SQLITE_OK && pRtree->nAux ){
-      sqlite3_stmt *pUp = pRtree->pWriteAux;
-      int jj;
-      sqlite3_bind_int64(pUp, 1, *pRowid);
-      for(jj=0; jj<pRtree->nAux; jj++){
-        sqlite3_bind_value(pUp, jj+2, aData[pRtree->nDim2+3+jj]);
-      }
-      sqlite3_step(pUp);
-      rc = sqlite3_reset(pUp);
-    }
+    if( rc==SQLITE_OK && pRtree->nAux ){ 
+      sqlite3_stmt *pUp = pRtree->pWriteAux; 
+      int jj; 
+      sqlite3_bind_int64(pUp, 1, *pRowid); 
+      for(jj=0; jj<pRtree->nAux; jj++){ 
+        sqlite3_bind_value(pUp, jj+2, aData[pRtree->nDim2+3+jj]); 
+      } 
+      sqlite3_step(pUp); 
+      rc = sqlite3_reset(pUp); 
+    } 
   }
 
 constraint:
@@ -197382,7 +197382,7 @@ static int rtreeRename(sqlite3_vtab *pVtab, const char *zNewName){
 */
 static int rtreeSavepoint(sqlite3_vtab *pVtab, int iSavepoint){
   Rtree *pRtree = (Rtree *)pVtab;
-  u8 iwt = pRtree->inWrTrans;
+  u8 iwt = pRtree->inWrTrans; 
   UNUSED_PARAMETER(iSavepoint);
   pRtree->inWrTrans = 0;
   nodeBlobReset(pRtree);
@@ -197424,24 +197424,24 @@ static int rtreeQueryStat1(sqlite3 *db, Rtree *pRtree){
   return rc;
 }
 
-
-/*
-** Return true if zName is the extension on one of the shadow tables used
-** by this module.
-*/
-static int rtreeShadowName(const char *zName){
-  static const char *azName[] = {
-    "node", "parent", "rowid"
-  };
-  unsigned int i;
-  for(i=0; i<sizeof(azName)/sizeof(azName[0]); i++){
-    if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
-  }
-  return 0;
-}
-
+ 
+/* 
+** Return true if zName is the extension on one of the shadow tables used 
+** by this module. 
+*/ 
+static int rtreeShadowName(const char *zName){ 
+  static const char *azName[] = { 
+    "node", "parent", "rowid" 
+  }; 
+  unsigned int i; 
+  for(i=0; i<sizeof(azName)/sizeof(azName[0]); i++){ 
+    if( sqlite3_stricmp(zName, azName[i])==0 ) return 1; 
+  } 
+  return 0; 
+} 
+ 
 static sqlite3_module rtreeModule = {
-  3,                          /* iVersion */
+  3,                          /* iVersion */ 
   rtreeCreate,                /* xCreate - create a table */
   rtreeConnect,               /* xConnect - connect to an existing table */
   rtreeBestIndex,             /* xBestIndex - Determine search strategy */
@@ -197464,7 +197464,7 @@ static sqlite3_module rtreeModule = {
   rtreeSavepoint,             /* xSavepoint */
   0,                          /* xRelease */
   0,                          /* xRollbackTo */
-  rtreeShadowName             /* xShadowName */
+  rtreeShadowName             /* xShadowName */ 
 };
 
 static int rtreeSqlInit(
@@ -197479,45 +197479,45 @@ static int rtreeSqlInit(
   #define N_STATEMENT 8
   static const char *azSql[N_STATEMENT] = {
     /* Write the xxx_node table */
-    "INSERT OR REPLACE INTO '%q'.'%q_node' VALUES(?1, ?2)",
-    "DELETE FROM '%q'.'%q_node' WHERE nodeno = ?1",
+    "INSERT OR REPLACE INTO '%q'.'%q_node' VALUES(?1, ?2)", 
+    "DELETE FROM '%q'.'%q_node' WHERE nodeno = ?1", 
 
     /* Read and write the xxx_rowid table */
-    "SELECT nodeno FROM '%q'.'%q_rowid' WHERE rowid = ?1",
-    "INSERT OR REPLACE INTO '%q'.'%q_rowid' VALUES(?1, ?2)",
-    "DELETE FROM '%q'.'%q_rowid' WHERE rowid = ?1",
+    "SELECT nodeno FROM '%q'.'%q_rowid' WHERE rowid = ?1", 
+    "INSERT OR REPLACE INTO '%q'.'%q_rowid' VALUES(?1, ?2)", 
+    "DELETE FROM '%q'.'%q_rowid' WHERE rowid = ?1", 
 
     /* Read and write the xxx_parent table */
-    "SELECT parentnode FROM '%q'.'%q_parent' WHERE nodeno = ?1",
-    "INSERT OR REPLACE INTO '%q'.'%q_parent' VALUES(?1, ?2)",
-    "DELETE FROM '%q'.'%q_parent' WHERE nodeno = ?1"
+    "SELECT parentnode FROM '%q'.'%q_parent' WHERE nodeno = ?1", 
+    "INSERT OR REPLACE INTO '%q'.'%q_parent' VALUES(?1, ?2)", 
+    "DELETE FROM '%q'.'%q_parent' WHERE nodeno = ?1" 
   };
   sqlite3_stmt **appStmt[N_STATEMENT];
   int i;
-  const int f = SQLITE_PREPARE_PERSISTENT|SQLITE_PREPARE_NO_VTAB;
+  const int f = SQLITE_PREPARE_PERSISTENT|SQLITE_PREPARE_NO_VTAB; 
 
   pRtree->db = db;
 
   if( isCreate ){
-    char *zCreate;
-    sqlite3_str *p = sqlite3_str_new(db);
-    int ii;
-    sqlite3_str_appendf(p,
-       "CREATE TABLE \"%w\".\"%w_rowid\"(rowid INTEGER PRIMARY KEY,nodeno",
-       zDb, zPrefix);
-    for(ii=0; ii<pRtree->nAux; ii++){
-      sqlite3_str_appendf(p,",a%d",ii);
-    }
-    sqlite3_str_appendf(p,
-      ");CREATE TABLE \"%w\".\"%w_node\"(nodeno INTEGER PRIMARY KEY,data);",
-      zDb, zPrefix);
-    sqlite3_str_appendf(p,
-    "CREATE TABLE \"%w\".\"%w_parent\"(nodeno INTEGER PRIMARY KEY,parentnode);",
-      zDb, zPrefix);
-    sqlite3_str_appendf(p,
-       "INSERT INTO \"%w\".\"%w_node\"VALUES(1,zeroblob(%d))",
-       zDb, zPrefix, pRtree->iNodeSize);
-    zCreate = sqlite3_str_finish(p);
+    char *zCreate; 
+    sqlite3_str *p = sqlite3_str_new(db); 
+    int ii; 
+    sqlite3_str_appendf(p, 
+       "CREATE TABLE \"%w\".\"%w_rowid\"(rowid INTEGER PRIMARY KEY,nodeno", 
+       zDb, zPrefix); 
+    for(ii=0; ii<pRtree->nAux; ii++){ 
+      sqlite3_str_appendf(p,",a%d",ii); 
+    } 
+    sqlite3_str_appendf(p, 
+      ");CREATE TABLE \"%w\".\"%w_node\"(nodeno INTEGER PRIMARY KEY,data);", 
+      zDb, zPrefix); 
+    sqlite3_str_appendf(p, 
+    "CREATE TABLE \"%w\".\"%w_parent\"(nodeno INTEGER PRIMARY KEY,parentnode);", 
+      zDb, zPrefix); 
+    sqlite3_str_appendf(p, 
+       "INSERT INTO \"%w\".\"%w_node\"VALUES(1,zeroblob(%d))", 
+       zDb, zPrefix, pRtree->iNodeSize); 
+    zCreate = sqlite3_str_finish(p); 
     if( !zCreate ){
       return SQLITE_NOMEM;
     }
@@ -197539,17 +197539,17 @@ static int rtreeSqlInit(
 
   rc = rtreeQueryStat1(db, pRtree);
   for(i=0; i<N_STATEMENT && rc==SQLITE_OK; i++){
-    char *zSql;
-    const char *zFormat;
-    if( i!=3 || pRtree->nAux==0 ){
-       zFormat = azSql[i];
-    }else {
-       /* An UPSERT is very slightly slower than REPLACE, but it is needed
-       ** if there are auxiliary columns */
-       zFormat = "INSERT INTO\"%w\".\"%w_rowid\"(rowid,nodeno)VALUES(?1,?2)"
-                  "ON CONFLICT(rowid)DO UPDATE SET nodeno=excluded.nodeno";
-    }
-    zSql = sqlite3_mprintf(zFormat, zDb, zPrefix);
+    char *zSql; 
+    const char *zFormat; 
+    if( i!=3 || pRtree->nAux==0 ){ 
+       zFormat = azSql[i]; 
+    }else { 
+       /* An UPSERT is very slightly slower than REPLACE, but it is needed 
+       ** if there are auxiliary columns */ 
+       zFormat = "INSERT INTO\"%w\".\"%w_rowid\"(rowid,nodeno)VALUES(?1,?2)" 
+                  "ON CONFLICT(rowid)DO UPDATE SET nodeno=excluded.nodeno"; 
+    } 
+    zSql = sqlite3_mprintf(zFormat, zDb, zPrefix); 
     if( zSql ){
       rc = sqlite3_prepare_v3(db, zSql, -1, f, appStmt[i], 0);
     }else{
@@ -197557,38 +197557,38 @@ static int rtreeSqlInit(
     }
     sqlite3_free(zSql);
   }
-  if( pRtree->nAux ){
-    pRtree->zReadAuxSql = sqlite3_mprintf(
-       "SELECT * FROM \"%w\".\"%w_rowid\" WHERE rowid=?1",
-       zDb, zPrefix);
-    if( pRtree->zReadAuxSql==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      sqlite3_str *p = sqlite3_str_new(db);
-      int ii;
-      char *zSql;
-      sqlite3_str_appendf(p, "UPDATE \"%w\".\"%w_rowid\"SET ", zDb, zPrefix);
-      for(ii=0; ii<pRtree->nAux; ii++){
-        if( ii ) sqlite3_str_append(p, ",", 1);
+  if( pRtree->nAux ){ 
+    pRtree->zReadAuxSql = sqlite3_mprintf( 
+       "SELECT * FROM \"%w\".\"%w_rowid\" WHERE rowid=?1", 
+       zDb, zPrefix); 
+    if( pRtree->zReadAuxSql==0 ){ 
+      rc = SQLITE_NOMEM; 
+    }else{ 
+      sqlite3_str *p = sqlite3_str_new(db); 
+      int ii; 
+      char *zSql; 
+      sqlite3_str_appendf(p, "UPDATE \"%w\".\"%w_rowid\"SET ", zDb, zPrefix); 
+      for(ii=0; ii<pRtree->nAux; ii++){ 
+        if( ii ) sqlite3_str_append(p, ",", 1); 
 #ifdef SQLITE_ENABLE_GEOPOLY
-        if( ii<pRtree->nAuxNotNull ){
-          sqlite3_str_appendf(p,"a%d=coalesce(?%d,a%d)",ii,ii+2,ii);
+        if( ii<pRtree->nAuxNotNull ){ 
+          sqlite3_str_appendf(p,"a%d=coalesce(?%d,a%d)",ii,ii+2,ii); 
         }else
 #endif
         {
-          sqlite3_str_appendf(p,"a%d=?%d",ii,ii+2);
-        }
-      }
-      sqlite3_str_appendf(p, " WHERE rowid=?1");
-      zSql = sqlite3_str_finish(p);
-      if( zSql==0 ){
-        rc = SQLITE_NOMEM;
-      }else{
+          sqlite3_str_appendf(p,"a%d=?%d",ii,ii+2); 
+        } 
+      } 
+      sqlite3_str_appendf(p, " WHERE rowid=?1"); 
+      zSql = sqlite3_str_finish(p); 
+      if( zSql==0 ){ 
+        rc = SQLITE_NOMEM; 
+      }else{ 
         rc = sqlite3_prepare_v3(db, zSql, -1, f, &pRtree->pWriteAux, 0);
-        sqlite3_free(zSql);
-      }
-    }
-  }
+        sqlite3_free(zSql); 
+      } 
+    } 
+  } 
 
   return rc;
 }
@@ -197660,7 +197660,7 @@ static int getNodeSize(
       *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
     }else if( pRtree->iNodeSize<(512-64) ){
       rc = SQLITE_CORRUPT_VTAB;
-      RTREE_IS_CORRUPT(pRtree);
+      RTREE_IS_CORRUPT(pRtree); 
       *pzErr = sqlite3_mprintf("undersize RTree blobs in \"%q_node\"",
                                pRtree->zName);
     }
@@ -197700,20 +197700,20 @@ static int rtreeInit(
   int nDb;              /* Length of string argv[1] */
   int nName;            /* Length of string argv[2] */
   int eCoordType = (pAux ? RTREE_COORD_INT32 : RTREE_COORD_REAL32);
-  sqlite3_str *pSql;
-  char *zSql;
-  int ii = 4;
-  int iErr;
+  sqlite3_str *pSql; 
+  char *zSql; 
+  int ii = 4; 
+  int iErr; 
 
   const char *aErrMsg[] = {
     0,                                                    /* 0 */
     "Wrong number of columns for an rtree table",         /* 1 */
     "Too few columns for an rtree table",                 /* 2 */
-    "Too many columns for an rtree table",                /* 3 */
-    "Auxiliary rtree columns must be last"                /* 4 */
+    "Too many columns for an rtree table",                /* 3 */ 
+    "Auxiliary rtree columns must be last"                /* 4 */ 
   };
 
-  assert( RTREE_MAX_AUX_COLUMN<256 ); /* Aux columns counted by a u8 */
+  assert( RTREE_MAX_AUX_COLUMN<256 ); /* Aux columns counted by a u8 */ 
   if( argc<6 || argc>RTREE_MAX_AUX_COLUMN+3 ){
     *pzErr = sqlite3_mprintf("%s", aErrMsg[2 + (argc>=6)]);
     return SQLITE_ERROR;
@@ -197724,7 +197724,7 @@ static int rtreeInit(
   /* Allocate the sqlite3_vtab structure */
   nDb = (int)strlen(argv[1]);
   nName = (int)strlen(argv[2]);
-  pRtree = (Rtree *)sqlite3_malloc64(sizeof(Rtree)+nDb+nName+2);
+  pRtree = (Rtree *)sqlite3_malloc64(sizeof(Rtree)+nDb+nName+2); 
   if( !pRtree ){
     return SQLITE_NOMEM;
   }
@@ -197742,68 +197742,68 @@ static int rtreeInit(
   ** that is successful, call sqlite3_declare_vtab() to configure
   ** the r-tree table schema.
   */
-  pSql = sqlite3_str_new(db);
+  pSql = sqlite3_str_new(db); 
   sqlite3_str_appendf(pSql, "CREATE TABLE x(%.*s INT",
                       rtreeTokenLength(argv[3]), argv[3]);
-  for(ii=4; ii<argc; ii++){
+  for(ii=4; ii<argc; ii++){ 
     const char *zArg = argv[ii];
     if( zArg[0]=='+' ){
-      pRtree->nAux++;
+      pRtree->nAux++; 
       sqlite3_str_appendf(pSql, ",%.*s", rtreeTokenLength(zArg+1), zArg+1);
-    }else if( pRtree->nAux>0 ){
-      break;
+    }else if( pRtree->nAux>0 ){ 
+      break; 
     }else{
       static const char *azFormat[] = {",%.*s REAL", ",%.*s INT"};
-      pRtree->nDim2++;
+      pRtree->nDim2++; 
       sqlite3_str_appendf(pSql, azFormat[eCoordType],
                           rtreeTokenLength(zArg), zArg);
     }
   }
-  sqlite3_str_appendf(pSql, ");");
-  zSql = sqlite3_str_finish(pSql);
-  if( !zSql ){
-    rc = SQLITE_NOMEM;
-  }else if( ii<argc ){
-    *pzErr = sqlite3_mprintf("%s", aErrMsg[4]);
-    rc = SQLITE_ERROR;
-  }else if( SQLITE_OK!=(rc = sqlite3_declare_vtab(db, zSql)) ){
-    *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
-  }
-  sqlite3_free(zSql);
-  if( rc ) goto rtreeInit_fail;
-  pRtree->nDim = pRtree->nDim2/2;
-  if( pRtree->nDim<1 ){
-    iErr = 2;
-  }else if( pRtree->nDim2>RTREE_MAX_DIMENSIONS*2 ){
-    iErr = 3;
-  }else if( pRtree->nDim2 % 2 ){
-    iErr = 1;
-  }else{
-    iErr = 0;
-  }
-  if( iErr ){
-    *pzErr = sqlite3_mprintf("%s", aErrMsg[iErr]);
-    goto rtreeInit_fail;
-  }
-  pRtree->nBytesPerCell = 8 + pRtree->nDim2*4;
-
-  /* Figure out the node size to use. */
-  rc = getNodeSize(db, pRtree, isCreate, pzErr);
-  if( rc ) goto rtreeInit_fail;
-  rc = rtreeSqlInit(pRtree, db, argv[1], argv[2], isCreate);
-  if( rc ){
-    *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
-    goto rtreeInit_fail;
-  }
-
-  *ppVtab = (sqlite3_vtab *)pRtree;
-  return SQLITE_OK;
-
-rtreeInit_fail:
-  if( rc==SQLITE_OK ) rc = SQLITE_ERROR;
-  assert( *ppVtab==0 );
-  assert( pRtree->nBusy==1 );
-  rtreeRelease(pRtree);
+  sqlite3_str_appendf(pSql, ");"); 
+  zSql = sqlite3_str_finish(pSql); 
+  if( !zSql ){ 
+    rc = SQLITE_NOMEM; 
+  }else if( ii<argc ){ 
+    *pzErr = sqlite3_mprintf("%s", aErrMsg[4]); 
+    rc = SQLITE_ERROR; 
+  }else if( SQLITE_OK!=(rc = sqlite3_declare_vtab(db, zSql)) ){ 
+    *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); 
+  } 
+  sqlite3_free(zSql); 
+  if( rc ) goto rtreeInit_fail; 
+  pRtree->nDim = pRtree->nDim2/2; 
+  if( pRtree->nDim<1 ){ 
+    iErr = 2; 
+  }else if( pRtree->nDim2>RTREE_MAX_DIMENSIONS*2 ){ 
+    iErr = 3; 
+  }else if( pRtree->nDim2 % 2 ){ 
+    iErr = 1; 
+  }else{
+    iErr = 0; 
+  }
+  if( iErr ){ 
+    *pzErr = sqlite3_mprintf("%s", aErrMsg[iErr]); 
+    goto rtreeInit_fail; 
+  } 
+  pRtree->nBytesPerCell = 8 + pRtree->nDim2*4; 
+ 
+  /* Figure out the node size to use. */ 
+  rc = getNodeSize(db, pRtree, isCreate, pzErr); 
+  if( rc ) goto rtreeInit_fail; 
+  rc = rtreeSqlInit(pRtree, db, argv[1], argv[2], isCreate); 
+  if( rc ){ 
+    *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); 
+    goto rtreeInit_fail; 
+  } 
+ 
+  *ppVtab = (sqlite3_vtab *)pRtree; 
+  return SQLITE_OK; 
+ 
+rtreeInit_fail: 
+  if( rc==SQLITE_OK ) rc = SQLITE_ERROR; 
+  assert( *ppVtab==0 ); 
+  assert( pRtree->nBusy==1 ); 
+  rtreeRelease(pRtree); 
   return rc;
 }
 
@@ -197828,43 +197828,43 @@ static void rtreenode(sqlite3_context *ctx, int nArg, sqlite3_value **apArg){
   RtreeNode node;
   Rtree tree;
   int ii;
-  int nData;
-  int errCode;
-  sqlite3_str *pOut;
+  int nData; 
+  int errCode; 
+  sqlite3_str *pOut; 
 
   UNUSED_PARAMETER(nArg);
   memset(&node, 0, sizeof(RtreeNode));
   memset(&tree, 0, sizeof(Rtree));
   tree.nDim = (u8)sqlite3_value_int(apArg[0]);
-  if( tree.nDim<1 || tree.nDim>5 ) return;
+  if( tree.nDim<1 || tree.nDim>5 ) return; 
   tree.nDim2 = tree.nDim*2;
   tree.nBytesPerCell = 8 + 8 * tree.nDim;
   node.zData = (u8 *)sqlite3_value_blob(apArg[1]);
   if( node.zData==0 ) return;
-  nData = sqlite3_value_bytes(apArg[1]);
-  if( nData<4 ) return;
-  if( nData<NCELL(&node)*tree.nBytesPerCell ) return;
+  nData = sqlite3_value_bytes(apArg[1]); 
+  if( nData<4 ) return; 
+  if( nData<NCELL(&node)*tree.nBytesPerCell ) return; 
 
-  pOut = sqlite3_str_new(0);
+  pOut = sqlite3_str_new(0); 
   for(ii=0; ii<NCELL(&node); ii++){
     RtreeCell cell;
     int jj;
 
     nodeGetCell(&tree, &node, ii, &cell);
-    if( ii>0 ) sqlite3_str_append(pOut, " ", 1);
-    sqlite3_str_appendf(pOut, "{%lld", cell.iRowid);
+    if( ii>0 ) sqlite3_str_append(pOut, " ", 1); 
+    sqlite3_str_appendf(pOut, "{%lld", cell.iRowid); 
     for(jj=0; jj<tree.nDim2; jj++){
 #ifndef SQLITE_RTREE_INT_ONLY
-      sqlite3_str_appendf(pOut, " %g", (double)cell.aCoord[jj].f);
+      sqlite3_str_appendf(pOut, " %g", (double)cell.aCoord[jj].f); 
 #else
-      sqlite3_str_appendf(pOut, " %d", cell.aCoord[jj].i);
+      sqlite3_str_appendf(pOut, " %d", cell.aCoord[jj].i); 
 #endif
     }
-    sqlite3_str_append(pOut, "}", 1);
+    sqlite3_str_append(pOut, "}", 1); 
   }
-  errCode = sqlite3_str_errcode(pOut);
-  sqlite3_result_text(ctx, sqlite3_str_finish(pOut), -1, sqlite3_free);
-  sqlite3_result_error_code(ctx, errCode);
+  errCode = sqlite3_str_errcode(pOut); 
+  sqlite3_result_text(ctx, sqlite3_str_finish(pOut), -1, sqlite3_free); 
+  sqlite3_result_error_code(ctx, errCode); 
 }
 
 /* This routine implements an SQL function that returns the "depth" parameter
@@ -197998,7 +197998,7 @@ static void rtreeCheckAppendMsg(RtreeCheck *pCheck, const char *zFmt, ...){
 static u8 *rtreeCheckGetNode(RtreeCheck *pCheck, i64 iNode, int *pnNode){
   u8 *pRet = 0;                   /* Return value */
 
-  if( pCheck->rc==SQLITE_OK && pCheck->pGetNode==0 ){
+  if( pCheck->rc==SQLITE_OK && pCheck->pGetNode==0 ){ 
     pCheck->pGetNode = rtreeCheckPrepare(pCheck,
         "SELECT data FROM %Q.'%q_node' WHERE nodeno=?",
         pCheck->zDb, pCheck->zTab
@@ -198010,7 +198010,7 @@ static u8 *rtreeCheckGetNode(RtreeCheck *pCheck, i64 iNode, int *pnNode){
     if( sqlite3_step(pCheck->pGetNode)==SQLITE_ROW ){
       int nNode = sqlite3_column_bytes(pCheck->pGetNode, 0);
       const u8 *pNode = (const u8*)sqlite3_column_blob(pCheck->pGetNode, 0);
-      pRet = sqlite3_malloc64(nNode);
+      pRet = sqlite3_malloc64(nNode); 
       if( pRet==0 ){
         pCheck->rc = SQLITE_NOMEM;
       }else{
@@ -198033,7 +198033,7 @@ static u8 *rtreeCheckGetNode(RtreeCheck *pCheck, i64 iNode, int *pnNode){
 ** two tables are:
 **
 **   CREATE TABLE %_parent(nodeno INTEGER PRIMARY KEY, parentnode INTEGER)
-**   CREATE TABLE %_rowid(rowid INTEGER PRIMARY KEY, nodeno INTEGER, ...)
+**   CREATE TABLE %_rowid(rowid INTEGER PRIMARY KEY, nodeno INTEGER, ...) 
 **
 ** In both cases, this function checks that there exists an entry with
 ** IPK value iKey and the second column set to iVal.
@@ -198048,8 +198048,8 @@ static void rtreeCheckMapping(
   int rc;
   sqlite3_stmt *pStmt;
   const char *azSql[2] = {
-    "SELECT parentnode FROM %Q.'%q_parent' WHERE nodeno=?1",
-    "SELECT nodeno FROM %Q.'%q_rowid' WHERE rowid=?1"
+    "SELECT parentnode FROM %Q.'%q_parent' WHERE nodeno=?1", 
+    "SELECT nodeno FROM %Q.'%q_rowid' WHERE rowid=?1" 
   };
 
   assert( bLeaf==0 || bLeaf==1 );
@@ -198233,7 +198233,7 @@ static int rtreeCheckTable(
   RtreeCheck check;               /* Common context for various routines */
   sqlite3_stmt *pStmt = 0;        /* Used to find column count of rtree table */
   int bEnd = 0;                   /* True if transaction should be closed */
-  int nAux = 0;                   /* Number of extra columns. */
+  int nAux = 0;                   /* Number of extra columns. */ 
 
   /* Initialize the context object */
   memset(&check, 0, sizeof(check));
@@ -198249,23 +198249,23 @@ static int rtreeCheckTable(
     bEnd = 1;
   }
 
-  /* Find the number of auxiliary columns */
-  if( check.rc==SQLITE_OK ){
-    pStmt = rtreeCheckPrepare(&check, "SELECT * FROM %Q.'%q_rowid'", zDb, zTab);
-    if( pStmt ){
-      nAux = sqlite3_column_count(pStmt) - 2;
-      sqlite3_finalize(pStmt);
+  /* Find the number of auxiliary columns */ 
+  if( check.rc==SQLITE_OK ){ 
+    pStmt = rtreeCheckPrepare(&check, "SELECT * FROM %Q.'%q_rowid'", zDb, zTab); 
+    if( pStmt ){ 
+      nAux = sqlite3_column_count(pStmt) - 2; 
+      sqlite3_finalize(pStmt); 
     }else
     if( check.rc!=SQLITE_NOMEM ){
       check.rc = SQLITE_OK;
-    }
-  }
-
+    } 
+  } 
+ 
   /* Find number of dimensions in the rtree table. */
   pStmt = rtreeCheckPrepare(&check, "SELECT * FROM %Q.%Q", zDb, zTab);
   if( pStmt ){
     int rc;
-    check.nDim = (sqlite3_column_count(pStmt) - 1 - nAux) / 2;
+    check.nDim = (sqlite3_column_count(pStmt) - 1 - nAux) / 2; 
     if( check.nDim<1 ){
       rtreeCheckAppendMsg(&check, "Schema corrupt or not an rtree");
     }else if( SQLITE_ROW==sqlite3_step(pStmt) ){
@@ -198361,1833 +198361,1833 @@ static void rtreecheck(
   }
 }
 
-/* Conditionally include the geopoly code */
-#ifdef SQLITE_ENABLE_GEOPOLY
-/************** Include geopoly.c in the middle of rtree.c *******************/
-/************** Begin file geopoly.c *****************************************/
-/*
-** 2018-05-25
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-******************************************************************************
-**
-** This file implements an alternative R-Tree virtual table that
-** uses polygons to express the boundaries of 2-dimensional objects.
-**
-** This file is #include-ed onto the end of "rtree.c" so that it has
-** access to all of the R-Tree internals.
-*/
-/* #include <stdlib.h> */
-
-/* Enable -DGEOPOLY_ENABLE_DEBUG for debugging facilities */
-#ifdef GEOPOLY_ENABLE_DEBUG
-  static int geo_debug = 0;
-# define GEODEBUG(X) if(geo_debug)printf X
-#else
-# define GEODEBUG(X)
-#endif
-
-#ifndef JSON_NULL   /* The following stuff repeats things found in json1 */
-/*
-** Versions of isspace(), isalnum() and isdigit() to which it is safe
-** to pass signed char values.
-*/
-#ifdef sqlite3Isdigit
-   /* Use the SQLite core versions if this routine is part of the
-   ** SQLite amalgamation */
-#  define safe_isdigit(x)  sqlite3Isdigit(x)
-#  define safe_isalnum(x)  sqlite3Isalnum(x)
-#  define safe_isxdigit(x) sqlite3Isxdigit(x)
-#else
-   /* Use the standard library for separate compilation */
-#include <ctype.h>  /* amalgamator: keep */
-#  define safe_isdigit(x)  isdigit((unsigned char)(x))
-#  define safe_isalnum(x)  isalnum((unsigned char)(x))
-#  define safe_isxdigit(x) isxdigit((unsigned char)(x))
-#endif
-
-/*
-** Growing our own isspace() routine this way is twice as fast as
-** the library isspace() function.
-*/
-static const char geopolyIsSpace[] = {
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 1, 1, 0, 0, 1, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  1, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
-};
-#define safe_isspace(x) (geopolyIsSpace[(unsigned char)x])
-#endif /* JSON NULL - back to original code */
-
-/* Compiler and version */
-#ifndef GCC_VERSION
-#if defined(__GNUC__) && !defined(SQLITE_DISABLE_INTRINSIC)
-# define GCC_VERSION (__GNUC__*1000000+__GNUC_MINOR__*1000+__GNUC_PATCHLEVEL__)
-#else
-# define GCC_VERSION 0
-#endif
-#endif
-#ifndef MSVC_VERSION
-#if defined(_MSC_VER) && !defined(SQLITE_DISABLE_INTRINSIC)
-# define MSVC_VERSION _MSC_VER
-#else
-# define MSVC_VERSION 0
-#endif
-#endif
-
-/* Datatype for coordinates
-*/
-typedef float GeoCoord;
-
-/*
-** Internal representation of a polygon.
-**
-** The polygon consists of a sequence of vertexes.  There is a line
-** segment between each pair of vertexes, and one final segment from
-** the last vertex back to the first.  (This differs from the GeoJSON
-** standard in which the final vertex is a repeat of the first.)
-**
-** The polygon follows the right-hand rule.  The area to the right of
-** each segment is "outside" and the area to the left is "inside".
-**
-** The on-disk representation consists of a 4-byte header followed by
-** the values.  The 4-byte header is:
-**
-**      encoding    (1 byte)   0=big-endian, 1=little-endian
-**      nvertex     (3 bytes)  Number of vertexes as a big-endian integer
-**
-** Enough space is allocated for 4 coordinates, to work around over-zealous
-** warnings coming from some compiler (notably, clang). In reality, the size
-** of each GeoPoly memory allocate is adjusted as necessary so that the
-** GeoPoly.a[] array at the end is the appropriate size.
-*/
-typedef struct GeoPoly GeoPoly;
-struct GeoPoly {
-  int nVertex;          /* Number of vertexes */
-  unsigned char hdr[4]; /* Header for on-disk representation */
-  GeoCoord a[8];        /* 2*nVertex values. X (longitude) first, then Y */
-};
-
-/* The size of a memory allocation needed for a GeoPoly object sufficient
-** to hold N coordinate pairs.
-*/
-#define GEOPOLY_SZ(N)  (sizeof(GeoPoly) + sizeof(GeoCoord)*2*((N)-4))
-
-/* Macros to access coordinates of a GeoPoly.
-** We have to use these macros, rather than just say p->a[i] in order
-** to silence (incorrect) UBSAN warnings if the array index is too large.
-*/
-#define GeoX(P,I)  (((GeoCoord*)(P)->a)[(I)*2])
-#define GeoY(P,I)  (((GeoCoord*)(P)->a)[(I)*2+1])
-
-
-/*
-** State of a parse of a GeoJSON input.
-*/
-typedef struct GeoParse GeoParse;
-struct GeoParse {
-  const unsigned char *z;   /* Unparsed input */
-  int nVertex;              /* Number of vertexes in a[] */
-  int nAlloc;               /* Space allocated to a[] */
-  int nErr;                 /* Number of errors encountered */
-  GeoCoord *a;          /* Array of vertexes.  From sqlite3_malloc64() */
-};
-
-/* Do a 4-byte byte swap */
-static void geopolySwab32(unsigned char *a){
-  unsigned char t = a[0];
-  a[0] = a[3];
-  a[3] = t;
-  t = a[1];
-  a[1] = a[2];
-  a[2] = t;
-}
-
-/* Skip whitespace.  Return the next non-whitespace character. */
-static char geopolySkipSpace(GeoParse *p){
-  while( safe_isspace(p->z[0]) ) p->z++;
-  return p->z[0];
-}
-
-/* Parse out a number.  Write the value into *pVal if pVal!=0.
-** return non-zero on success and zero if the next token is not a number.
-*/
-static int geopolyParseNumber(GeoParse *p, GeoCoord *pVal){
-  char c = geopolySkipSpace(p);
-  const unsigned char *z = p->z;
-  int j = 0;
-  int seenDP = 0;
-  int seenE = 0;
-  if( c=='-' ){
-    j = 1;
-    c = z[j];
-  }
-  if( c=='0' && z[j+1]>='0' && z[j+1]<='9' ) return 0;
-  for(;; j++){
-    c = z[j];
-    if( safe_isdigit(c) ) continue;
-    if( c=='.' ){
-      if( z[j-1]=='-' ) return 0;
-      if( seenDP ) return 0;
-      seenDP = 1;
-      continue;
-    }
-    if( c=='e' || c=='E' ){
-      if( z[j-1]<'0' ) return 0;
-      if( seenE ) return -1;
-      seenDP = seenE = 1;
-      c = z[j+1];
-      if( c=='+' || c=='-' ){
-        j++;
-        c = z[j+1];
-      }
-      if( c<'0' || c>'9' ) return 0;
-      continue;
-    }
-    break;
-  }
-  if( z[j-1]<'0' ) return 0;
-  if( pVal ){
-#ifdef SQLITE_AMALGAMATION
-     /* The sqlite3AtoF() routine is much much faster than atof(), if it
-     ** is available */
-     double r;
-     (void)sqlite3AtoF((const char*)p->z, &r, j, SQLITE_UTF8);
-     *pVal = r;
-#else
-     *pVal = (GeoCoord)atof((const char*)p->z);
-#endif
-  }
-  p->z += j;
-  return 1;
-}
-
-/*
-** If the input is a well-formed JSON array of coordinates with at least
-** four coordinates and where each coordinate is itself a two-value array,
-** then convert the JSON into a GeoPoly object and return a pointer to
-** that object.
-**
-** If any error occurs, return NULL.
-*/
-static GeoPoly *geopolyParseJson(const unsigned char *z, int *pRc){
-  GeoParse s;
-  int rc = SQLITE_OK;
-  memset(&s, 0, sizeof(s));
-  s.z = z;
-  if( geopolySkipSpace(&s)=='[' ){
-    s.z++;
-    while( geopolySkipSpace(&s)=='[' ){
-      int ii = 0;
-      char c;
-      s.z++;
-      if( s.nVertex>=s.nAlloc ){
-        GeoCoord *aNew;
-        s.nAlloc = s.nAlloc*2 + 16;
-        aNew = sqlite3_realloc64(s.a, s.nAlloc*sizeof(GeoCoord)*2 );
-        if( aNew==0 ){
-          rc = SQLITE_NOMEM;
-          s.nErr++;
-          break;
-        }
-        s.a = aNew;
-      }
-      while( geopolyParseNumber(&s, ii<=1 ? &s.a[s.nVertex*2+ii] : 0) ){
-        ii++;
-        if( ii==2 ) s.nVertex++;
-        c = geopolySkipSpace(&s);
-        s.z++;
-        if( c==',' ) continue;
-        if( c==']' && ii>=2 ) break;
-        s.nErr++;
-        rc = SQLITE_ERROR;
-        goto parse_json_err;
-      }
-      if( geopolySkipSpace(&s)==',' ){
-        s.z++;
-        continue;
-      }
-      break;
-    }
-    if( geopolySkipSpace(&s)==']'
-     && s.nVertex>=4
-     && s.a[0]==s.a[s.nVertex*2-2]
-     && s.a[1]==s.a[s.nVertex*2-1]
-     && (s.z++, geopolySkipSpace(&s)==0)
-    ){
-      GeoPoly *pOut;
-      int x = 1;
-      s.nVertex--;  /* Remove the redundant vertex at the end */
-      pOut = sqlite3_malloc64( GEOPOLY_SZ((sqlite3_int64)s.nVertex) );
-      x = 1;
-      if( pOut==0 ) goto parse_json_err;
-      pOut->nVertex = s.nVertex;
-      memcpy(pOut->a, s.a, s.nVertex*2*sizeof(GeoCoord));
-      pOut->hdr[0] = *(unsigned char*)&x;
-      pOut->hdr[1] = (s.nVertex>>16)&0xff;
-      pOut->hdr[2] = (s.nVertex>>8)&0xff;
-      pOut->hdr[3] = s.nVertex&0xff;
-      sqlite3_free(s.a);
-      if( pRc ) *pRc = SQLITE_OK;
-      return pOut;
-    }else{
-      s.nErr++;
-      rc = SQLITE_ERROR;
-    }
-  }
-parse_json_err:
-  if( pRc ) *pRc = rc;
-  sqlite3_free(s.a);
-  return 0;
-}
-
-/*
-** Given a function parameter, try to interpret it as a polygon, either
-** in the binary format or JSON text.  Compute a GeoPoly object and
-** return a pointer to that object.  Or if the input is not a well-formed
-** polygon, put an error message in sqlite3_context and return NULL.
-*/
-static GeoPoly *geopolyFuncParam(
-  sqlite3_context *pCtx,      /* Context for error messages */
-  sqlite3_value *pVal,        /* The value to decode */
-  int *pRc                    /* Write error here */
-){
-  GeoPoly *p = 0;
-  int nByte;
+/* Conditionally include the geopoly code */ 
+#ifdef SQLITE_ENABLE_GEOPOLY 
+/************** Include geopoly.c in the middle of rtree.c *******************/ 
+/************** Begin file geopoly.c *****************************************/ 
+/* 
+** 2018-05-25 
+** 
+** The author disclaims copyright to this source code.  In place of 
+** a legal notice, here is a blessing: 
+** 
+**    May you do good and not evil. 
+**    May you find forgiveness for yourself and forgive others. 
+**    May you share freely, never taking more than you give. 
+** 
+****************************************************************************** 
+** 
+** This file implements an alternative R-Tree virtual table that 
+** uses polygons to express the boundaries of 2-dimensional objects. 
+** 
+** This file is #include-ed onto the end of "rtree.c" so that it has 
+** access to all of the R-Tree internals. 
+*/ 
+/* #include <stdlib.h> */ 
+
+/* Enable -DGEOPOLY_ENABLE_DEBUG for debugging facilities */ 
+#ifdef GEOPOLY_ENABLE_DEBUG 
+  static int geo_debug = 0; 
+# define GEODEBUG(X) if(geo_debug)printf X 
+#else 
+# define GEODEBUG(X) 
+#endif 
+ 
+#ifndef JSON_NULL   /* The following stuff repeats things found in json1 */ 
+/*
+** Versions of isspace(), isalnum() and isdigit() to which it is safe 
+** to pass signed char values. 
+*/ 
+#ifdef sqlite3Isdigit 
+   /* Use the SQLite core versions if this routine is part of the 
+   ** SQLite amalgamation */ 
+#  define safe_isdigit(x)  sqlite3Isdigit(x) 
+#  define safe_isalnum(x)  sqlite3Isalnum(x) 
+#  define safe_isxdigit(x) sqlite3Isxdigit(x) 
+#else 
+   /* Use the standard library for separate compilation */ 
+#include <ctype.h>  /* amalgamator: keep */ 
+#  define safe_isdigit(x)  isdigit((unsigned char)(x)) 
+#  define safe_isalnum(x)  isalnum((unsigned char)(x)) 
+#  define safe_isxdigit(x) isxdigit((unsigned char)(x)) 
+#endif 
+ 
+/* 
+** Growing our own isspace() routine this way is twice as fast as 
+** the library isspace() function. 
+*/ 
+static const char geopolyIsSpace[] = { 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 1, 1, 0, 0, 1, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  1, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0, 
+}; 
+#define safe_isspace(x) (geopolyIsSpace[(unsigned char)x]) 
+#endif /* JSON NULL - back to original code */ 
+ 
+/* Compiler and version */ 
+#ifndef GCC_VERSION 
+#if defined(__GNUC__) && !defined(SQLITE_DISABLE_INTRINSIC) 
+# define GCC_VERSION (__GNUC__*1000000+__GNUC_MINOR__*1000+__GNUC_PATCHLEVEL__) 
+#else 
+# define GCC_VERSION 0 
+#endif 
+#endif 
+#ifndef MSVC_VERSION 
+#if defined(_MSC_VER) && !defined(SQLITE_DISABLE_INTRINSIC) 
+# define MSVC_VERSION _MSC_VER 
+#else 
+# define MSVC_VERSION 0 
+#endif 
+#endif 
+ 
+/* Datatype for coordinates 
+*/ 
+typedef float GeoCoord; 
+ 
+/* 
+** Internal representation of a polygon. 
+** 
+** The polygon consists of a sequence of vertexes.  There is a line 
+** segment between each pair of vertexes, and one final segment from 
+** the last vertex back to the first.  (This differs from the GeoJSON 
+** standard in which the final vertex is a repeat of the first.) 
+** 
+** The polygon follows the right-hand rule.  The area to the right of 
+** each segment is "outside" and the area to the left is "inside". 
+** 
+** The on-disk representation consists of a 4-byte header followed by 
+** the values.  The 4-byte header is: 
+** 
+**      encoding    (1 byte)   0=big-endian, 1=little-endian 
+**      nvertex     (3 bytes)  Number of vertexes as a big-endian integer 
+** 
+** Enough space is allocated for 4 coordinates, to work around over-zealous 
+** warnings coming from some compiler (notably, clang). In reality, the size 
+** of each GeoPoly memory allocate is adjusted as necessary so that the 
+** GeoPoly.a[] array at the end is the appropriate size. 
+*/ 
+typedef struct GeoPoly GeoPoly; 
+struct GeoPoly { 
+  int nVertex;          /* Number of vertexes */ 
+  unsigned char hdr[4]; /* Header for on-disk representation */ 
+  GeoCoord a[8];        /* 2*nVertex values. X (longitude) first, then Y */ 
+}; 
+ 
+/* The size of a memory allocation needed for a GeoPoly object sufficient 
+** to hold N coordinate pairs. 
+*/ 
+#define GEOPOLY_SZ(N)  (sizeof(GeoPoly) + sizeof(GeoCoord)*2*((N)-4)) 
+ 
+/* Macros to access coordinates of a GeoPoly. 
+** We have to use these macros, rather than just say p->a[i] in order 
+** to silence (incorrect) UBSAN warnings if the array index is too large. 
+*/ 
+#define GeoX(P,I)  (((GeoCoord*)(P)->a)[(I)*2]) 
+#define GeoY(P,I)  (((GeoCoord*)(P)->a)[(I)*2+1]) 
+ 
+ 
+/* 
+** State of a parse of a GeoJSON input. 
+*/ 
+typedef struct GeoParse GeoParse; 
+struct GeoParse { 
+  const unsigned char *z;   /* Unparsed input */ 
+  int nVertex;              /* Number of vertexes in a[] */ 
+  int nAlloc;               /* Space allocated to a[] */ 
+  int nErr;                 /* Number of errors encountered */ 
+  GeoCoord *a;          /* Array of vertexes.  From sqlite3_malloc64() */ 
+}; 
+ 
+/* Do a 4-byte byte swap */ 
+static void geopolySwab32(unsigned char *a){ 
+  unsigned char t = a[0]; 
+  a[0] = a[3]; 
+  a[3] = t; 
+  t = a[1]; 
+  a[1] = a[2]; 
+  a[2] = t; 
+} 
+ 
+/* Skip whitespace.  Return the next non-whitespace character. */ 
+static char geopolySkipSpace(GeoParse *p){ 
+  while( safe_isspace(p->z[0]) ) p->z++; 
+  return p->z[0]; 
+} 
+ 
+/* Parse out a number.  Write the value into *pVal if pVal!=0. 
+** return non-zero on success and zero if the next token is not a number. 
+*/ 
+static int geopolyParseNumber(GeoParse *p, GeoCoord *pVal){ 
+  char c = geopolySkipSpace(p); 
+  const unsigned char *z = p->z; 
+  int j = 0; 
+  int seenDP = 0; 
+  int seenE = 0; 
+  if( c=='-' ){ 
+    j = 1; 
+    c = z[j]; 
+  } 
+  if( c=='0' && z[j+1]>='0' && z[j+1]<='9' ) return 0; 
+  for(;; j++){ 
+    c = z[j]; 
+    if( safe_isdigit(c) ) continue; 
+    if( c=='.' ){ 
+      if( z[j-1]=='-' ) return 0; 
+      if( seenDP ) return 0; 
+      seenDP = 1; 
+      continue; 
+    } 
+    if( c=='e' || c=='E' ){ 
+      if( z[j-1]<'0' ) return 0; 
+      if( seenE ) return -1; 
+      seenDP = seenE = 1; 
+      c = z[j+1]; 
+      if( c=='+' || c=='-' ){ 
+        j++; 
+        c = z[j+1]; 
+      } 
+      if( c<'0' || c>'9' ) return 0; 
+      continue; 
+    } 
+    break; 
+  } 
+  if( z[j-1]<'0' ) return 0; 
+  if( pVal ){ 
+#ifdef SQLITE_AMALGAMATION 
+     /* The sqlite3AtoF() routine is much much faster than atof(), if it 
+     ** is available */ 
+     double r; 
+     (void)sqlite3AtoF((const char*)p->z, &r, j, SQLITE_UTF8); 
+     *pVal = r; 
+#else 
+     *pVal = (GeoCoord)atof((const char*)p->z); 
+#endif 
+  } 
+  p->z += j; 
+  return 1; 
+} 
+ 
+/* 
+** If the input is a well-formed JSON array of coordinates with at least 
+** four coordinates and where each coordinate is itself a two-value array, 
+** then convert the JSON into a GeoPoly object and return a pointer to 
+** that object. 
+** 
+** If any error occurs, return NULL. 
+*/ 
+static GeoPoly *geopolyParseJson(const unsigned char *z, int *pRc){ 
+  GeoParse s; 
+  int rc = SQLITE_OK; 
+  memset(&s, 0, sizeof(s)); 
+  s.z = z; 
+  if( geopolySkipSpace(&s)=='[' ){ 
+    s.z++; 
+    while( geopolySkipSpace(&s)=='[' ){ 
+      int ii = 0; 
+      char c; 
+      s.z++; 
+      if( s.nVertex>=s.nAlloc ){ 
+        GeoCoord *aNew; 
+        s.nAlloc = s.nAlloc*2 + 16; 
+        aNew = sqlite3_realloc64(s.a, s.nAlloc*sizeof(GeoCoord)*2 ); 
+        if( aNew==0 ){ 
+          rc = SQLITE_NOMEM; 
+          s.nErr++; 
+          break; 
+        } 
+        s.a = aNew; 
+      } 
+      while( geopolyParseNumber(&s, ii<=1 ? &s.a[s.nVertex*2+ii] : 0) ){ 
+        ii++; 
+        if( ii==2 ) s.nVertex++; 
+        c = geopolySkipSpace(&s); 
+        s.z++; 
+        if( c==',' ) continue; 
+        if( c==']' && ii>=2 ) break; 
+        s.nErr++; 
+        rc = SQLITE_ERROR; 
+        goto parse_json_err; 
+      } 
+      if( geopolySkipSpace(&s)==',' ){ 
+        s.z++; 
+        continue; 
+      } 
+      break; 
+    } 
+    if( geopolySkipSpace(&s)==']' 
+     && s.nVertex>=4 
+     && s.a[0]==s.a[s.nVertex*2-2] 
+     && s.a[1]==s.a[s.nVertex*2-1] 
+     && (s.z++, geopolySkipSpace(&s)==0) 
+    ){ 
+      GeoPoly *pOut; 
+      int x = 1; 
+      s.nVertex--;  /* Remove the redundant vertex at the end */ 
+      pOut = sqlite3_malloc64( GEOPOLY_SZ((sqlite3_int64)s.nVertex) ); 
+      x = 1; 
+      if( pOut==0 ) goto parse_json_err; 
+      pOut->nVertex = s.nVertex; 
+      memcpy(pOut->a, s.a, s.nVertex*2*sizeof(GeoCoord)); 
+      pOut->hdr[0] = *(unsigned char*)&x; 
+      pOut->hdr[1] = (s.nVertex>>16)&0xff; 
+      pOut->hdr[2] = (s.nVertex>>8)&0xff; 
+      pOut->hdr[3] = s.nVertex&0xff; 
+      sqlite3_free(s.a); 
+      if( pRc ) *pRc = SQLITE_OK; 
+      return pOut; 
+    }else{ 
+      s.nErr++; 
+      rc = SQLITE_ERROR; 
+    } 
+  } 
+parse_json_err: 
+  if( pRc ) *pRc = rc; 
+  sqlite3_free(s.a); 
+  return 0; 
+} 
+ 
+/* 
+** Given a function parameter, try to interpret it as a polygon, either 
+** in the binary format or JSON text.  Compute a GeoPoly object and 
+** return a pointer to that object.  Or if the input is not a well-formed 
+** polygon, put an error message in sqlite3_context and return NULL. 
+*/ 
+static GeoPoly *geopolyFuncParam( 
+  sqlite3_context *pCtx,      /* Context for error messages */ 
+  sqlite3_value *pVal,        /* The value to decode */ 
+  int *pRc                    /* Write error here */ 
+){ 
+  GeoPoly *p = 0; 
+  int nByte; 
   testcase( pCtx==0 );
-  if( sqlite3_value_type(pVal)==SQLITE_BLOB
-   && (nByte = sqlite3_value_bytes(pVal))>=(4+6*sizeof(GeoCoord))
-  ){
-    const unsigned char *a = sqlite3_value_blob(pVal);
-    int nVertex;
+  if( sqlite3_value_type(pVal)==SQLITE_BLOB 
+   && (nByte = sqlite3_value_bytes(pVal))>=(4+6*sizeof(GeoCoord)) 
+  ){ 
+    const unsigned char *a = sqlite3_value_blob(pVal); 
+    int nVertex; 
     if( a==0 ){
       if( pCtx ) sqlite3_result_error_nomem(pCtx);
       return 0;
     }
-    nVertex = (a[1]<<16) + (a[2]<<8) + a[3];
-    if( (a[0]==0 || a[0]==1)
-     && (nVertex*2*sizeof(GeoCoord) + 4)==(unsigned int)nByte
-    ){
-      p = sqlite3_malloc64( sizeof(*p) + (nVertex-1)*2*sizeof(GeoCoord) );
-      if( p==0 ){
-        if( pRc ) *pRc = SQLITE_NOMEM;
-        if( pCtx ) sqlite3_result_error_nomem(pCtx);
-      }else{
-        int x = 1;
-        p->nVertex = nVertex;
-        memcpy(p->hdr, a, nByte);
-        if( a[0] != *(unsigned char*)&x ){
-          int ii;
-          for(ii=0; ii<nVertex; ii++){
-            geopolySwab32((unsigned char*)&GeoX(p,ii));
-            geopolySwab32((unsigned char*)&GeoY(p,ii));
-          }
-          p->hdr[0] ^= 1;
-        }
-      }
-    }
-    if( pRc ) *pRc = SQLITE_OK;
-    return p;
-  }else if( sqlite3_value_type(pVal)==SQLITE_TEXT ){
-    const unsigned char *zJson = sqlite3_value_text(pVal);
-    if( zJson==0 ){
-      if( pRc ) *pRc = SQLITE_NOMEM;
-      return 0;
-    }
-    return geopolyParseJson(zJson, pRc);
-  }else{
-    if( pRc ) *pRc = SQLITE_ERROR;
-    return 0;
-  }
-}
-
-/*
-** Implementation of the geopoly_blob(X) function.
-**
-** If the input is a well-formed Geopoly BLOB or JSON string
-** then return the BLOB representation of the polygon.  Otherwise
-** return NULL.
-*/
-static void geopolyBlobFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  GeoPoly *p = geopolyFuncParam(context, argv[0], 0);
-  if( p ){
+    nVertex = (a[1]<<16) + (a[2]<<8) + a[3]; 
+    if( (a[0]==0 || a[0]==1) 
+     && (nVertex*2*sizeof(GeoCoord) + 4)==(unsigned int)nByte 
+    ){ 
+      p = sqlite3_malloc64( sizeof(*p) + (nVertex-1)*2*sizeof(GeoCoord) ); 
+      if( p==0 ){ 
+        if( pRc ) *pRc = SQLITE_NOMEM; 
+        if( pCtx ) sqlite3_result_error_nomem(pCtx); 
+      }else{ 
+        int x = 1; 
+        p->nVertex = nVertex; 
+        memcpy(p->hdr, a, nByte); 
+        if( a[0] != *(unsigned char*)&x ){ 
+          int ii; 
+          for(ii=0; ii<nVertex; ii++){ 
+            geopolySwab32((unsigned char*)&GeoX(p,ii)); 
+            geopolySwab32((unsigned char*)&GeoY(p,ii)); 
+          } 
+          p->hdr[0] ^= 1; 
+        } 
+      } 
+    } 
+    if( pRc ) *pRc = SQLITE_OK; 
+    return p; 
+  }else if( sqlite3_value_type(pVal)==SQLITE_TEXT ){ 
+    const unsigned char *zJson = sqlite3_value_text(pVal); 
+    if( zJson==0 ){ 
+      if( pRc ) *pRc = SQLITE_NOMEM; 
+      return 0; 
+    } 
+    return geopolyParseJson(zJson, pRc); 
+  }else{ 
+    if( pRc ) *pRc = SQLITE_ERROR; 
+    return 0; 
+  } 
+} 
+ 
+/* 
+** Implementation of the geopoly_blob(X) function. 
+** 
+** If the input is a well-formed Geopoly BLOB or JSON string 
+** then return the BLOB representation of the polygon.  Otherwise 
+** return NULL. 
+*/ 
+static void geopolyBlobFunc( 
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  GeoPoly *p = geopolyFuncParam(context, argv[0], 0); 
+  if( p ){ 
     sqlite3_result_blob(context, p->hdr,
-       4+8*p->nVertex, SQLITE_TRANSIENT);
-    sqlite3_free(p);
-  }
-}
-
-/*
-** SQL function:     geopoly_json(X)
-**
-** Interpret X as a polygon and render it as a JSON array
-** of coordinates.  Or, if X is not a valid polygon, return NULL.
-*/
-static void geopolyJsonFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  GeoPoly *p = geopolyFuncParam(context, argv[0], 0);
-  if( p ){
-    sqlite3 *db = sqlite3_context_db_handle(context);
-    sqlite3_str *x = sqlite3_str_new(db);
-    int i;
-    sqlite3_str_append(x, "[", 1);
-    for(i=0; i<p->nVertex; i++){
-      sqlite3_str_appendf(x, "[%!g,%!g],", GeoX(p,i), GeoY(p,i));
-    }
-    sqlite3_str_appendf(x, "[%!g,%!g]]", GeoX(p,0), GeoY(p,0));
-    sqlite3_result_text(context, sqlite3_str_finish(x), -1, sqlite3_free);
-    sqlite3_free(p);
-  }
-}
-
-/*
-** SQL function:     geopoly_svg(X, ....)
-**
-** Interpret X as a polygon and render it as a SVG <polyline>.
-** Additional arguments are added as attributes to the <polyline>.
-*/
-static void geopolySvgFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  GeoPoly *p;
-  if( argc<1 ) return;
-  p = geopolyFuncParam(context, argv[0], 0);
-  if( p ){
-    sqlite3 *db = sqlite3_context_db_handle(context);
-    sqlite3_str *x = sqlite3_str_new(db);
-    int i;
-    char cSep = '\'';
-    sqlite3_str_appendf(x, "<polyline points=");
-    for(i=0; i<p->nVertex; i++){
-      sqlite3_str_appendf(x, "%c%g,%g", cSep, GeoX(p,i), GeoY(p,i));
-      cSep = ' ';
-    }
-    sqlite3_str_appendf(x, " %g,%g'", GeoX(p,0), GeoY(p,0));
-    for(i=1; i<argc; i++){
-      const char *z = (const char*)sqlite3_value_text(argv[i]);
-      if( z && z[0] ){
-        sqlite3_str_appendf(x, " %s", z);
-      }
-    }
-    sqlite3_str_appendf(x, "></polyline>");
-    sqlite3_result_text(context, sqlite3_str_finish(x), -1, sqlite3_free);
-    sqlite3_free(p);
-  }
-}
-
-/*
-** SQL Function:      geopoly_xform(poly, A, B, C, D, E, F)
-**
-** Transform and/or translate a polygon as follows:
-**
-**      x1 = A*x0 + B*y0 + E
-**      y1 = C*x0 + D*y0 + F
-**
-** For a translation:
-**
-**      geopoly_xform(poly, 1, 0, 0, 1, x-offset, y-offset)
-**
-** Rotate by R around the point (0,0):
-**
-**      geopoly_xform(poly, cos(R), sin(R), -sin(R), cos(R), 0, 0)
-*/
-static void geopolyXformFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  GeoPoly *p = geopolyFuncParam(context, argv[0], 0);
-  double A = sqlite3_value_double(argv[1]);
-  double B = sqlite3_value_double(argv[2]);
-  double C = sqlite3_value_double(argv[3]);
-  double D = sqlite3_value_double(argv[4]);
-  double E = sqlite3_value_double(argv[5]);
-  double F = sqlite3_value_double(argv[6]);
-  GeoCoord x1, y1, x0, y0;
-  int ii;
-  if( p ){
-    for(ii=0; ii<p->nVertex; ii++){
-      x0 = GeoX(p,ii);
-      y0 = GeoY(p,ii);
-      x1 = (GeoCoord)(A*x0 + B*y0 + E);
-      y1 = (GeoCoord)(C*x0 + D*y0 + F);
-      GeoX(p,ii) = x1;
-      GeoY(p,ii) = y1;
-    }
+       4+8*p->nVertex, SQLITE_TRANSIENT); 
+    sqlite3_free(p); 
+  } 
+} 
+ 
+/* 
+** SQL function:     geopoly_json(X) 
+** 
+** Interpret X as a polygon and render it as a JSON array 
+** of coordinates.  Or, if X is not a valid polygon, return NULL. 
+*/ 
+static void geopolyJsonFunc( 
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  GeoPoly *p = geopolyFuncParam(context, argv[0], 0); 
+  if( p ){ 
+    sqlite3 *db = sqlite3_context_db_handle(context); 
+    sqlite3_str *x = sqlite3_str_new(db); 
+    int i; 
+    sqlite3_str_append(x, "[", 1); 
+    for(i=0; i<p->nVertex; i++){ 
+      sqlite3_str_appendf(x, "[%!g,%!g],", GeoX(p,i), GeoY(p,i)); 
+    } 
+    sqlite3_str_appendf(x, "[%!g,%!g]]", GeoX(p,0), GeoY(p,0)); 
+    sqlite3_result_text(context, sqlite3_str_finish(x), -1, sqlite3_free); 
+    sqlite3_free(p); 
+  } 
+} 
+ 
+/* 
+** SQL function:     geopoly_svg(X, ....) 
+** 
+** Interpret X as a polygon and render it as a SVG <polyline>. 
+** Additional arguments are added as attributes to the <polyline>. 
+*/ 
+static void geopolySvgFunc( 
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  GeoPoly *p; 
+  if( argc<1 ) return; 
+  p = geopolyFuncParam(context, argv[0], 0); 
+  if( p ){ 
+    sqlite3 *db = sqlite3_context_db_handle(context); 
+    sqlite3_str *x = sqlite3_str_new(db); 
+    int i; 
+    char cSep = '\''; 
+    sqlite3_str_appendf(x, "<polyline points="); 
+    for(i=0; i<p->nVertex; i++){ 
+      sqlite3_str_appendf(x, "%c%g,%g", cSep, GeoX(p,i), GeoY(p,i)); 
+      cSep = ' '; 
+    } 
+    sqlite3_str_appendf(x, " %g,%g'", GeoX(p,0), GeoY(p,0)); 
+    for(i=1; i<argc; i++){ 
+      const char *z = (const char*)sqlite3_value_text(argv[i]); 
+      if( z && z[0] ){ 
+        sqlite3_str_appendf(x, " %s", z); 
+      } 
+    } 
+    sqlite3_str_appendf(x, "></polyline>"); 
+    sqlite3_result_text(context, sqlite3_str_finish(x), -1, sqlite3_free); 
+    sqlite3_free(p); 
+  } 
+} 
+ 
+/* 
+** SQL Function:      geopoly_xform(poly, A, B, C, D, E, F) 
+** 
+** Transform and/or translate a polygon as follows: 
+** 
+**      x1 = A*x0 + B*y0 + E 
+**      y1 = C*x0 + D*y0 + F 
+** 
+** For a translation: 
+** 
+**      geopoly_xform(poly, 1, 0, 0, 1, x-offset, y-offset) 
+** 
+** Rotate by R around the point (0,0): 
+** 
+**      geopoly_xform(poly, cos(R), sin(R), -sin(R), cos(R), 0, 0) 
+*/ 
+static void geopolyXformFunc( 
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  GeoPoly *p = geopolyFuncParam(context, argv[0], 0); 
+  double A = sqlite3_value_double(argv[1]); 
+  double B = sqlite3_value_double(argv[2]); 
+  double C = sqlite3_value_double(argv[3]); 
+  double D = sqlite3_value_double(argv[4]); 
+  double E = sqlite3_value_double(argv[5]); 
+  double F = sqlite3_value_double(argv[6]); 
+  GeoCoord x1, y1, x0, y0; 
+  int ii; 
+  if( p ){ 
+    for(ii=0; ii<p->nVertex; ii++){ 
+      x0 = GeoX(p,ii); 
+      y0 = GeoY(p,ii); 
+      x1 = (GeoCoord)(A*x0 + B*y0 + E); 
+      y1 = (GeoCoord)(C*x0 + D*y0 + F); 
+      GeoX(p,ii) = x1; 
+      GeoY(p,ii) = y1; 
+    } 
     sqlite3_result_blob(context, p->hdr,
-       4+8*p->nVertex, SQLITE_TRANSIENT);
-    sqlite3_free(p);
-  }
-}
-
-/*
-** Compute the area enclosed by the polygon.
-**
-** This routine can also be used to detect polygons that rotate in
-** the wrong direction.  Polygons are suppose to be counter-clockwise (CCW).
-** This routine returns a negative value for clockwise (CW) polygons.
-*/
-static double geopolyArea(GeoPoly *p){
-  double rArea = 0.0;
-  int ii;
-  for(ii=0; ii<p->nVertex-1; ii++){
-    rArea += (GeoX(p,ii) - GeoX(p,ii+1))           /* (x0 - x1) */
-              * (GeoY(p,ii) + GeoY(p,ii+1))        /* (y0 + y1) */
-              * 0.5;
-  }
-  rArea += (GeoX(p,ii) - GeoX(p,0))                /* (xN - x0) */
-           * (GeoY(p,ii) + GeoY(p,0))              /* (yN + y0) */
-           * 0.5;
-  return rArea;
-}
-
-/*
-** Implementation of the geopoly_area(X) function.
-**
-** If the input is a well-formed Geopoly BLOB then return the area
-** enclosed by the polygon.  If the polygon circulates clockwise instead
-** of counterclockwise (as it should) then return the negative of the
-** enclosed area.  Otherwise return NULL.
-*/
-static void geopolyAreaFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  GeoPoly *p = geopolyFuncParam(context, argv[0], 0);
-  if( p ){
-    sqlite3_result_double(context, geopolyArea(p));
-    sqlite3_free(p);
-  }
-}
-
-/*
-** Implementation of the geopoly_ccw(X) function.
-**
-** If the rotation of polygon X is clockwise (incorrect) instead of
-** counter-clockwise (the correct winding order according to RFC7946)
+       4+8*p->nVertex, SQLITE_TRANSIENT); 
+    sqlite3_free(p); 
+  } 
+} 
+ 
+/* 
+** Compute the area enclosed by the polygon. 
+** 
+** This routine can also be used to detect polygons that rotate in 
+** the wrong direction.  Polygons are suppose to be counter-clockwise (CCW). 
+** This routine returns a negative value for clockwise (CW) polygons. 
+*/ 
+static double geopolyArea(GeoPoly *p){ 
+  double rArea = 0.0; 
+  int ii; 
+  for(ii=0; ii<p->nVertex-1; ii++){ 
+    rArea += (GeoX(p,ii) - GeoX(p,ii+1))           /* (x0 - x1) */ 
+              * (GeoY(p,ii) + GeoY(p,ii+1))        /* (y0 + y1) */ 
+              * 0.5; 
+  } 
+  rArea += (GeoX(p,ii) - GeoX(p,0))                /* (xN - x0) */ 
+           * (GeoY(p,ii) + GeoY(p,0))              /* (yN + y0) */ 
+           * 0.5; 
+  return rArea; 
+} 
+ 
+/* 
+** Implementation of the geopoly_area(X) function. 
+** 
+** If the input is a well-formed Geopoly BLOB then return the area 
+** enclosed by the polygon.  If the polygon circulates clockwise instead 
+** of counterclockwise (as it should) then return the negative of the 
+** enclosed area.  Otherwise return NULL. 
+*/ 
+static void geopolyAreaFunc( 
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  GeoPoly *p = geopolyFuncParam(context, argv[0], 0); 
+  if( p ){ 
+    sqlite3_result_double(context, geopolyArea(p)); 
+    sqlite3_free(p); 
+  }
+} 
+ 
+/* 
+** Implementation of the geopoly_ccw(X) function. 
+** 
+** If the rotation of polygon X is clockwise (incorrect) instead of 
+** counter-clockwise (the correct winding order according to RFC7946) 
 ** then reverse the order of the vertexes in polygon X.
-**
-** In other words, this routine returns a CCW polygon regardless of the
-** winding order of its input.
-**
-** Use this routine to sanitize historical inputs that that sometimes
-** contain polygons that wind in the wrong direction.
-*/
-static void geopolyCcwFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  GeoPoly *p = geopolyFuncParam(context, argv[0], 0);
-  if( p ){
-    if( geopolyArea(p)<0.0 ){
-      int ii, jj;
-      for(ii=1, jj=p->nVertex-1; ii<jj; ii++, jj--){
-        GeoCoord t = GeoX(p,ii);
-        GeoX(p,ii) = GeoX(p,jj);
-        GeoX(p,jj) = t;
-        t = GeoY(p,ii);
-        GeoY(p,ii) = GeoY(p,jj);
-        GeoY(p,jj) = t;
-      }
-    }
+** 
+** In other words, this routine returns a CCW polygon regardless of the 
+** winding order of its input. 
+** 
+** Use this routine to sanitize historical inputs that that sometimes 
+** contain polygons that wind in the wrong direction. 
+*/ 
+static void geopolyCcwFunc( 
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  GeoPoly *p = geopolyFuncParam(context, argv[0], 0); 
+  if( p ){ 
+    if( geopolyArea(p)<0.0 ){ 
+      int ii, jj; 
+      for(ii=1, jj=p->nVertex-1; ii<jj; ii++, jj--){ 
+        GeoCoord t = GeoX(p,ii); 
+        GeoX(p,ii) = GeoX(p,jj); 
+        GeoX(p,jj) = t; 
+        t = GeoY(p,ii); 
+        GeoY(p,ii) = GeoY(p,jj); 
+        GeoY(p,jj) = t; 
+      } 
+    } 
     sqlite3_result_blob(context, p->hdr,
-       4+8*p->nVertex, SQLITE_TRANSIENT);
-    sqlite3_free(p);
-  }
-}
-
-#define GEOPOLY_PI 3.1415926535897932385
-
-/* Fast approximation for sine(X) for X between -0.5*pi and 2*pi
-*/
-static double geopolySine(double r){
-  assert( r>=-0.5*GEOPOLY_PI && r<=2.0*GEOPOLY_PI );
-  if( r>=1.5*GEOPOLY_PI ){
-    r -= 2.0*GEOPOLY_PI;
-  }
-  if( r>=0.5*GEOPOLY_PI ){
-    return -geopolySine(r-GEOPOLY_PI);
-  }else{
-    double r2 = r*r;
-    double r3 = r2*r;
-    double r5 = r3*r2;
-    return 0.9996949*r - 0.1656700*r3 + 0.0075134*r5;
-  }
-}
-
-/*
-** Function:   geopoly_regular(X,Y,R,N)
-**
-** Construct a simple, convex, regular polygon centered at X, Y
-** with circumradius R and with N sides.
-*/
-static void geopolyRegularFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  double x = sqlite3_value_double(argv[0]);
-  double y = sqlite3_value_double(argv[1]);
-  double r = sqlite3_value_double(argv[2]);
-  int n = sqlite3_value_int(argv[3]);
-  int i;
-  GeoPoly *p;
-
-  if( n<3 || r<=0.0 ) return;
-  if( n>1000 ) n = 1000;
-  p = sqlite3_malloc64( sizeof(*p) + (n-1)*2*sizeof(GeoCoord) );
-  if( p==0 ){
-    sqlite3_result_error_nomem(context);
-    return;
-  }
-  i = 1;
-  p->hdr[0] = *(unsigned char*)&i;
-  p->hdr[1] = 0;
-  p->hdr[2] = (n>>8)&0xff;
-  p->hdr[3] = n&0xff;
-  for(i=0; i<n; i++){
-    double rAngle = 2.0*GEOPOLY_PI*i/n;
-    GeoX(p,i) = x - r*geopolySine(rAngle-0.5*GEOPOLY_PI);
-    GeoY(p,i) = y + r*geopolySine(rAngle);
-  }
-  sqlite3_result_blob(context, p->hdr, 4+8*n, SQLITE_TRANSIENT);
-  sqlite3_free(p);
-}
-
-/*
-** If pPoly is a polygon, compute its bounding box. Then:
-**
-**    (1) if aCoord!=0 store the bounding box in aCoord, returning NULL
-**    (2) otherwise, compute a GeoPoly for the bounding box and return the
-**        new GeoPoly
-**
-** If pPoly is NULL but aCoord is not NULL, then compute a new GeoPoly from
-** the bounding box in aCoord and return a pointer to that GeoPoly.
-*/
-static GeoPoly *geopolyBBox(
-  sqlite3_context *context,   /* For recording the error */
-  sqlite3_value *pPoly,       /* The polygon */
-  RtreeCoord *aCoord,         /* Results here */
-  int *pRc                    /* Error code here */
-){
-  GeoPoly *pOut = 0;
-  GeoPoly *p;
-  float mnX, mxX, mnY, mxY;
-  if( pPoly==0 && aCoord!=0 ){
-    p = 0;
-    mnX = aCoord[0].f;
-    mxX = aCoord[1].f;
-    mnY = aCoord[2].f;
-    mxY = aCoord[3].f;
-    goto geopolyBboxFill;
-  }else{
-    p = geopolyFuncParam(context, pPoly, pRc);
-  }
-  if( p ){
-    int ii;
-    mnX = mxX = GeoX(p,0);
-    mnY = mxY = GeoY(p,0);
-    for(ii=1; ii<p->nVertex; ii++){
-      double r = GeoX(p,ii);
-      if( r<mnX ) mnX = (float)r;
-      else if( r>mxX ) mxX = (float)r;
-      r = GeoY(p,ii);
-      if( r<mnY ) mnY = (float)r;
-      else if( r>mxY ) mxY = (float)r;
-    }
-    if( pRc ) *pRc = SQLITE_OK;
-    if( aCoord==0 ){
-      geopolyBboxFill:
-      pOut = sqlite3_realloc64(p, GEOPOLY_SZ(4));
-      if( pOut==0 ){
-        sqlite3_free(p);
-        if( context ) sqlite3_result_error_nomem(context);
-        if( pRc ) *pRc = SQLITE_NOMEM;
-        return 0;
-      }
-      pOut->nVertex = 4;
-      ii = 1;
-      pOut->hdr[0] = *(unsigned char*)&ii;
-      pOut->hdr[1] = 0;
-      pOut->hdr[2] = 0;
-      pOut->hdr[3] = 4;
-      GeoX(pOut,0) = mnX;
-      GeoY(pOut,0) = mnY;
-      GeoX(pOut,1) = mxX;
-      GeoY(pOut,1) = mnY;
-      GeoX(pOut,2) = mxX;
-      GeoY(pOut,2) = mxY;
-      GeoX(pOut,3) = mnX;
-      GeoY(pOut,3) = mxY;
-    }else{
-      sqlite3_free(p);
-      aCoord[0].f = mnX;
-      aCoord[1].f = mxX;
-      aCoord[2].f = mnY;
-      aCoord[3].f = mxY;
-    }
+       4+8*p->nVertex, SQLITE_TRANSIENT); 
+    sqlite3_free(p); 
+  }
+} 
+ 
+#define GEOPOLY_PI 3.1415926535897932385 
+ 
+/* Fast approximation for sine(X) for X between -0.5*pi and 2*pi 
+*/ 
+static double geopolySine(double r){ 
+  assert( r>=-0.5*GEOPOLY_PI && r<=2.0*GEOPOLY_PI ); 
+  if( r>=1.5*GEOPOLY_PI ){ 
+    r -= 2.0*GEOPOLY_PI; 
+  } 
+  if( r>=0.5*GEOPOLY_PI ){ 
+    return -geopolySine(r-GEOPOLY_PI); 
+  }else{ 
+    double r2 = r*r; 
+    double r3 = r2*r; 
+    double r5 = r3*r2; 
+    return 0.9996949*r - 0.1656700*r3 + 0.0075134*r5; 
+  } 
+} 
+ 
+/* 
+** Function:   geopoly_regular(X,Y,R,N) 
+** 
+** Construct a simple, convex, regular polygon centered at X, Y 
+** with circumradius R and with N sides. 
+*/ 
+static void geopolyRegularFunc( 
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  double x = sqlite3_value_double(argv[0]); 
+  double y = sqlite3_value_double(argv[1]); 
+  double r = sqlite3_value_double(argv[2]); 
+  int n = sqlite3_value_int(argv[3]); 
+  int i; 
+  GeoPoly *p; 
+ 
+  if( n<3 || r<=0.0 ) return; 
+  if( n>1000 ) n = 1000; 
+  p = sqlite3_malloc64( sizeof(*p) + (n-1)*2*sizeof(GeoCoord) ); 
+  if( p==0 ){ 
+    sqlite3_result_error_nomem(context); 
+    return; 
+  } 
+  i = 1; 
+  p->hdr[0] = *(unsigned char*)&i; 
+  p->hdr[1] = 0; 
+  p->hdr[2] = (n>>8)&0xff; 
+  p->hdr[3] = n&0xff; 
+  for(i=0; i<n; i++){ 
+    double rAngle = 2.0*GEOPOLY_PI*i/n; 
+    GeoX(p,i) = x - r*geopolySine(rAngle-0.5*GEOPOLY_PI); 
+    GeoY(p,i) = y + r*geopolySine(rAngle); 
+  } 
+  sqlite3_result_blob(context, p->hdr, 4+8*n, SQLITE_TRANSIENT); 
+  sqlite3_free(p); 
+} 
+ 
+/* 
+** If pPoly is a polygon, compute its bounding box. Then: 
+** 
+**    (1) if aCoord!=0 store the bounding box in aCoord, returning NULL 
+**    (2) otherwise, compute a GeoPoly for the bounding box and return the 
+**        new GeoPoly 
+** 
+** If pPoly is NULL but aCoord is not NULL, then compute a new GeoPoly from 
+** the bounding box in aCoord and return a pointer to that GeoPoly. 
+*/ 
+static GeoPoly *geopolyBBox( 
+  sqlite3_context *context,   /* For recording the error */ 
+  sqlite3_value *pPoly,       /* The polygon */ 
+  RtreeCoord *aCoord,         /* Results here */ 
+  int *pRc                    /* Error code here */ 
+){ 
+  GeoPoly *pOut = 0; 
+  GeoPoly *p; 
+  float mnX, mxX, mnY, mxY; 
+  if( pPoly==0 && aCoord!=0 ){ 
+    p = 0; 
+    mnX = aCoord[0].f; 
+    mxX = aCoord[1].f; 
+    mnY = aCoord[2].f; 
+    mxY = aCoord[3].f; 
+    goto geopolyBboxFill; 
+  }else{ 
+    p = geopolyFuncParam(context, pPoly, pRc); 
+  } 
+  if( p ){ 
+    int ii; 
+    mnX = mxX = GeoX(p,0); 
+    mnY = mxY = GeoY(p,0); 
+    for(ii=1; ii<p->nVertex; ii++){ 
+      double r = GeoX(p,ii); 
+      if( r<mnX ) mnX = (float)r; 
+      else if( r>mxX ) mxX = (float)r; 
+      r = GeoY(p,ii); 
+      if( r<mnY ) mnY = (float)r; 
+      else if( r>mxY ) mxY = (float)r; 
+    } 
+    if( pRc ) *pRc = SQLITE_OK; 
+    if( aCoord==0 ){ 
+      geopolyBboxFill: 
+      pOut = sqlite3_realloc64(p, GEOPOLY_SZ(4)); 
+      if( pOut==0 ){ 
+        sqlite3_free(p); 
+        if( context ) sqlite3_result_error_nomem(context); 
+        if( pRc ) *pRc = SQLITE_NOMEM; 
+        return 0; 
+      } 
+      pOut->nVertex = 4; 
+      ii = 1; 
+      pOut->hdr[0] = *(unsigned char*)&ii; 
+      pOut->hdr[1] = 0; 
+      pOut->hdr[2] = 0; 
+      pOut->hdr[3] = 4; 
+      GeoX(pOut,0) = mnX; 
+      GeoY(pOut,0) = mnY; 
+      GeoX(pOut,1) = mxX; 
+      GeoY(pOut,1) = mnY; 
+      GeoX(pOut,2) = mxX; 
+      GeoY(pOut,2) = mxY; 
+      GeoX(pOut,3) = mnX; 
+      GeoY(pOut,3) = mxY; 
+    }else{ 
+      sqlite3_free(p); 
+      aCoord[0].f = mnX; 
+      aCoord[1].f = mxX; 
+      aCoord[2].f = mnY; 
+      aCoord[3].f = mxY; 
+    } 
   }else if( aCoord ){
     memset(aCoord, 0, sizeof(RtreeCoord)*4);
-  }
-  return pOut;
-}
-
-/*
-** Implementation of the geopoly_bbox(X) SQL function.
-*/
-static void geopolyBBoxFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  GeoPoly *p = geopolyBBox(context, argv[0], 0, 0);
-  if( p ){
+  } 
+  return pOut; 
+} 
+ 
+/* 
+** Implementation of the geopoly_bbox(X) SQL function. 
+*/ 
+static void geopolyBBoxFunc( 
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  GeoPoly *p = geopolyBBox(context, argv[0], 0, 0); 
+  if( p ){ 
     sqlite3_result_blob(context, p->hdr,
-       4+8*p->nVertex, SQLITE_TRANSIENT);
-    sqlite3_free(p);
-  }
-}
-
-/*
-** State vector for the geopoly_group_bbox() aggregate function.
-*/
-typedef struct GeoBBox GeoBBox;
-struct GeoBBox {
-  int isInit;
-  RtreeCoord a[4];
-};
-
-
-/*
-** Implementation of the geopoly_group_bbox(X) aggregate SQL function.
-*/
-static void geopolyBBoxStep(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  RtreeCoord a[4];
-  int rc = SQLITE_OK;
-  (void)geopolyBBox(context, argv[0], a, &rc);
-  if( rc==SQLITE_OK ){
-    GeoBBox *pBBox;
-    pBBox = (GeoBBox*)sqlite3_aggregate_context(context, sizeof(*pBBox));
-    if( pBBox==0 ) return;
-    if( pBBox->isInit==0 ){
-      pBBox->isInit = 1;
-      memcpy(pBBox->a, a, sizeof(RtreeCoord)*4);
-    }else{
-      if( a[0].f < pBBox->a[0].f ) pBBox->a[0] = a[0];
-      if( a[1].f > pBBox->a[1].f ) pBBox->a[1] = a[1];
-      if( a[2].f < pBBox->a[2].f ) pBBox->a[2] = a[2];
-      if( a[3].f > pBBox->a[3].f ) pBBox->a[3] = a[3];
-    }
-  }
-}
-static void geopolyBBoxFinal(
-  sqlite3_context *context
-){
-  GeoPoly *p;
-  GeoBBox *pBBox;
-  pBBox = (GeoBBox*)sqlite3_aggregate_context(context, 0);
-  if( pBBox==0 ) return;
-  p = geopolyBBox(context, 0, pBBox->a, 0);
-  if( p ){
+       4+8*p->nVertex, SQLITE_TRANSIENT); 
+    sqlite3_free(p); 
+  } 
+} 
+ 
+/* 
+** State vector for the geopoly_group_bbox() aggregate function. 
+*/ 
+typedef struct GeoBBox GeoBBox; 
+struct GeoBBox { 
+  int isInit; 
+  RtreeCoord a[4]; 
+}; 
+ 
+ 
+/* 
+** Implementation of the geopoly_group_bbox(X) aggregate SQL function. 
+*/ 
+static void geopolyBBoxStep( 
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  RtreeCoord a[4]; 
+  int rc = SQLITE_OK; 
+  (void)geopolyBBox(context, argv[0], a, &rc); 
+  if( rc==SQLITE_OK ){ 
+    GeoBBox *pBBox; 
+    pBBox = (GeoBBox*)sqlite3_aggregate_context(context, sizeof(*pBBox)); 
+    if( pBBox==0 ) return; 
+    if( pBBox->isInit==0 ){ 
+      pBBox->isInit = 1; 
+      memcpy(pBBox->a, a, sizeof(RtreeCoord)*4); 
+    }else{ 
+      if( a[0].f < pBBox->a[0].f ) pBBox->a[0] = a[0]; 
+      if( a[1].f > pBBox->a[1].f ) pBBox->a[1] = a[1]; 
+      if( a[2].f < pBBox->a[2].f ) pBBox->a[2] = a[2]; 
+      if( a[3].f > pBBox->a[3].f ) pBBox->a[3] = a[3]; 
+    } 
+  } 
+} 
+static void geopolyBBoxFinal( 
+  sqlite3_context *context 
+){ 
+  GeoPoly *p; 
+  GeoBBox *pBBox; 
+  pBBox = (GeoBBox*)sqlite3_aggregate_context(context, 0); 
+  if( pBBox==0 ) return; 
+  p = geopolyBBox(context, 0, pBBox->a, 0); 
+  if( p ){ 
     sqlite3_result_blob(context, p->hdr,
-       4+8*p->nVertex, SQLITE_TRANSIENT);
-    sqlite3_free(p);
-  }
-}
-
-
-/*
-** Determine if point (x0,y0) is beneath line segment (x1,y1)->(x2,y2).
-** Returns:
-**
-**    +2  x0,y0 is on the line segement
-**
-**    +1  x0,y0 is beneath line segment
-**
-**    0   x0,y0 is not on or beneath the line segment or the line segment
-**        is vertical and x0,y0 is not on the line segment
-**
-** The left-most coordinate min(x1,x2) is not considered to be part of
-** the line segment for the purposes of this analysis.
-*/
-static int pointBeneathLine(
-  double x0, double y0,
-  double x1, double y1,
-  double x2, double y2
-){
-  double y;
-  if( x0==x1 && y0==y1 ) return 2;
-  if( x1<x2 ){
-    if( x0<=x1 || x0>x2 ) return 0;
-  }else if( x1>x2 ){
-    if( x0<=x2 || x0>x1 ) return 0;
-  }else{
-    /* Vertical line segment */
-    if( x0!=x1 ) return 0;
-    if( y0<y1 && y0<y2 ) return 0;
-    if( y0>y1 && y0>y2 ) return 0;
-    return 2;
-  }
-  y = y1 + (y2-y1)*(x0-x1)/(x2-x1);
-  if( y0==y ) return 2;
-  if( y0<y ) return 1;
-  return 0;
-}
-
-/*
-** SQL function:    geopoly_contains_point(P,X,Y)
-**
-** Return +2 if point X,Y is within polygon P.
-** Return +1 if point X,Y is on the polygon boundary.
-** Return 0 if point X,Y is outside the polygon
-*/
-static void geopolyContainsPointFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  GeoPoly *p1 = geopolyFuncParam(context, argv[0], 0);
-  double x0 = sqlite3_value_double(argv[1]);
-  double y0 = sqlite3_value_double(argv[2]);
-  int v = 0;
-  int cnt = 0;
-  int ii;
-  if( p1==0 ) return;
-  for(ii=0; ii<p1->nVertex-1; ii++){
-    v = pointBeneathLine(x0,y0,GeoX(p1,ii), GeoY(p1,ii),
-                               GeoX(p1,ii+1),GeoY(p1,ii+1));
-    if( v==2 ) break;
-    cnt += v;
-  }
-  if( v!=2 ){
-    v = pointBeneathLine(x0,y0,GeoX(p1,ii), GeoY(p1,ii),
-                               GeoX(p1,0),  GeoY(p1,0));
-  }
-  if( v==2 ){
-    sqlite3_result_int(context, 1);
-  }else if( ((v+cnt)&1)==0 ){
-    sqlite3_result_int(context, 0);
-  }else{
-    sqlite3_result_int(context, 2);
-  }
-  sqlite3_free(p1);
-}
-
-/* Forward declaration */
-static int geopolyOverlap(GeoPoly *p1, GeoPoly *p2);
-
-/*
-** SQL function:    geopoly_within(P1,P2)
-**
-** Return +2 if P1 and P2 are the same polygon
-** Return +1 if P2 is contained within P1
-** Return 0 if any part of P2 is on the outside of P1
-**
-*/
-static void geopolyWithinFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  GeoPoly *p1 = geopolyFuncParam(context, argv[0], 0);
-  GeoPoly *p2 = geopolyFuncParam(context, argv[1], 0);
-  if( p1 && p2 ){
-    int x = geopolyOverlap(p1, p2);
-    if( x<0 ){
-      sqlite3_result_error_nomem(context);
-    }else{
-      sqlite3_result_int(context, x==2 ? 1 : x==4 ? 2 : 0);
-    }
-  }
-  sqlite3_free(p1);
-  sqlite3_free(p2);
-}
-
-/* Objects used by the overlap algorihm. */
-typedef struct GeoEvent GeoEvent;
-typedef struct GeoSegment GeoSegment;
-typedef struct GeoOverlap GeoOverlap;
-struct GeoEvent {
-  double x;              /* X coordinate at which event occurs */
-  int eType;             /* 0 for ADD, 1 for REMOVE */
-  GeoSegment *pSeg;      /* The segment to be added or removed */
-  GeoEvent *pNext;       /* Next event in the sorted list */
-};
-struct GeoSegment {
-  double C, B;           /* y = C*x + B */
-  double y;              /* Current y value */
-  float y0;              /* Initial y value */
-  unsigned char side;    /* 1 for p1, 2 for p2 */
-  unsigned int idx;      /* Which segment within the side */
-  GeoSegment *pNext;     /* Next segment in a list sorted by y */
-};
-struct GeoOverlap {
-  GeoEvent *aEvent;          /* Array of all events */
-  GeoSegment *aSegment;      /* Array of all segments */
-  int nEvent;                /* Number of events */
-  int nSegment;              /* Number of segments */
-};
-
-/*
-** Add a single segment and its associated events.
-*/
-static void geopolyAddOneSegment(
-  GeoOverlap *p,
-  GeoCoord x0,
-  GeoCoord y0,
-  GeoCoord x1,
-  GeoCoord y1,
-  unsigned char side,
-  unsigned int idx
-){
-  GeoSegment *pSeg;
-  GeoEvent *pEvent;
-  if( x0==x1 ) return;  /* Ignore vertical segments */
-  if( x0>x1 ){
-    GeoCoord t = x0;
-    x0 = x1;
-    x1 = t;
-    t = y0;
-    y0 = y1;
-    y1 = t;
-  }
-  pSeg = p->aSegment + p->nSegment;
-  p->nSegment++;
-  pSeg->C = (y1-y0)/(x1-x0);
-  pSeg->B = y1 - x1*pSeg->C;
-  pSeg->y0 = y0;
-  pSeg->side = side;
-  pSeg->idx = idx;
-  pEvent = p->aEvent + p->nEvent;
-  p->nEvent++;
-  pEvent->x = x0;
-  pEvent->eType = 0;
-  pEvent->pSeg = pSeg;
-  pEvent = p->aEvent + p->nEvent;
-  p->nEvent++;
-  pEvent->x = x1;
-  pEvent->eType = 1;
-  pEvent->pSeg = pSeg;
-}
-
-
-
-/*
-** Insert all segments and events for polygon pPoly.
-*/
-static void geopolyAddSegments(
-  GeoOverlap *p,          /* Add segments to this Overlap object */
-  GeoPoly *pPoly,         /* Take all segments from this polygon */
-  unsigned char side      /* The side of pPoly */
-){
-  unsigned int i;
-  GeoCoord *x;
-  for(i=0; i<(unsigned)pPoly->nVertex-1; i++){
-    x = &GeoX(pPoly,i);
-    geopolyAddOneSegment(p, x[0], x[1], x[2], x[3], side, i);
-  }
-  x = &GeoX(pPoly,i);
-  geopolyAddOneSegment(p, x[0], x[1], pPoly->a[0], pPoly->a[1], side, i);
-}
-
-/*
-** Merge two lists of sorted events by X coordinate
-*/
-static GeoEvent *geopolyEventMerge(GeoEvent *pLeft, GeoEvent *pRight){
-  GeoEvent head, *pLast;
-  head.pNext = 0;
-  pLast = &head;
-  while( pRight && pLeft ){
-    if( pRight->x <= pLeft->x ){
-      pLast->pNext = pRight;
-      pLast = pRight;
-      pRight = pRight->pNext;
-    }else{
-      pLast->pNext = pLeft;
-      pLast = pLeft;
-      pLeft = pLeft->pNext;
-    }
-  }
-  pLast->pNext = pRight ? pRight : pLeft;
+       4+8*p->nVertex, SQLITE_TRANSIENT); 
+    sqlite3_free(p); 
+  } 
+} 
+ 
+ 
+/* 
+** Determine if point (x0,y0) is beneath line segment (x1,y1)->(x2,y2). 
+** Returns: 
+** 
+**    +2  x0,y0 is on the line segement 
+** 
+**    +1  x0,y0 is beneath line segment 
+** 
+**    0   x0,y0 is not on or beneath the line segment or the line segment 
+**        is vertical and x0,y0 is not on the line segment 
+** 
+** The left-most coordinate min(x1,x2) is not considered to be part of 
+** the line segment for the purposes of this analysis. 
+*/ 
+static int pointBeneathLine( 
+  double x0, double y0, 
+  double x1, double y1, 
+  double x2, double y2 
+){ 
+  double y; 
+  if( x0==x1 && y0==y1 ) return 2; 
+  if( x1<x2 ){ 
+    if( x0<=x1 || x0>x2 ) return 0; 
+  }else if( x1>x2 ){ 
+    if( x0<=x2 || x0>x1 ) return 0; 
+  }else{ 
+    /* Vertical line segment */ 
+    if( x0!=x1 ) return 0; 
+    if( y0<y1 && y0<y2 ) return 0; 
+    if( y0>y1 && y0>y2 ) return 0; 
+    return 2; 
+  } 
+  y = y1 + (y2-y1)*(x0-x1)/(x2-x1); 
+  if( y0==y ) return 2; 
+  if( y0<y ) return 1; 
+  return 0; 
+} 
+ 
+/* 
+** SQL function:    geopoly_contains_point(P,X,Y) 
+** 
+** Return +2 if point X,Y is within polygon P. 
+** Return +1 if point X,Y is on the polygon boundary. 
+** Return 0 if point X,Y is outside the polygon 
+*/ 
+static void geopolyContainsPointFunc( 
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  GeoPoly *p1 = geopolyFuncParam(context, argv[0], 0); 
+  double x0 = sqlite3_value_double(argv[1]); 
+  double y0 = sqlite3_value_double(argv[2]); 
+  int v = 0; 
+  int cnt = 0; 
+  int ii; 
+  if( p1==0 ) return; 
+  for(ii=0; ii<p1->nVertex-1; ii++){ 
+    v = pointBeneathLine(x0,y0,GeoX(p1,ii), GeoY(p1,ii), 
+                               GeoX(p1,ii+1),GeoY(p1,ii+1)); 
+    if( v==2 ) break; 
+    cnt += v; 
+  } 
+  if( v!=2 ){ 
+    v = pointBeneathLine(x0,y0,GeoX(p1,ii), GeoY(p1,ii), 
+                               GeoX(p1,0),  GeoY(p1,0)); 
+  } 
+  if( v==2 ){ 
+    sqlite3_result_int(context, 1); 
+  }else if( ((v+cnt)&1)==0 ){ 
+    sqlite3_result_int(context, 0); 
+  }else{ 
+    sqlite3_result_int(context, 2); 
+  } 
+  sqlite3_free(p1); 
+} 
+ 
+/* Forward declaration */ 
+static int geopolyOverlap(GeoPoly *p1, GeoPoly *p2); 
+ 
+/* 
+** SQL function:    geopoly_within(P1,P2) 
+** 
+** Return +2 if P1 and P2 are the same polygon 
+** Return +1 if P2 is contained within P1 
+** Return 0 if any part of P2 is on the outside of P1 
+** 
+*/ 
+static void geopolyWithinFunc( 
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  GeoPoly *p1 = geopolyFuncParam(context, argv[0], 0); 
+  GeoPoly *p2 = geopolyFuncParam(context, argv[1], 0); 
+  if( p1 && p2 ){ 
+    int x = geopolyOverlap(p1, p2); 
+    if( x<0 ){ 
+      sqlite3_result_error_nomem(context); 
+    }else{ 
+      sqlite3_result_int(context, x==2 ? 1 : x==4 ? 2 : 0); 
+    } 
+  } 
+  sqlite3_free(p1); 
+  sqlite3_free(p2); 
+} 
+ 
+/* Objects used by the overlap algorihm. */ 
+typedef struct GeoEvent GeoEvent; 
+typedef struct GeoSegment GeoSegment; 
+typedef struct GeoOverlap GeoOverlap; 
+struct GeoEvent { 
+  double x;              /* X coordinate at which event occurs */ 
+  int eType;             /* 0 for ADD, 1 for REMOVE */ 
+  GeoSegment *pSeg;      /* The segment to be added or removed */ 
+  GeoEvent *pNext;       /* Next event in the sorted list */ 
+}; 
+struct GeoSegment { 
+  double C, B;           /* y = C*x + B */ 
+  double y;              /* Current y value */ 
+  float y0;              /* Initial y value */ 
+  unsigned char side;    /* 1 for p1, 2 for p2 */ 
+  unsigned int idx;      /* Which segment within the side */ 
+  GeoSegment *pNext;     /* Next segment in a list sorted by y */ 
+}; 
+struct GeoOverlap { 
+  GeoEvent *aEvent;          /* Array of all events */ 
+  GeoSegment *aSegment;      /* Array of all segments */ 
+  int nEvent;                /* Number of events */ 
+  int nSegment;              /* Number of segments */ 
+}; 
+ 
+/* 
+** Add a single segment and its associated events. 
+*/ 
+static void geopolyAddOneSegment( 
+  GeoOverlap *p, 
+  GeoCoord x0, 
+  GeoCoord y0, 
+  GeoCoord x1, 
+  GeoCoord y1, 
+  unsigned char side, 
+  unsigned int idx 
+){ 
+  GeoSegment *pSeg; 
+  GeoEvent *pEvent; 
+  if( x0==x1 ) return;  /* Ignore vertical segments */ 
+  if( x0>x1 ){ 
+    GeoCoord t = x0; 
+    x0 = x1; 
+    x1 = t; 
+    t = y0; 
+    y0 = y1; 
+    y1 = t; 
+  } 
+  pSeg = p->aSegment + p->nSegment; 
+  p->nSegment++; 
+  pSeg->C = (y1-y0)/(x1-x0); 
+  pSeg->B = y1 - x1*pSeg->C; 
+  pSeg->y0 = y0; 
+  pSeg->side = side; 
+  pSeg->idx = idx; 
+  pEvent = p->aEvent + p->nEvent; 
+  p->nEvent++; 
+  pEvent->x = x0; 
+  pEvent->eType = 0; 
+  pEvent->pSeg = pSeg; 
+  pEvent = p->aEvent + p->nEvent; 
+  p->nEvent++; 
+  pEvent->x = x1; 
+  pEvent->eType = 1; 
+  pEvent->pSeg = pSeg; 
+} 
+ 
+ 
+
+/* 
+** Insert all segments and events for polygon pPoly. 
+*/ 
+static void geopolyAddSegments( 
+  GeoOverlap *p,          /* Add segments to this Overlap object */ 
+  GeoPoly *pPoly,         /* Take all segments from this polygon */ 
+  unsigned char side      /* The side of pPoly */ 
+){ 
+  unsigned int i; 
+  GeoCoord *x; 
+  for(i=0; i<(unsigned)pPoly->nVertex-1; i++){ 
+    x = &GeoX(pPoly,i); 
+    geopolyAddOneSegment(p, x[0], x[1], x[2], x[3], side, i); 
+  } 
+  x = &GeoX(pPoly,i); 
+  geopolyAddOneSegment(p, x[0], x[1], pPoly->a[0], pPoly->a[1], side, i); 
+} 
+ 
+/* 
+** Merge two lists of sorted events by X coordinate 
+*/ 
+static GeoEvent *geopolyEventMerge(GeoEvent *pLeft, GeoEvent *pRight){ 
+  GeoEvent head, *pLast; 
+  head.pNext = 0; 
+  pLast = &head; 
+  while( pRight && pLeft ){ 
+    if( pRight->x <= pLeft->x ){ 
+      pLast->pNext = pRight; 
+      pLast = pRight; 
+      pRight = pRight->pNext; 
+    }else{ 
+      pLast->pNext = pLeft; 
+      pLast = pLeft; 
+      pLeft = pLeft->pNext; 
+    } 
+  } 
+  pLast->pNext = pRight ? pRight : pLeft; 
   return head.pNext;
-}
-
-/*
-** Sort an array of nEvent event objects into a list.
-*/
-static GeoEvent *geopolySortEventsByX(GeoEvent *aEvent, int nEvent){
-  int mx = 0;
-  int i, j;
-  GeoEvent *p;
-  GeoEvent *a[50];
-  for(i=0; i<nEvent; i++){
-    p = &aEvent[i];
-    p->pNext = 0;
-    for(j=0; j<mx && a[j]; j++){
-      p = geopolyEventMerge(a[j], p);
-      a[j] = 0;
-    }
-    a[j] = p;
-    if( j>=mx ) mx = j+1;
-  }
-  p = 0;
-  for(i=0; i<mx; i++){
-    p = geopolyEventMerge(a[i], p);
-  }
-  return p;
-}
-
-/*
-** Merge two lists of sorted segments by Y, and then by C.
-*/
-static GeoSegment *geopolySegmentMerge(GeoSegment *pLeft, GeoSegment *pRight){
-  GeoSegment head, *pLast;
-  head.pNext = 0;
-  pLast = &head;
-  while( pRight && pLeft ){
-    double r = pRight->y - pLeft->y;
-    if( r==0.0 ) r = pRight->C - pLeft->C;
-    if( r<0.0 ){
-      pLast->pNext = pRight;
-      pLast = pRight;
-      pRight = pRight->pNext;
-    }else{
-      pLast->pNext = pLeft;
-      pLast = pLeft;
-      pLeft = pLeft->pNext;
-    }
-  }
-  pLast->pNext = pRight ? pRight : pLeft;
+} 
+ 
+/* 
+** Sort an array of nEvent event objects into a list. 
+*/ 
+static GeoEvent *geopolySortEventsByX(GeoEvent *aEvent, int nEvent){ 
+  int mx = 0; 
+  int i, j; 
+  GeoEvent *p; 
+  GeoEvent *a[50]; 
+  for(i=0; i<nEvent; i++){ 
+    p = &aEvent[i]; 
+    p->pNext = 0; 
+    for(j=0; j<mx && a[j]; j++){ 
+      p = geopolyEventMerge(a[j], p); 
+      a[j] = 0; 
+    } 
+    a[j] = p; 
+    if( j>=mx ) mx = j+1; 
+  } 
+  p = 0; 
+  for(i=0; i<mx; i++){ 
+    p = geopolyEventMerge(a[i], p); 
+  } 
+  return p; 
+} 
+ 
+/* 
+** Merge two lists of sorted segments by Y, and then by C. 
+*/ 
+static GeoSegment *geopolySegmentMerge(GeoSegment *pLeft, GeoSegment *pRight){ 
+  GeoSegment head, *pLast; 
+  head.pNext = 0; 
+  pLast = &head; 
+  while( pRight && pLeft ){ 
+    double r = pRight->y - pLeft->y; 
+    if( r==0.0 ) r = pRight->C - pLeft->C; 
+    if( r<0.0 ){ 
+      pLast->pNext = pRight; 
+      pLast = pRight; 
+      pRight = pRight->pNext; 
+    }else{ 
+      pLast->pNext = pLeft; 
+      pLast = pLeft; 
+      pLeft = pLeft->pNext; 
+    } 
+  } 
+  pLast->pNext = pRight ? pRight : pLeft; 
   return head.pNext;
-}
-
-/*
-** Sort a list of GeoSegments in order of increasing Y and in the event of
-** a tie, increasing C (slope).
-*/
-static GeoSegment *geopolySortSegmentsByYAndC(GeoSegment *pList){
-  int mx = 0;
-  int i;
-  GeoSegment *p;
-  GeoSegment *a[50];
-  while( pList ){
-    p = pList;
-    pList = pList->pNext;
-    p->pNext = 0;
-    for(i=0; i<mx && a[i]; i++){
-      p = geopolySegmentMerge(a[i], p);
-      a[i] = 0;
-    }
-    a[i] = p;
-    if( i>=mx ) mx = i+1;
-  }
-  p = 0;
-  for(i=0; i<mx; i++){
-    p = geopolySegmentMerge(a[i], p);
-  }
-  return p;
-}
-
-/*
-** Determine the overlap between two polygons
-*/
-static int geopolyOverlap(GeoPoly *p1, GeoPoly *p2){
-  sqlite3_int64 nVertex = p1->nVertex + p2->nVertex + 2;
-  GeoOverlap *p;
-  sqlite3_int64 nByte;
-  GeoEvent *pThisEvent;
-  double rX;
-  int rc = 0;
-  int needSort = 0;
-  GeoSegment *pActive = 0;
-  GeoSegment *pSeg;
-  unsigned char aOverlap[4];
-
+} 
+ 
+/* 
+** Sort a list of GeoSegments in order of increasing Y and in the event of 
+** a tie, increasing C (slope). 
+*/ 
+static GeoSegment *geopolySortSegmentsByYAndC(GeoSegment *pList){ 
+  int mx = 0; 
+  int i; 
+  GeoSegment *p; 
+  GeoSegment *a[50]; 
+  while( pList ){ 
+    p = pList; 
+    pList = pList->pNext; 
+    p->pNext = 0; 
+    for(i=0; i<mx && a[i]; i++){ 
+      p = geopolySegmentMerge(a[i], p); 
+      a[i] = 0; 
+    } 
+    a[i] = p; 
+    if( i>=mx ) mx = i+1; 
+  } 
+  p = 0; 
+  for(i=0; i<mx; i++){ 
+    p = geopolySegmentMerge(a[i], p); 
+  } 
+  return p; 
+} 
+ 
+/* 
+** Determine the overlap between two polygons 
+*/ 
+static int geopolyOverlap(GeoPoly *p1, GeoPoly *p2){ 
+  sqlite3_int64 nVertex = p1->nVertex + p2->nVertex + 2; 
+  GeoOverlap *p; 
+  sqlite3_int64 nByte; 
+  GeoEvent *pThisEvent; 
+  double rX; 
+  int rc = 0; 
+  int needSort = 0; 
+  GeoSegment *pActive = 0; 
+  GeoSegment *pSeg; 
+  unsigned char aOverlap[4]; 
+ 
   nByte = sizeof(GeoEvent)*nVertex*2
            + sizeof(GeoSegment)*nVertex
-           + sizeof(GeoOverlap);
-  p = sqlite3_malloc64( nByte );
-  if( p==0 ) return -1;
-  p->aEvent = (GeoEvent*)&p[1];
-  p->aSegment = (GeoSegment*)&p->aEvent[nVertex*2];
-  p->nEvent = p->nSegment = 0;
-  geopolyAddSegments(p, p1, 1);
-  geopolyAddSegments(p, p2, 2);
-  pThisEvent = geopolySortEventsByX(p->aEvent, p->nEvent);
+           + sizeof(GeoOverlap); 
+  p = sqlite3_malloc64( nByte ); 
+  if( p==0 ) return -1; 
+  p->aEvent = (GeoEvent*)&p[1]; 
+  p->aSegment = (GeoSegment*)&p->aEvent[nVertex*2]; 
+  p->nEvent = p->nSegment = 0; 
+  geopolyAddSegments(p, p1, 1); 
+  geopolyAddSegments(p, p2, 2); 
+  pThisEvent = geopolySortEventsByX(p->aEvent, p->nEvent); 
   rX = pThisEvent && pThisEvent->x==0.0 ? -1.0 : 0.0;
-  memset(aOverlap, 0, sizeof(aOverlap));
-  while( pThisEvent ){
-    if( pThisEvent->x!=rX ){
-      GeoSegment *pPrev = 0;
-      int iMask = 0;
-      GEODEBUG(("Distinct X: %g\n", pThisEvent->x));
-      rX = pThisEvent->x;
-      if( needSort ){
-        GEODEBUG(("SORT\n"));
-        pActive = geopolySortSegmentsByYAndC(pActive);
-        needSort = 0;
-      }
-      for(pSeg=pActive; pSeg; pSeg=pSeg->pNext){
-        if( pPrev ){
-          if( pPrev->y!=pSeg->y ){
-            GEODEBUG(("MASK: %d\n", iMask));
-            aOverlap[iMask] = 1;
-          }
-        }
-        iMask ^= pSeg->side;
-        pPrev = pSeg;
-      }
-      pPrev = 0;
-      for(pSeg=pActive; pSeg; pSeg=pSeg->pNext){
-        double y = pSeg->C*rX + pSeg->B;
-        GEODEBUG(("Segment %d.%d %g->%g\n", pSeg->side, pSeg->idx, pSeg->y, y));
-        pSeg->y = y;
-        if( pPrev ){
-          if( pPrev->y>pSeg->y && pPrev->side!=pSeg->side ){
-            rc = 1;
-            GEODEBUG(("Crossing: %d.%d and %d.%d\n",
-                    pPrev->side, pPrev->idx,
-                    pSeg->side, pSeg->idx));
-            goto geopolyOverlapDone;
-          }else if( pPrev->y!=pSeg->y ){
-            GEODEBUG(("MASK: %d\n", iMask));
-            aOverlap[iMask] = 1;
-          }
-        }
-        iMask ^= pSeg->side;
-        pPrev = pSeg;
-      }
-    }
-    GEODEBUG(("%s %d.%d C=%g B=%g\n",
-      pThisEvent->eType ? "RM " : "ADD",
-      pThisEvent->pSeg->side, pThisEvent->pSeg->idx,
-      pThisEvent->pSeg->C,
-      pThisEvent->pSeg->B));
-    if( pThisEvent->eType==0 ){
-      /* Add a segment */
-      pSeg = pThisEvent->pSeg;
-      pSeg->y = pSeg->y0;
-      pSeg->pNext = pActive;
-      pActive = pSeg;
-      needSort = 1;
-    }else{
-      /* Remove a segment */
-      if( pActive==pThisEvent->pSeg ){
+  memset(aOverlap, 0, sizeof(aOverlap)); 
+  while( pThisEvent ){ 
+    if( pThisEvent->x!=rX ){ 
+      GeoSegment *pPrev = 0; 
+      int iMask = 0; 
+      GEODEBUG(("Distinct X: %g\n", pThisEvent->x)); 
+      rX = pThisEvent->x; 
+      if( needSort ){ 
+        GEODEBUG(("SORT\n")); 
+        pActive = geopolySortSegmentsByYAndC(pActive); 
+        needSort = 0; 
+      } 
+      for(pSeg=pActive; pSeg; pSeg=pSeg->pNext){ 
+        if( pPrev ){ 
+          if( pPrev->y!=pSeg->y ){ 
+            GEODEBUG(("MASK: %d\n", iMask)); 
+            aOverlap[iMask] = 1; 
+          } 
+        } 
+        iMask ^= pSeg->side; 
+        pPrev = pSeg; 
+      } 
+      pPrev = 0; 
+      for(pSeg=pActive; pSeg; pSeg=pSeg->pNext){ 
+        double y = pSeg->C*rX + pSeg->B; 
+        GEODEBUG(("Segment %d.%d %g->%g\n", pSeg->side, pSeg->idx, pSeg->y, y)); 
+        pSeg->y = y; 
+        if( pPrev ){ 
+          if( pPrev->y>pSeg->y && pPrev->side!=pSeg->side ){ 
+            rc = 1; 
+            GEODEBUG(("Crossing: %d.%d and %d.%d\n", 
+                    pPrev->side, pPrev->idx, 
+                    pSeg->side, pSeg->idx)); 
+            goto geopolyOverlapDone; 
+          }else if( pPrev->y!=pSeg->y ){ 
+            GEODEBUG(("MASK: %d\n", iMask)); 
+            aOverlap[iMask] = 1; 
+          } 
+        } 
+        iMask ^= pSeg->side; 
+        pPrev = pSeg; 
+      } 
+    } 
+    GEODEBUG(("%s %d.%d C=%g B=%g\n", 
+      pThisEvent->eType ? "RM " : "ADD", 
+      pThisEvent->pSeg->side, pThisEvent->pSeg->idx, 
+      pThisEvent->pSeg->C, 
+      pThisEvent->pSeg->B)); 
+    if( pThisEvent->eType==0 ){ 
+      /* Add a segment */ 
+      pSeg = pThisEvent->pSeg; 
+      pSeg->y = pSeg->y0; 
+      pSeg->pNext = pActive; 
+      pActive = pSeg; 
+      needSort = 1; 
+    }else{ 
+      /* Remove a segment */ 
+      if( pActive==pThisEvent->pSeg ){ 
         pActive = ALWAYS(pActive) ? pActive->pNext : 0;
-      }else{
-        for(pSeg=pActive; pSeg; pSeg=pSeg->pNext){
-          if( pSeg->pNext==pThisEvent->pSeg ){
+      }else{ 
+        for(pSeg=pActive; pSeg; pSeg=pSeg->pNext){ 
+          if( pSeg->pNext==pThisEvent->pSeg ){ 
             pSeg->pNext = ALWAYS(pSeg->pNext) ? pSeg->pNext->pNext : 0;
-            break;
-          }
-        }
-      }
-    }
-    pThisEvent = pThisEvent->pNext;
-  }
-  if( aOverlap[3]==0 ){
-    rc = 0;
-  }else if( aOverlap[1]!=0 && aOverlap[2]==0 ){
-    rc = 3;
-  }else if( aOverlap[1]==0 && aOverlap[2]!=0 ){
-    rc = 2;
-  }else if( aOverlap[1]==0 && aOverlap[2]==0 ){
-    rc = 4;
-  }else{
-    rc = 1;
-  }
-
-geopolyOverlapDone:
-  sqlite3_free(p);
-  return rc;
-}
-
-/*
-** SQL function:    geopoly_overlap(P1,P2)
-**
-** Determine whether or not P1 and P2 overlap. Return value:
-**
-**   0     The two polygons are disjoint
-**   1     They overlap
-**   2     P1 is completely contained within P2
-**   3     P2 is completely contained within P1
-**   4     P1 and P2 are the same polygon
-**   NULL  Either P1 or P2 or both are not valid polygons
-*/
-static void geopolyOverlapFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  GeoPoly *p1 = geopolyFuncParam(context, argv[0], 0);
-  GeoPoly *p2 = geopolyFuncParam(context, argv[1], 0);
-  if( p1 && p2 ){
-    int x = geopolyOverlap(p1, p2);
-    if( x<0 ){
-      sqlite3_result_error_nomem(context);
-    }else{
-      sqlite3_result_int(context, x);
-    }
-  }
-  sqlite3_free(p1);
-  sqlite3_free(p2);
-}
-
-/*
-** Enable or disable debugging output
-*/
-static void geopolyDebugFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-#ifdef GEOPOLY_ENABLE_DEBUG
-  geo_debug = sqlite3_value_int(argv[0]);
-#endif
-}
-
-/*
-** This function is the implementation of both the xConnect and xCreate
-** methods of the geopoly virtual table.
-**
-**   argv[0]   -> module name
-**   argv[1]   -> database name
-**   argv[2]   -> table name
-**   argv[...] -> column names...
-*/
-static int geopolyInit(
-  sqlite3 *db,                        /* Database connection */
-  void *pAux,                         /* One of the RTREE_COORD_* constants */
-  int argc, const char *const*argv,   /* Parameters to CREATE TABLE statement */
-  sqlite3_vtab **ppVtab,              /* OUT: New virtual table */
-  char **pzErr,                       /* OUT: Error message, if any */
-  int isCreate                        /* True for xCreate, false for xConnect */
-){
-  int rc = SQLITE_OK;
-  Rtree *pRtree;
-  sqlite3_int64 nDb;              /* Length of string argv[1] */
-  sqlite3_int64 nName;            /* Length of string argv[2] */
-  sqlite3_str *pSql;
-  char *zSql;
-  int ii;
-
-  sqlite3_vtab_config(db, SQLITE_VTAB_CONSTRAINT_SUPPORT, 1);
-
-  /* Allocate the sqlite3_vtab structure */
-  nDb = strlen(argv[1]);
-  nName = strlen(argv[2]);
-  pRtree = (Rtree *)sqlite3_malloc64(sizeof(Rtree)+nDb+nName+2);
-  if( !pRtree ){
-    return SQLITE_NOMEM;
-  }
-  memset(pRtree, 0, sizeof(Rtree)+nDb+nName+2);
-  pRtree->nBusy = 1;
-  pRtree->base.pModule = &rtreeModule;
-  pRtree->zDb = (char *)&pRtree[1];
-  pRtree->zName = &pRtree->zDb[nDb+1];
-  pRtree->eCoordType = RTREE_COORD_REAL32;
-  pRtree->nDim = 2;
-  pRtree->nDim2 = 4;
-  memcpy(pRtree->zDb, argv[1], nDb);
-  memcpy(pRtree->zName, argv[2], nName);
-
-
-  /* Create/Connect to the underlying relational database schema. If
-  ** that is successful, call sqlite3_declare_vtab() to configure
-  ** the r-tree table schema.
-  */
-  pSql = sqlite3_str_new(db);
-  sqlite3_str_appendf(pSql, "CREATE TABLE x(_shape");
-  pRtree->nAux = 1;         /* Add one for _shape */
-  pRtree->nAuxNotNull = 1;  /* The _shape column is always not-null */
-  for(ii=3; ii<argc; ii++){
-    pRtree->nAux++;
-    sqlite3_str_appendf(pSql, ",%s", argv[ii]);
-  }
-  sqlite3_str_appendf(pSql, ");");
-  zSql = sqlite3_str_finish(pSql);
-  if( !zSql ){
-    rc = SQLITE_NOMEM;
-  }else if( SQLITE_OK!=(rc = sqlite3_declare_vtab(db, zSql)) ){
-    *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
-  }
-  sqlite3_free(zSql);
-  if( rc ) goto geopolyInit_fail;
-  pRtree->nBytesPerCell = 8 + pRtree->nDim2*4;
-
-  /* Figure out the node size to use. */
-  rc = getNodeSize(db, pRtree, isCreate, pzErr);
-  if( rc ) goto geopolyInit_fail;
-  rc = rtreeSqlInit(pRtree, db, argv[1], argv[2], isCreate);
-  if( rc ){
-    *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
-    goto geopolyInit_fail;
-  }
-
-  *ppVtab = (sqlite3_vtab *)pRtree;
-  return SQLITE_OK;
-
-geopolyInit_fail:
-  if( rc==SQLITE_OK ) rc = SQLITE_ERROR;
-  assert( *ppVtab==0 );
-  assert( pRtree->nBusy==1 );
-  rtreeRelease(pRtree);
-  return rc;
-}
-
-
-/*
-** GEOPOLY virtual table module xCreate method.
-*/
-static int geopolyCreate(
-  sqlite3 *db,
-  void *pAux,
-  int argc, const char *const*argv,
-  sqlite3_vtab **ppVtab,
-  char **pzErr
-){
-  return geopolyInit(db, pAux, argc, argv, ppVtab, pzErr, 1);
-}
-
-/*
-** GEOPOLY virtual table module xConnect method.
-*/
-static int geopolyConnect(
-  sqlite3 *db,
-  void *pAux,
-  int argc, const char *const*argv,
-  sqlite3_vtab **ppVtab,
-  char **pzErr
-){
-  return geopolyInit(db, pAux, argc, argv, ppVtab, pzErr, 0);
-}
-
-
-/*
-** GEOPOLY virtual table module xFilter method.
-**
-** Query plans:
-**
-**      1         rowid lookup
-**      2         search for objects overlapping the same bounding box
-**                that contains polygon argv[0]
-**      3         search for objects overlapping the same bounding box
-**                that contains polygon argv[0]
-**      4         full table scan
-*/
-static int geopolyFilter(
-  sqlite3_vtab_cursor *pVtabCursor,     /* The cursor to initialize */
-  int idxNum,                           /* Query plan */
-  const char *idxStr,                   /* Not Used */
-  int argc, sqlite3_value **argv        /* Parameters to the query plan */
-){
-  Rtree *pRtree = (Rtree *)pVtabCursor->pVtab;
-  RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor;
-  RtreeNode *pRoot = 0;
-  int rc = SQLITE_OK;
-  int iCell = 0;
-
-  rtreeReference(pRtree);
-
-  /* Reset the cursor to the same state as rtreeOpen() leaves it in. */
+            break; 
+          } 
+        } 
+      } 
+    } 
+    pThisEvent = pThisEvent->pNext; 
+  } 
+  if( aOverlap[3]==0 ){ 
+    rc = 0; 
+  }else if( aOverlap[1]!=0 && aOverlap[2]==0 ){ 
+    rc = 3; 
+  }else if( aOverlap[1]==0 && aOverlap[2]!=0 ){ 
+    rc = 2; 
+  }else if( aOverlap[1]==0 && aOverlap[2]==0 ){ 
+    rc = 4; 
+  }else{ 
+    rc = 1; 
+  } 
+ 
+geopolyOverlapDone: 
+  sqlite3_free(p); 
+  return rc; 
+} 
+ 
+/* 
+** SQL function:    geopoly_overlap(P1,P2) 
+** 
+** Determine whether or not P1 and P2 overlap. Return value: 
+** 
+**   0     The two polygons are disjoint 
+**   1     They overlap 
+**   2     P1 is completely contained within P2 
+**   3     P2 is completely contained within P1 
+**   4     P1 and P2 are the same polygon 
+**   NULL  Either P1 or P2 or both are not valid polygons 
+*/ 
+static void geopolyOverlapFunc( 
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+  GeoPoly *p1 = geopolyFuncParam(context, argv[0], 0); 
+  GeoPoly *p2 = geopolyFuncParam(context, argv[1], 0); 
+  if( p1 && p2 ){ 
+    int x = geopolyOverlap(p1, p2); 
+    if( x<0 ){ 
+      sqlite3_result_error_nomem(context); 
+    }else{ 
+      sqlite3_result_int(context, x); 
+    } 
+  } 
+  sqlite3_free(p1); 
+  sqlite3_free(p2); 
+} 
+ 
+/* 
+** Enable or disable debugging output 
+*/ 
+static void geopolyDebugFunc( 
+  sqlite3_context *context, 
+  int argc, 
+  sqlite3_value **argv 
+){ 
+#ifdef GEOPOLY_ENABLE_DEBUG 
+  geo_debug = sqlite3_value_int(argv[0]); 
+#endif 
+} 
+ 
+/*
+** This function is the implementation of both the xConnect and xCreate 
+** methods of the geopoly virtual table. 
+** 
+**   argv[0]   -> module name 
+**   argv[1]   -> database name 
+**   argv[2]   -> table name 
+**   argv[...] -> column names... 
+*/ 
+static int geopolyInit( 
+  sqlite3 *db,                        /* Database connection */ 
+  void *pAux,                         /* One of the RTREE_COORD_* constants */ 
+  int argc, const char *const*argv,   /* Parameters to CREATE TABLE statement */ 
+  sqlite3_vtab **ppVtab,              /* OUT: New virtual table */ 
+  char **pzErr,                       /* OUT: Error message, if any */ 
+  int isCreate                        /* True for xCreate, false for xConnect */ 
+){ 
+  int rc = SQLITE_OK; 
+  Rtree *pRtree; 
+  sqlite3_int64 nDb;              /* Length of string argv[1] */ 
+  sqlite3_int64 nName;            /* Length of string argv[2] */ 
+  sqlite3_str *pSql; 
+  char *zSql; 
+  int ii; 
+ 
+  sqlite3_vtab_config(db, SQLITE_VTAB_CONSTRAINT_SUPPORT, 1); 
+ 
+  /* Allocate the sqlite3_vtab structure */ 
+  nDb = strlen(argv[1]); 
+  nName = strlen(argv[2]); 
+  pRtree = (Rtree *)sqlite3_malloc64(sizeof(Rtree)+nDb+nName+2); 
+  if( !pRtree ){ 
+    return SQLITE_NOMEM; 
+  } 
+  memset(pRtree, 0, sizeof(Rtree)+nDb+nName+2); 
+  pRtree->nBusy = 1; 
+  pRtree->base.pModule = &rtreeModule; 
+  pRtree->zDb = (char *)&pRtree[1]; 
+  pRtree->zName = &pRtree->zDb[nDb+1]; 
+  pRtree->eCoordType = RTREE_COORD_REAL32; 
+  pRtree->nDim = 2; 
+  pRtree->nDim2 = 4; 
+  memcpy(pRtree->zDb, argv[1], nDb); 
+  memcpy(pRtree->zName, argv[2], nName); 
+ 
+ 
+  /* Create/Connect to the underlying relational database schema. If 
+  ** that is successful, call sqlite3_declare_vtab() to configure 
+  ** the r-tree table schema. 
+  */ 
+  pSql = sqlite3_str_new(db); 
+  sqlite3_str_appendf(pSql, "CREATE TABLE x(_shape"); 
+  pRtree->nAux = 1;         /* Add one for _shape */ 
+  pRtree->nAuxNotNull = 1;  /* The _shape column is always not-null */ 
+  for(ii=3; ii<argc; ii++){ 
+    pRtree->nAux++; 
+    sqlite3_str_appendf(pSql, ",%s", argv[ii]); 
+  } 
+  sqlite3_str_appendf(pSql, ");"); 
+  zSql = sqlite3_str_finish(pSql); 
+  if( !zSql ){ 
+    rc = SQLITE_NOMEM; 
+  }else if( SQLITE_OK!=(rc = sqlite3_declare_vtab(db, zSql)) ){ 
+    *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); 
+  } 
+  sqlite3_free(zSql); 
+  if( rc ) goto geopolyInit_fail; 
+  pRtree->nBytesPerCell = 8 + pRtree->nDim2*4; 
+ 
+  /* Figure out the node size to use. */ 
+  rc = getNodeSize(db, pRtree, isCreate, pzErr); 
+  if( rc ) goto geopolyInit_fail; 
+  rc = rtreeSqlInit(pRtree, db, argv[1], argv[2], isCreate); 
+  if( rc ){ 
+    *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db)); 
+    goto geopolyInit_fail; 
+  } 
+ 
+  *ppVtab = (sqlite3_vtab *)pRtree; 
+  return SQLITE_OK; 
+ 
+geopolyInit_fail: 
+  if( rc==SQLITE_OK ) rc = SQLITE_ERROR; 
+  assert( *ppVtab==0 ); 
+  assert( pRtree->nBusy==1 ); 
+  rtreeRelease(pRtree); 
+  return rc; 
+} 
+ 
+ 
+/*
+** GEOPOLY virtual table module xCreate method. 
+*/ 
+static int geopolyCreate( 
+  sqlite3 *db, 
+  void *pAux, 
+  int argc, const char *const*argv, 
+  sqlite3_vtab **ppVtab, 
+  char **pzErr 
+){ 
+  return geopolyInit(db, pAux, argc, argv, ppVtab, pzErr, 1); 
+} 
+ 
+/*
+** GEOPOLY virtual table module xConnect method. 
+*/ 
+static int geopolyConnect( 
+  sqlite3 *db, 
+  void *pAux, 
+  int argc, const char *const*argv, 
+  sqlite3_vtab **ppVtab, 
+  char **pzErr 
+){ 
+  return geopolyInit(db, pAux, argc, argv, ppVtab, pzErr, 0); 
+} 
+ 
+ 
+/*
+** GEOPOLY virtual table module xFilter method. 
+** 
+** Query plans: 
+** 
+**      1         rowid lookup 
+**      2         search for objects overlapping the same bounding box 
+**                that contains polygon argv[0] 
+**      3         search for objects overlapping the same bounding box 
+**                that contains polygon argv[0] 
+**      4         full table scan 
+*/ 
+static int geopolyFilter( 
+  sqlite3_vtab_cursor *pVtabCursor,     /* The cursor to initialize */ 
+  int idxNum,                           /* Query plan */ 
+  const char *idxStr,                   /* Not Used */ 
+  int argc, sqlite3_value **argv        /* Parameters to the query plan */ 
+){ 
+  Rtree *pRtree = (Rtree *)pVtabCursor->pVtab; 
+  RtreeCursor *pCsr = (RtreeCursor *)pVtabCursor; 
+  RtreeNode *pRoot = 0; 
+  int rc = SQLITE_OK; 
+  int iCell = 0; 
+ 
+  rtreeReference(pRtree); 
+ 
+  /* Reset the cursor to the same state as rtreeOpen() leaves it in. */ 
   resetCursor(pCsr);
-
-  pCsr->iStrategy = idxNum;
-  if( idxNum==1 ){
-    /* Special case - lookup by rowid. */
-    RtreeNode *pLeaf;        /* Leaf on which the required cell resides */
-    RtreeSearchPoint *p;     /* Search point for the leaf */
-    i64 iRowid = sqlite3_value_int64(argv[0]);
-    i64 iNode = 0;
-    rc = findLeafNode(pRtree, iRowid, &pLeaf, &iNode);
-    if( rc==SQLITE_OK && pLeaf!=0 ){
-      p = rtreeSearchPointNew(pCsr, RTREE_ZERO, 0);
-      assert( p!=0 );  /* Always returns pCsr->sPoint */
-      pCsr->aNode[0] = pLeaf;
-      p->id = iNode;
-      p->eWithin = PARTLY_WITHIN;
-      rc = nodeRowidIndex(pRtree, pLeaf, iRowid, &iCell);
-      p->iCell = (u8)iCell;
-      RTREE_QUEUE_TRACE(pCsr, "PUSH-F1:");
-    }else{
-      pCsr->atEOF = 1;
-    }
-  }else{
+ 
+  pCsr->iStrategy = idxNum; 
+  if( idxNum==1 ){ 
+    /* Special case - lookup by rowid. */ 
+    RtreeNode *pLeaf;        /* Leaf on which the required cell resides */ 
+    RtreeSearchPoint *p;     /* Search point for the leaf */ 
+    i64 iRowid = sqlite3_value_int64(argv[0]); 
+    i64 iNode = 0; 
+    rc = findLeafNode(pRtree, iRowid, &pLeaf, &iNode); 
+    if( rc==SQLITE_OK && pLeaf!=0 ){ 
+      p = rtreeSearchPointNew(pCsr, RTREE_ZERO, 0); 
+      assert( p!=0 );  /* Always returns pCsr->sPoint */ 
+      pCsr->aNode[0] = pLeaf; 
+      p->id = iNode; 
+      p->eWithin = PARTLY_WITHIN; 
+      rc = nodeRowidIndex(pRtree, pLeaf, iRowid, &iCell); 
+      p->iCell = (u8)iCell; 
+      RTREE_QUEUE_TRACE(pCsr, "PUSH-F1:"); 
+    }else{ 
+      pCsr->atEOF = 1; 
+    } 
+  }else{ 
     /* Normal case - r-tree scan. Set up the RtreeCursor.aConstraint array
     ** with the configured constraints.
-    */
-    rc = nodeAcquire(pRtree, 1, 0, &pRoot);
-    if( rc==SQLITE_OK && idxNum<=3 ){
-      RtreeCoord bbox[4];
-      RtreeConstraint *p;
-      assert( argc==1 );
+    */ 
+    rc = nodeAcquire(pRtree, 1, 0, &pRoot); 
+    if( rc==SQLITE_OK && idxNum<=3 ){ 
+      RtreeCoord bbox[4]; 
+      RtreeConstraint *p; 
+      assert( argc==1 ); 
       assert( argv[0]!=0 );
-      geopolyBBox(0, argv[0], bbox, &rc);
-      if( rc ){
-        goto geopoly_filter_end;
-      }
-      pCsr->aConstraint = p = sqlite3_malloc(sizeof(RtreeConstraint)*4);
-      pCsr->nConstraint = 4;
-      if( p==0 ){
-        rc = SQLITE_NOMEM;
-      }else{
-        memset(pCsr->aConstraint, 0, sizeof(RtreeConstraint)*4);
-        memset(pCsr->anQueue, 0, sizeof(u32)*(pRtree->iDepth + 1));
-        if( idxNum==2 ){
-          /* Overlap query */
-          p->op = 'B';
-          p->iCoord = 0;
-          p->u.rValue = bbox[1].f;
-          p++;
-          p->op = 'D';
-          p->iCoord = 1;
-          p->u.rValue = bbox[0].f;
-          p++;
-          p->op = 'B';
-          p->iCoord = 2;
-          p->u.rValue = bbox[3].f;
-          p++;
-          p->op = 'D';
-          p->iCoord = 3;
-          p->u.rValue = bbox[2].f;
-        }else{
-          /* Within query */
-          p->op = 'D';
-          p->iCoord = 0;
-          p->u.rValue = bbox[0].f;
-          p++;
-          p->op = 'B';
-          p->iCoord = 1;
-          p->u.rValue = bbox[1].f;
-          p++;
-          p->op = 'D';
-          p->iCoord = 2;
-          p->u.rValue = bbox[2].f;
-          p++;
-          p->op = 'B';
-          p->iCoord = 3;
-          p->u.rValue = bbox[3].f;
-        }
-      }
-    }
-    if( rc==SQLITE_OK ){
-      RtreeSearchPoint *pNew;
-      pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1));
-      if( pNew==0 ){
-        rc = SQLITE_NOMEM;
-        goto geopoly_filter_end;
-      }
-      pNew->id = 1;
-      pNew->iCell = 0;
-      pNew->eWithin = PARTLY_WITHIN;
-      assert( pCsr->bPoint==1 );
-      pCsr->aNode[0] = pRoot;
-      pRoot = 0;
-      RTREE_QUEUE_TRACE(pCsr, "PUSH-Fm:");
-      rc = rtreeStepToLeaf(pCsr);
-    }
-  }
-
-geopoly_filter_end:
-  nodeRelease(pRtree, pRoot);
-  rtreeRelease(pRtree);
-  return rc;
-}
-
-/*
-** Rtree virtual table module xBestIndex method. There are three
+      geopolyBBox(0, argv[0], bbox, &rc); 
+      if( rc ){ 
+        goto geopoly_filter_end; 
+      } 
+      pCsr->aConstraint = p = sqlite3_malloc(sizeof(RtreeConstraint)*4); 
+      pCsr->nConstraint = 4; 
+      if( p==0 ){ 
+        rc = SQLITE_NOMEM; 
+      }else{ 
+        memset(pCsr->aConstraint, 0, sizeof(RtreeConstraint)*4); 
+        memset(pCsr->anQueue, 0, sizeof(u32)*(pRtree->iDepth + 1)); 
+        if( idxNum==2 ){ 
+          /* Overlap query */ 
+          p->op = 'B'; 
+          p->iCoord = 0; 
+          p->u.rValue = bbox[1].f; 
+          p++; 
+          p->op = 'D'; 
+          p->iCoord = 1; 
+          p->u.rValue = bbox[0].f; 
+          p++; 
+          p->op = 'B'; 
+          p->iCoord = 2; 
+          p->u.rValue = bbox[3].f; 
+          p++; 
+          p->op = 'D'; 
+          p->iCoord = 3; 
+          p->u.rValue = bbox[2].f; 
+        }else{ 
+          /* Within query */ 
+          p->op = 'D'; 
+          p->iCoord = 0; 
+          p->u.rValue = bbox[0].f; 
+          p++; 
+          p->op = 'B'; 
+          p->iCoord = 1; 
+          p->u.rValue = bbox[1].f; 
+          p++; 
+          p->op = 'D'; 
+          p->iCoord = 2; 
+          p->u.rValue = bbox[2].f; 
+          p++; 
+          p->op = 'B'; 
+          p->iCoord = 3; 
+          p->u.rValue = bbox[3].f; 
+        } 
+      } 
+    } 
+    if( rc==SQLITE_OK ){ 
+      RtreeSearchPoint *pNew; 
+      pNew = rtreeSearchPointNew(pCsr, RTREE_ZERO, (u8)(pRtree->iDepth+1)); 
+      if( pNew==0 ){ 
+        rc = SQLITE_NOMEM; 
+        goto geopoly_filter_end; 
+      } 
+      pNew->id = 1; 
+      pNew->iCell = 0; 
+      pNew->eWithin = PARTLY_WITHIN; 
+      assert( pCsr->bPoint==1 ); 
+      pCsr->aNode[0] = pRoot; 
+      pRoot = 0; 
+      RTREE_QUEUE_TRACE(pCsr, "PUSH-Fm:"); 
+      rc = rtreeStepToLeaf(pCsr); 
+    } 
+  } 
+ 
+geopoly_filter_end: 
+  nodeRelease(pRtree, pRoot); 
+  rtreeRelease(pRtree); 
+  return rc; 
+} 
+ 
+/* 
+** Rtree virtual table module xBestIndex method. There are three 
 ** table scan strategies to choose from (in order from most to
-** least desirable):
-**
-**   idxNum     idxStr        Strategy
-**   ------------------------------------------------
-**     1        "rowid"       Direct lookup by rowid.
-**     2        "rtree"       R-tree overlap query using geopoly_overlap()
-**     3        "rtree"       R-tree within query using geopoly_within()
-**     4        "fullscan"    full-table scan.
-**   ------------------------------------------------
-*/
-static int geopolyBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
-  int ii;
-  int iRowidTerm = -1;
-  int iFuncTerm = -1;
-  int idxNum = 0;
-
-  for(ii=0; ii<pIdxInfo->nConstraint; ii++){
-    struct sqlite3_index_constraint *p = &pIdxInfo->aConstraint[ii];
-    if( !p->usable ) continue;
-    if( p->iColumn<0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ  ){
-      iRowidTerm = ii;
-      break;
-    }
-    if( p->iColumn==0 && p->op>=SQLITE_INDEX_CONSTRAINT_FUNCTION ){
-      /* p->op==SQLITE_INDEX_CONSTRAINT_FUNCTION for geopoly_overlap()
-      ** p->op==(SQLITE_INDEX_CONTRAINT_FUNCTION+1) for geopoly_within().
-      ** See geopolyFindFunction() */
-      iFuncTerm = ii;
-      idxNum = p->op - SQLITE_INDEX_CONSTRAINT_FUNCTION + 2;
-    }
-  }
-
-  if( iRowidTerm>=0 ){
-    pIdxInfo->idxNum = 1;
-    pIdxInfo->idxStr = "rowid";
-    pIdxInfo->aConstraintUsage[iRowidTerm].argvIndex = 1;
-    pIdxInfo->aConstraintUsage[iRowidTerm].omit = 1;
-    pIdxInfo->estimatedCost = 30.0;
-    pIdxInfo->estimatedRows = 1;
-    pIdxInfo->idxFlags = SQLITE_INDEX_SCAN_UNIQUE;
-    return SQLITE_OK;
-  }
-  if( iFuncTerm>=0 ){
-    pIdxInfo->idxNum = idxNum;
-    pIdxInfo->idxStr = "rtree";
-    pIdxInfo->aConstraintUsage[iFuncTerm].argvIndex = 1;
-    pIdxInfo->aConstraintUsage[iFuncTerm].omit = 0;
-    pIdxInfo->estimatedCost = 300.0;
-    pIdxInfo->estimatedRows = 10;
-    return SQLITE_OK;
-  }
-  pIdxInfo->idxNum = 4;
-  pIdxInfo->idxStr = "fullscan";
-  pIdxInfo->estimatedCost = 3000000.0;
-  pIdxInfo->estimatedRows = 100000;
-  return SQLITE_OK;
-}
-
-
-/*
-** GEOPOLY virtual table module xColumn method.
-*/
-static int geopolyColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
-  Rtree *pRtree = (Rtree *)cur->pVtab;
-  RtreeCursor *pCsr = (RtreeCursor *)cur;
-  RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr);
-  int rc = SQLITE_OK;
-  RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc);
-
-  if( rc ) return rc;
-  if( p==0 ) return SQLITE_OK;
-  if( i==0 && sqlite3_vtab_nochange(ctx) ) return SQLITE_OK;
-  if( i<=pRtree->nAux ){
-    if( !pCsr->bAuxValid ){
-      if( pCsr->pReadAux==0 ){
-        rc = sqlite3_prepare_v3(pRtree->db, pRtree->zReadAuxSql, -1, 0,
-                                &pCsr->pReadAux, 0);
-        if( rc ) return rc;
-      }
+** least desirable): 
+** 
+**   idxNum     idxStr        Strategy 
+**   ------------------------------------------------ 
+**     1        "rowid"       Direct lookup by rowid. 
+**     2        "rtree"       R-tree overlap query using geopoly_overlap() 
+**     3        "rtree"       R-tree within query using geopoly_within() 
+**     4        "fullscan"    full-table scan. 
+**   ------------------------------------------------ 
+*/ 
+static int geopolyBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){ 
+  int ii; 
+  int iRowidTerm = -1; 
+  int iFuncTerm = -1; 
+  int idxNum = 0; 
+ 
+  for(ii=0; ii<pIdxInfo->nConstraint; ii++){ 
+    struct sqlite3_index_constraint *p = &pIdxInfo->aConstraint[ii]; 
+    if( !p->usable ) continue; 
+    if( p->iColumn<0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ  ){ 
+      iRowidTerm = ii; 
+      break; 
+    } 
+    if( p->iColumn==0 && p->op>=SQLITE_INDEX_CONSTRAINT_FUNCTION ){ 
+      /* p->op==SQLITE_INDEX_CONSTRAINT_FUNCTION for geopoly_overlap() 
+      ** p->op==(SQLITE_INDEX_CONTRAINT_FUNCTION+1) for geopoly_within(). 
+      ** See geopolyFindFunction() */ 
+      iFuncTerm = ii; 
+      idxNum = p->op - SQLITE_INDEX_CONSTRAINT_FUNCTION + 2; 
+    } 
+  } 
+ 
+  if( iRowidTerm>=0 ){ 
+    pIdxInfo->idxNum = 1; 
+    pIdxInfo->idxStr = "rowid"; 
+    pIdxInfo->aConstraintUsage[iRowidTerm].argvIndex = 1; 
+    pIdxInfo->aConstraintUsage[iRowidTerm].omit = 1; 
+    pIdxInfo->estimatedCost = 30.0; 
+    pIdxInfo->estimatedRows = 1; 
+    pIdxInfo->idxFlags = SQLITE_INDEX_SCAN_UNIQUE; 
+    return SQLITE_OK; 
+  } 
+  if( iFuncTerm>=0 ){ 
+    pIdxInfo->idxNum = idxNum; 
+    pIdxInfo->idxStr = "rtree"; 
+    pIdxInfo->aConstraintUsage[iFuncTerm].argvIndex = 1; 
+    pIdxInfo->aConstraintUsage[iFuncTerm].omit = 0; 
+    pIdxInfo->estimatedCost = 300.0; 
+    pIdxInfo->estimatedRows = 10; 
+    return SQLITE_OK; 
+  } 
+  pIdxInfo->idxNum = 4; 
+  pIdxInfo->idxStr = "fullscan"; 
+  pIdxInfo->estimatedCost = 3000000.0; 
+  pIdxInfo->estimatedRows = 100000; 
+  return SQLITE_OK; 
+} 
+ 
+ 
+/*
+** GEOPOLY virtual table module xColumn method. 
+*/ 
+static int geopolyColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){ 
+  Rtree *pRtree = (Rtree *)cur->pVtab; 
+  RtreeCursor *pCsr = (RtreeCursor *)cur; 
+  RtreeSearchPoint *p = rtreeSearchPointFirst(pCsr); 
+  int rc = SQLITE_OK; 
+  RtreeNode *pNode = rtreeNodeOfFirstSearchPoint(pCsr, &rc); 
+ 
+  if( rc ) return rc; 
+  if( p==0 ) return SQLITE_OK; 
+  if( i==0 && sqlite3_vtab_nochange(ctx) ) return SQLITE_OK; 
+  if( i<=pRtree->nAux ){ 
+    if( !pCsr->bAuxValid ){ 
+      if( pCsr->pReadAux==0 ){ 
+        rc = sqlite3_prepare_v3(pRtree->db, pRtree->zReadAuxSql, -1, 0, 
+                                &pCsr->pReadAux, 0); 
+        if( rc ) return rc; 
+      } 
       sqlite3_bind_int64(pCsr->pReadAux, 1,
-          nodeGetRowid(pRtree, pNode, p->iCell));
-      rc = sqlite3_step(pCsr->pReadAux);
-      if( rc==SQLITE_ROW ){
-        pCsr->bAuxValid = 1;
-      }else{
-        sqlite3_reset(pCsr->pReadAux);
-        if( rc==SQLITE_DONE ) rc = SQLITE_OK;
-        return rc;
-      }
-    }
-    sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pReadAux, i+2));
-  }
-  return SQLITE_OK;
-}
-
-
-/*
-** The xUpdate method for GEOPOLY module virtual tables.
-**
-** For DELETE:
-**
-**     argv[0] = the rowid to be deleted
-**
-** For INSERT:
-**
-**     argv[0] = SQL NULL
-**     argv[1] = rowid to insert, or an SQL NULL to select automatically
-**     argv[2] = _shape column
-**     argv[3] = first application-defined column....
-**
-** For UPDATE:
-**
-**     argv[0] = rowid to modify.  Never NULL
-**     argv[1] = rowid after the change.  Never NULL
-**     argv[2] = new value for _shape
-**     argv[3] = new value for first application-defined column....
-*/
-static int geopolyUpdate(
+          nodeGetRowid(pRtree, pNode, p->iCell)); 
+      rc = sqlite3_step(pCsr->pReadAux); 
+      if( rc==SQLITE_ROW ){ 
+        pCsr->bAuxValid = 1; 
+      }else{ 
+        sqlite3_reset(pCsr->pReadAux); 
+        if( rc==SQLITE_DONE ) rc = SQLITE_OK; 
+        return rc; 
+      } 
+    } 
+    sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pReadAux, i+2)); 
+  } 
+  return SQLITE_OK; 
+} 
+ 
+ 
+/* 
+** The xUpdate method for GEOPOLY module virtual tables. 
+** 
+** For DELETE: 
+** 
+**     argv[0] = the rowid to be deleted 
+** 
+** For INSERT: 
+** 
+**     argv[0] = SQL NULL 
+**     argv[1] = rowid to insert, or an SQL NULL to select automatically 
+**     argv[2] = _shape column 
+**     argv[3] = first application-defined column.... 
+** 
+** For UPDATE: 
+** 
+**     argv[0] = rowid to modify.  Never NULL 
+**     argv[1] = rowid after the change.  Never NULL 
+**     argv[2] = new value for _shape 
+**     argv[3] = new value for first application-defined column.... 
+*/ 
+static int geopolyUpdate( 
   sqlite3_vtab *pVtab,
   int nData,
   sqlite3_value **aData,
-  sqlite_int64 *pRowid
-){
-  Rtree *pRtree = (Rtree *)pVtab;
-  int rc = SQLITE_OK;
-  RtreeCell cell;                 /* New cell to insert if nData>1 */
-  i64 oldRowid;                   /* The old rowid */
-  int oldRowidValid;              /* True if oldRowid is valid */
-  i64 newRowid;                   /* The new rowid */
-  int newRowidValid;              /* True if newRowid is valid */
-  int coordChange = 0;            /* Change in coordinates */
-
-  if( pRtree->nNodeRef ){
-    /* Unable to write to the btree while another cursor is reading from it,
-    ** since the write might do a rebalance which would disrupt the read
-    ** cursor. */
-    return SQLITE_LOCKED_VTAB;
-  }
-  rtreeReference(pRtree);
-  assert(nData>=1);
-
-  oldRowidValid = sqlite3_value_type(aData[0])!=SQLITE_NULL;;
-  oldRowid = oldRowidValid ? sqlite3_value_int64(aData[0]) : 0;
-  newRowidValid = nData>1 && sqlite3_value_type(aData[1])!=SQLITE_NULL;
-  newRowid = newRowidValid ? sqlite3_value_int64(aData[1]) : 0;
-  cell.iRowid = newRowid;
-
-  if( nData>1                                 /* not a DELETE */
-   && (!oldRowidValid                         /* INSERT */
-        || !sqlite3_value_nochange(aData[2])  /* UPDATE _shape */
-        || oldRowid!=newRowid)                /* Rowid change */
-  ){
+  sqlite_int64 *pRowid 
+){ 
+  Rtree *pRtree = (Rtree *)pVtab; 
+  int rc = SQLITE_OK; 
+  RtreeCell cell;                 /* New cell to insert if nData>1 */ 
+  i64 oldRowid;                   /* The old rowid */ 
+  int oldRowidValid;              /* True if oldRowid is valid */ 
+  i64 newRowid;                   /* The new rowid */ 
+  int newRowidValid;              /* True if newRowid is valid */ 
+  int coordChange = 0;            /* Change in coordinates */ 
+ 
+  if( pRtree->nNodeRef ){ 
+    /* Unable to write to the btree while another cursor is reading from it, 
+    ** since the write might do a rebalance which would disrupt the read 
+    ** cursor. */ 
+    return SQLITE_LOCKED_VTAB; 
+  } 
+  rtreeReference(pRtree); 
+  assert(nData>=1); 
+ 
+  oldRowidValid = sqlite3_value_type(aData[0])!=SQLITE_NULL;; 
+  oldRowid = oldRowidValid ? sqlite3_value_int64(aData[0]) : 0; 
+  newRowidValid = nData>1 && sqlite3_value_type(aData[1])!=SQLITE_NULL; 
+  newRowid = newRowidValid ? sqlite3_value_int64(aData[1]) : 0; 
+  cell.iRowid = newRowid; 
+ 
+  if( nData>1                                 /* not a DELETE */ 
+   && (!oldRowidValid                         /* INSERT */ 
+        || !sqlite3_value_nochange(aData[2])  /* UPDATE _shape */ 
+        || oldRowid!=newRowid)                /* Rowid change */ 
+  ){ 
     assert( aData[2]!=0 );
-    geopolyBBox(0, aData[2], cell.aCoord, &rc);
-    if( rc ){
-      if( rc==SQLITE_ERROR ){
-        pVtab->zErrMsg =
-          sqlite3_mprintf("_shape does not contain a valid polygon");
-      }
-      goto geopoly_update_end;
-    }
-    coordChange = 1;
-
+    geopolyBBox(0, aData[2], cell.aCoord, &rc); 
+    if( rc ){ 
+      if( rc==SQLITE_ERROR ){ 
+        pVtab->zErrMsg = 
+          sqlite3_mprintf("_shape does not contain a valid polygon"); 
+      } 
+      goto geopoly_update_end; 
+    } 
+    coordChange = 1; 
+ 
     /* If a rowid value was supplied, check if it is already present in
-    ** the table. If so, the constraint has failed. */
-    if( newRowidValid && (!oldRowidValid || oldRowid!=newRowid) ){
-      int steprc;
-      sqlite3_bind_int64(pRtree->pReadRowid, 1, cell.iRowid);
-      steprc = sqlite3_step(pRtree->pReadRowid);
-      rc = sqlite3_reset(pRtree->pReadRowid);
-      if( SQLITE_ROW==steprc ){
-        if( sqlite3_vtab_on_conflict(pRtree->db)==SQLITE_REPLACE ){
-          rc = rtreeDeleteRowid(pRtree, cell.iRowid);
-        }else{
-          rc = rtreeConstraintError(pRtree, 0);
-        }
-      }
-    }
-  }
-
-  /* If aData[0] is not an SQL NULL value, it is the rowid of a
-  ** record to delete from the r-tree table. The following block does
-  ** just that.
-  */
-  if( rc==SQLITE_OK && (nData==1 || (coordChange && oldRowidValid)) ){
-    rc = rtreeDeleteRowid(pRtree, oldRowid);
-  }
-
-  /* If the aData[] array contains more than one element, elements
-  ** (aData[2]..aData[argc-1]) contain a new record to insert into
-  ** the r-tree structure.
-  */
-  if( rc==SQLITE_OK && nData>1 && coordChange ){
-    /* Insert the new record into the r-tree */
-    RtreeNode *pLeaf = 0;
-    if( !newRowidValid ){
-      rc = rtreeNewRowid(pRtree, &cell.iRowid);
-    }
-    *pRowid = cell.iRowid;
-    if( rc==SQLITE_OK ){
-      rc = ChooseLeaf(pRtree, &cell, 0, &pLeaf);
-    }
-    if( rc==SQLITE_OK ){
-      int rc2;
-      pRtree->iReinsertHeight = -1;
-      rc = rtreeInsertCell(pRtree, pLeaf, &cell, 0);
-      rc2 = nodeRelease(pRtree, pLeaf);
-      if( rc==SQLITE_OK ){
-        rc = rc2;
-      }
-    }
-  }
-
-  /* Change the data */
-  if( rc==SQLITE_OK && nData>1 ){
-    sqlite3_stmt *pUp = pRtree->pWriteAux;
-    int jj;
-    int nChange = 0;
-    sqlite3_bind_int64(pUp, 1, cell.iRowid);
-    assert( pRtree->nAux>=1 );
-    if( sqlite3_value_nochange(aData[2]) ){
-      sqlite3_bind_null(pUp, 2);
-    }else{
-      GeoPoly *p = 0;
-      if( sqlite3_value_type(aData[2])==SQLITE_TEXT
-       && (p = geopolyFuncParam(0, aData[2], &rc))!=0
-       && rc==SQLITE_OK
-      ){
-        sqlite3_bind_blob(pUp, 2, p->hdr, 4+8*p->nVertex, SQLITE_TRANSIENT);
-      }else{
-        sqlite3_bind_value(pUp, 2, aData[2]);
-      }
-      sqlite3_free(p);
-      nChange = 1;
-    }
-    for(jj=1; jj<pRtree->nAux; jj++){
-      nChange++;
-      sqlite3_bind_value(pUp, jj+2, aData[jj+2]);
-    }
-    if( nChange ){
-      sqlite3_step(pUp);
-      rc = sqlite3_reset(pUp);
-    }
-  }
-
-geopoly_update_end:
-  rtreeRelease(pRtree);
-  return rc;
-}
-
-/*
-** Report that geopoly_overlap() is an overloaded function suitable
-** for use in xBestIndex.
-*/
-static int geopolyFindFunction(
-  sqlite3_vtab *pVtab,
-  int nArg,
-  const char *zName,
-  void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
-  void **ppArg
-){
-  if( sqlite3_stricmp(zName, "geopoly_overlap")==0 ){
-    *pxFunc = geopolyOverlapFunc;
-    *ppArg = 0;
-    return SQLITE_INDEX_CONSTRAINT_FUNCTION;
-  }
-  if( sqlite3_stricmp(zName, "geopoly_within")==0 ){
-    *pxFunc = geopolyWithinFunc;
-    *ppArg = 0;
-    return SQLITE_INDEX_CONSTRAINT_FUNCTION+1;
-  }
-  return 0;
-}
-
-
-static sqlite3_module geopolyModule = {
-  3,                          /* iVersion */
-  geopolyCreate,              /* xCreate - create a table */
-  geopolyConnect,             /* xConnect - connect to an existing table */
-  geopolyBestIndex,           /* xBestIndex - Determine search strategy */
-  rtreeDisconnect,            /* xDisconnect - Disconnect from a table */
-  rtreeDestroy,               /* xDestroy - Drop a table */
-  rtreeOpen,                  /* xOpen - open a cursor */
-  rtreeClose,                 /* xClose - close a cursor */
-  geopolyFilter,              /* xFilter - configure scan constraints */
-  rtreeNext,                  /* xNext - advance a cursor */
-  rtreeEof,                   /* xEof */
-  geopolyColumn,              /* xColumn - read data */
-  rtreeRowid,                 /* xRowid - read data */
-  geopolyUpdate,              /* xUpdate - write data */
-  rtreeBeginTransaction,      /* xBegin - begin transaction */
-  rtreeEndTransaction,        /* xSync - sync transaction */
-  rtreeEndTransaction,        /* xCommit - commit transaction */
-  rtreeEndTransaction,        /* xRollback - rollback transaction */
-  geopolyFindFunction,        /* xFindFunction - function overloading */
-  rtreeRename,                /* xRename - rename the table */
-  rtreeSavepoint,             /* xSavepoint */
-  0,                          /* xRelease */
-  0,                          /* xRollbackTo */
-  rtreeShadowName             /* xShadowName */
-};
-
-static int sqlite3_geopoly_init(sqlite3 *db){
-  int rc = SQLITE_OK;
-  static const struct {
-    void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
-    signed char nArg;
-    unsigned char bPure;
-    const char *zName;
-  } aFunc[] = {
-     { geopolyAreaFunc,          1, 1,    "geopoly_area"             },
-     { geopolyBlobFunc,          1, 1,    "geopoly_blob"             },
-     { geopolyJsonFunc,          1, 1,    "geopoly_json"             },
-     { geopolySvgFunc,          -1, 1,    "geopoly_svg"              },
-     { geopolyWithinFunc,        2, 1,    "geopoly_within"           },
-     { geopolyContainsPointFunc, 3, 1,    "geopoly_contains_point"   },
-     { geopolyOverlapFunc,       2, 1,    "geopoly_overlap"          },
-     { geopolyDebugFunc,         1, 0,    "geopoly_debug"            },
-     { geopolyBBoxFunc,          1, 1,    "geopoly_bbox"             },
-     { geopolyXformFunc,         7, 1,    "geopoly_xform"            },
-     { geopolyRegularFunc,       4, 1,    "geopoly_regular"          },
-     { geopolyCcwFunc,           1, 1,    "geopoly_ccw"              },
-  };
-  static const struct {
-    void (*xStep)(sqlite3_context*,int,sqlite3_value**);
-    void (*xFinal)(sqlite3_context*);
-    const char *zName;
-  } aAgg[] = {
-     { geopolyBBoxStep, geopolyBBoxFinal, "geopoly_group_bbox"    },
-  };
-  int i;
-  for(i=0; i<sizeof(aFunc)/sizeof(aFunc[0]) && rc==SQLITE_OK; i++){
+    ** the table. If so, the constraint has failed. */ 
+    if( newRowidValid && (!oldRowidValid || oldRowid!=newRowid) ){ 
+      int steprc; 
+      sqlite3_bind_int64(pRtree->pReadRowid, 1, cell.iRowid); 
+      steprc = sqlite3_step(pRtree->pReadRowid); 
+      rc = sqlite3_reset(pRtree->pReadRowid); 
+      if( SQLITE_ROW==steprc ){ 
+        if( sqlite3_vtab_on_conflict(pRtree->db)==SQLITE_REPLACE ){ 
+          rc = rtreeDeleteRowid(pRtree, cell.iRowid); 
+        }else{ 
+          rc = rtreeConstraintError(pRtree, 0); 
+        } 
+      } 
+    } 
+  } 
+ 
+  /* If aData[0] is not an SQL NULL value, it is the rowid of a 
+  ** record to delete from the r-tree table. The following block does 
+  ** just that. 
+  */ 
+  if( rc==SQLITE_OK && (nData==1 || (coordChange && oldRowidValid)) ){ 
+    rc = rtreeDeleteRowid(pRtree, oldRowid); 
+  } 
+ 
+  /* If the aData[] array contains more than one element, elements 
+  ** (aData[2]..aData[argc-1]) contain a new record to insert into 
+  ** the r-tree structure. 
+  */ 
+  if( rc==SQLITE_OK && nData>1 && coordChange ){ 
+    /* Insert the new record into the r-tree */ 
+    RtreeNode *pLeaf = 0; 
+    if( !newRowidValid ){ 
+      rc = rtreeNewRowid(pRtree, &cell.iRowid); 
+    } 
+    *pRowid = cell.iRowid; 
+    if( rc==SQLITE_OK ){ 
+      rc = ChooseLeaf(pRtree, &cell, 0, &pLeaf); 
+    } 
+    if( rc==SQLITE_OK ){ 
+      int rc2; 
+      pRtree->iReinsertHeight = -1; 
+      rc = rtreeInsertCell(pRtree, pLeaf, &cell, 0); 
+      rc2 = nodeRelease(pRtree, pLeaf); 
+      if( rc==SQLITE_OK ){ 
+        rc = rc2; 
+      } 
+    } 
+  } 
+ 
+  /* Change the data */ 
+  if( rc==SQLITE_OK && nData>1 ){ 
+    sqlite3_stmt *pUp = pRtree->pWriteAux; 
+    int jj; 
+    int nChange = 0; 
+    sqlite3_bind_int64(pUp, 1, cell.iRowid); 
+    assert( pRtree->nAux>=1 ); 
+    if( sqlite3_value_nochange(aData[2]) ){ 
+      sqlite3_bind_null(pUp, 2); 
+    }else{ 
+      GeoPoly *p = 0; 
+      if( sqlite3_value_type(aData[2])==SQLITE_TEXT 
+       && (p = geopolyFuncParam(0, aData[2], &rc))!=0 
+       && rc==SQLITE_OK 
+      ){ 
+        sqlite3_bind_blob(pUp, 2, p->hdr, 4+8*p->nVertex, SQLITE_TRANSIENT); 
+      }else{ 
+        sqlite3_bind_value(pUp, 2, aData[2]); 
+      } 
+      sqlite3_free(p); 
+      nChange = 1; 
+    } 
+    for(jj=1; jj<pRtree->nAux; jj++){ 
+      nChange++; 
+      sqlite3_bind_value(pUp, jj+2, aData[jj+2]); 
+    } 
+    if( nChange ){ 
+      sqlite3_step(pUp); 
+      rc = sqlite3_reset(pUp); 
+    } 
+  } 
+ 
+geopoly_update_end: 
+  rtreeRelease(pRtree); 
+  return rc; 
+} 
+ 
+/* 
+** Report that geopoly_overlap() is an overloaded function suitable 
+** for use in xBestIndex. 
+*/ 
+static int geopolyFindFunction( 
+  sqlite3_vtab *pVtab, 
+  int nArg, 
+  const char *zName, 
+  void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), 
+  void **ppArg 
+){ 
+  if( sqlite3_stricmp(zName, "geopoly_overlap")==0 ){ 
+    *pxFunc = geopolyOverlapFunc; 
+    *ppArg = 0; 
+    return SQLITE_INDEX_CONSTRAINT_FUNCTION; 
+  } 
+  if( sqlite3_stricmp(zName, "geopoly_within")==0 ){ 
+    *pxFunc = geopolyWithinFunc; 
+    *ppArg = 0; 
+    return SQLITE_INDEX_CONSTRAINT_FUNCTION+1; 
+  } 
+  return 0; 
+} 
+ 
+ 
+static sqlite3_module geopolyModule = { 
+  3,                          /* iVersion */ 
+  geopolyCreate,              /* xCreate - create a table */ 
+  geopolyConnect,             /* xConnect - connect to an existing table */ 
+  geopolyBestIndex,           /* xBestIndex - Determine search strategy */ 
+  rtreeDisconnect,            /* xDisconnect - Disconnect from a table */ 
+  rtreeDestroy,               /* xDestroy - Drop a table */ 
+  rtreeOpen,                  /* xOpen - open a cursor */ 
+  rtreeClose,                 /* xClose - close a cursor */ 
+  geopolyFilter,              /* xFilter - configure scan constraints */ 
+  rtreeNext,                  /* xNext - advance a cursor */ 
+  rtreeEof,                   /* xEof */ 
+  geopolyColumn,              /* xColumn - read data */ 
+  rtreeRowid,                 /* xRowid - read data */ 
+  geopolyUpdate,              /* xUpdate - write data */ 
+  rtreeBeginTransaction,      /* xBegin - begin transaction */ 
+  rtreeEndTransaction,        /* xSync - sync transaction */ 
+  rtreeEndTransaction,        /* xCommit - commit transaction */ 
+  rtreeEndTransaction,        /* xRollback - rollback transaction */ 
+  geopolyFindFunction,        /* xFindFunction - function overloading */ 
+  rtreeRename,                /* xRename - rename the table */ 
+  rtreeSavepoint,             /* xSavepoint */ 
+  0,                          /* xRelease */ 
+  0,                          /* xRollbackTo */ 
+  rtreeShadowName             /* xShadowName */ 
+}; 
+ 
+static int sqlite3_geopoly_init(sqlite3 *db){ 
+  int rc = SQLITE_OK; 
+  static const struct { 
+    void (*xFunc)(sqlite3_context*,int,sqlite3_value**); 
+    signed char nArg; 
+    unsigned char bPure; 
+    const char *zName; 
+  } aFunc[] = { 
+     { geopolyAreaFunc,          1, 1,    "geopoly_area"             }, 
+     { geopolyBlobFunc,          1, 1,    "geopoly_blob"             }, 
+     { geopolyJsonFunc,          1, 1,    "geopoly_json"             }, 
+     { geopolySvgFunc,          -1, 1,    "geopoly_svg"              }, 
+     { geopolyWithinFunc,        2, 1,    "geopoly_within"           }, 
+     { geopolyContainsPointFunc, 3, 1,    "geopoly_contains_point"   }, 
+     { geopolyOverlapFunc,       2, 1,    "geopoly_overlap"          }, 
+     { geopolyDebugFunc,         1, 0,    "geopoly_debug"            }, 
+     { geopolyBBoxFunc,          1, 1,    "geopoly_bbox"             }, 
+     { geopolyXformFunc,         7, 1,    "geopoly_xform"            }, 
+     { geopolyRegularFunc,       4, 1,    "geopoly_regular"          }, 
+     { geopolyCcwFunc,           1, 1,    "geopoly_ccw"              }, 
+  }; 
+  static const struct { 
+    void (*xStep)(sqlite3_context*,int,sqlite3_value**); 
+    void (*xFinal)(sqlite3_context*); 
+    const char *zName; 
+  } aAgg[] = { 
+     { geopolyBBoxStep, geopolyBBoxFinal, "geopoly_group_bbox"    }, 
+  }; 
+  int i; 
+  for(i=0; i<sizeof(aFunc)/sizeof(aFunc[0]) && rc==SQLITE_OK; i++){ 
     int enc;
     if( aFunc[i].bPure ){
       enc = SQLITE_UTF8|SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS;
     }else{
       enc = SQLITE_UTF8|SQLITE_DIRECTONLY;
     }
-    rc = sqlite3_create_function(db, aFunc[i].zName, aFunc[i].nArg,
-                                 enc, 0,
-                                 aFunc[i].xFunc, 0, 0);
-  }
-  for(i=0; i<sizeof(aAgg)/sizeof(aAgg[0]) && rc==SQLITE_OK; i++){
+    rc = sqlite3_create_function(db, aFunc[i].zName, aFunc[i].nArg, 
+                                 enc, 0, 
+                                 aFunc[i].xFunc, 0, 0); 
+  } 
+  for(i=0; i<sizeof(aAgg)/sizeof(aAgg[0]) && rc==SQLITE_OK; i++){ 
     rc = sqlite3_create_function(db, aAgg[i].zName, 1,
               SQLITE_UTF8|SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS, 0,
               0, aAgg[i].xStep, aAgg[i].xFinal);
-  }
-  if( rc==SQLITE_OK ){
-    rc = sqlite3_create_module_v2(db, "geopoly", &geopolyModule, 0, 0);
-  }
-  return rc;
-}
-
-/************** End of geopoly.c *********************************************/
-/************** Continuing where we left off in rtree.c **********************/
-#endif
-
-/*
+  } 
+  if( rc==SQLITE_OK ){ 
+    rc = sqlite3_create_module_v2(db, "geopoly", &geopolyModule, 0, 0); 
+  } 
+  return rc; 
+} 
+ 
+/************** End of geopoly.c *********************************************/ 
+/************** Continuing where we left off in rtree.c **********************/ 
+#endif 
+ 
+/* 
 ** Register the r-tree module with database handle db. This creates the
 ** virtual table module "rtree" and the debugging/analysis scalar
 ** function "rtreenode".
@@ -200215,11 +200215,11 @@ SQLITE_PRIVATE int sqlite3RtreeInit(sqlite3 *db){
     void *c = (void *)RTREE_COORD_INT32;
     rc = sqlite3_create_module_v2(db, "rtree_i32", &rtreeModule, c, 0);
   }
-#ifdef SQLITE_ENABLE_GEOPOLY
-  if( rc==SQLITE_OK ){
-    rc = sqlite3_geopoly_init(db);
-  }
-#endif
+#ifdef SQLITE_ENABLE_GEOPOLY 
+  if( rc==SQLITE_OK ){ 
+    rc = sqlite3_geopoly_init(db); 
+  } 
+#endif 
 
   return rc;
 }
@@ -200266,12 +200266,12 @@ static void rtreeMatchArgFree(void *pArg){
 static void geomCallback(sqlite3_context *ctx, int nArg, sqlite3_value **aArg){
   RtreeGeomCallback *pGeomCtx = (RtreeGeomCallback *)sqlite3_user_data(ctx);
   RtreeMatchArg *pBlob;
-  sqlite3_int64 nBlob;
+  sqlite3_int64 nBlob; 
   int memErr = 0;
 
   nBlob = sizeof(RtreeMatchArg) + (nArg-1)*sizeof(RtreeDValue)
            + nArg*sizeof(sqlite3_value*);
-  pBlob = (RtreeMatchArg *)sqlite3_malloc64(nBlob);
+  pBlob = (RtreeMatchArg *)sqlite3_malloc64(nBlob); 
   if( !pBlob ){
     sqlite3_result_error_nomem(ctx);
   }else{
@@ -200986,7 +200986,7 @@ static int icuCreate(
   if( argc>0 ){
     n = strlen(argv[0])+1;
   }
-  p = (IcuTokenizer *)sqlite3_malloc64(sizeof(IcuTokenizer)+n);
+  p = (IcuTokenizer *)sqlite3_malloc64(sizeof(IcuTokenizer)+n); 
   if( !p ){
     return SQLITE_NOMEM;
   }
@@ -201043,7 +201043,7 @@ static int icuOpen(
     nInput = strlen(zInput);
   }
   nChar = nInput+1;
-  pCsr = (IcuCursor *)sqlite3_malloc64(
+  pCsr = (IcuCursor *)sqlite3_malloc64( 
       sizeof(IcuCursor) +                /* IcuCursor */
       ((nChar+3)&~3) * sizeof(UChar) +   /* IcuCursor.aChar[] */
       (nChar+1) * sizeof(int)            /* IcuCursor.aOffset[] */
@@ -201619,8 +201619,8 @@ SQLITE_API sqlite3rbu *sqlite3rbu_open(
 **
 ** With an RBU vacuum, it is an SQLITE_MISUSE error if the name of the
 ** state database ends with "-vactmp". This name is reserved for internal
-** use.
-**
+** use. 
+** 
 ** This function does not delete the state database after an RBU vacuum
 ** is completed, even if it created it. However, if the call to
 ** sqlite3rbu_close() returns any value other than SQLITE_OK, the contents
@@ -201960,10 +201960,10 @@ SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName);
 **
 ** RBU_STATE_OALSZ:
 **   Valid if STAGE==1. The size in bytes of the *-oal file.
-**
-** RBU_STATE_DATATBL:
+** 
+** RBU_STATE_DATATBL: 
 **   Only valid if STAGE==1. The RBU database name of the table
-**   currently being read.
+**   currently being read. 
 */
 #define RBU_STATE_STAGE        1
 #define RBU_STATE_TBL          2
@@ -201974,7 +201974,7 @@ SQLITE_API void sqlite3rbu_destroy_vfs(const char *zName);
 #define RBU_STATE_COOKIE       7
 #define RBU_STATE_OALSZ        8
 #define RBU_STATE_PHASEONESTEP 9
-#define RBU_STATE_DATATBL     10
+#define RBU_STATE_DATATBL     10 
 
 #define RBU_STAGE_OAL         1
 #define RBU_STAGE_MOVE        2
@@ -202018,7 +202018,7 @@ typedef sqlite3_int64 i64;
 struct RbuState {
   int eStage;
   char *zTbl;
-  char *zDataTbl;
+  char *zDataTbl; 
   char *zIdx;
   i64 iWalCksum;
   int nRow;
@@ -202053,11 +202053,11 @@ struct RbuSpan {
 **   it points to an array of flags nTblCol elements in size. The flag is
 **   set for each column that is either a part of the PK or a part of an
 **   index. Or clear otherwise.
-**
-**   If there are one or more partial indexes on the table, all fields of
-**   this array set set to 1. This is because in that case, the module has
-**   no way to tell which fields will be required to add and remove entries
-**   from the partial indexes.
+** 
+**   If there are one or more partial indexes on the table, all fields of 
+**   this array set set to 1. This is because in that case, the module has 
+**   no way to tell which fields will be required to add and remove entries 
+**   from the partial indexes. 
 **
 */
 struct RbuObjIter {
@@ -202226,8 +202226,8 @@ struct rbu_vfs {
   sqlite3_vfs *pRealVfs;          /* Underlying VFS */
   sqlite3_mutex *mutex;           /* Mutex to protect pMain */
   sqlite3rbu *pRbu;               /* Owner RBU object */
-  rbu_file *pMain;                /* List of main db files */
-  rbu_file *pMainRbu;             /* List of main db files with pRbu!=0 */
+  rbu_file *pMain;                /* List of main db files */ 
+  rbu_file *pMainRbu;             /* List of main db files with pRbu!=0 */ 
 };
 
 /*
@@ -202256,7 +202256,7 @@ struct rbu_file {
   const char *zWal;               /* Wal filename for this main db file */
   rbu_file *pWalFd;               /* Wal file descriptor for this main db */
   rbu_file *pMainNext;            /* Next MAIN_DB file */
-  rbu_file *pMainRbuNext;         /* Next MAIN_DB file with pRbu!=0 */
+  rbu_file *pMainRbuNext;         /* Next MAIN_DB file with pRbu!=0 */ 
 };
 
 /*
@@ -202505,7 +202505,7 @@ static void rbuFossilDeltaFunc(
   }else{
     nOut2 = rbuDeltaApply(aOrig, nOrig, aDelta, nDelta, aOut);
     if( nOut2!=nOut ){
-      sqlite3_free(aOut);
+      sqlite3_free(aOut); 
       sqlite3_result_error(context, "corrupt fossil delta", -1);
     }else{
       sqlite3_result_blob(context, aOut, nOut, sqlite3_free);
@@ -202862,7 +202862,7 @@ static int rbuMPrintfExec(sqlite3rbu *p, sqlite3 *db, const char *zFmt, ...){
 ** immediately without attempting the allocation or modifying the stored
 ** error code.
 */
-static void *rbuMalloc(sqlite3rbu *p, sqlite3_int64 nByte){
+static void *rbuMalloc(sqlite3rbu *p, sqlite3_int64 nByte){ 
   void *pRet = 0;
   if( p->rc==SQLITE_OK ){
     assert( nByte>0 );
@@ -202883,7 +202883,7 @@ static void *rbuMalloc(sqlite3rbu *p, sqlite3_int64 nByte){
 ** error code in the RBU handle passed as the first argument.
 */
 static void rbuAllocateIterArrays(sqlite3rbu *p, RbuObjIter *pIter, int nCol){
-  sqlite3_int64 nByte = (2*sizeof(char*) + sizeof(int) + 3*sizeof(u8)) * nCol;
+  sqlite3_int64 nByte = (2*sizeof(char*) + sizeof(int) + 3*sizeof(u8)) * nCol; 
   char **azNew;
 
   azNew = (char**)rbuMalloc(p, nByte);
@@ -203080,12 +203080,12 @@ static void rbuObjIterCacheIndexedCols(sqlite3rbu *p, RbuObjIter *pIter){
   pIter->nIndex = 0;
   while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pList) ){
     const char *zIdx = (const char*)sqlite3_column_text(pList, 1);
-    int bPartial = sqlite3_column_int(pList, 4);
+    int bPartial = sqlite3_column_int(pList, 4); 
     sqlite3_stmt *pXInfo = 0;
     if( zIdx==0 ) break;
-    if( bPartial ){
-      memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol);
-    }
+    if( bPartial ){ 
+      memset(pIter->abIndexed, 0x01, sizeof(u8)*pIter->nTblCol); 
+    } 
     p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg,
         sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", zIdx)
     );
@@ -203209,8 +203209,8 @@ static int rbuObjIterCacheTableInfo(sqlite3rbu *p, RbuObjIter *pIter){
         }
 
         pIter->azTblType[iOrder] = rbuStrndup(zType, &p->rc);
-        assert( iPk>=0 );
-        pIter->abTblPk[iOrder] = (u8)iPk;
+        assert( iPk>=0 ); 
+        pIter->abTblPk[iOrder] = (u8)iPk; 
         pIter->abNotNull[iOrder] = (u8)bNotNull || (iPk!=0);
         iOrder++;
       }
@@ -203246,215 +203246,215 @@ static char *rbuObjIterGetCollist(
 }
 
 /*
-** Return a comma separated list of the quoted PRIMARY KEY column names,
-** in order, for the current table. Before each column name, add the text
-** zPre. After each column name, add the zPost text. Use zSeparator as
-** the separator text (usually ", ").
-*/
-static char *rbuObjIterGetPkList(
-  sqlite3rbu *p,                  /* RBU object */
-  RbuObjIter *pIter,              /* Object iterator for column names */
-  const char *zPre,               /* Before each quoted column name */
-  const char *zSeparator,         /* Separator to use between columns */
-  const char *zPost               /* After each quoted column name */
-){
-  int iPk = 1;
-  char *zRet = 0;
-  const char *zSep = "";
-  while( 1 ){
-    int i;
-    for(i=0; i<pIter->nTblCol; i++){
-      if( (int)pIter->abTblPk[i]==iPk ){
-        const char *zCol = pIter->azTblCol[i];
-        zRet = rbuMPrintf(p, "%z%s%s\"%w\"%s", zRet, zSep, zPre, zCol, zPost);
-        zSep = zSeparator;
-        break;
-      }
-    }
-    if( i==pIter->nTblCol ) break;
-    iPk++;
-  }
-  return zRet;
-}
-
-/*
+** Return a comma separated list of the quoted PRIMARY KEY column names, 
+** in order, for the current table. Before each column name, add the text 
+** zPre. After each column name, add the zPost text. Use zSeparator as 
+** the separator text (usually ", "). 
+*/ 
+static char *rbuObjIterGetPkList( 
+  sqlite3rbu *p,                  /* RBU object */ 
+  RbuObjIter *pIter,              /* Object iterator for column names */ 
+  const char *zPre,               /* Before each quoted column name */ 
+  const char *zSeparator,         /* Separator to use between columns */ 
+  const char *zPost               /* After each quoted column name */ 
+){ 
+  int iPk = 1; 
+  char *zRet = 0; 
+  const char *zSep = ""; 
+  while( 1 ){ 
+    int i; 
+    for(i=0; i<pIter->nTblCol; i++){ 
+      if( (int)pIter->abTblPk[i]==iPk ){ 
+        const char *zCol = pIter->azTblCol[i]; 
+        zRet = rbuMPrintf(p, "%z%s%s\"%w\"%s", zRet, zSep, zPre, zCol, zPost); 
+        zSep = zSeparator; 
+        break; 
+      } 
+    } 
+    if( i==pIter->nTblCol ) break; 
+    iPk++; 
+  } 
+  return zRet; 
+} 
+ 
+/* 
 ** This function is called as part of restarting an RBU vacuum within
-** stage 1 of the process (while the *-oal file is being built) while
-** updating a table (not an index). The table may be a rowid table or
+** stage 1 of the process (while the *-oal file is being built) while 
+** updating a table (not an index). The table may be a rowid table or 
 ** a WITHOUT ROWID table. It queries the target database to find the
-** largest key that has already been written to the target table and
-** constructs a WHERE clause that can be used to extract the remaining
-** rows from the source table. For a rowid table, the WHERE clause
-** is of the form:
-**
-**     "WHERE _rowid_ > ?"
-**
-** and for WITHOUT ROWID tables:
-**
-**     "WHERE (key1, key2) > (?, ?)"
-**
-** Instead of "?" placeholders, the actual WHERE clauses created by
-** this function contain literal SQL values.
-*/
-static char *rbuVacuumTableStart(
-  sqlite3rbu *p,                  /* RBU handle */
-  RbuObjIter *pIter,              /* RBU iterator object */
-  int bRowid,                     /* True for a rowid table */
-  const char *zWrite              /* Target table name prefix */
-){
-  sqlite3_stmt *pMax = 0;
-  char *zRet = 0;
-  if( bRowid ){
+** largest key that has already been written to the target table and 
+** constructs a WHERE clause that can be used to extract the remaining 
+** rows from the source table. For a rowid table, the WHERE clause 
+** is of the form: 
+** 
+**     "WHERE _rowid_ > ?" 
+** 
+** and for WITHOUT ROWID tables: 
+** 
+**     "WHERE (key1, key2) > (?, ?)" 
+** 
+** Instead of "?" placeholders, the actual WHERE clauses created by 
+** this function contain literal SQL values. 
+*/ 
+static char *rbuVacuumTableStart( 
+  sqlite3rbu *p,                  /* RBU handle */ 
+  RbuObjIter *pIter,              /* RBU iterator object */ 
+  int bRowid,                     /* True for a rowid table */ 
+  const char *zWrite              /* Target table name prefix */ 
+){ 
+  sqlite3_stmt *pMax = 0; 
+  char *zRet = 0; 
+  if( bRowid ){ 
     p->rc = prepareFreeAndCollectError(p->dbMain, &pMax, &p->zErrmsg,
-        sqlite3_mprintf(
-          "SELECT max(_rowid_) FROM \"%s%w\"", zWrite, pIter->zTbl
-        )
-    );
-    if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){
-      sqlite3_int64 iMax = sqlite3_column_int64(pMax, 0);
-      zRet = rbuMPrintf(p, " WHERE _rowid_ > %lld ", iMax);
-    }
-    rbuFinalize(p, pMax);
-  }else{
-    char *zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", " DESC");
-    char *zSelect = rbuObjIterGetPkList(p, pIter, "quote(", "||','||", ")");
-    char *zList = rbuObjIterGetPkList(p, pIter, "", ", ", "");
-
-    if( p->rc==SQLITE_OK ){
+        sqlite3_mprintf( 
+          "SELECT max(_rowid_) FROM \"%s%w\"", zWrite, pIter->zTbl 
+        ) 
+    ); 
+    if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){ 
+      sqlite3_int64 iMax = sqlite3_column_int64(pMax, 0); 
+      zRet = rbuMPrintf(p, " WHERE _rowid_ > %lld ", iMax); 
+    } 
+    rbuFinalize(p, pMax); 
+  }else{ 
+    char *zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", " DESC"); 
+    char *zSelect = rbuObjIterGetPkList(p, pIter, "quote(", "||','||", ")"); 
+    char *zList = rbuObjIterGetPkList(p, pIter, "", ", ", ""); 
+ 
+    if( p->rc==SQLITE_OK ){ 
       p->rc = prepareFreeAndCollectError(p->dbMain, &pMax, &p->zErrmsg,
-          sqlite3_mprintf(
+          sqlite3_mprintf( 
             "SELECT %s FROM \"%s%w\" ORDER BY %s LIMIT 1",
-                zSelect, zWrite, pIter->zTbl, zOrder
-          )
-      );
-      if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){
-        const char *zVal = (const char*)sqlite3_column_text(pMax, 0);
-        zRet = rbuMPrintf(p, " WHERE (%s) > (%s) ", zList, zVal);
-      }
-      rbuFinalize(p, pMax);
-    }
-
-    sqlite3_free(zOrder);
-    sqlite3_free(zSelect);
-    sqlite3_free(zList);
-  }
-  return zRet;
-}
-
-/*
-** This function is called as part of restating an RBU vacuum when the
-** current operation is writing content to an index. If possible, it
-** queries the target index b-tree for the largest key already written to
+                zSelect, zWrite, pIter->zTbl, zOrder 
+          ) 
+      ); 
+      if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pMax) ){ 
+        const char *zVal = (const char*)sqlite3_column_text(pMax, 0); 
+        zRet = rbuMPrintf(p, " WHERE (%s) > (%s) ", zList, zVal); 
+      } 
+      rbuFinalize(p, pMax); 
+    } 
+ 
+    sqlite3_free(zOrder); 
+    sqlite3_free(zSelect); 
+    sqlite3_free(zList); 
+  } 
+  return zRet; 
+} 
+ 
+/* 
+** This function is called as part of restating an RBU vacuum when the 
+** current operation is writing content to an index. If possible, it 
+** queries the target index b-tree for the largest key already written to 
 ** it, then composes and returns an expression that can be used in a WHERE
 ** clause to select the remaining required rows from the source table.
-** It is only possible to return such an expression if:
-**
-**   * The index contains no DESC columns, and
+** It is only possible to return such an expression if: 
+** 
+**   * The index contains no DESC columns, and 
 **   * The last key written to the index before the operation was
-**     suspended does not contain any NULL values.
-**
-** The expression is of the form:
-**
-**   (index-field1, index-field2, ...) > (?, ?, ...)
-**
-** except that the "?" placeholders are replaced with literal values.
-**
-** If the expression cannot be created, NULL is returned. In this case,
+**     suspended does not contain any NULL values. 
+** 
+** The expression is of the form: 
+** 
+**   (index-field1, index-field2, ...) > (?, ?, ...) 
+** 
+** except that the "?" placeholders are replaced with literal values. 
+** 
+** If the expression cannot be created, NULL is returned. In this case, 
 ** the caller has to use an OFFSET clause to extract only the required
-** rows from the sourct table, just as it does for an RBU update operation.
-*/
-char *rbuVacuumIndexStart(
-  sqlite3rbu *p,                  /* RBU handle */
-  RbuObjIter *pIter               /* RBU iterator object */
-){
-  char *zOrder = 0;
-  char *zLhs = 0;
-  char *zSelect = 0;
-  char *zVector = 0;
-  char *zRet = 0;
-  int bFailed = 0;
-  const char *zSep = "";
-  int iCol = 0;
-  sqlite3_stmt *pXInfo = 0;
-
-  p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg,
-      sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx)
-  );
-  while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){
-    int iCid = sqlite3_column_int(pXInfo, 1);
-    const char *zCollate = (const char*)sqlite3_column_text(pXInfo, 4);
-    const char *zCol;
-    if( sqlite3_column_int(pXInfo, 3) ){
-      bFailed = 1;
-      break;
-    }
-
-    if( iCid<0 ){
-      if( pIter->eType==RBU_PK_IPK ){
-        int i;
-        for(i=0; pIter->abTblPk[i]==0; i++);
-        assert( i<pIter->nTblCol );
-        zCol = pIter->azTblCol[i];
-      }else{
-        zCol = "_rowid_";
-      }
-    }else{
-      zCol = pIter->azTblCol[iCid];
-    }
-
-    zLhs = rbuMPrintf(p, "%z%s \"%w\" COLLATE %Q",
-        zLhs, zSep, zCol, zCollate
-        );
-    zOrder = rbuMPrintf(p, "%z%s \"rbu_imp_%d%w\" COLLATE %Q DESC",
-        zOrder, zSep, iCol, zCol, zCollate
-        );
-    zSelect = rbuMPrintf(p, "%z%s quote(\"rbu_imp_%d%w\")",
-        zSelect, zSep, iCol, zCol
-        );
-    zSep = ", ";
-    iCol++;
-  }
-  rbuFinalize(p, pXInfo);
-  if( bFailed ) goto index_start_out;
-
-  if( p->rc==SQLITE_OK ){
-    sqlite3_stmt *pSel = 0;
-
-    p->rc = prepareFreeAndCollectError(p->dbMain, &pSel, &p->zErrmsg,
-        sqlite3_mprintf("SELECT %s FROM \"rbu_imp_%w\" ORDER BY %s LIMIT 1",
-          zSelect, pIter->zTbl, zOrder
-        )
-    );
-    if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSel) ){
-      zSep = "";
-      for(iCol=0; iCol<pIter->nCol; iCol++){
-        const char *zQuoted = (const char*)sqlite3_column_text(pSel, iCol);
+** rows from the sourct table, just as it does for an RBU update operation. 
+*/ 
+char *rbuVacuumIndexStart( 
+  sqlite3rbu *p,                  /* RBU handle */ 
+  RbuObjIter *pIter               /* RBU iterator object */ 
+){ 
+  char *zOrder = 0; 
+  char *zLhs = 0; 
+  char *zSelect = 0; 
+  char *zVector = 0; 
+  char *zRet = 0; 
+  int bFailed = 0; 
+  const char *zSep = ""; 
+  int iCol = 0; 
+  sqlite3_stmt *pXInfo = 0; 
+ 
+  p->rc = prepareFreeAndCollectError(p->dbMain, &pXInfo, &p->zErrmsg, 
+      sqlite3_mprintf("PRAGMA main.index_xinfo = %Q", pIter->zIdx) 
+  ); 
+  while( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pXInfo) ){ 
+    int iCid = sqlite3_column_int(pXInfo, 1); 
+    const char *zCollate = (const char*)sqlite3_column_text(pXInfo, 4); 
+    const char *zCol; 
+    if( sqlite3_column_int(pXInfo, 3) ){ 
+      bFailed = 1; 
+      break; 
+    } 
+ 
+    if( iCid<0 ){ 
+      if( pIter->eType==RBU_PK_IPK ){ 
+        int i; 
+        for(i=0; pIter->abTblPk[i]==0; i++); 
+        assert( i<pIter->nTblCol ); 
+        zCol = pIter->azTblCol[i]; 
+      }else{ 
+        zCol = "_rowid_"; 
+      } 
+    }else{ 
+      zCol = pIter->azTblCol[iCid]; 
+    } 
+ 
+    zLhs = rbuMPrintf(p, "%z%s \"%w\" COLLATE %Q", 
+        zLhs, zSep, zCol, zCollate 
+        ); 
+    zOrder = rbuMPrintf(p, "%z%s \"rbu_imp_%d%w\" COLLATE %Q DESC", 
+        zOrder, zSep, iCol, zCol, zCollate 
+        ); 
+    zSelect = rbuMPrintf(p, "%z%s quote(\"rbu_imp_%d%w\")", 
+        zSelect, zSep, iCol, zCol 
+        ); 
+    zSep = ", "; 
+    iCol++; 
+  } 
+  rbuFinalize(p, pXInfo); 
+  if( bFailed ) goto index_start_out; 
+ 
+  if( p->rc==SQLITE_OK ){ 
+    sqlite3_stmt *pSel = 0; 
+ 
+    p->rc = prepareFreeAndCollectError(p->dbMain, &pSel, &p->zErrmsg, 
+        sqlite3_mprintf("SELECT %s FROM \"rbu_imp_%w\" ORDER BY %s LIMIT 1", 
+          zSelect, pIter->zTbl, zOrder 
+        ) 
+    ); 
+    if( p->rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pSel) ){ 
+      zSep = ""; 
+      for(iCol=0; iCol<pIter->nCol; iCol++){ 
+        const char *zQuoted = (const char*)sqlite3_column_text(pSel, iCol); 
         if( zQuoted==0 ){
           p->rc = SQLITE_NOMEM;
         }else if( zQuoted[0]=='N' ){
-          bFailed = 1;
-          break;
-        }
-        zVector = rbuMPrintf(p, "%z%s%s", zVector, zSep, zQuoted);
-        zSep = ", ";
-      }
-
-      if( !bFailed ){
-        zRet = rbuMPrintf(p, "(%s) > (%s)", zLhs, zVector);
-      }
-    }
-    rbuFinalize(p, pSel);
-  }
-
- index_start_out:
-  sqlite3_free(zOrder);
-  sqlite3_free(zSelect);
-  sqlite3_free(zVector);
-  sqlite3_free(zLhs);
-  return zRet;
-}
-
-/*
+          bFailed = 1; 
+          break; 
+        } 
+        zVector = rbuMPrintf(p, "%z%s%s", zVector, zSep, zQuoted); 
+        zSep = ", "; 
+      } 
+ 
+      if( !bFailed ){ 
+        zRet = rbuMPrintf(p, "(%s) > (%s)", zLhs, zVector); 
+      } 
+    } 
+    rbuFinalize(p, pSel); 
+  } 
+ 
+ index_start_out: 
+  sqlite3_free(zOrder); 
+  sqlite3_free(zSelect); 
+  sqlite3_free(zVector); 
+  sqlite3_free(zLhs); 
+  return zRet; 
+} 
+ 
+/* 
 ** This function is used to create a SELECT list (the list of SQL
 ** expressions that follows a SELECT keyword) for a SELECT statement
 ** used to read from an data_xxx or rbu_tmp_xxx table while updating the
@@ -203751,7 +203751,7 @@ static char *rbuObjIterGetSetlist(
 */
 static char *rbuObjIterGetBindlist(sqlite3rbu *p, int nBind){
   char *zRet = 0;
-  sqlite3_int64 nByte = 2*(sqlite3_int64)nBind + 1;
+  sqlite3_int64 nByte = 2*(sqlite3_int64)nBind + 1; 
 
   zRet = (char*)rbuMalloc(p, nByte);
   if( zRet ){
@@ -204013,33 +204013,33 @@ static void rbuTmpInsertFunc(
   }
 }
 
-static char *rbuObjIterGetIndexWhere(sqlite3rbu *p, RbuObjIter *pIter){
-  sqlite3_stmt *pStmt = 0;
-  int rc = p->rc;
-  char *zRet = 0;
-
+static char *rbuObjIterGetIndexWhere(sqlite3rbu *p, RbuObjIter *pIter){ 
+  sqlite3_stmt *pStmt = 0; 
+  int rc = p->rc; 
+  char *zRet = 0; 
+ 
   assert( pIter->zIdxSql==0 && pIter->nIdxCol==0 && pIter->aIdxCol==0 );
 
-  if( rc==SQLITE_OK ){
-    rc = prepareAndCollectError(p->dbMain, &pStmt, &p->zErrmsg,
+  if( rc==SQLITE_OK ){ 
+    rc = prepareAndCollectError(p->dbMain, &pStmt, &p->zErrmsg, 
         "SELECT trim(sql) FROM sqlite_schema WHERE type='index' AND name=?"
-    );
-  }
-  if( rc==SQLITE_OK ){
-    int rc2;
-    rc = sqlite3_bind_text(pStmt, 1, pIter->zIdx, -1, SQLITE_STATIC);
-    if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){
+    ); 
+  } 
+  if( rc==SQLITE_OK ){ 
+    int rc2; 
+    rc = sqlite3_bind_text(pStmt, 1, pIter->zIdx, -1, SQLITE_STATIC); 
+    if( rc==SQLITE_OK && SQLITE_ROW==sqlite3_step(pStmt) ){ 
       char *zSql = (char*)sqlite3_column_text(pStmt, 0);
-      if( zSql ){
+      if( zSql ){ 
         pIter->zIdxSql = zSql = rbuStrndup(zSql, &rc);
       }
       if( zSql ){
-        int nParen = 0;           /* Number of open parenthesis */
-        int i;
+        int nParen = 0;           /* Number of open parenthesis */ 
+        int i; 
         int iIdxCol = 0;
         int nIdxAlloc = 0;
-        for(i=0; zSql[i]; i++){
-          char c = zSql[i];
+        for(i=0; zSql[i]; i++){ 
+          char c = zSql[i]; 
 
           /* If necessary, grow the pIter->aIdxCol[] array */
           if( iIdxCol==nIdxAlloc ){
@@ -204054,36 +204054,36 @@ static char *rbuObjIterGetIndexWhere(sqlite3rbu *p, RbuObjIter *pIter){
             nIdxAlloc += 16;
           }
 
-          if( c=='(' ){
+          if( c=='(' ){ 
             if( nParen==0 ){
               assert( iIdxCol==0 );
               pIter->aIdxCol[0].zSpan = &zSql[i+1];
             }
-            nParen++;
-          }
-          else if( c==')' ){
-            nParen--;
-            if( nParen==0 ){
+            nParen++; 
+          } 
+          else if( c==')' ){ 
+            nParen--; 
+            if( nParen==0 ){ 
               int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan;
               pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
-              i++;
-              break;
-            }
+              i++; 
+              break; 
+            } 
           }else if( c==',' && nParen==1 ){
             int nSpan = &zSql[i] - pIter->aIdxCol[iIdxCol].zSpan;
             pIter->aIdxCol[iIdxCol++].nSpan = nSpan;
             pIter->aIdxCol[iIdxCol].zSpan = &zSql[i+1];
-          }else if( c=='"' || c=='\'' || c=='`' ){
-            for(i++; 1; i++){
-              if( zSql[i]==c ){
-                if( zSql[i+1]!=c ) break;
-                i++;
-              }
-            }
-          }else if( c=='[' ){
-            for(i++; 1; i++){
-              if( zSql[i]==']' ) break;
-            }
+          }else if( c=='"' || c=='\'' || c=='`' ){ 
+            for(i++; 1; i++){ 
+              if( zSql[i]==c ){ 
+                if( zSql[i+1]!=c ) break; 
+                i++; 
+              } 
+            } 
+          }else if( c=='[' ){ 
+            for(i++; 1; i++){ 
+              if( zSql[i]==']' ) break; 
+            } 
           }else if( c=='-' && zSql[i+1]=='-' ){
             for(i=i+2; zSql[i] && zSql[i]!='\n'; i++);
             if( zSql[i]=='\0' ) break;
@@ -204091,23 +204091,23 @@ static char *rbuObjIterGetIndexWhere(sqlite3rbu *p, RbuObjIter *pIter){
             for(i=i+2; zSql[i] && (zSql[i]!='*' || zSql[i+1]!='/'); i++);
             if( zSql[i]=='\0' ) break;
             i++;
-          }
-        }
-        if( zSql[i] ){
-          zRet = rbuStrndup(&zSql[i], &rc);
-        }
+          } 
+        } 
+        if( zSql[i] ){ 
+          zRet = rbuStrndup(&zSql[i], &rc); 
+        } 
         pIter->nIdxCol = iIdxCol;
-      }
-    }
-
-    rc2 = sqlite3_finalize(pStmt);
-    if( rc==SQLITE_OK ) rc = rc2;
-  }
-
-  p->rc = rc;
-  return zRet;
-}
-
+      } 
+    } 
+ 
+    rc2 = sqlite3_finalize(pStmt); 
+    if( rc==SQLITE_OK ) rc = rc2; 
+  } 
+ 
+  p->rc = rc; 
+  return zRet; 
+} 
+ 
 /*
 ** Ensure that the SQLite statement handles required to update the
 ** target database object currently indicated by the iterator passed
@@ -204137,7 +204137,7 @@ static int rbuObjIterPrepareAll(
       char *zImposterPK = 0;      /* Primary key declaration for imposter */
       char *zWhere = 0;           /* WHERE clause on PK columns */
       char *zBind = 0;
-      char *zPart = 0;
+      char *zPart = 0; 
       int nBind = 0;
 
       assert( pIter->eType!=RBU_PK_VTAB );
@@ -204177,58 +204177,58 @@ static int rbuObjIterPrepareAll(
       if( p->rc==SQLITE_OK ){
         char *zSql;
         if( rbuIsVacuum(p) ){
-          char *zStart = 0;
-          if( nOffset ){
-            zStart = rbuVacuumIndexStart(p, pIter);
-            if( zStart ){
-              sqlite3_free(zLimit);
-              zLimit = 0;
-            }
-          }
-
+          char *zStart = 0; 
+          if( nOffset ){ 
+            zStart = rbuVacuumIndexStart(p, pIter); 
+            if( zStart ){ 
+              sqlite3_free(zLimit); 
+              zLimit = 0; 
+            } 
+          } 
+ 
           zSql = sqlite3_mprintf(
-              "SELECT %s, 0 AS rbu_control FROM '%q' %s %s %s ORDER BY %s%s",
+              "SELECT %s, 0 AS rbu_control FROM '%q' %s %s %s ORDER BY %s%s", 
               zCollist,
               pIter->zDataTbl,
               zPart,
-              (zStart ? (zPart ? "AND" : "WHERE") : ""), zStart,
+              (zStart ? (zPart ? "AND" : "WHERE") : ""), zStart, 
               zCollist, zLimit
           );
-          sqlite3_free(zStart);
+          sqlite3_free(zStart); 
         }else
 
         if( pIter->eType==RBU_PK_EXTERNAL || pIter->eType==RBU_PK_NONE ){
           zSql = sqlite3_mprintf(
-              "SELECT %s, rbu_control FROM %s.'rbu_tmp_%q' %s ORDER BY %s%s",
+              "SELECT %s, rbu_control FROM %s.'rbu_tmp_%q' %s ORDER BY %s%s", 
               zCollist, p->zStateDb, pIter->zDataTbl,
-              zPart, zCollist, zLimit
+              zPart, zCollist, zLimit 
           );
         }else{
           zSql = sqlite3_mprintf(
-              "SELECT %s, rbu_control FROM %s.'rbu_tmp_%q' %s "
+              "SELECT %s, rbu_control FROM %s.'rbu_tmp_%q' %s " 
               "UNION ALL "
               "SELECT %s, rbu_control FROM '%q' "
-              "%s %s typeof(rbu_control)='integer' AND rbu_control!=1 "
+              "%s %s typeof(rbu_control)='integer' AND rbu_control!=1 " 
               "ORDER BY %s%s",
-              zCollist, p->zStateDb, pIter->zDataTbl, zPart,
+              zCollist, p->zStateDb, pIter->zDataTbl, zPart, 
               zCollist, pIter->zDataTbl,
-              zPart,
-              (zPart ? "AND" : "WHERE"),
+              zPart, 
+              (zPart ? "AND" : "WHERE"), 
               zCollist, zLimit
           );
         }
-        if( p->rc==SQLITE_OK ){
-          p->rc = prepareFreeAndCollectError(p->dbRbu,&pIter->pSelect,pz,zSql);
-        }else{
-          sqlite3_free(zSql);
-        }
+        if( p->rc==SQLITE_OK ){ 
+          p->rc = prepareFreeAndCollectError(p->dbRbu,&pIter->pSelect,pz,zSql); 
+        }else{ 
+          sqlite3_free(zSql); 
+        } 
       }
 
       sqlite3_free(zImposterCols);
       sqlite3_free(zImposterPK);
       sqlite3_free(zWhere);
       sqlite3_free(zBind);
-      sqlite3_free(zPart);
+      sqlite3_free(zPart); 
     }else{
       int bRbuRowid = (pIter->eType==RBU_PK_VTAB)
                     ||(pIter->eType==RBU_PK_NONE)
@@ -204321,42 +204321,42 @@ static int rbuObjIterPrepareAll(
       /* Create the SELECT statement to read keys from data_xxx */
       if( p->rc==SQLITE_OK ){
         const char *zRbuRowid = "";
-        char *zStart = 0;
-        char *zOrder = 0;
+        char *zStart = 0; 
+        char *zOrder = 0; 
         if( bRbuRowid ){
           zRbuRowid = rbuIsVacuum(p) ? ",_rowid_ " : ",rbu_rowid";
         }
-
-        if( rbuIsVacuum(p) ){
-          if( nOffset ){
-            zStart = rbuVacuumTableStart(p, pIter, bRbuRowid, zWrite);
-            if( zStart ){
-              sqlite3_free(zLimit);
-              zLimit = 0;
-            }
-          }
-          if( bRbuRowid ){
-            zOrder = rbuMPrintf(p, "_rowid_");
-          }else{
-            zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", "");
-          }
-        }
-
-        if( p->rc==SQLITE_OK ){
-          p->rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pSelect, pz,
-              sqlite3_mprintf(
-                "SELECT %s,%s rbu_control%s FROM '%q'%s %s %s %s",
+ 
+        if( rbuIsVacuum(p) ){ 
+          if( nOffset ){ 
+            zStart = rbuVacuumTableStart(p, pIter, bRbuRowid, zWrite); 
+            if( zStart ){ 
+              sqlite3_free(zLimit); 
+              zLimit = 0; 
+            } 
+          } 
+          if( bRbuRowid ){ 
+            zOrder = rbuMPrintf(p, "_rowid_"); 
+          }else{ 
+            zOrder = rbuObjIterGetPkList(p, pIter, "", ", ", ""); 
+          } 
+        } 
+ 
+        if( p->rc==SQLITE_OK ){ 
+          p->rc = prepareFreeAndCollectError(p->dbRbu, &pIter->pSelect, pz, 
+              sqlite3_mprintf( 
+                "SELECT %s,%s rbu_control%s FROM '%q'%s %s %s %s", 
                 zCollist,
-                (rbuIsVacuum(p) ? "0 AS " : ""),
-                zRbuRowid,
+                (rbuIsVacuum(p) ? "0 AS " : ""), 
+                zRbuRowid, 
                 pIter->zDataTbl, (zStart ? zStart : ""),
-                (zOrder ? "ORDER BY" : ""), zOrder,
-                zLimit
-              )
-          );
-        }
-        sqlite3_free(zStart);
-        sqlite3_free(zOrder);
+                (zOrder ? "ORDER BY" : ""), zOrder, 
+                zLimit 
+              ) 
+          ); 
+        } 
+        sqlite3_free(zStart); 
+        sqlite3_free(zOrder); 
       }
 
       sqlite3_free(zWhere);
@@ -204472,7 +204472,7 @@ static sqlite3 *rbuOpenDbhandle(
 static void rbuFreeState(RbuState *p){
   if( p ){
     sqlite3_free(p->zTbl);
-    sqlite3_free(p->zDataTbl);
+    sqlite3_free(p->zDataTbl); 
     sqlite3_free(p->zIdx);
     sqlite3_free(p);
   }
@@ -204543,10 +204543,10 @@ static RbuState *rbuLoadState(sqlite3rbu *p){
         pRet->nPhaseOneStep = sqlite3_column_int64(pStmt, 1);
         break;
 
-      case RBU_STATE_DATATBL:
-        pRet->zDataTbl = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc);
-        break;
-
+      case RBU_STATE_DATATBL: 
+        pRet->zDataTbl = rbuStrndup((char*)sqlite3_column_text(pStmt, 1), &rc); 
+        break; 
+ 
       default:
         rc = SQLITE_CORRUPT;
         break;
@@ -205357,8 +205357,8 @@ static void rbuSaveState(sqlite3rbu *p, int eStage){
           "(%d, %lld), "
           "(%d, %lld), "
           "(%d, %lld), "
-          "(%d, %lld), "
-          "(%d, %Q)  ",
+          "(%d, %lld), " 
+          "(%d, %Q)  ", 
           p->zStateDb,
           RBU_STATE_STAGE, eStage,
           RBU_STATE_TBL, p->objiter.zTbl,
@@ -205368,8 +205368,8 @@ static void rbuSaveState(sqlite3rbu *p, int eStage){
           RBU_STATE_CKPT, p->iWalCksum,
           RBU_STATE_COOKIE, (i64)pFd->iCookie,
           RBU_STATE_OALSZ, p->iOalSz,
-          RBU_STATE_PHASEONESTEP, p->nPhaseOneStep,
-          RBU_STATE_DATATBL, p->objiter.zDataTbl
+          RBU_STATE_PHASEONESTEP, p->nPhaseOneStep, 
+          RBU_STATE_DATATBL, p->objiter.zDataTbl 
       )
     );
     assert( pInsert==0 || rc==SQLITE_OK );
@@ -205625,8 +205625,8 @@ static void rbuSetupOal(sqlite3rbu *p, RbuState *pState){
 
     while( rc==SQLITE_OK && pIter->zTbl && (pIter->bCleanup
        || rbuStrCompare(pIter->zIdx, pState->zIdx)
-       || (pState->zDataTbl==0 && rbuStrCompare(pIter->zTbl, pState->zTbl))
-       || (pState->zDataTbl && rbuStrCompare(pIter->zDataTbl, pState->zDataTbl))
+       || (pState->zDataTbl==0 && rbuStrCompare(pIter->zTbl, pState->zTbl)) 
+       || (pState->zDataTbl && rbuStrCompare(pIter->zDataTbl, pState->zDataTbl)) 
     )){
       rc = rbuObjIterNext(p, pIter);
     }
@@ -205983,12 +205983,12 @@ SQLITE_API sqlite3rbu *sqlite3rbu_vacuum(
   const char *zState
 ){
   if( zTarget==0 ){ return rbuMisuseError(); }
-  if( zState ){
-    int n = strlen(zState);
-    if( n>=7 && 0==memcmp("-vactmp", &zState[n-7], 7) ){
-      return rbuMisuseError();
-    }
-  }
+  if( zState ){ 
+    int n = strlen(zState); 
+    if( n>=7 && 0==memcmp("-vactmp", &zState[n-7], 7) ){ 
+      return rbuMisuseError(); 
+    } 
+  } 
   /* TODO: Check that both arguments are non-NULL */
   return openRbuHandle(0, zTarget, zState);
 }
@@ -206186,9 +206186,9 @@ SQLITE_API int sqlite3rbu_savestate(sqlite3rbu *p){
     assert( rc!=SQLITE_DONE );
     if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbRbu, "COMMIT", 0, 0, 0);
     if( rc==SQLITE_OK ){
-      const char *zBegin = rbuIsVacuum(p) ? "BEGIN" : "BEGIN IMMEDIATE";
-      rc = sqlite3_exec(p->dbRbu, zBegin, 0, 0, 0);
-    }
+      const char *zBegin = rbuIsVacuum(p) ? "BEGIN" : "BEGIN IMMEDIATE"; 
+      rc = sqlite3_exec(p->dbRbu, zBegin, 0, 0, 0); 
+    } 
     if( rc==SQLITE_OK ) rc = sqlite3_exec(p->dbMain, "BEGIN IMMEDIATE", 0, 0,0);
   }
 
@@ -206282,69 +206282,69 @@ static int rbuUpdateTempSize(rbu_file *pFd, sqlite3_int64 nNew){
 }
 
 /*
-** Add an item to the main-db lists, if it is not already present.
-**
-** There are two main-db lists. One for all file descriptors, and one
-** for all file descriptors with rbu_file.pDb!=0. If the argument has
-** rbu_file.pDb!=0, then it is assumed to already be present on the
-** main list and is only added to the pDb!=0 list.
-*/
-static void rbuMainlistAdd(rbu_file *p){
-  rbu_vfs *pRbuVfs = p->pRbuVfs;
-  rbu_file *pIter;
-  assert( (p->openFlags & SQLITE_OPEN_MAIN_DB) );
-  sqlite3_mutex_enter(pRbuVfs->mutex);
-  if( p->pRbu==0 ){
-    for(pIter=pRbuVfs->pMain; pIter; pIter=pIter->pMainNext);
-    p->pMainNext = pRbuVfs->pMain;
-    pRbuVfs->pMain = p;
-  }else{
-    for(pIter=pRbuVfs->pMainRbu; pIter && pIter!=p; pIter=pIter->pMainRbuNext){}
-    if( pIter==0 ){
-      p->pMainRbuNext = pRbuVfs->pMainRbu;
-      pRbuVfs->pMainRbu = p;
-    }
-  }
-  sqlite3_mutex_leave(pRbuVfs->mutex);
-}
-
-/*
-** Remove an item from the main-db lists.
-*/
-static void rbuMainlistRemove(rbu_file *p){
-  rbu_file **pp;
-  sqlite3_mutex_enter(p->pRbuVfs->mutex);
-  for(pp=&p->pRbuVfs->pMain; *pp && *pp!=p; pp=&((*pp)->pMainNext)){}
-  if( *pp ) *pp = p->pMainNext;
-  p->pMainNext = 0;
-  for(pp=&p->pRbuVfs->pMainRbu; *pp && *pp!=p; pp=&((*pp)->pMainRbuNext)){}
-  if( *pp ) *pp = p->pMainRbuNext;
-  p->pMainRbuNext = 0;
-  sqlite3_mutex_leave(p->pRbuVfs->mutex);
-}
-
-/*
+** Add an item to the main-db lists, if it is not already present. 
+** 
+** There are two main-db lists. One for all file descriptors, and one 
+** for all file descriptors with rbu_file.pDb!=0. If the argument has 
+** rbu_file.pDb!=0, then it is assumed to already be present on the 
+** main list and is only added to the pDb!=0 list. 
+*/ 
+static void rbuMainlistAdd(rbu_file *p){ 
+  rbu_vfs *pRbuVfs = p->pRbuVfs; 
+  rbu_file *pIter; 
+  assert( (p->openFlags & SQLITE_OPEN_MAIN_DB) ); 
+  sqlite3_mutex_enter(pRbuVfs->mutex); 
+  if( p->pRbu==0 ){ 
+    for(pIter=pRbuVfs->pMain; pIter; pIter=pIter->pMainNext); 
+    p->pMainNext = pRbuVfs->pMain; 
+    pRbuVfs->pMain = p; 
+  }else{ 
+    for(pIter=pRbuVfs->pMainRbu; pIter && pIter!=p; pIter=pIter->pMainRbuNext){} 
+    if( pIter==0 ){ 
+      p->pMainRbuNext = pRbuVfs->pMainRbu; 
+      pRbuVfs->pMainRbu = p; 
+    } 
+  } 
+  sqlite3_mutex_leave(pRbuVfs->mutex); 
+} 
+ 
+/* 
+** Remove an item from the main-db lists. 
+*/ 
+static void rbuMainlistRemove(rbu_file *p){ 
+  rbu_file **pp; 
+  sqlite3_mutex_enter(p->pRbuVfs->mutex); 
+  for(pp=&p->pRbuVfs->pMain; *pp && *pp!=p; pp=&((*pp)->pMainNext)){} 
+  if( *pp ) *pp = p->pMainNext; 
+  p->pMainNext = 0; 
+  for(pp=&p->pRbuVfs->pMainRbu; *pp && *pp!=p; pp=&((*pp)->pMainRbuNext)){} 
+  if( *pp ) *pp = p->pMainRbuNext; 
+  p->pMainRbuNext = 0; 
+  sqlite3_mutex_leave(p->pRbuVfs->mutex); 
+} 
+ 
+/* 
 ** Given that zWal points to a buffer containing a wal file name passed to
-** either the xOpen() or xAccess() VFS method, search the main-db list for
-** a file-handle opened by the same database connection on the corresponding
-** database file.
-**
-** If parameter bRbu is true, only search for file-descriptors with
-** rbu_file.pDb!=0.
-*/
-static rbu_file *rbuFindMaindb(rbu_vfs *pRbuVfs, const char *zWal, int bRbu){
-  rbu_file *pDb;
-  sqlite3_mutex_enter(pRbuVfs->mutex);
-  if( bRbu ){
-    for(pDb=pRbuVfs->pMainRbu; pDb && pDb->zWal!=zWal; pDb=pDb->pMainRbuNext){}
-  }else{
-    for(pDb=pRbuVfs->pMain; pDb && pDb->zWal!=zWal; pDb=pDb->pMainNext){}
-  }
-  sqlite3_mutex_leave(pRbuVfs->mutex);
-  return pDb;
-}
-
-/*
+** either the xOpen() or xAccess() VFS method, search the main-db list for 
+** a file-handle opened by the same database connection on the corresponding 
+** database file. 
+** 
+** If parameter bRbu is true, only search for file-descriptors with 
+** rbu_file.pDb!=0. 
+*/ 
+static rbu_file *rbuFindMaindb(rbu_vfs *pRbuVfs, const char *zWal, int bRbu){ 
+  rbu_file *pDb; 
+  sqlite3_mutex_enter(pRbuVfs->mutex); 
+  if( bRbu ){ 
+    for(pDb=pRbuVfs->pMainRbu; pDb && pDb->zWal!=zWal; pDb=pDb->pMainRbuNext){} 
+  }else{ 
+    for(pDb=pRbuVfs->pMain; pDb && pDb->zWal!=zWal; pDb=pDb->pMainNext){} 
+  } 
+  sqlite3_mutex_leave(pRbuVfs->mutex); 
+  return pDb; 
+} 
+ 
+/* 
 ** Close an rbu file.
 */
 static int rbuVfsClose(sqlite3_file *pFile){
@@ -206361,14 +206361,14 @@ static int rbuVfsClose(sqlite3_file *pFile){
   sqlite3_free(p->zDel);
 
   if( p->openFlags & SQLITE_OPEN_MAIN_DB ){
-    rbuMainlistRemove(p);
+    rbuMainlistRemove(p); 
     rbuUnlockShm(p);
     p->pReal->pMethods->xShmUnmap(p->pReal, 0);
   }
   else if( (p->openFlags & SQLITE_OPEN_DELETEONCLOSE) && p->pRbu ){
     rbuUpdateTempSize(p, 0);
   }
-  assert( p->pMainNext==0 && p->pRbuVfs->pMain!=p );
+  assert( p->pMainNext==0 && p->pRbuVfs->pMain!=p ); 
 
   /* Close the underlying file handle */
   rc = p->pReal->pMethods->xClose(p->pReal);
@@ -206627,7 +206627,7 @@ static int rbuVfsFileControl(sqlite3_file *pFile, int op, void *pArg){
       }else if( rc==SQLITE_NOTFOUND ){
         pRbu->pTargetFd = p;
         p->pRbu = pRbu;
-        rbuMainlistAdd(p);
+        rbuMainlistAdd(p); 
         if( p->pWalFd ) p->pWalFd->pRbu = pRbu;
         rc = SQLITE_OK;
       }
@@ -206693,7 +206693,7 @@ static int rbuVfsShmLock(sqlite3_file *pFile, int ofst, int n, int flags){
     if( ofst==WAL_LOCK_CKPT && n==1 ) rc = SQLITE_BUSY;
   }else{
     int bCapture = 0;
-    if( pRbu && pRbu->eStage==RBU_STAGE_CAPTURE ){
+    if( pRbu && pRbu->eStage==RBU_STAGE_CAPTURE ){ 
       bCapture = 1;
     }
     if( bCapture==0 || 0==(flags & SQLITE_SHM_UNLOCK) ){
@@ -206725,24 +206725,24 @@ static int rbuVfsShmMap(
   ** rbu is in the RBU_STAGE_OAL state, use heap memory for *-shm space
   ** instead of a file on disk.  */
   assert( p->openFlags & (SQLITE_OPEN_MAIN_DB|SQLITE_OPEN_TEMP_DB) );
-  if( eStage==RBU_STAGE_OAL ){
-    sqlite3_int64 nByte = (iRegion+1) * sizeof(char*);
-    char **apNew = (char**)sqlite3_realloc64(p->apShm, nByte);
-
-    /* This is an RBU connection that uses its own heap memory for the
-    ** pages of the *-shm file. Since no other process can have run
-    ** recovery, the connection must request *-shm pages in order
-    ** from start to finish.  */
-    assert( iRegion==p->nShm );
-    if( apNew==0 ){
-      rc = SQLITE_NOMEM;
-    }else{
-      memset(&apNew[p->nShm], 0, sizeof(char*) * (1 + iRegion - p->nShm));
-      p->apShm = apNew;
-      p->nShm = iRegion+1;
-    }
-
-    if( rc==SQLITE_OK ){
+  if( eStage==RBU_STAGE_OAL ){ 
+    sqlite3_int64 nByte = (iRegion+1) * sizeof(char*); 
+    char **apNew = (char**)sqlite3_realloc64(p->apShm, nByte); 
+ 
+    /* This is an RBU connection that uses its own heap memory for the 
+    ** pages of the *-shm file. Since no other process can have run 
+    ** recovery, the connection must request *-shm pages in order 
+    ** from start to finish.  */ 
+    assert( iRegion==p->nShm ); 
+    if( apNew==0 ){ 
+      rc = SQLITE_NOMEM; 
+    }else{ 
+      memset(&apNew[p->nShm], 0, sizeof(char*) * (1 + iRegion - p->nShm)); 
+      p->apShm = apNew; 
+      p->nShm = iRegion+1; 
+    }
+
+    if( rc==SQLITE_OK ){ 
       char *pNew = (char*)sqlite3_malloc64(szRegion);
       if( pNew==0 ){
         rc = SQLITE_NOMEM;
@@ -206843,7 +206843,7 @@ static int rbuVfsOpen(
       pFd->zWal = sqlite3_filename_wal(zName);
     }
     else if( flags & SQLITE_OPEN_WAL ){
-      rbu_file *pDb = rbuFindMaindb(pRbuVfs, zName, 0);
+      rbu_file *pDb = rbuFindMaindb(pRbuVfs, zName, 0); 
       if( pDb ){
         if( pDb->pRbu && pDb->pRbu->eStage==RBU_STAGE_OAL ){
           /* This call is to open a *-wal file. Intead, open the *-oal. */
@@ -206881,7 +206881,7 @@ static int rbuVfsOpen(
     ** mutex protected linked list of all such files.  */
     pFile->pMethods = &rbuvfs_io_methods;
     if( flags & SQLITE_OPEN_MAIN_DB ){
-      rbuMainlistAdd(pFd);
+      rbuMainlistAdd(pFd); 
     }
   }else{
     sqlite3_free(pFd->zDel);
@@ -206929,9 +206929,9 @@ static int rbuVfsAccess(
   **      file opened instead.
   */
   if( rc==SQLITE_OK && flags==SQLITE_ACCESS_EXISTS ){
-    rbu_file *pDb = rbuFindMaindb(pRbuVfs, zPath, 1);
-    if( pDb && pDb->pRbu->eStage==RBU_STAGE_OAL ){
-      assert( pDb->pRbu );
+    rbu_file *pDb = rbuFindMaindb(pRbuVfs, zPath, 1); 
+    if( pDb && pDb->pRbu->eStage==RBU_STAGE_OAL ){ 
+      assert( pDb->pRbu ); 
       if( *pResOut ){
         rc = SQLITE_CANTOPEN;
       }else{
@@ -207450,7 +207450,7 @@ static int statOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
   return SQLITE_OK;
 }
 
-static void statClearCells(StatPage *p){
+static void statClearCells(StatPage *p){ 
   int i;
   if( p->aCell ){
     for(i=0; i<p->nCell; i++){
@@ -207458,13 +207458,13 @@ static void statClearCells(StatPage *p){
     }
     sqlite3_free(p->aCell);
   }
-  p->nCell = 0;
-  p->aCell = 0;
-}
-
-static void statClearPage(StatPage *p){
+  p->nCell = 0; 
+  p->aCell = 0; 
+} 
+ 
+static void statClearPage(StatPage *p){ 
   u8 *aPg = p->aPg;
-  statClearCells(p);
+  statClearCells(p); 
   sqlite3_free(p->zPath);
   memset(p, 0, sizeof(StatPage));
   p->aPg = aPg;
@@ -207550,30 +207550,30 @@ static int statDecodePage(Btree *pBt, StatPage *p){
   u8 *aHdr = &aData[p->iPgno==1 ? 100 : 0];
 
   p->flags = aHdr[0];
-  if( p->flags==0x0A || p->flags==0x0D ){
-    isLeaf = 1;
-    nHdr = 8;
-  }else if( p->flags==0x05 || p->flags==0x02 ){
-    isLeaf = 0;
-    nHdr = 12;
-  }else{
-    goto statPageIsCorrupt;
-  }
-  if( p->iPgno==1 ) nHdr += 100;
+  if( p->flags==0x0A || p->flags==0x0D ){ 
+    isLeaf = 1; 
+    nHdr = 8; 
+  }else if( p->flags==0x05 || p->flags==0x02 ){ 
+    isLeaf = 0; 
+    nHdr = 12; 
+  }else{ 
+    goto statPageIsCorrupt; 
+  } 
+  if( p->iPgno==1 ) nHdr += 100; 
   p->nCell = get2byte(&aHdr[3]);
   p->nMxPayload = 0;
-  szPage = sqlite3BtreeGetPageSize(pBt);
+  szPage = sqlite3BtreeGetPageSize(pBt); 
 
   nUnused = get2byte(&aHdr[5]) - nHdr - 2*p->nCell;
   nUnused += (int)aHdr[7];
   iOff = get2byte(&aHdr[1]);
   while( iOff ){
-    int iNext;
-    if( iOff>=szPage ) goto statPageIsCorrupt;
+    int iNext; 
+    if( iOff>=szPage ) goto statPageIsCorrupt; 
     nUnused += get2byte(&aData[iOff+2]);
-    iNext = get2byte(&aData[iOff]);
-    if( iNext<iOff+4 && iNext>0 ) goto statPageIsCorrupt;
-    iOff = iNext;
+    iNext = get2byte(&aData[iOff]); 
+    if( iNext<iOff+4 && iNext>0 ) goto statPageIsCorrupt; 
+    iOff = iNext; 
   }
   p->nUnused = nUnused;
   p->iRightChildPg = isLeaf ? 0 : sqlite3Get4byte(&aHdr[8]);
@@ -207593,7 +207593,7 @@ static int statDecodePage(Btree *pBt, StatPage *p){
       StatCell *pCell = &p->aCell[i];
 
       iOff = get2byte(&aData[nHdr+i*2]);
-      if( iOff<nHdr || iOff>=szPage ) goto statPageIsCorrupt;
+      if( iOff<nHdr || iOff>=szPage ) goto statPageIsCorrupt; 
       if( !isLeaf ){
         pCell->iChildPg = sqlite3Get4byte(&aData[iOff]);
         iOff += 4;
@@ -207610,7 +207610,7 @@ static int statDecodePage(Btree *pBt, StatPage *p){
         }
         if( nPayload>(u32)p->nMxPayload ) p->nMxPayload = nPayload;
         nLocal = getLocalPayload(nUsable, p->flags, nPayload);
-        if( nLocal<0 ) goto statPageIsCorrupt;
+        if( nLocal<0 ) goto statPageIsCorrupt; 
         pCell->nLocal = nLocal;
         assert( nPayload>=(u32)nLocal );
         assert( nLocal<=(nUsable-35) );
@@ -207643,11 +207643,11 @@ static int statDecodePage(Btree *pBt, StatPage *p){
   }
 
   return SQLITE_OK;
-
-statPageIsCorrupt:
-  p->flags = 0;
-  statClearCells(p);
-  return SQLITE_OK;
+ 
+statPageIsCorrupt: 
+  p->flags = 0; 
+  statClearCells(p); 
+  return SQLITE_OK; 
 }
 
 /*
@@ -207666,7 +207666,7 @@ static void statSizeAndOffset(StatCursor *pCsr){
   */
   fd = sqlite3PagerFile(pPager);
   x[0] = pCsr->iPageno;
-  if( sqlite3OsFileControl(fd, 230440, &x)==SQLITE_OK ){
+  if( sqlite3OsFileControl(fd, 230440, &x)==SQLITE_OK ){ 
     pCsr->iOffset = x[0];
     pCsr->szPage += x[1];
   }else{
@@ -207798,10 +207798,10 @@ statNextRestart:
       goto statNextRestart; /* Tail recursion */
     }
     pCsr->iPage++;
-    if( pCsr->iPage>=ArraySize(pCsr->aPage) ){
-      statResetCsr(pCsr);
-      return SQLITE_CORRUPT_BKPT;
-    }
+    if( pCsr->iPage>=ArraySize(pCsr->aPage) ){ 
+      statResetCsr(pCsr); 
+      return SQLITE_CORRUPT_BKPT; 
+    } 
     assert( p==&pCsr->aPage[pCsr->iPage-1] );
 
     if( p->iCell==p->nCell ){
@@ -208040,7 +208040,7 @@ SQLITE_PRIVATE int sqlite3DbstatRegister(sqlite3 *db){
     0,                            /* xSavepoint */
     0,                            /* xRelease */
     0,                            /* xRollbackTo */
-    0                             /* xShadowName */
+    0                             /* xShadowName */ 
   };
   return sqlite3_create_module(db, "dbstat", &dbstat_module, 0);
 }
@@ -208172,8 +208172,8 @@ static int dbpageBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
     if( p->iColumn!=DBPAGE_COLUMN_SCHEMA ) continue;
     if( p->op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
     if( !p->usable ){
-      /* No solution. */
-      return SQLITE_CONSTRAINT;
+      /* No solution. */ 
+      return SQLITE_CONSTRAINT; 
     }
     iPlan = 2;
     pIdxInfo->aConstraintUsage[i].argvIndex = 1;
@@ -208365,10 +208365,10 @@ static int dbpageUpdate(
   Pager *pPager;
   int szPage;
 
-  if( pTab->db->flags & SQLITE_Defensive ){
-    zErr = "read-only";
-    goto update_fail;
-  }
+  if( pTab->db->flags & SQLITE_Defensive ){ 
+    zErr = "read-only"; 
+    goto update_fail; 
+  } 
   if( argc==1 ){
     zErr = "cannot delete";
     goto update_fail;
@@ -208425,7 +208425,7 @@ static int dbpageBegin(sqlite3_vtab *pVtab){
   int i;
   for(i=0; i<db->nDb; i++){
     Btree *pBt = db->aDb[i].pBt;
-    if( pBt ) sqlite3BtreeBeginTrans(pBt, 1, 0);
+    if( pBt ) sqlite3BtreeBeginTrans(pBt, 1, 0); 
   }
   return SQLITE_OK;
 }
@@ -208459,7 +208459,7 @@ SQLITE_PRIVATE int sqlite3DbpageRegister(sqlite3 *db){
     0,                            /* xSavepoint */
     0,                            /* xRelease */
     0,                            /* xRollbackTo */
-    0                             /* xShadowName */
+    0                             /* xShadowName */ 
   };
   return sqlite3_create_module(db, "sqlite_dbpage", &dbpage_module, 0);
 }
@@ -208496,8 +208496,8 @@ typedef struct SessionInput SessionInput;
 # endif
 #endif
 
-static int sessions_strm_chunk_size = SESSIONS_STRM_CHUNK_SIZE;
-
+static int sessions_strm_chunk_size = SESSIONS_STRM_CHUNK_SIZE; 
+ 
 typedef struct SessionHook SessionHook;
 struct SessionHook {
   void *pCtx;
@@ -208544,7 +208544,7 @@ struct SessionBuffer {
 **  sqlite3changeset_start_strm()).
 */
 struct SessionInput {
-  int bNoDiscard;                 /* If true, do not discard in InputBuffer() */
+  int bNoDiscard;                 /* If true, do not discard in InputBuffer() */ 
   int iCurrent;                   /* Offset in aData[] of current change */
   int iNext;                      /* Offset in aData[] of next change */
   u8 *aData;                      /* Pointer to buffer containing changeset */
@@ -208563,7 +208563,7 @@ struct sqlite3_changeset_iter {
   SessionInput in;                /* Input buffer or stream */
   SessionBuffer tblhdr;           /* Buffer to hold apValue/zTab/abPK/ */
   int bPatchset;                  /* True if this is a patchset */
-  int bInvert;                    /* True to invert changeset */
+  int bInvert;                    /* True to invert changeset */ 
   int bSkipEmpty;                 /* Skip noop UPDATE changes */
   int rc;                         /* Iterator error code */
   sqlite3_stmt *pConflict;        /* Points to conflicting row, if any */
@@ -208710,8 +208710,8 @@ struct SessionTable {
 ** statement.
 **
 ** For a DELETE change, all fields within the record except those associated
-** with PRIMARY KEY columns are omitted. The PRIMARY KEY fields contain the
-** values identifying the row to delete.
+** with PRIMARY KEY columns are omitted. The PRIMARY KEY fields contain the 
+** values identifying the row to delete. 
 **
 ** For an UPDATE change, all fields except those associated with PRIMARY KEY
 ** columns and columns that are modified by the UPDATE are set to "undefined".
@@ -208721,42 +208721,42 @@ struct SessionTable {
 ** The records associated with INSERT changes are in the same format as for
 ** changesets. It is not possible for a record associated with an INSERT
 ** change to contain a field set to "undefined".
-**
-** REBASE BLOB FORMAT:
-**
+** 
+** REBASE BLOB FORMAT: 
+** 
 ** A rebase blob may be output by sqlite3changeset_apply_v2() and its
-** streaming equivalent for use with the sqlite3_rebaser APIs to rebase
-** existing changesets. A rebase blob contains one entry for each conflict
-** resolved using either the OMIT or REPLACE strategies within the apply_v2()
-** call.
-**
-** The format used for a rebase blob is very similar to that used for
-** changesets. All entries related to a single table are grouped together.
-**
-** Each group of entries begins with a table header in changeset format:
-**
-**   1 byte: Constant 0x54 (capital 'T')
-**   Varint: Number of columns in the table.
-**   nCol bytes: 0x01 for PK columns, 0x00 otherwise.
-**   N bytes: Unqualified table name (encoded using UTF-8). Nul-terminated.
-**
-** Followed by one or more entries associated with the table.
-**
-**   1 byte: Either SQLITE_INSERT (0x12), DELETE (0x09).
-**   1 byte: Flag. 0x01 for REPLACE, 0x00 for OMIT.
-**   record: (in the record format defined above).
-**
-** In a rebase blob, the first field is set to SQLITE_INSERT if the change
-** that caused the conflict was an INSERT or UPDATE, or to SQLITE_DELETE if
+** streaming equivalent for use with the sqlite3_rebaser APIs to rebase 
+** existing changesets. A rebase blob contains one entry for each conflict 
+** resolved using either the OMIT or REPLACE strategies within the apply_v2() 
+** call. 
+** 
+** The format used for a rebase blob is very similar to that used for 
+** changesets. All entries related to a single table are grouped together. 
+** 
+** Each group of entries begins with a table header in changeset format: 
+** 
+**   1 byte: Constant 0x54 (capital 'T') 
+**   Varint: Number of columns in the table. 
+**   nCol bytes: 0x01 for PK columns, 0x00 otherwise. 
+**   N bytes: Unqualified table name (encoded using UTF-8). Nul-terminated. 
+** 
+** Followed by one or more entries associated with the table. 
+** 
+**   1 byte: Either SQLITE_INSERT (0x12), DELETE (0x09). 
+**   1 byte: Flag. 0x01 for REPLACE, 0x00 for OMIT. 
+**   record: (in the record format defined above). 
+** 
+** In a rebase blob, the first field is set to SQLITE_INSERT if the change 
+** that caused the conflict was an INSERT or UPDATE, or to SQLITE_DELETE if 
 ** it was a DELETE. The second field is set to 0x01 if the conflict
-** resolution strategy was REPLACE, or 0x00 if it was OMIT.
-**
-** If the change that caused the conflict was a DELETE, then the single
-** record is a copy of the old.* record from the original changeset. If it
-** was an INSERT, then the single record is a copy of the new.* record. If
-** the conflicting change was an UPDATE, then the single record is a copy
-** of the new.* record with the PK fields filled in based on the original
-** old.* record.
+** resolution strategy was REPLACE, or 0x00 if it was OMIT. 
+** 
+** If the change that caused the conflict was a DELETE, then the single 
+** record is a copy of the old.* record from the original changeset. If it 
+** was an INSERT, then the single record is a copy of the new.* record. If 
+** the conflicting change was an UPDATE, then the single record is a copy 
+** of the new.* record with the PK fields filled in based on the original 
+** old.* record. 
 */
 
 /*
@@ -208839,7 +208839,7 @@ static void sessionPutI64(u8 *aBuf, sqlite3_int64 i){
 static int sessionSerializeValue(
   u8 *aBuf,                       /* If non-NULL, write serialized value here */
   sqlite3_value *pValue,          /* Value to serialize */
-  sqlite3_int64 *pnWrite          /* IN/OUT: Increment by bytes written */
+  sqlite3_int64 *pnWrite          /* IN/OUT: Increment by bytes written */ 
 ){
   int nByte;                      /* Size of serialized value in bytes */
 
@@ -209051,7 +209051,7 @@ static int sessionPreupdateHash(
 static int sessionSerialLen(u8 *a){
   int e = *a;
   int n;
-  if( e==0 || e==0xFF ) return 1;
+  if( e==0 || e==0xFF ) return 1; 
   if( e==SQLITE_NULL ) return 1;
   if( e==SQLITE_INTEGER || e==SQLITE_FLOAT ) return 9;
   return sessionVarintGet(&a[1], &n) + 1 + n;
@@ -209131,7 +209131,7 @@ static int sessionChangeEqual(
       int n1 = sessionSerialLen(a1);
       int n2 = sessionSerialLen(a2);
 
-      if( n1!=n2 || memcmp(a1, a2, n1) ){
+      if( n1!=n2 || memcmp(a1, a2, n1) ){ 
         return 0;
       }
       a1 += n1;
@@ -209374,7 +209374,7 @@ static int sessionPreupdateEqual(
         }else{
           z = sqlite3_value_blob(pVal);
         }
-        if( n>0 && memcmp(a, z, n) ) return 0;
+        if( n>0 && memcmp(a, z, n) ) return 0; 
         a += n;
       }
     }
@@ -209402,7 +209402,7 @@ static int sessionGrowHash(
   if( pTab->nChange==0 || pTab->nEntry>=(pTab->nChange/2) ){
     int i;
     SessionChange **apNew;
-    sqlite3_int64 nNew = 2*(sqlite3_int64)(pTab->nChange ? pTab->nChange : 128);
+    sqlite3_int64 nNew = 2*(sqlite3_int64)(pTab->nChange ? pTab->nChange : 128); 
 
     apNew = (SessionChange**)sessionMalloc64(
         pSession, sizeof(SessionChange*) * nNew
@@ -209473,7 +209473,7 @@ static int sessionTableInfo(
   char *zPragma;
   sqlite3_stmt *pStmt;
   int rc;
-  sqlite3_int64 nByte;
+  sqlite3_int64 nByte; 
   int nDbCol = 0;
   int nThis;
   int i;
@@ -209776,7 +209776,7 @@ static void sessionPreupdateOneChange(
   int iHash;
   int bNull = 0;
   int rc = SQLITE_OK;
-  SessionStat1Ctx stat1 = {{0,0,0,0,0},0};
+  SessionStat1Ctx stat1 = {{0,0,0,0,0},0}; 
 
   if( pSession->rc ) return;
 
@@ -209832,7 +209832,7 @@ static void sessionPreupdateOneChange(
       /* Create a new change object containing all the old values (if
       ** this is an SQLITE_UPDATE or SQLITE_DELETE), or just the PK
       ** values (if this is an INSERT). */
-      sqlite3_int64 nByte;    /* Number of bytes to allocate */
+      sqlite3_int64 nByte;    /* Number of bytes to allocate */ 
       int i;                  /* Used to iterate through columns */
 
       assert( rc==SQLITE_OK );
@@ -210255,9 +210255,9 @@ SQLITE_API int sqlite3session_diff(
       }
       sqlite3_free((char*)azCol);
       if( bMismatch ){
-        if( pzErrMsg ){
-          *pzErrMsg = sqlite3_mprintf("table schemas do not match");
-        }
+        if( pzErrMsg ){ 
+          *pzErrMsg = sqlite3_mprintf("table schemas do not match"); 
+        } 
         rc = SQLITE_SCHEMA;
       }
       if( bHasPk==0 ){
@@ -210313,7 +210313,7 @@ SQLITE_API int sqlite3session_create(
   *ppSession = 0;
 
   /* Allocate and populate the new session object. */
-  pNew = (sqlite3_session *)sqlite3_malloc64(sizeof(sqlite3_session) + nDb + 1);
+  pNew = (sqlite3_session *)sqlite3_malloc64(sizeof(sqlite3_session) + nDb + 1); 
   if( !pNew ) return SQLITE_NOMEM;
   memset(pNew, 0, sizeof(sqlite3_session));
   pNew->db = db;
@@ -210470,7 +210470,7 @@ static int sessionBufferGrow(SessionBuffer *p, i64 nByte, int *pRc){
   i64 nReq = p->nBuf + nByte;
   if( *pRc==SQLITE_OK && nReq>p->nAlloc ){
     u8 *aNew;
-    i64 nNew = p->nAlloc ? p->nAlloc : 128;
+    i64 nNew = p->nAlloc ? p->nAlloc : 128; 
 
     do {
       nNew = nNew*2;
@@ -210489,7 +210489,7 @@ static int sessionBufferGrow(SessionBuffer *p, i64 nByte, int *pRc){
       }
     }
 
-    aNew = (u8 *)sqlite3_realloc64(p->aBuf, nNew);
+    aNew = (u8 *)sqlite3_realloc64(p->aBuf, nNew); 
     if( 0==aNew ){
       *pRc = SQLITE_NOMEM;
     }else{
@@ -210511,7 +210511,7 @@ static int sessionBufferGrow(SessionBuffer *p, i64 nByte, int *pRc){
 static void sessionAppendValue(SessionBuffer *p, sqlite3_value *pVal, int *pRc){
   int rc = *pRc;
   if( rc==SQLITE_OK ){
-    sqlite3_int64 nByte = 0;
+    sqlite3_int64 nByte = 0; 
     rc = sessionSerializeValue(0, pVal, &nByte);
     sessionBufferGrow(p, nByte, &rc);
     if( rc==SQLITE_OK ){
@@ -210875,7 +210875,7 @@ static int sessionSelectStmt(
         "SELECT tbl, ?2, stat FROM %Q.sqlite_stat1 WHERE tbl IS ?1 AND "
         "idx IS (CASE WHEN ?2=X'' THEN NULL ELSE ?2 END)", zDb
     );
-    if( zSql==0 ) rc = SQLITE_NOMEM;
+    if( zSql==0 ) rc = SQLITE_NOMEM; 
   }else{
     int i;
     const char *zSep = "";
@@ -211091,7 +211091,7 @@ static int sessionGenerateChangeset(
             rc = sqlite3_reset(pSel);
           }
 
-          /* If the buffer is now larger than sessions_strm_chunk_size, pass
+          /* If the buffer is now larger than sessions_strm_chunk_size, pass 
           ** its contents to the xOutput() callback. */
           if( xOutput
            && rc==SQLITE_OK
@@ -211285,7 +211285,7 @@ static int sessionChangesetStart(
   int (*xInput)(void *pIn, void *pData, int *pnData),
   void *pIn,
   int nChangeset,                 /* Size of buffer pChangeset in bytes */
-  void *pChangeset,               /* Pointer to buffer containing changeset */
+  void *pChangeset,               /* Pointer to buffer containing changeset */ 
   int bInvert,                    /* True to invert changeset */
   int bSkipEmpty                  /* True to skip empty UPDATE changes */
 ){
@@ -211307,7 +211307,7 @@ static int sessionChangesetStart(
   pRet->in.xInput = xInput;
   pRet->in.pIn = pIn;
   pRet->in.bEof = (xInput ? 0 : 1);
-  pRet->bInvert = bInvert;
+  pRet->bInvert = bInvert; 
   pRet->bSkipEmpty = bSkipEmpty;
 
   /* Populate the output variable and return success. */
@@ -211325,15 +211325,15 @@ SQLITE_API int sqlite3changeset_start(
 ){
   return sessionChangesetStart(pp, 0, 0, nChangeset, pChangeset, 0, 0);
 }
-SQLITE_API int sqlite3changeset_start_v2(
-  sqlite3_changeset_iter **pp,    /* OUT: Changeset iterator handle */
-  int nChangeset,                 /* Size of buffer pChangeset in bytes */
-  void *pChangeset,               /* Pointer to buffer containing changeset */
-  int flags
-){
-  int bInvert = !!(flags & SQLITE_CHANGESETSTART_INVERT);
+SQLITE_API int sqlite3changeset_start_v2( 
+  sqlite3_changeset_iter **pp,    /* OUT: Changeset iterator handle */ 
+  int nChangeset,                 /* Size of buffer pChangeset in bytes */ 
+  void *pChangeset,               /* Pointer to buffer containing changeset */ 
+  int flags 
+){ 
+  int bInvert = !!(flags & SQLITE_CHANGESETSTART_INVERT); 
   return sessionChangesetStart(pp, 0, 0, nChangeset, pChangeset, bInvert, 0);
-}
+} 
 
 /*
 ** Streaming version of sqlite3changeset_start().
@@ -211345,22 +211345,22 @@ SQLITE_API int sqlite3changeset_start_strm(
 ){
   return sessionChangesetStart(pp, xInput, pIn, 0, 0, 0, 0);
 }
-SQLITE_API int sqlite3changeset_start_v2_strm(
-  sqlite3_changeset_iter **pp,    /* OUT: Changeset iterator handle */
-  int (*xInput)(void *pIn, void *pData, int *pnData),
-  void *pIn,
-  int flags
-){
-  int bInvert = !!(flags & SQLITE_CHANGESETSTART_INVERT);
+SQLITE_API int sqlite3changeset_start_v2_strm( 
+  sqlite3_changeset_iter **pp,    /* OUT: Changeset iterator handle */ 
+  int (*xInput)(void *pIn, void *pData, int *pnData), 
+  void *pIn, 
+  int flags 
+){ 
+  int bInvert = !!(flags & SQLITE_CHANGESETSTART_INVERT); 
   return sessionChangesetStart(pp, xInput, pIn, 0, 0, bInvert, 0);
-}
+} 
 
 /*
 ** If the SessionInput object passed as the only argument is a streaming
 ** object and the buffer is full, discard some data to free up space.
 */
 static void sessionDiscardData(SessionInput *pIn){
-  if( pIn->xInput && pIn->iNext>=sessions_strm_chunk_size ){
+  if( pIn->xInput && pIn->iNext>=sessions_strm_chunk_size ){ 
     int nMove = pIn->buf.nBuf - pIn->iNext;
     assert( nMove>=0 );
     if( nMove>0 ){
@@ -211383,7 +211383,7 @@ static int sessionInputBuffer(SessionInput *pIn, int nByte){
   int rc = SQLITE_OK;
   if( pIn->xInput ){
     while( !pIn->bEof && (pIn->iNext+nByte)>=pIn->nData && rc==SQLITE_OK ){
-      int nNew = sessions_strm_chunk_size;
+      int nNew = sessions_strm_chunk_size; 
 
       if( pIn->bNoDiscard==0 ) sessionDiscardData(pIn);
       if( SQLITE_OK==sessionBufferGrow(&pIn->buf, nNew, &rc) ){
@@ -211443,7 +211443,7 @@ static int sessionValueSetStr(
   ** argument to sqlite3ValueSetStr() and have the copy created
   ** automatically. But doing so makes it difficult to detect any OOM
   ** error. Hence the code to create the copy externally. */
-  u8 *aCopy = sqlite3_malloc64((sqlite3_int64)nData+1);
+  u8 *aCopy = sqlite3_malloc64((sqlite3_int64)nData+1); 
   if( aCopy==0 ) return SQLITE_NOMEM;
   memcpy(aCopy, aData, nData);
   sqlite3ValueSetStr(pVal, nData, (char*)aCopy, enc, sqlite3_free);
@@ -211491,17 +211491,17 @@ static int sessionReadRecord(
     if( abPK && abPK[i]==0 ) continue;
     rc = sessionInputBuffer(pIn, 9);
     if( rc==SQLITE_OK ){
-      if( pIn->iNext>=pIn->nData ){
-        rc = SQLITE_CORRUPT_BKPT;
-      }else{
-        eType = pIn->aData[pIn->iNext++];
-        assert( apOut[i]==0 );
-        if( eType ){
+      if( pIn->iNext>=pIn->nData ){ 
+        rc = SQLITE_CORRUPT_BKPT; 
+      }else{ 
+        eType = pIn->aData[pIn->iNext++]; 
+        assert( apOut[i]==0 ); 
+        if( eType ){ 
           if( pbEmpty ) *pbEmpty = 0;
-          apOut[i] = sqlite3ValueNew(0);
-          if( !apOut[i] ) rc = SQLITE_NOMEM;
-        }
-      }
+          apOut[i] = sqlite3ValueNew(0); 
+          if( !apOut[i] ) rc = SQLITE_NOMEM; 
+        } 
+      } 
     }
 
     if( rc==SQLITE_OK ){
@@ -211511,13 +211511,13 @@ static int sessionReadRecord(
         pIn->iNext += sessionVarintGet(aVal, &nByte);
         rc = sessionInputBuffer(pIn, nByte);
         if( rc==SQLITE_OK ){
-          if( nByte<0 || nByte>pIn->nData-pIn->iNext ){
-            rc = SQLITE_CORRUPT_BKPT;
-          }else{
-            u8 enc = (eType==SQLITE_TEXT ? SQLITE_UTF8 : 0);
-            rc = sessionValueSetStr(apOut[i],&pIn->aData[pIn->iNext],nByte,enc);
-            pIn->iNext += nByte;
-          }
+          if( nByte<0 || nByte>pIn->nData-pIn->iNext ){ 
+            rc = SQLITE_CORRUPT_BKPT; 
+          }else{ 
+            u8 enc = (eType==SQLITE_TEXT ? SQLITE_UTF8 : 0); 
+            rc = sessionValueSetStr(apOut[i],&pIn->aData[pIn->iNext],nByte,enc); 
+            pIn->iNext += nByte; 
+          } 
         }
       }
       if( eType==SQLITE_INTEGER || eType==SQLITE_FLOAT ){
@@ -211558,19 +211558,19 @@ static int sessionChangesetBufferTblhdr(SessionInput *pIn, int *pnByte){
   rc = sessionInputBuffer(pIn, 9);
   if( rc==SQLITE_OK ){
     nRead += sessionVarintGet(&pIn->aData[pIn->iNext + nRead], &nCol);
-    /* The hard upper limit for the number of columns in an SQLite
+    /* The hard upper limit for the number of columns in an SQLite 
     ** database table is, according to sqliteLimit.h, 32676. So
     ** consider any table-header that purports to have more than 65536
     ** columns to be corrupt. This is convenient because otherwise,
     ** if the (nCol>65536) condition below were omitted, a sufficiently
     ** large value for nCol may cause nRead to wrap around and become
-    ** negative. Leading to a crash. */
-    if( nCol<0 || nCol>65536 ){
-      rc = SQLITE_CORRUPT_BKPT;
-    }else{
-      rc = sessionInputBuffer(pIn, nRead+nCol+100);
-      nRead += nCol;
-    }
+    ** negative. Leading to a crash. */ 
+    if( nCol<0 || nCol>65536 ){ 
+      rc = SQLITE_CORRUPT_BKPT; 
+    }else{ 
+      rc = sessionInputBuffer(pIn, nRead+nCol+100); 
+      nRead += nCol; 
+    } 
   }
 
   while( rc==SQLITE_OK ){
@@ -211647,19 +211647,19 @@ static int sessionChangesetReadTblhdr(sqlite3_changeset_iter *p){
     int nByte;
     int nVarint;
     nVarint = sessionVarintGet(&p->in.aData[p->in.iNext], &p->nCol);
-    if( p->nCol>0 ){
-      nCopy -= nVarint;
-      p->in.iNext += nVarint;
-      nByte = p->nCol * sizeof(sqlite3_value*) * 2 + nCopy;
-      p->tblhdr.nBuf = 0;
-      sessionBufferGrow(&p->tblhdr, nByte, &rc);
-    }else{
-      rc = SQLITE_CORRUPT_BKPT;
-    }
+    if( p->nCol>0 ){ 
+      nCopy -= nVarint; 
+      p->in.iNext += nVarint; 
+      nByte = p->nCol * sizeof(sqlite3_value*) * 2 + nCopy; 
+      p->tblhdr.nBuf = 0; 
+      sessionBufferGrow(&p->tblhdr, nByte, &rc); 
+    }else{ 
+      rc = SQLITE_CORRUPT_BKPT; 
+    } 
   }
 
   if( rc==SQLITE_OK ){
-    size_t iPK = sizeof(sqlite3_value*)*p->nCol*2;
+    size_t iPK = sizeof(sqlite3_value*)*p->nCol*2; 
     memset(p->tblhdr.aBuf, 0, iPK);
     memcpy(&p->tblhdr.aBuf[iPK], &p->in.aData[p->in.iNext], nCopy);
     p->in.iNext += nCopy;
@@ -211689,7 +211689,7 @@ static int sessionChangesetReadTblhdr(sqlite3_changeset_iter *p){
 static int sessionChangesetNextOne(
   sqlite3_changeset_iter *p,      /* Changeset iterator */
   u8 **paRec,                     /* If non-NULL, store record pointer here */
-  int *pnRec,                     /* If non-NULL, store size of record here */
+  int *pnRec,                     /* If non-NULL, store size of record here */ 
   int *pbNew,                     /* If non-NULL, true if new table */
   int *pbEmpty
 ){
@@ -211727,7 +211727,7 @@ static int sessionChangesetNextOne(
 
   op = p->in.aData[p->in.iNext++];
   while( op=='T' || op=='P' ){
-    if( pbNew ) *pbNew = 1;
+    if( pbNew ) *pbNew = 1; 
     p->bPatchset = (op=='P');
     if( sessionChangesetReadTblhdr(p) ) return p->rc;
     if( (p->rc = sessionInputBuffer(&p->in, 2)) ) return p->rc;
@@ -211736,13 +211736,13 @@ static int sessionChangesetNextOne(
     op = p->in.aData[p->in.iNext++];
   }
 
-  if( p->zTab==0 || (p->bPatchset && p->bInvert) ){
-    /* The first record in the changeset is not a table header. Must be a
-    ** corrupt changeset. */
-    assert( p->in.iNext==1 || p->zTab );
-    return (p->rc = SQLITE_CORRUPT_BKPT);
-  }
-
+  if( p->zTab==0 || (p->bPatchset && p->bInvert) ){ 
+    /* The first record in the changeset is not a table header. Must be a 
+    ** corrupt changeset. */ 
+    assert( p->in.iNext==1 || p->zTab ); 
+    return (p->rc = SQLITE_CORRUPT_BKPT); 
+  } 
+ 
   p->op = op;
   p->bIndirect = p->in.aData[p->in.iNext++];
   if( p->op!=SQLITE_UPDATE && p->op!=SQLITE_DELETE && p->op!=SQLITE_INSERT ){
@@ -211764,8 +211764,8 @@ static int sessionChangesetNextOne(
     *paRec = &p->in.aData[p->in.iNext];
     p->in.iNext += *pnRec;
   }else{
-    sqlite3_value **apOld = (p->bInvert ? &p->apValue[p->nCol] : p->apValue);
-    sqlite3_value **apNew = (p->bInvert ? p->apValue : &p->apValue[p->nCol]);
+    sqlite3_value **apOld = (p->bInvert ? &p->apValue[p->nCol] : p->apValue); 
+    sqlite3_value **apNew = (p->bInvert ? p->apValue : &p->apValue[p->nCol]); 
 
     /* If this is an UPDATE or DELETE, read the old.* record. */
     if( p->op!=SQLITE_INSERT && (p->bPatchset==0 || p->op==SQLITE_DELETE) ){
@@ -211780,23 +211780,23 @@ static int sessionChangesetNextOne(
       if( p->rc!=SQLITE_OK ) return p->rc;
     }
 
-    if( (p->bPatchset || p->bInvert) && p->op==SQLITE_UPDATE ){
+    if( (p->bPatchset || p->bInvert) && p->op==SQLITE_UPDATE ){ 
       /* If this is an UPDATE that is part of a patchset, then all PK and
       ** modified fields are present in the new.* record. The old.* record
       ** is currently completely empty. This block shifts the PK fields from
       ** new.* to old.*, to accommodate the code that reads these arrays.  */
       for(i=0; i<p->nCol; i++){
-        assert( p->bPatchset==0 || p->apValue[i]==0 );
+        assert( p->bPatchset==0 || p->apValue[i]==0 ); 
         if( p->abPK[i] ){
-          assert( p->apValue[i]==0 );
+          assert( p->apValue[i]==0 ); 
           p->apValue[i] = p->apValue[i+p->nCol];
-          if( p->apValue[i]==0 ) return (p->rc = SQLITE_CORRUPT_BKPT);
+          if( p->apValue[i]==0 ) return (p->rc = SQLITE_CORRUPT_BKPT); 
           p->apValue[i+p->nCol] = 0;
         }
       }
-    }else if( p->bInvert ){
-      if( p->op==SQLITE_INSERT ) p->op = SQLITE_DELETE;
-      else if( p->op==SQLITE_DELETE ) p->op = SQLITE_INSERT;
+    }else if( p->bInvert ){ 
+      if( p->op==SQLITE_INSERT ) p->op = SQLITE_DELETE; 
+      else if( p->op==SQLITE_DELETE ) p->op = SQLITE_INSERT; 
     }
   }
 
@@ -211843,7 +211843,7 @@ static int sessionChangesetNext(
 ** callback by changeset_apply().
 */
 SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *p){
-  return sessionChangesetNext(p, 0, 0, 0);
+  return sessionChangesetNext(p, 0, 0, 0); 
 }
 
 /*
@@ -212092,7 +212092,7 @@ static int sessionChangesetInvert(
         int iCol;
 
         if( 0==apVal ){
-          apVal = (sqlite3_value **)sqlite3_malloc64(sizeof(apVal[0])*nCol*2);
+          apVal = (sqlite3_value **)sqlite3_malloc64(sizeof(apVal[0])*nCol*2); 
           if( 0==apVal ){
             rc = SQLITE_NOMEM;
             goto finished_invert;
@@ -212144,7 +212144,7 @@ static int sessionChangesetInvert(
     }
 
     assert( rc==SQLITE_OK );
-    if( xOutput && sOut.nBuf>=sessions_strm_chunk_size ){
+    if( xOutput && sOut.nBuf>=sessions_strm_chunk_size ){ 
       rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
       sOut.nBuf = 0;
       if( rc!=SQLITE_OK ) goto finished_invert;
@@ -212232,9 +212232,9 @@ struct SessionApplyCtx {
   int bDeferConstraints;          /* True to defer constraints */
   int bInvertConstraints;         /* Invert when iterating constraints buffer */
   SessionBuffer constraints;      /* Deferred constraints are stored here */
-  SessionBuffer rebase;           /* Rebase information (if any) here */
-  u8 bRebaseStarted;              /* If table header is already in rebase */
-  u8 bRebase;                     /* True to collect rebase information */
+  SessionBuffer rebase;           /* Rebase information (if any) here */ 
+  u8 bRebaseStarted;              /* If table header is already in rebase */ 
+  u8 bRebase;                     /* True to collect rebase information */ 
 };
 
 /* Number of prepared UPDATE statements to cache. */
@@ -212614,13 +212614,13 @@ static int sessionBindRow(
     if( !abPK || abPK[i] ){
       sqlite3_value *pVal = 0;
       (void)xValue(pIter, i, &pVal);
-      if( pVal==0 ){
-        /* The value in the changeset was "undefined". This indicates a
-        ** corrupt changeset blob.  */
-        rc = SQLITE_CORRUPT_BKPT;
-      }else{
-        rc = sessionBindValue(pStmt, i+1, pVal);
-      }
+      if( pVal==0 ){ 
+        /* The value in the changeset was "undefined". This indicates a 
+        ** corrupt changeset blob.  */ 
+        rc = SQLITE_CORRUPT_BKPT; 
+      }else{ 
+        rc = sessionBindValue(pStmt, i+1, pVal); 
+      } 
     }
   }
   return rc;
@@ -212669,55 +212669,55 @@ static int sessionSeekToRow(
 }
 
 /*
-** This function is called from within sqlite3changeset_apply_v2() when
-** a conflict is encountered and resolved using conflict resolution
-** mode eType (either SQLITE_CHANGESET_OMIT or SQLITE_CHANGESET_REPLACE)..
+** This function is called from within sqlite3changeset_apply_v2() when 
+** a conflict is encountered and resolved using conflict resolution 
+** mode eType (either SQLITE_CHANGESET_OMIT or SQLITE_CHANGESET_REPLACE).. 
 ** It adds a conflict resolution record to the buffer in
-** SessionApplyCtx.rebase, which will eventually be returned to the caller
-** of apply_v2() as the "rebase" buffer.
-**
-** Return SQLITE_OK if successful, or an SQLite error code otherwise.
-*/
-static int sessionRebaseAdd(
-  SessionApplyCtx *p,             /* Apply context */
-  int eType,                      /* Conflict resolution (OMIT or REPLACE) */
-  sqlite3_changeset_iter *pIter   /* Iterator pointing at current change */
-){
-  int rc = SQLITE_OK;
-  if( p->bRebase ){
-    int i;
-    int eOp = pIter->op;
-    if( p->bRebaseStarted==0 ){
-      /* Append a table-header to the rebase buffer */
-      const char *zTab = pIter->zTab;
-      sessionAppendByte(&p->rebase, 'T', &rc);
-      sessionAppendVarint(&p->rebase, p->nCol, &rc);
-      sessionAppendBlob(&p->rebase, p->abPK, p->nCol, &rc);
-      sessionAppendBlob(&p->rebase, (u8*)zTab, (int)strlen(zTab)+1, &rc);
-      p->bRebaseStarted = 1;
-    }
-
-    assert( eType==SQLITE_CHANGESET_REPLACE||eType==SQLITE_CHANGESET_OMIT );
-    assert( eOp==SQLITE_DELETE || eOp==SQLITE_INSERT || eOp==SQLITE_UPDATE );
-
+** SessionApplyCtx.rebase, which will eventually be returned to the caller 
+** of apply_v2() as the "rebase" buffer. 
+** 
+** Return SQLITE_OK if successful, or an SQLite error code otherwise. 
+*/ 
+static int sessionRebaseAdd( 
+  SessionApplyCtx *p,             /* Apply context */ 
+  int eType,                      /* Conflict resolution (OMIT or REPLACE) */ 
+  sqlite3_changeset_iter *pIter   /* Iterator pointing at current change */ 
+){ 
+  int rc = SQLITE_OK; 
+  if( p->bRebase ){ 
+    int i; 
+    int eOp = pIter->op; 
+    if( p->bRebaseStarted==0 ){ 
+      /* Append a table-header to the rebase buffer */ 
+      const char *zTab = pIter->zTab; 
+      sessionAppendByte(&p->rebase, 'T', &rc); 
+      sessionAppendVarint(&p->rebase, p->nCol, &rc); 
+      sessionAppendBlob(&p->rebase, p->abPK, p->nCol, &rc); 
+      sessionAppendBlob(&p->rebase, (u8*)zTab, (int)strlen(zTab)+1, &rc); 
+      p->bRebaseStarted = 1; 
+    } 
+ 
+    assert( eType==SQLITE_CHANGESET_REPLACE||eType==SQLITE_CHANGESET_OMIT ); 
+    assert( eOp==SQLITE_DELETE || eOp==SQLITE_INSERT || eOp==SQLITE_UPDATE ); 
+ 
     sessionAppendByte(&p->rebase,
-        (eOp==SQLITE_DELETE ? SQLITE_DELETE : SQLITE_INSERT), &rc
-        );
-    sessionAppendByte(&p->rebase, (eType==SQLITE_CHANGESET_REPLACE), &rc);
-    for(i=0; i<p->nCol; i++){
-      sqlite3_value *pVal = 0;
-      if( eOp==SQLITE_DELETE || (eOp==SQLITE_UPDATE && p->abPK[i]) ){
-        sqlite3changeset_old(pIter, i, &pVal);
-      }else{
-        sqlite3changeset_new(pIter, i, &pVal);
-      }
-      sessionAppendValue(&p->rebase, pVal, &rc);
-    }
-  }
-  return rc;
-}
-
-/*
+        (eOp==SQLITE_DELETE ? SQLITE_DELETE : SQLITE_INSERT), &rc 
+        ); 
+    sessionAppendByte(&p->rebase, (eType==SQLITE_CHANGESET_REPLACE), &rc); 
+    for(i=0; i<p->nCol; i++){ 
+      sqlite3_value *pVal = 0; 
+      if( eOp==SQLITE_DELETE || (eOp==SQLITE_UPDATE && p->abPK[i]) ){ 
+        sqlite3changeset_old(pIter, i, &pVal); 
+      }else{ 
+        sqlite3changeset_new(pIter, i, &pVal); 
+      } 
+      sessionAppendValue(&p->rebase, pVal, &rc); 
+    } 
+  } 
+  return rc; 
+} 
+ 
+/* 
 ** Invoke the conflict handler for the change that the changeset iterator
 ** currently points to.
 **
@@ -212792,7 +212792,7 @@ static int sessionConflictHandler(
       u8 *aBlob = &pIter->in.aData[pIter->in.iCurrent];
       int nBlob = pIter->in.iNext - pIter->in.iCurrent;
       sessionAppendBlob(&p->constraints, aBlob, nBlob, &rc);
-      return SQLITE_OK;
+      return SQLITE_OK; 
     }else{
       /* No other row with the new.* primary key. */
       res = xConflict(pCtx, eType+1, pIter);
@@ -212818,9 +212818,9 @@ static int sessionConflictHandler(
         rc = SQLITE_MISUSE;
         break;
     }
-    if( rc==SQLITE_OK ){
-      rc = sessionRebaseAdd(p, res, pIter);
-    }
+    if( rc==SQLITE_OK ){ 
+      rc = sessionRebaseAdd(p, res, pIter); 
+    } 
   }
 
   return rc;
@@ -212995,42 +212995,42 @@ static int sessionApplyOneWithRetry(
   int rc;
 
   rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, &bReplace, &bRetry);
-  if( rc==SQLITE_OK ){
-    /* If the bRetry flag is set, the change has not been applied due to an
-    ** SQLITE_CHANGESET_DATA problem (i.e. this is an UPDATE or DELETE and
-    ** a row with the correct PK is present in the db, but one or more other
+  if( rc==SQLITE_OK ){ 
+    /* If the bRetry flag is set, the change has not been applied due to an 
+    ** SQLITE_CHANGESET_DATA problem (i.e. this is an UPDATE or DELETE and 
+    ** a row with the correct PK is present in the db, but one or more other 
     ** fields do not contain the expected values) and the conflict handler
-    ** returned SQLITE_CHANGESET_REPLACE. In this case retry the operation,
-    ** but pass NULL as the final argument so that sessionApplyOneOp() ignores
-    ** the SQLITE_CHANGESET_DATA problem.  */
-    if( bRetry ){
-      assert( pIter->op==SQLITE_UPDATE || pIter->op==SQLITE_DELETE );
+    ** returned SQLITE_CHANGESET_REPLACE. In this case retry the operation, 
+    ** but pass NULL as the final argument so that sessionApplyOneOp() ignores 
+    ** the SQLITE_CHANGESET_DATA problem.  */ 
+    if( bRetry ){ 
+      assert( pIter->op==SQLITE_UPDATE || pIter->op==SQLITE_DELETE ); 
       rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
     }
-
-    /* If the bReplace flag is set, the change is an INSERT that has not
-    ** been performed because the database already contains a row with the
-    ** specified primary key and the conflict handler returned
-    ** SQLITE_CHANGESET_REPLACE. In this case remove the conflicting row
-    ** before reattempting the INSERT.  */
-    else if( bReplace ){
-      assert( pIter->op==SQLITE_INSERT );
-      rc = sqlite3_exec(db, "SAVEPOINT replace_op", 0, 0, 0);
-      if( rc==SQLITE_OK ){
+ 
+    /* If the bReplace flag is set, the change is an INSERT that has not 
+    ** been performed because the database already contains a row with the 
+    ** specified primary key and the conflict handler returned 
+    ** SQLITE_CHANGESET_REPLACE. In this case remove the conflicting row 
+    ** before reattempting the INSERT.  */ 
+    else if( bReplace ){ 
+      assert( pIter->op==SQLITE_INSERT ); 
+      rc = sqlite3_exec(db, "SAVEPOINT replace_op", 0, 0, 0); 
+      if( rc==SQLITE_OK ){ 
         rc = sessionBindRow(pIter,
-            sqlite3changeset_new, pApply->nCol, pApply->abPK, pApply->pDelete);
-        sqlite3_bind_int(pApply->pDelete, pApply->nCol+1, 1);
-      }
-      if( rc==SQLITE_OK ){
-        sqlite3_step(pApply->pDelete);
-        rc = sqlite3_reset(pApply->pDelete);
-      }
-      if( rc==SQLITE_OK ){
-        rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
-      }
-      if( rc==SQLITE_OK ){
-        rc = sqlite3_exec(db, "RELEASE replace_op", 0, 0, 0);
-      }
+            sqlite3changeset_new, pApply->nCol, pApply->abPK, pApply->pDelete); 
+        sqlite3_bind_int(pApply->pDelete, pApply->nCol+1, 1); 
+      } 
+      if( rc==SQLITE_OK ){ 
+        sqlite3_step(pApply->pDelete); 
+        rc = sqlite3_reset(pApply->pDelete); 
+      } 
+      if( rc==SQLITE_OK ){ 
+        rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0); 
+      } 
+      if( rc==SQLITE_OK ){ 
+        rc = sqlite3_exec(db, "RELEASE replace_op", 0, 0, 0); 
+      } 
     }
   }
 
@@ -213059,7 +213059,7 @@ static int sessionRetryConstraints(
         &pIter2, 0, 0, cons.nBuf, cons.aBuf, pApply->bInvertConstraints, 1
     );
     if( rc==SQLITE_OK ){
-      size_t nByte = 2*pApply->nCol*sizeof(sqlite3_value*);
+      size_t nByte = 2*pApply->nCol*sizeof(sqlite3_value*); 
       int rc2;
       pIter2->bPatchset = bPatchset;
       pIter2->zTab = (char*)zTab;
@@ -213108,12 +213108,12 @@ static int sessionChangesetApply(
     int eConflict,                /* DATA, MISSING, CONFLICT, CONSTRAINT */
     sqlite3_changeset_iter *p     /* Handle describing change and conflict */
   ),
-  void *pCtx,                     /* First argument passed to xConflict */
-  void **ppRebase, int *pnRebase, /* OUT: Rebase information */
-  int flags                       /* SESSION_APPLY_XXX flags */
+  void *pCtx,                     /* First argument passed to xConflict */ 
+  void **ppRebase, int *pnRebase, /* OUT: Rebase information */ 
+  int flags                       /* SESSION_APPLY_XXX flags */ 
 ){
   int schemaMismatch = 0;
-  int rc = SQLITE_OK;             /* Return code */
+  int rc = SQLITE_OK;             /* Return code */ 
   const char *zTab = 0;           /* Name of current table */
   int nTab = 0;                   /* Result of sqlite3Strlen30(zTab) */
   SessionApplyCtx sApply;         /* changeset_apply() context object */
@@ -213123,12 +213123,12 @@ static int sessionChangesetApply(
 
   pIter->in.bNoDiscard = 1;
   memset(&sApply, 0, sizeof(sApply));
-  sApply.bRebase = (ppRebase && pnRebase);
+  sApply.bRebase = (ppRebase && pnRebase); 
   sApply.bInvertConstraints = !!(flags & SQLITE_CHANGESETAPPLY_INVERT);
   sqlite3_mutex_enter(sqlite3_db_mutex(db));
-  if( (flags & SQLITE_CHANGESETAPPLY_NOSAVEPOINT)==0 ){
-    rc = sqlite3_exec(db, "SAVEPOINT changeset_apply", 0, 0, 0);
-  }
+  if( (flags & SQLITE_CHANGESETAPPLY_NOSAVEPOINT)==0 ){ 
+    rc = sqlite3_exec(db, "SAVEPOINT changeset_apply", 0, 0, 0); 
+  } 
   if( rc==SQLITE_OK ){
     rc = sqlite3_exec(db, "PRAGMA defer_foreign_keys = 1", 0, 0, 0);
   }
@@ -213153,16 +213153,16 @@ static int sessionChangesetApply(
       sqlite3_finalize(sApply.pInsert);
       sqlite3_finalize(sApply.pSelect);
       sApply.db = db;
-      sApply.pDelete = 0;
-      sApply.pInsert = 0;
-      sApply.pSelect = 0;
-      sApply.nCol = 0;
-      sApply.azCol = 0;
-      sApply.abPK = 0;
-      sApply.bStat1 = 0;
+      sApply.pDelete = 0; 
+      sApply.pInsert = 0; 
+      sApply.pSelect = 0; 
+      sApply.nCol = 0; 
+      sApply.azCol = 0; 
+      sApply.abPK = 0; 
+      sApply.bStat1 = 0; 
       sApply.bDeferConstraints = 1;
-      sApply.bRebaseStarted = 0;
-      memset(&sApply.constraints, 0, sizeof(SessionBuffer));
+      sApply.bRebaseStarted = 0; 
+      memset(&sApply.constraints, 0, sizeof(SessionBuffer)); 
 
       /* If an xFilter() callback was specified, invoke it now. If the
       ** xFilter callback returns zero, skip this table. If it returns
@@ -213264,65 +213264,65 @@ static int sessionChangesetApply(
   }
   sqlite3_exec(db, "PRAGMA defer_foreign_keys = 0", 0, 0, 0);
 
-  if( (flags & SQLITE_CHANGESETAPPLY_NOSAVEPOINT)==0 ){
-    if( rc==SQLITE_OK ){
-      rc = sqlite3_exec(db, "RELEASE changeset_apply", 0, 0, 0);
-    }else{
-      sqlite3_exec(db, "ROLLBACK TO changeset_apply", 0, 0, 0);
-      sqlite3_exec(db, "RELEASE changeset_apply", 0, 0, 0);
-    }
-  }
-
-  assert( sApply.bRebase || sApply.rebase.nBuf==0 );
-  if( rc==SQLITE_OK && bPatchset==0 && sApply.bRebase ){
-    *ppRebase = (void*)sApply.rebase.aBuf;
-    *pnRebase = sApply.rebase.nBuf;
-    sApply.rebase.aBuf = 0;
-  }
+  if( (flags & SQLITE_CHANGESETAPPLY_NOSAVEPOINT)==0 ){ 
+    if( rc==SQLITE_OK ){ 
+      rc = sqlite3_exec(db, "RELEASE changeset_apply", 0, 0, 0); 
+    }else{ 
+      sqlite3_exec(db, "ROLLBACK TO changeset_apply", 0, 0, 0); 
+      sqlite3_exec(db, "RELEASE changeset_apply", 0, 0, 0); 
+    } 
+  }
+
+  assert( sApply.bRebase || sApply.rebase.nBuf==0 ); 
+  if( rc==SQLITE_OK && bPatchset==0 && sApply.bRebase ){ 
+    *ppRebase = (void*)sApply.rebase.aBuf; 
+    *pnRebase = sApply.rebase.nBuf; 
+    sApply.rebase.aBuf = 0; 
+  } 
   sessionUpdateFree(&sApply);
   sqlite3_finalize(sApply.pInsert);
   sqlite3_finalize(sApply.pDelete);
   sqlite3_finalize(sApply.pSelect);
   sqlite3_free((char*)sApply.azCol);  /* cast works around VC++ bug */
   sqlite3_free((char*)sApply.constraints.aBuf);
-  sqlite3_free((char*)sApply.rebase.aBuf);
+  sqlite3_free((char*)sApply.rebase.aBuf); 
   sqlite3_mutex_leave(sqlite3_db_mutex(db));
   return rc;
 }
 
 /*
 ** Apply the changeset passed via pChangeset/nChangeset to the main
-** database attached to handle "db".
-*/
-SQLITE_API int sqlite3changeset_apply_v2(
-  sqlite3 *db,                    /* Apply change to "main" db of this handle */
-  int nChangeset,                 /* Size of changeset in bytes */
-  void *pChangeset,               /* Changeset blob */
-  int(*xFilter)(
-    void *pCtx,                   /* Copy of sixth arg to _apply() */
-    const char *zTab              /* Table name */
-  ),
-  int(*xConflict)(
-    void *pCtx,                   /* Copy of sixth arg to _apply() */
-    int eConflict,                /* DATA, MISSING, CONFLICT, CONSTRAINT */
-    sqlite3_changeset_iter *p     /* Handle describing change and conflict */
-  ),
-  void *pCtx,                     /* First argument passed to xConflict */
-  void **ppRebase, int *pnRebase,
-  int flags
-){
+** database attached to handle "db". 
+*/ 
+SQLITE_API int sqlite3changeset_apply_v2( 
+  sqlite3 *db,                    /* Apply change to "main" db of this handle */ 
+  int nChangeset,                 /* Size of changeset in bytes */ 
+  void *pChangeset,               /* Changeset blob */ 
+  int(*xFilter)( 
+    void *pCtx,                   /* Copy of sixth arg to _apply() */ 
+    const char *zTab              /* Table name */ 
+  ), 
+  int(*xConflict)( 
+    void *pCtx,                   /* Copy of sixth arg to _apply() */ 
+    int eConflict,                /* DATA, MISSING, CONFLICT, CONSTRAINT */ 
+    sqlite3_changeset_iter *p     /* Handle describing change and conflict */ 
+  ), 
+  void *pCtx,                     /* First argument passed to xConflict */ 
+  void **ppRebase, int *pnRebase, 
+  int flags 
+){ 
   sqlite3_changeset_iter *pIter;  /* Iterator to skip through changeset */
   int bInv = !!(flags & SQLITE_CHANGESETAPPLY_INVERT);
   int rc = sessionChangesetStart(&pIter, 0, 0, nChangeset, pChangeset, bInv, 1);
-  if( rc==SQLITE_OK ){
-    rc = sessionChangesetApply(
-        db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
-    );
-  }
-  return rc;
-}
-
-/*
+  if( rc==SQLITE_OK ){ 
+    rc = sessionChangesetApply( 
+        db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags 
+    ); 
+  } 
+  return rc; 
+} 
+ 
+/* 
 ** Apply the changeset passed via pChangeset/nChangeset to the main database
 ** attached to handle "db". Invoke the supplied conflict handler callback
 ** to resolve any conflicts encountered while applying the change.
@@ -213342,9 +213342,9 @@ SQLITE_API int sqlite3changeset_apply(
   ),
   void *pCtx                      /* First argument passed to xConflict */
 ){
-  return sqlite3changeset_apply_v2(
-      db, nChangeset, pChangeset, xFilter, xConflict, pCtx, 0, 0, 0
-  );
+  return sqlite3changeset_apply_v2( 
+      db, nChangeset, pChangeset, xFilter, xConflict, pCtx, 0, 0, 0 
+  ); 
 }
 
 /*
@@ -213352,7 +213352,7 @@ SQLITE_API int sqlite3changeset_apply(
 ** attached to handle "db". Invoke the supplied conflict handler callback
 ** to resolve any conflicts encountered while applying the change.
 */
-SQLITE_API int sqlite3changeset_apply_v2_strm(
+SQLITE_API int sqlite3changeset_apply_v2_strm( 
   sqlite3 *db,                    /* Apply change to "main" db of this handle */
   int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */
   void *pIn,                                          /* First arg for xInput */
@@ -213365,39 +213365,39 @@ SQLITE_API int sqlite3changeset_apply_v2_strm(
     int eConflict,                /* DATA, MISSING, CONFLICT, CONSTRAINT */
     sqlite3_changeset_iter *p     /* Handle describing change and conflict */
   ),
-  void *pCtx,                     /* First argument passed to xConflict */
-  void **ppRebase, int *pnRebase,
-  int flags
+  void *pCtx,                     /* First argument passed to xConflict */ 
+  void **ppRebase, int *pnRebase, 
+  int flags 
 ){
   sqlite3_changeset_iter *pIter;  /* Iterator to skip through changeset */
-  int bInverse = !!(flags & SQLITE_CHANGESETAPPLY_INVERT);
+  int bInverse = !!(flags & SQLITE_CHANGESETAPPLY_INVERT); 
   int rc = sessionChangesetStart(&pIter, xInput, pIn, 0, 0, bInverse, 1);
   if( rc==SQLITE_OK ){
-    rc = sessionChangesetApply(
-        db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
-    );
-  }
-  return rc;
-}
-SQLITE_API int sqlite3changeset_apply_strm(
-  sqlite3 *db,                    /* Apply change to "main" db of this handle */
-  int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */
-  void *pIn,                                          /* First arg for xInput */
-  int(*xFilter)(
-    void *pCtx,                   /* Copy of sixth arg to _apply() */
-    const char *zTab              /* Table name */
-  ),
-  int(*xConflict)(
-    void *pCtx,                   /* Copy of sixth arg to _apply() */
-    int eConflict,                /* DATA, MISSING, CONFLICT, CONSTRAINT */
-    sqlite3_changeset_iter *p     /* Handle describing change and conflict */
-  ),
-  void *pCtx                      /* First argument passed to xConflict */
-){
-  return sqlite3changeset_apply_v2_strm(
-      db, xInput, pIn, xFilter, xConflict, pCtx, 0, 0, 0
-  );
-}
+    rc = sessionChangesetApply( 
+        db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags 
+    ); 
+  }
+  return rc;
+}
+SQLITE_API int sqlite3changeset_apply_strm( 
+  sqlite3 *db,                    /* Apply change to "main" db of this handle */ 
+  int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */ 
+  void *pIn,                                          /* First arg for xInput */ 
+  int(*xFilter)( 
+    void *pCtx,                   /* Copy of sixth arg to _apply() */ 
+    const char *zTab              /* Table name */ 
+  ), 
+  int(*xConflict)( 
+    void *pCtx,                   /* Copy of sixth arg to _apply() */ 
+    int eConflict,                /* DATA, MISSING, CONFLICT, CONSTRAINT */ 
+    sqlite3_changeset_iter *p     /* Handle describing change and conflict */ 
+  ), 
+  void *pCtx                      /* First argument passed to xConflict */ 
+){ 
+  return sqlite3changeset_apply_v2_strm( 
+      db, xInput, pIn, xFilter, xConflict, pCtx, 0, 0, 0 
+  ); 
+} 
 
 /*
 ** sqlite3_changegroup handle.
@@ -213415,7 +213415,7 @@ struct sqlite3_changegroup {
 */
 static int sessionChangeMerge(
   SessionTable *pTab,             /* Table structure */
-  int bRebase,                    /* True for a rebase hash-table */
+  int bRebase,                    /* True for a rebase hash-table */ 
   int bPatchset,                  /* True for patchsets */
   SessionChange *pExist,          /* Existing change */
   int op2,                        /* Second change operation */
@@ -213425,10 +213425,10 @@ static int sessionChangeMerge(
   SessionChange **ppNew           /* OUT: Merged change */
 ){
   SessionChange *pNew = 0;
-  int rc = SQLITE_OK;
+  int rc = SQLITE_OK; 
 
   if( !pExist ){
-    pNew = (SessionChange *)sqlite3_malloc64(sizeof(SessionChange) + nRec);
+    pNew = (SessionChange *)sqlite3_malloc64(sizeof(SessionChange) + nRec); 
     if( !pNew ){
       return SQLITE_NOMEM;
     }
@@ -213436,65 +213436,65 @@ static int sessionChangeMerge(
     pNew->op = op2;
     pNew->bIndirect = bIndirect;
     pNew->aRecord = (u8*)&pNew[1];
-    if( bIndirect==0 || bRebase==0 ){
-      pNew->nRecord = nRec;
-      memcpy(pNew->aRecord, aRec, nRec);
-    }else{
-      int i;
-      u8 *pIn = aRec;
-      u8 *pOut = pNew->aRecord;
-      for(i=0; i<pTab->nCol; i++){
-        int nIn = sessionSerialLen(pIn);
-        if( *pIn==0 ){
-          *pOut++ = 0;
-        }else if( pTab->abPK[i]==0 ){
-          *pOut++ = 0xFF;
-        }else{
-          memcpy(pOut, pIn, nIn);
-          pOut += nIn;
-        }
-        pIn += nIn;
-      }
-      pNew->nRecord = pOut - pNew->aRecord;
-    }
-  }else if( bRebase ){
-    if( pExist->op==SQLITE_DELETE && pExist->bIndirect ){
-      *ppNew = pExist;
-    }else{
-      sqlite3_int64 nByte = nRec + pExist->nRecord + sizeof(SessionChange);
-      pNew = (SessionChange*)sqlite3_malloc64(nByte);
-      if( pNew==0 ){
-        rc = SQLITE_NOMEM;
-      }else{
-        int i;
-        u8 *a1 = pExist->aRecord;
-        u8 *a2 = aRec;
-        u8 *pOut;
-
-        memset(pNew, 0, nByte);
-        pNew->bIndirect = bIndirect || pExist->bIndirect;
-        pNew->op = op2;
-        pOut = pNew->aRecord = (u8*)&pNew[1];
-
-        for(i=0; i<pTab->nCol; i++){
-          int n1 = sessionSerialLen(a1);
-          int n2 = sessionSerialLen(a2);
-          if( *a1==0xFF || (pTab->abPK[i]==0 && bIndirect) ){
-            *pOut++ = 0xFF;
-          }else if( *a2==0 ){
-            memcpy(pOut, a1, n1);
-            pOut += n1;
-          }else{
-            memcpy(pOut, a2, n2);
-            pOut += n2;
-          }
-          a1 += n1;
-          a2 += n2;
-        }
-        pNew->nRecord = pOut - pNew->aRecord;
-      }
-      sqlite3_free(pExist);
-    }
+    if( bIndirect==0 || bRebase==0 ){ 
+      pNew->nRecord = nRec; 
+      memcpy(pNew->aRecord, aRec, nRec); 
+    }else{ 
+      int i; 
+      u8 *pIn = aRec; 
+      u8 *pOut = pNew->aRecord; 
+      for(i=0; i<pTab->nCol; i++){ 
+        int nIn = sessionSerialLen(pIn); 
+        if( *pIn==0 ){ 
+          *pOut++ = 0; 
+        }else if( pTab->abPK[i]==0 ){ 
+          *pOut++ = 0xFF; 
+        }else{ 
+          memcpy(pOut, pIn, nIn); 
+          pOut += nIn; 
+        } 
+        pIn += nIn; 
+      } 
+      pNew->nRecord = pOut - pNew->aRecord; 
+    } 
+  }else if( bRebase ){ 
+    if( pExist->op==SQLITE_DELETE && pExist->bIndirect ){ 
+      *ppNew = pExist; 
+    }else{ 
+      sqlite3_int64 nByte = nRec + pExist->nRecord + sizeof(SessionChange); 
+      pNew = (SessionChange*)sqlite3_malloc64(nByte); 
+      if( pNew==0 ){ 
+        rc = SQLITE_NOMEM; 
+      }else{ 
+        int i; 
+        u8 *a1 = pExist->aRecord; 
+        u8 *a2 = aRec; 
+        u8 *pOut; 
+ 
+        memset(pNew, 0, nByte); 
+        pNew->bIndirect = bIndirect || pExist->bIndirect; 
+        pNew->op = op2; 
+        pOut = pNew->aRecord = (u8*)&pNew[1]; 
+ 
+        for(i=0; i<pTab->nCol; i++){ 
+          int n1 = sessionSerialLen(a1); 
+          int n2 = sessionSerialLen(a2); 
+          if( *a1==0xFF || (pTab->abPK[i]==0 && bIndirect) ){ 
+            *pOut++ = 0xFF; 
+          }else if( *a2==0 ){ 
+            memcpy(pOut, a1, n1); 
+            pOut += n1; 
+          }else{ 
+            memcpy(pOut, a2, n2); 
+            pOut += n2; 
+          } 
+          a1 += n1; 
+          a2 += n2; 
+        } 
+        pNew->nRecord = pOut - pNew->aRecord; 
+      } 
+      sqlite3_free(pExist); 
+    } 
   }else{
     int op1 = pExist->op;
 
@@ -213522,14 +213522,14 @@ static int sessionChangeMerge(
       assert( pNew==0 );
     }else{
       u8 *aExist = pExist->aRecord;
-      sqlite3_int64 nByte;
+      sqlite3_int64 nByte; 
       u8 *aCsr;
 
       /* Allocate a new SessionChange object. Ensure that the aRecord[]
       ** buffer of the new object is large enough to hold any record that
       ** may be generated by combining the input records.  */
       nByte = sizeof(SessionChange) + pExist->nRecord + nRec;
-      pNew = (SessionChange *)sqlite3_malloc64(nByte);
+      pNew = (SessionChange *)sqlite3_malloc64(nByte); 
       if( !pNew ){
         sqlite3_free(pExist);
         return SQLITE_NOMEM;
@@ -213588,7 +213588,7 @@ static int sessionChangeMerge(
   }
 
   *ppNew = pNew;
-  return rc;
+  return rc; 
 }
 
 /*
@@ -213597,15 +213597,15 @@ static int sessionChangeMerge(
 */
 static int sessionChangesetToHash(
   sqlite3_changeset_iter *pIter,   /* Iterator to read from */
-  sqlite3_changegroup *pGrp,       /* Changegroup object to add changeset to */
-  int bRebase                      /* True if hash table is for rebasing */
+  sqlite3_changegroup *pGrp,       /* Changegroup object to add changeset to */ 
+  int bRebase                      /* True if hash table is for rebasing */ 
 ){
   u8 *aRec;
   int nRec;
   int rc = SQLITE_OK;
   SessionTable *pTab = 0;
 
-  while( SQLITE_ROW==sessionChangesetNext(pIter, &aRec, &nRec, 0) ){
+  while( SQLITE_ROW==sessionChangesetNext(pIter, &aRec, &nRec, 0) ){ 
     const char *zNew;
     int nCol;
     int op;
@@ -213635,7 +213635,7 @@ static int sessionChangesetToHash(
       if( !pTab ){
         SessionTable **ppTab;
 
-        pTab = sqlite3_malloc64(sizeof(SessionTable) + nCol + nNew+1);
+        pTab = sqlite3_malloc64(sizeof(SessionTable) + nCol + nNew+1); 
         if( !pTab ){
           rc = SQLITE_NOMEM;
           break;
@@ -213744,10 +213744,10 @@ static int sessionChangegroupOutput(
         sessionAppendByte(&buf, p->op, &rc);
         sessionAppendByte(&buf, p->bIndirect, &rc);
         sessionAppendBlob(&buf, p->aRecord, p->nRecord, &rc);
-        if( rc==SQLITE_OK && xOutput && buf.nBuf>=sessions_strm_chunk_size ){
-          rc = xOutput(pOut, buf.aBuf, buf.nBuf);
-          buf.nBuf = 0;
-        }
+        if( rc==SQLITE_OK && xOutput && buf.nBuf>=sessions_strm_chunk_size ){ 
+          rc = xOutput(pOut, buf.aBuf, buf.nBuf); 
+          buf.nBuf = 0; 
+        } 
       }
     }
   }
@@ -213792,7 +213792,7 @@ SQLITE_API int sqlite3changegroup_add(sqlite3_changegroup *pGrp, int nData, void
 
   rc = sqlite3changeset_start(&pIter, nData, pData);
   if( rc==SQLITE_OK ){
-    rc = sessionChangesetToHash(pIter, pGrp, 0);
+    rc = sessionChangesetToHash(pIter, pGrp, 0); 
   }
   sqlite3changeset_finalize(pIter);
   return rc;
@@ -213823,7 +213823,7 @@ SQLITE_API int sqlite3changegroup_add_strm(
 
   rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
   if( rc==SQLITE_OK ){
-    rc = sessionChangesetToHash(pIter, pGrp, 0);
+    rc = sessionChangesetToHash(pIter, pGrp, 0); 
   }
   sqlite3changeset_finalize(pIter);
   return rc;
@@ -213909,116 +213909,116 @@ SQLITE_API int sqlite3changeset_concat_strm(
 }
 
 /*
-** Changeset rebaser handle.
+** Changeset rebaser handle. 
 */
-struct sqlite3_rebaser {
-  sqlite3_changegroup grp;        /* Hash table */
+struct sqlite3_rebaser { 
+  sqlite3_changegroup grp;        /* Hash table */ 
 };
 
 /*
-** Buffers a1 and a2 must both contain a sessions module record nCol
+** Buffers a1 and a2 must both contain a sessions module record nCol 
 ** fields in size. This function appends an nCol sessions module
-** record to buffer pBuf that is a copy of a1, except that for
-** each field that is undefined in a1[], swap in the field from a2[].
-*/
-static void sessionAppendRecordMerge(
-  SessionBuffer *pBuf,            /* Buffer to append to */
-  int nCol,                       /* Number of columns in each record */
-  u8 *a1, int n1,                 /* Record 1 */
-  u8 *a2, int n2,                 /* Record 2 */
-  int *pRc                        /* IN/OUT: error code */
-){
-  sessionBufferGrow(pBuf, n1+n2, pRc);
-  if( *pRc==SQLITE_OK ){
-    int i;
-    u8 *pOut = &pBuf->aBuf[pBuf->nBuf];
-    for(i=0; i<nCol; i++){
-      int nn1 = sessionSerialLen(a1);
-      int nn2 = sessionSerialLen(a2);
-      if( *a1==0 || *a1==0xFF ){
-        memcpy(pOut, a2, nn2);
-        pOut += nn2;
+** record to buffer pBuf that is a copy of a1, except that for 
+** each field that is undefined in a1[], swap in the field from a2[]. 
+*/
+static void sessionAppendRecordMerge( 
+  SessionBuffer *pBuf,            /* Buffer to append to */ 
+  int nCol,                       /* Number of columns in each record */ 
+  u8 *a1, int n1,                 /* Record 1 */ 
+  u8 *a2, int n2,                 /* Record 2 */ 
+  int *pRc                        /* IN/OUT: error code */ 
+){
+  sessionBufferGrow(pBuf, n1+n2, pRc); 
+  if( *pRc==SQLITE_OK ){ 
+    int i; 
+    u8 *pOut = &pBuf->aBuf[pBuf->nBuf]; 
+    for(i=0; i<nCol; i++){ 
+      int nn1 = sessionSerialLen(a1); 
+      int nn2 = sessionSerialLen(a2); 
+      if( *a1==0 || *a1==0xFF ){ 
+        memcpy(pOut, a2, nn2); 
+        pOut += nn2; 
       }else{
-        memcpy(pOut, a1, nn1);
-        pOut += nn1;
+        memcpy(pOut, a1, nn1); 
+        pOut += nn1; 
       }
-      a1 += nn1;
-      a2 += nn2;
+      a1 += nn1; 
+      a2 += nn2; 
     }
 
-    pBuf->nBuf = pOut-pBuf->aBuf;
-    assert( pBuf->nBuf<=pBuf->nAlloc );
+    pBuf->nBuf = pOut-pBuf->aBuf; 
+    assert( pBuf->nBuf<=pBuf->nAlloc ); 
   }
 }
 
 /*
 ** This function is called when rebasing a local UPDATE change against one
-** or more remote UPDATE changes. The aRec/nRec buffer contains the current
-** old.* and new.* records for the change. The rebase buffer (a single
-** record) is in aChange/nChange. The rebased change is appended to buffer
-** pBuf.
+** or more remote UPDATE changes. The aRec/nRec buffer contains the current 
+** old.* and new.* records for the change. The rebase buffer (a single 
+** record) is in aChange/nChange. The rebased change is appended to buffer 
+** pBuf. 
 **
 ** Rebasing the UPDATE involves:
-**
-**   * Removing any changes to fields for which the corresponding field
-**     in the rebase buffer is set to "replaced" (type 0xFF). If this
-**     means the UPDATE change updates no fields, nothing is appended
-**     to the output buffer.
-**
+** 
+**   * Removing any changes to fields for which the corresponding field 
+**     in the rebase buffer is set to "replaced" (type 0xFF). If this 
+**     means the UPDATE change updates no fields, nothing is appended 
+**     to the output buffer. 
+** 
 **   * For each field modified by the local change for which the
-**     corresponding field in the rebase buffer is not "undefined" (0x00)
-**     or "replaced" (0xFF), the old.* value is replaced by the value
-**     in the rebase buffer.
-*/
-static void sessionAppendPartialUpdate(
-  SessionBuffer *pBuf,            /* Append record here */
-  sqlite3_changeset_iter *pIter,  /* Iterator pointed at local change */
-  u8 *aRec, int nRec,             /* Local change */
-  u8 *aChange, int nChange,       /* Record to rebase against */
-  int *pRc                        /* IN/OUT: Return Code */
-){
-  sessionBufferGrow(pBuf, 2+nRec+nChange, pRc);
-  if( *pRc==SQLITE_OK ){
-    int bData = 0;
-    u8 *pOut = &pBuf->aBuf[pBuf->nBuf];
-    int i;
-    u8 *a1 = aRec;
-    u8 *a2 = aChange;
-
-    *pOut++ = SQLITE_UPDATE;
-    *pOut++ = pIter->bIndirect;
-    for(i=0; i<pIter->nCol; i++){
-      int n1 = sessionSerialLen(a1);
-      int n2 = sessionSerialLen(a2);
-      if( pIter->abPK[i] || a2[0]==0 ){
+**     corresponding field in the rebase buffer is not "undefined" (0x00) 
+**     or "replaced" (0xFF), the old.* value is replaced by the value 
+**     in the rebase buffer. 
+*/
+static void sessionAppendPartialUpdate( 
+  SessionBuffer *pBuf,            /* Append record here */ 
+  sqlite3_changeset_iter *pIter,  /* Iterator pointed at local change */ 
+  u8 *aRec, int nRec,             /* Local change */ 
+  u8 *aChange, int nChange,       /* Record to rebase against */ 
+  int *pRc                        /* IN/OUT: Return Code */ 
+){
+  sessionBufferGrow(pBuf, 2+nRec+nChange, pRc); 
+  if( *pRc==SQLITE_OK ){ 
+    int bData = 0; 
+    u8 *pOut = &pBuf->aBuf[pBuf->nBuf]; 
+    int i; 
+    u8 *a1 = aRec; 
+    u8 *a2 = aChange; 
+
+    *pOut++ = SQLITE_UPDATE; 
+    *pOut++ = pIter->bIndirect; 
+    for(i=0; i<pIter->nCol; i++){ 
+      int n1 = sessionSerialLen(a1); 
+      int n2 = sessionSerialLen(a2); 
+      if( pIter->abPK[i] || a2[0]==0 ){ 
         if( !pIter->abPK[i] && a1[0] ) bData = 1;
-        memcpy(pOut, a1, n1);
-        pOut += n1;
-      }else if( a2[0]!=0xFF ){
-        bData = 1;
-        memcpy(pOut, a2, n2);
-        pOut += n2;
-      }else{
-        *pOut++ = '\0';
+        memcpy(pOut, a1, n1); 
+        pOut += n1; 
+      }else if( a2[0]!=0xFF ){ 
+        bData = 1; 
+        memcpy(pOut, a2, n2); 
+        pOut += n2; 
+      }else{ 
+        *pOut++ = '\0'; 
       }
-      a1 += n1;
-      a2 += n2;
+      a1 += n1; 
+      a2 += n2; 
     }
-    if( bData ){
-      a2 = aChange;
-      for(i=0; i<pIter->nCol; i++){
-        int n1 = sessionSerialLen(a1);
-        int n2 = sessionSerialLen(a2);
-        if( pIter->abPK[i] || a2[0]!=0xFF ){
-          memcpy(pOut, a1, n1);
-          pOut += n1;
-        }else{
-          *pOut++ = '\0';
+    if( bData ){ 
+      a2 = aChange; 
+      for(i=0; i<pIter->nCol; i++){ 
+        int n1 = sessionSerialLen(a1); 
+        int n2 = sessionSerialLen(a2); 
+        if( pIter->abPK[i] || a2[0]!=0xFF ){ 
+          memcpy(pOut, a1, n1); 
+          pOut += n1; 
+        }else{ 
+          *pOut++ = '\0'; 
         }
-        a1 += n1;
-        a2 += n2;
+        a1 += n1; 
+        a2 += n2; 
       }
-      pBuf->nBuf = (pOut - pBuf->aBuf);
+      pBuf->nBuf = (pOut - pBuf->aBuf); 
     }
   }
 }
@@ -214026,216 +214026,216 @@ static void sessionAppendPartialUpdate(
 /*
 ** pIter is configured to iterate through a changeset. This function rebases
 ** that changeset according to the current configuration of the rebaser
-** object passed as the first argument. If no error occurs and argument xOutput
-** is not NULL, then the changeset is returned to the caller by invoking
-** xOutput zero or more times and SQLITE_OK returned. Or, if xOutput is NULL,
-** then (*ppOut) is set to point to a buffer containing the rebased changeset
-** before this function returns. In this case (*pnOut) is set to the size of
-** the buffer in bytes.  It is the responsibility of the caller to eventually
+** object passed as the first argument. If no error occurs and argument xOutput 
+** is not NULL, then the changeset is returned to the caller by invoking 
+** xOutput zero or more times and SQLITE_OK returned. Or, if xOutput is NULL, 
+** then (*ppOut) is set to point to a buffer containing the rebased changeset 
+** before this function returns. In this case (*pnOut) is set to the size of 
+** the buffer in bytes.  It is the responsibility of the caller to eventually 
 ** free the (*ppOut) buffer using sqlite3_free().
-**
-** If an error occurs, an SQLite error code is returned. If ppOut and
-** pnOut are not NULL, then the two output parameters are set to 0 before
-** returning.
-*/
-static int sessionRebase(
-  sqlite3_rebaser *p,             /* Rebaser hash table */
-  sqlite3_changeset_iter *pIter,  /* Input data */
-  int (*xOutput)(void *pOut, const void *pData, int nData),
-  void *pOut,                     /* Context for xOutput callback */
-  int *pnOut,                     /* OUT: Number of bytes in output changeset */
-  void **ppOut                    /* OUT: Inverse of pChangeset */
-){
-  int rc = SQLITE_OK;
-  u8 *aRec = 0;
-  int nRec = 0;
-  int bNew = 0;
-  SessionTable *pTab = 0;
-  SessionBuffer sOut = {0,0,0};
-
-  while( SQLITE_ROW==sessionChangesetNext(pIter, &aRec, &nRec, &bNew) ){
-    SessionChange *pChange = 0;
-    int bDone = 0;
-
-    if( bNew ){
-      const char *zTab = pIter->zTab;
-      for(pTab=p->grp.pList; pTab; pTab=pTab->pNext){
-        if( 0==sqlite3_stricmp(pTab->zName, zTab) ) break;
-      }
-      bNew = 0;
-
-      /* A patchset may not be rebased */
-      if( pIter->bPatchset ){
-        rc = SQLITE_ERROR;
-      }
-
-      /* Append a table header to the output for this new table */
-      sessionAppendByte(&sOut, pIter->bPatchset ? 'P' : 'T', &rc);
-      sessionAppendVarint(&sOut, pIter->nCol, &rc);
-      sessionAppendBlob(&sOut, pIter->abPK, pIter->nCol, &rc);
-      sessionAppendBlob(&sOut,(u8*)pIter->zTab,(int)strlen(pIter->zTab)+1,&rc);
-    }
-
-    if( pTab && rc==SQLITE_OK ){
-      int iHash = sessionChangeHash(pTab, 0, aRec, pTab->nChange);
-
-      for(pChange=pTab->apChange[iHash]; pChange; pChange=pChange->pNext){
-        if( sessionChangeEqual(pTab, 0, aRec, 0, pChange->aRecord) ){
-          break;
-        }
-      }
-    }
-
-    if( pChange ){
-      assert( pChange->op==SQLITE_DELETE || pChange->op==SQLITE_INSERT );
-      switch( pIter->op ){
-        case SQLITE_INSERT:
-          if( pChange->op==SQLITE_INSERT ){
-            bDone = 1;
-            if( pChange->bIndirect==0 ){
-              sessionAppendByte(&sOut, SQLITE_UPDATE, &rc);
-              sessionAppendByte(&sOut, pIter->bIndirect, &rc);
-              sessionAppendBlob(&sOut, pChange->aRecord, pChange->nRecord, &rc);
-              sessionAppendBlob(&sOut, aRec, nRec, &rc);
-            }
-          }
-          break;
-
-        case SQLITE_UPDATE:
-          bDone = 1;
-          if( pChange->op==SQLITE_DELETE ){
-            if( pChange->bIndirect==0 ){
-              u8 *pCsr = aRec;
-              sessionSkipRecord(&pCsr, pIter->nCol);
-              sessionAppendByte(&sOut, SQLITE_INSERT, &rc);
-              sessionAppendByte(&sOut, pIter->bIndirect, &rc);
-              sessionAppendRecordMerge(&sOut, pIter->nCol,
+** 
+** If an error occurs, an SQLite error code is returned. If ppOut and 
+** pnOut are not NULL, then the two output parameters are set to 0 before 
+** returning. 
+*/
+static int sessionRebase( 
+  sqlite3_rebaser *p,             /* Rebaser hash table */ 
+  sqlite3_changeset_iter *pIter,  /* Input data */ 
+  int (*xOutput)(void *pOut, const void *pData, int nData), 
+  void *pOut,                     /* Context for xOutput callback */ 
+  int *pnOut,                     /* OUT: Number of bytes in output changeset */ 
+  void **ppOut                    /* OUT: Inverse of pChangeset */ 
+){
+  int rc = SQLITE_OK; 
+  u8 *aRec = 0; 
+  int nRec = 0; 
+  int bNew = 0; 
+  SessionTable *pTab = 0; 
+  SessionBuffer sOut = {0,0,0}; 
+
+  while( SQLITE_ROW==sessionChangesetNext(pIter, &aRec, &nRec, &bNew) ){ 
+    SessionChange *pChange = 0; 
+    int bDone = 0; 
+
+    if( bNew ){ 
+      const char *zTab = pIter->zTab; 
+      for(pTab=p->grp.pList; pTab; pTab=pTab->pNext){ 
+        if( 0==sqlite3_stricmp(pTab->zName, zTab) ) break; 
+      }
+      bNew = 0; 
+
+      /* A patchset may not be rebased */ 
+      if( pIter->bPatchset ){ 
+        rc = SQLITE_ERROR; 
+      }
+
+      /* Append a table header to the output for this new table */ 
+      sessionAppendByte(&sOut, pIter->bPatchset ? 'P' : 'T', &rc); 
+      sessionAppendVarint(&sOut, pIter->nCol, &rc); 
+      sessionAppendBlob(&sOut, pIter->abPK, pIter->nCol, &rc); 
+      sessionAppendBlob(&sOut,(u8*)pIter->zTab,(int)strlen(pIter->zTab)+1,&rc); 
+    }
+
+    if( pTab && rc==SQLITE_OK ){ 
+      int iHash = sessionChangeHash(pTab, 0, aRec, pTab->nChange); 
+
+      for(pChange=pTab->apChange[iHash]; pChange; pChange=pChange->pNext){ 
+        if( sessionChangeEqual(pTab, 0, aRec, 0, pChange->aRecord) ){ 
+          break; 
+        }
+      }
+    }
+
+    if( pChange ){ 
+      assert( pChange->op==SQLITE_DELETE || pChange->op==SQLITE_INSERT ); 
+      switch( pIter->op ){ 
+        case SQLITE_INSERT: 
+          if( pChange->op==SQLITE_INSERT ){ 
+            bDone = 1; 
+            if( pChange->bIndirect==0 ){ 
+              sessionAppendByte(&sOut, SQLITE_UPDATE, &rc); 
+              sessionAppendByte(&sOut, pIter->bIndirect, &rc); 
+              sessionAppendBlob(&sOut, pChange->aRecord, pChange->nRecord, &rc); 
+              sessionAppendBlob(&sOut, aRec, nRec, &rc); 
+            } 
+          } 
+          break; 
+
+        case SQLITE_UPDATE: 
+          bDone = 1; 
+          if( pChange->op==SQLITE_DELETE ){ 
+            if( pChange->bIndirect==0 ){ 
+              u8 *pCsr = aRec; 
+              sessionSkipRecord(&pCsr, pIter->nCol); 
+              sessionAppendByte(&sOut, SQLITE_INSERT, &rc); 
+              sessionAppendByte(&sOut, pIter->bIndirect, &rc); 
+              sessionAppendRecordMerge(&sOut, pIter->nCol, 
                   pCsr, nRec-(pCsr-aRec),
-                  pChange->aRecord, pChange->nRecord, &rc
-              );
-            }
-          }else{
-            sessionAppendPartialUpdate(&sOut, pIter,
-                aRec, nRec, pChange->aRecord, pChange->nRecord, &rc
-            );
-          }
-          break;
-
-        default:
-          assert( pIter->op==SQLITE_DELETE );
-          bDone = 1;
-          if( pChange->op==SQLITE_INSERT ){
-            sessionAppendByte(&sOut, SQLITE_DELETE, &rc);
-            sessionAppendByte(&sOut, pIter->bIndirect, &rc);
-            sessionAppendRecordMerge(&sOut, pIter->nCol,
-                pChange->aRecord, pChange->nRecord, aRec, nRec, &rc
-            );
-          }
-          break;
-      }
-    }
-
-    if( bDone==0 ){
-      sessionAppendByte(&sOut, pIter->op, &rc);
-      sessionAppendByte(&sOut, pIter->bIndirect, &rc);
-      sessionAppendBlob(&sOut, aRec, nRec, &rc);
-    }
-    if( rc==SQLITE_OK && xOutput && sOut.nBuf>sessions_strm_chunk_size ){
-      rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
-      sOut.nBuf = 0;
-    }
-    if( rc ) break;
-  }
-
-  if( rc!=SQLITE_OK ){
-    sqlite3_free(sOut.aBuf);
-    memset(&sOut, 0, sizeof(sOut));
-  }
-
-  if( rc==SQLITE_OK ){
-    if( xOutput ){
-      if( sOut.nBuf>0 ){
-        rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
+                  pChange->aRecord, pChange->nRecord, &rc 
+              ); 
+            } 
+          }else{ 
+            sessionAppendPartialUpdate(&sOut, pIter, 
+                aRec, nRec, pChange->aRecord, pChange->nRecord, &rc 
+            ); 
+          } 
+          break; 
+
+        default: 
+          assert( pIter->op==SQLITE_DELETE ); 
+          bDone = 1; 
+          if( pChange->op==SQLITE_INSERT ){ 
+            sessionAppendByte(&sOut, SQLITE_DELETE, &rc); 
+            sessionAppendByte(&sOut, pIter->bIndirect, &rc); 
+            sessionAppendRecordMerge(&sOut, pIter->nCol, 
+                pChange->aRecord, pChange->nRecord, aRec, nRec, &rc 
+            ); 
+          } 
+          break; 
+      } 
+    }
+
+    if( bDone==0 ){ 
+      sessionAppendByte(&sOut, pIter->op, &rc); 
+      sessionAppendByte(&sOut, pIter->bIndirect, &rc); 
+      sessionAppendBlob(&sOut, aRec, nRec, &rc); 
+    }
+    if( rc==SQLITE_OK && xOutput && sOut.nBuf>sessions_strm_chunk_size ){ 
+      rc = xOutput(pOut, sOut.aBuf, sOut.nBuf); 
+      sOut.nBuf = 0; 
+    }
+    if( rc ) break; 
+  }
+
+  if( rc!=SQLITE_OK ){ 
+    sqlite3_free(sOut.aBuf); 
+    memset(&sOut, 0, sizeof(sOut)); 
+  }
+
+  if( rc==SQLITE_OK ){ 
+    if( xOutput ){ 
+      if( sOut.nBuf>0 ){ 
+        rc = xOutput(pOut, sOut.aBuf, sOut.nBuf); 
       }
     }else if( ppOut ){
-      *ppOut = (void*)sOut.aBuf;
-      *pnOut = sOut.nBuf;
-      sOut.aBuf = 0;
+      *ppOut = (void*)sOut.aBuf; 
+      *pnOut = sOut.nBuf; 
+      sOut.aBuf = 0; 
     }
   }
-  sqlite3_free(sOut.aBuf);
-  return rc;
+  sqlite3_free(sOut.aBuf); 
+  return rc; 
 }
 
 /*
-** Create a new rebaser object.
+** Create a new rebaser object. 
 */
-SQLITE_API int sqlite3rebaser_create(sqlite3_rebaser **ppNew){
-  int rc = SQLITE_OK;
-  sqlite3_rebaser *pNew;
+SQLITE_API int sqlite3rebaser_create(sqlite3_rebaser **ppNew){ 
+  int rc = SQLITE_OK; 
+  sqlite3_rebaser *pNew; 
 
-  pNew = sqlite3_malloc(sizeof(sqlite3_rebaser));
-  if( pNew==0 ){
-    rc = SQLITE_NOMEM;
+  pNew = sqlite3_malloc(sizeof(sqlite3_rebaser)); 
+  if( pNew==0 ){ 
+    rc = SQLITE_NOMEM; 
   }else{
-    memset(pNew, 0, sizeof(sqlite3_rebaser));
+    memset(pNew, 0, sizeof(sqlite3_rebaser)); 
   }
-  *ppNew = pNew;
-  return rc;
+  *ppNew = pNew; 
+  return rc; 
 }
 
 /*
-** Call this one or more times to configure a rebaser.
+** Call this one or more times to configure a rebaser. 
 */
-SQLITE_API int sqlite3rebaser_configure(
+SQLITE_API int sqlite3rebaser_configure( 
   sqlite3_rebaser *p,
-  int nRebase, const void *pRebase
+  int nRebase, const void *pRebase 
 ){
-  sqlite3_changeset_iter *pIter = 0;   /* Iterator opened on pData/nData */
-  int rc;                              /* Return code */
-  rc = sqlite3changeset_start(&pIter, nRebase, (void*)pRebase);
-  if( rc==SQLITE_OK ){
-    rc = sessionChangesetToHash(pIter, &p->grp, 1);
+  sqlite3_changeset_iter *pIter = 0;   /* Iterator opened on pData/nData */ 
+  int rc;                              /* Return code */ 
+  rc = sqlite3changeset_start(&pIter, nRebase, (void*)pRebase); 
+  if( rc==SQLITE_OK ){ 
+    rc = sessionChangesetToHash(pIter, &p->grp, 1); 
   }
-  sqlite3changeset_finalize(pIter);
-  return rc;
+  sqlite3changeset_finalize(pIter); 
+  return rc; 
 }
 
 /*
 ** Rebase a changeset according to current rebaser configuration
 */
-SQLITE_API int sqlite3rebaser_rebase(
-  sqlite3_rebaser *p,
+SQLITE_API int sqlite3rebaser_rebase( 
+  sqlite3_rebaser *p, 
   int nIn, const void *pIn,
   int *pnOut, void **ppOut
 ){
   sqlite3_changeset_iter *pIter = 0;   /* Iterator to skip through input */
-  int rc = sqlite3changeset_start(&pIter, nIn, (void*)pIn);
+  int rc = sqlite3changeset_start(&pIter, nIn, (void*)pIn); 
 
-  if( rc==SQLITE_OK ){
-    rc = sessionRebase(p, pIter, 0, 0, pnOut, ppOut);
-    sqlite3changeset_finalize(pIter);
+  if( rc==SQLITE_OK ){ 
+    rc = sessionRebase(p, pIter, 0, 0, pnOut, ppOut); 
+    sqlite3changeset_finalize(pIter); 
   }
 
-  return rc;
+  return rc; 
 }
 
 /*
 ** Rebase a changeset according to current rebaser configuration
 */
-SQLITE_API int sqlite3rebaser_rebase_strm(
-  sqlite3_rebaser *p,
-  int (*xInput)(void *pIn, void *pData, int *pnData),
-  void *pIn,
-  int (*xOutput)(void *pOut, const void *pData, int nData),
-  void *pOut
+SQLITE_API int sqlite3rebaser_rebase_strm( 
+  sqlite3_rebaser *p, 
+  int (*xInput)(void *pIn, void *pData, int *pnData), 
+  void *pIn, 
+  int (*xOutput)(void *pOut, const void *pData, int nData), 
+  void *pOut 
 ){
   sqlite3_changeset_iter *pIter = 0;   /* Iterator to skip through input */
-  int rc = sqlite3changeset_start_strm(&pIter, xInput, pIn);
+  int rc = sqlite3changeset_start_strm(&pIter, xInput, pIn); 
 
   if( rc==SQLITE_OK ){
-    rc = sessionRebase(p, pIter, xOutput, pOut, 0, 0);
-    sqlite3changeset_finalize(pIter);
+    rc = sessionRebase(p, pIter, xOutput, pOut, 0, 0); 
+    sqlite3changeset_finalize(pIter); 
   }
 
   return rc;
@@ -214243,38 +214243,38 @@ SQLITE_API int sqlite3rebaser_rebase_strm(
 
 /*
 ** Destroy a rebaser object
-*/
-SQLITE_API void sqlite3rebaser_delete(sqlite3_rebaser *p){
-  if( p ){
+*/ 
+SQLITE_API void sqlite3rebaser_delete(sqlite3_rebaser *p){ 
+  if( p ){ 
     sessionDeleteTable(0, p->grp.pList);
-    sqlite3_free(p);
+    sqlite3_free(p); 
   }
 }
 
 /*
-** Global configuration
+** Global configuration 
 */
-SQLITE_API int sqlite3session_config(int op, void *pArg){
-  int rc = SQLITE_OK;
-  switch( op ){
-    case SQLITE_SESSION_CONFIG_STRMSIZE: {
-      int *pInt = (int*)pArg;
-      if( *pInt>0 ){
-        sessions_strm_chunk_size = *pInt;
+SQLITE_API int sqlite3session_config(int op, void *pArg){ 
+  int rc = SQLITE_OK; 
+  switch( op ){ 
+    case SQLITE_SESSION_CONFIG_STRMSIZE: { 
+      int *pInt = (int*)pArg; 
+      if( *pInt>0 ){ 
+        sessions_strm_chunk_size = *pInt; 
       }
-      *pInt = sessions_strm_chunk_size;
+      *pInt = sessions_strm_chunk_size; 
       break;
     }
-    default:
-      rc = SQLITE_MISUSE;
+    default: 
+      rc = SQLITE_MISUSE; 
       break;
   }
   return rc;
 }
 
-#endif /* SQLITE_ENABLE_SESSION && SQLITE_ENABLE_PREUPDATE_HOOK */
+#endif /* SQLITE_ENABLE_SESSION && SQLITE_ENABLE_PREUPDATE_HOOK */ 
 
-/************** End of sqlite3session.c **************************************/
+/************** End of sqlite3session.c **************************************/ 
 /************** Begin file fts5.c ********************************************/
 
 
@@ -214409,8 +214409,8 @@ struct Fts5PhraseIter {
 **
 **   Usually, output parameter *piPhrase is set to the phrase number, *piCol
 **   to the column in which it occurs and *piOff the token offset of the
-**   first token of the phrase. Returns SQLITE_OK if successful, or an error
-**   code (i.e. SQLITE_NOMEM) if an error occurs.
+**   first token of the phrase. Returns SQLITE_OK if successful, or an error 
+**   code (i.e. SQLITE_NOMEM) if an error occurs. 
 **
 **   This API can be quite slow if used with an FTS5 table created with the
 **   "detail=none" or "detail=column" option.
@@ -214451,7 +214451,7 @@ struct Fts5PhraseIter {
 **   Save the pointer passed as the second argument as the extension function's
 **   "auxiliary data". The pointer may then be retrieved by the current or any
 **   future invocation of the same fts5 extension function made as part of
-**   the same MATCH query using the xGetAuxdata() API.
+**   the same MATCH query using the xGetAuxdata() API. 
 **
 **   Each extension function is allocated a single auxiliary data slot for
 **   each FTS query (MATCH expression). If the extension function is invoked
@@ -214466,7 +214466,7 @@ struct Fts5PhraseIter {
 **   The xDelete callback, if one is specified, is also invoked on the
 **   auxiliary data pointer after the FTS5 query has finished.
 **
-**   If an error (e.g. an OOM condition) occurs within this function,
+**   If an error (e.g. an OOM condition) occurs within this function, 
 **   the auxiliary data is set to NULL and an error code returned. If the
 **   xDelete parameter was not NULL, it is invoked on the auxiliary data
 **   pointer before returning.
@@ -214699,11 +214699,11 @@ struct Fts5ExtensionApi {
 **            the tokenizer substitutes "first" for "1st" and the query works
 **            as expected.
 **
-**       <li> By querying the index for all synonyms of each query term
-**            separately. In this case, when tokenizing query text, the
+**       <li> By querying the index for all synonyms of each query term 
+**            separately. In this case, when tokenizing query text, the 
 **            tokenizer may provide multiple synonyms for a single term
 **            within the document. FTS5 then queries the index for each
-**            synonym individually. For example, faced with the query:
+**            synonym individually. For example, faced with the query: 
 **
 **   <codeblock>
 **     ... MATCH 'first place'</codeblock>
@@ -214727,9 +214727,9 @@ struct Fts5ExtensionApi {
 **            "place".
 **
 **            This way, even if the tokenizer does not provide synonyms
-**            when tokenizing query text (it should not - to do so would be
+**            when tokenizing query text (it should not - to do so would be 
 **            inefficient), it doesn't matter if the user queries for
-**            'first + place' or '1st + place', as there are entries in the
+**            'first + place' or '1st + place', as there are entries in the 
 **            FTS index corresponding to both forms of the first token.
 **   </ol>
 **
@@ -214757,7 +214757,7 @@ struct Fts5ExtensionApi {
 **   extra data to the FTS index or require FTS5 to query for multiple terms,
 **   so it is efficient in terms of disk space and query speed. However, it
 **   does not support prefix queries very well. If, as suggested above, the
-**   token "first" is substituted for "1st" by the tokenizer, then the query:
+**   token "first" is substituted for "1st" by the tokenizer, then the query: 
 **
 **   <codeblock>
 **     ... MATCH '1s*'</codeblock>
@@ -214969,12 +214969,12 @@ SQLITE_API extern int sqlite3_fts5_may_be_corrupt;
 # define assert_nc(x) assert(x)
 #endif
 
-/*
-** A version of memcmp() that does not cause asan errors if one of the pointer
-** parameters is NULL and the number of bytes to compare is zero.
-*/
+/* 
+** A version of memcmp() that does not cause asan errors if one of the pointer 
+** parameters is NULL and the number of bytes to compare is zero. 
+*/ 
 #define fts5Memcmp(s1, s2, n) ((n)<=0 ? 0 : memcmp((s1), (s2), (n)))
-
+ 
 /* Mark a function parameter as unused, to suppress nuisance compiler
 ** warnings. */
 #ifndef UNUSED_PARAM
@@ -215166,7 +215166,7 @@ static void sqlite3Fts5Put32(u8*, int);
 static int sqlite3Fts5Get32(const u8*);
 
 #define FTS5_POS2COLUMN(iPos) (int)(iPos >> 32)
-#define FTS5_POS2OFFSET(iPos) (int)(iPos & 0x7FFFFFFF)
+#define FTS5_POS2OFFSET(iPos) (int)(iPos & 0x7FFFFFFF) 
 
 typedef struct Fts5PoslistReader Fts5PoslistReader;
 struct Fts5PoslistReader {
@@ -215201,7 +215201,7 @@ static int sqlite3Fts5PoslistNext64(
 );
 
 /* Malloc utility */
-static void *sqlite3Fts5MallocZero(int *pRc, sqlite3_int64 nByte);
+static void *sqlite3Fts5MallocZero(int *pRc, sqlite3_int64 nByte); 
 static char *sqlite3Fts5Strndup(int *pRc, const char *pIn, int nIn);
 
 /* Character set tests (like isspace(), isalpha() etc.) */
@@ -215423,16 +215423,16 @@ static int sqlite3Fts5PutVarint(unsigned char *p, u64 v);
 ** Interface to code in fts5_main.c.
 */
 
-/*
-** Virtual-table object.
-*/
-typedef struct Fts5Table Fts5Table;
-struct Fts5Table {
-  sqlite3_vtab base;              /* Base class used by SQLite core */
-  Fts5Config *pConfig;            /* Virtual table configuration */
-  Fts5Index *pIndex;              /* Full-text index */
-};
-
+/* 
+** Virtual-table object. 
+*/ 
+typedef struct Fts5Table Fts5Table; 
+struct Fts5Table { 
+  sqlite3_vtab base;              /* Base class used by SQLite core */ 
+  Fts5Config *pConfig;            /* Virtual table configuration */ 
+  Fts5Index *pIndex;              /* Full-text index */ 
+}; 
+ 
 static int sqlite3Fts5GetTokenizer(
   Fts5Global*,
   const char **azArg,
@@ -215441,10 +215441,10 @@ static int sqlite3Fts5GetTokenizer(
   char **pzErr
 );
 
-static Fts5Table *sqlite3Fts5TableFromCsrid(Fts5Global*, i64);
-
-static int sqlite3Fts5FlushToDisk(Fts5Table*);
+static Fts5Table *sqlite3Fts5TableFromCsrid(Fts5Global*, i64); 
 
+static int sqlite3Fts5FlushToDisk(Fts5Table*); 
+ 
 /*
 ** End of interface to code in fts5.c.
 **************************************************************************/
@@ -215476,9 +215476,9 @@ static void sqlite3Fts5HashClear(Fts5Hash*);
 
 static int sqlite3Fts5HashQuery(
   Fts5Hash*,                      /* Hash table to query */
-  int nPre,
+  int nPre, 
   const char *pTerm, int nTerm,   /* Query term */
-  void **ppObj,                   /* OUT: Pointer to doclist for pTerm */
+  void **ppObj,                   /* OUT: Pointer to doclist for pTerm */ 
   int *pnDoclist                  /* OUT: Size of doclist in bytes */
 );
 
@@ -215711,10 +215711,10 @@ static int sqlite3Fts5VocabInit(Fts5Global*, sqlite3*);
 */
 static int sqlite3Fts5UnicodeIsdiacritic(int c);
 static int sqlite3Fts5UnicodeFold(int c, int bRemoveDiacritic);
-
-static int sqlite3Fts5UnicodeCatParse(const char*, u8*);
-static int sqlite3Fts5UnicodeCategory(u32 iCode);
-static void sqlite3Fts5UnicodeAscii(u8*, u8*);
+ 
+static int sqlite3Fts5UnicodeCatParse(const char*, u8*); 
+static int sqlite3Fts5UnicodeCategory(u32 iCode); 
+static void sqlite3Fts5UnicodeAscii(u8*, u8*); 
 /*
 ** End of interface to code in fts5_unicode2.c.
 **************************************************************************/
@@ -215846,10 +215846,10 @@ static void sqlite3Fts5UnicodeAscii(u8*, u8*);
 **                       zero the stack is dynamically sized using realloc()
 **    sqlite3Fts5ParserARG_SDECL     A static variable declaration for the %extra_argument
 **    sqlite3Fts5ParserARG_PDECL     A parameter declaration for the %extra_argument
-**    sqlite3Fts5ParserARG_PARAM     Code to pass %extra_argument as a subroutine parameter
+**    sqlite3Fts5ParserARG_PARAM     Code to pass %extra_argument as a subroutine parameter 
 **    sqlite3Fts5ParserARG_STORE     Code to store %extra_argument into fts5yypParser
 **    sqlite3Fts5ParserARG_FETCH     Code to extract %extra_argument from fts5yypParser
-**    sqlite3Fts5ParserCTX_*         As sqlite3Fts5ParserARG_ except for %extra_context
+**    sqlite3Fts5ParserCTX_*         As sqlite3Fts5ParserARG_ except for %extra_context 
 **    fts5YYERRORSYMBOL      is the code number of the error symbol.  If not
 **                       defined, then do no error processing.
 **    fts5YYNSTATE           the combined number of states.
@@ -215869,31 +215869,31 @@ static void sqlite3Fts5UnicodeAscii(u8*, u8*);
 #endif
 /************* Begin control #defines *****************************************/
 #define fts5YYCODETYPE unsigned char
-#define fts5YYNOCODE 27
+#define fts5YYNOCODE 27 
 #define fts5YYACTIONTYPE unsigned char
 #define sqlite3Fts5ParserFTS5TOKENTYPE Fts5Token
 typedef union {
   int fts5yyinit;
   sqlite3Fts5ParserFTS5TOKENTYPE fts5yy0;
   int fts5yy4;
-  Fts5Colset* fts5yy11;
-  Fts5ExprNode* fts5yy24;
-  Fts5ExprNearset* fts5yy46;
-  Fts5ExprPhrase* fts5yy53;
+  Fts5Colset* fts5yy11; 
+  Fts5ExprNode* fts5yy24; 
+  Fts5ExprNearset* fts5yy46; 
+  Fts5ExprPhrase* fts5yy53; 
 } fts5YYMINORTYPE;
 #ifndef fts5YYSTACKDEPTH
 #define fts5YYSTACKDEPTH 100
 #endif
 #define sqlite3Fts5ParserARG_SDECL Fts5Parse *pParse;
 #define sqlite3Fts5ParserARG_PDECL ,Fts5Parse *pParse
-#define sqlite3Fts5ParserARG_PARAM ,pParse
-#define sqlite3Fts5ParserARG_FETCH Fts5Parse *pParse=fts5yypParser->pParse;
-#define sqlite3Fts5ParserARG_STORE fts5yypParser->pParse=pParse;
-#define sqlite3Fts5ParserCTX_SDECL
-#define sqlite3Fts5ParserCTX_PDECL
-#define sqlite3Fts5ParserCTX_PARAM
-#define sqlite3Fts5ParserCTX_FETCH
-#define sqlite3Fts5ParserCTX_STORE
+#define sqlite3Fts5ParserARG_PARAM ,pParse 
+#define sqlite3Fts5ParserARG_FETCH Fts5Parse *pParse=fts5yypParser->pParse; 
+#define sqlite3Fts5ParserARG_STORE fts5yypParser->pParse=pParse; 
+#define sqlite3Fts5ParserCTX_SDECL 
+#define sqlite3Fts5ParserCTX_PDECL 
+#define sqlite3Fts5ParserCTX_PARAM 
+#define sqlite3Fts5ParserCTX_FETCH 
+#define sqlite3Fts5ParserCTX_STORE 
 #define fts5YYNSTATE             35
 #define fts5YYNRULE              28
 #define fts5YYNRULE_WITH_ACTION  28
@@ -215907,7 +215907,7 @@ typedef union {
 #define fts5YY_MIN_REDUCE        83
 #define fts5YY_MAX_REDUCE        110
 /************* End control #defines *******************************************/
-#define fts5YY_NLOOKAHEAD ((int)(sizeof(fts5yy_lookahead)/sizeof(fts5yy_lookahead[0])))
+#define fts5YY_NLOOKAHEAD ((int)(sizeof(fts5yy_lookahead)/sizeof(fts5yy_lookahead[0]))) 
 
 /* Define the fts5yytestcase() macro to be a no-op if is not already defined
 ** otherwise.
@@ -215976,46 +215976,46 @@ typedef union {
 static const fts5YYACTIONTYPE fts5yy_action[] = {
  /*     0 */    81,   20,   96,    6,   28,   99,   98,   26,   26,   18,
  /*    10 */    96,    6,   28,   17,   98,   56,   26,   19,   96,    6,
- /*    20 */    28,   14,   98,   14,   26,   31,   92,   96,    6,   28,
- /*    30 */   108,   98,   25,   26,   21,   96,    6,   28,   78,   98,
- /*    40 */    58,   26,   29,   96,    6,   28,  107,   98,   22,   26,
- /*    50 */    24,   16,   12,   11,    1,   13,   13,   24,   16,   23,
- /*    60 */    11,   33,   34,   13,   97,    8,   27,   32,   98,    7,
- /*    70 */    26,    3,    4,    5,    3,    4,    5,    3,   83,    4,
- /*    80 */     5,    3,   63,    5,    3,   62,   12,    2,   86,   13,
- /*    90 */     9,   30,   10,   10,   54,   57,   75,   78,   78,   53,
- /*   100 */    57,   15,   82,   82,   71,
+ /*    20 */    28,   14,   98,   14,   26,   31,   92,   96,    6,   28, 
+ /*    30 */   108,   98,   25,   26,   21,   96,    6,   28,   78,   98, 
+ /*    40 */    58,   26,   29,   96,    6,   28,  107,   98,   22,   26, 
+ /*    50 */    24,   16,   12,   11,    1,   13,   13,   24,   16,   23, 
+ /*    60 */    11,   33,   34,   13,   97,    8,   27,   32,   98,    7, 
+ /*    70 */    26,    3,    4,    5,    3,    4,    5,    3,   83,    4, 
+ /*    80 */     5,    3,   63,    5,    3,   62,   12,    2,   86,   13, 
+ /*    90 */     9,   30,   10,   10,   54,   57,   75,   78,   78,   53, 
+ /*   100 */    57,   15,   82,   82,   71, 
 };
 static const fts5YYCODETYPE fts5yy_lookahead[] = {
- /*     0 */    16,   17,   18,   19,   20,   22,   22,   24,   24,   17,
- /*    10 */    18,   19,   20,    7,   22,    9,   24,   17,   18,   19,
- /*    20 */    20,    9,   22,    9,   24,   13,   17,   18,   19,   20,
- /*    30 */    26,   22,   24,   24,   17,   18,   19,   20,   15,   22,
- /*    40 */     9,   24,   17,   18,   19,   20,   26,   22,   21,   24,
- /*    50 */     6,    7,    9,    9,   10,   12,   12,    6,    7,   21,
- /*    60 */     9,   24,   25,   12,   18,    5,   20,   14,   22,    5,
- /*    70 */    24,    3,    1,    2,    3,    1,    2,    3,    0,    1,
- /*    80 */     2,    3,   11,    2,    3,   11,    9,   10,    5,   12,
- /*    90 */    23,   24,   10,   10,    8,    9,    9,   15,   15,    8,
- /*   100 */     9,    9,   27,   27,   11,   27,   27,   27,   27,   27,
- /*   110 */    27,   27,   27,   27,   27,   27,   27,   27,   27,   27,
- /*   120 */    27,
+ /*     0 */    16,   17,   18,   19,   20,   22,   22,   24,   24,   17, 
+ /*    10 */    18,   19,   20,    7,   22,    9,   24,   17,   18,   19, 
+ /*    20 */    20,    9,   22,    9,   24,   13,   17,   18,   19,   20, 
+ /*    30 */    26,   22,   24,   24,   17,   18,   19,   20,   15,   22, 
+ /*    40 */     9,   24,   17,   18,   19,   20,   26,   22,   21,   24, 
+ /*    50 */     6,    7,    9,    9,   10,   12,   12,    6,    7,   21, 
+ /*    60 */     9,   24,   25,   12,   18,    5,   20,   14,   22,    5, 
+ /*    70 */    24,    3,    1,    2,    3,    1,    2,    3,    0,    1, 
+ /*    80 */     2,    3,   11,    2,    3,   11,    9,   10,    5,   12, 
+ /*    90 */    23,   24,   10,   10,    8,    9,    9,   15,   15,    8, 
+ /*   100 */     9,    9,   27,   27,   11,   27,   27,   27,   27,   27, 
+ /*   110 */    27,   27,   27,   27,   27,   27,   27,   27,   27,   27, 
+ /*   120 */    27, 
 };
 #define fts5YY_SHIFT_COUNT    (34)
 #define fts5YY_SHIFT_MIN      (0)
-#define fts5YY_SHIFT_MAX      (93)
+#define fts5YY_SHIFT_MAX      (93) 
 static const unsigned char fts5yy_shift_ofst[] = {
- /*     0 */    44,   44,   44,   44,   44,   44,   51,   77,   43,   12,
- /*    10 */    14,   83,   82,   14,   23,   23,   31,   31,   71,   74,
- /*    20 */    78,   81,   86,   91,    6,   53,   53,   60,   64,   68,
- /*    30 */    53,   87,   92,   53,   93,
+ /*     0 */    44,   44,   44,   44,   44,   44,   51,   77,   43,   12, 
+ /*    10 */    14,   83,   82,   14,   23,   23,   31,   31,   71,   74, 
+ /*    20 */    78,   81,   86,   91,    6,   53,   53,   60,   64,   68, 
+ /*    30 */    53,   87,   92,   53,   93, 
 };
 #define fts5YY_REDUCE_COUNT (17)
-#define fts5YY_REDUCE_MIN   (-17)
-#define fts5YY_REDUCE_MAX   (67)
+#define fts5YY_REDUCE_MIN   (-17) 
+#define fts5YY_REDUCE_MAX   (67) 
 static const signed char fts5yy_reduce_ofst[] = {
- /*     0 */   -16,   -8,    0,    9,   17,   25,   46,  -17,  -17,   37,
- /*    10 */    67,    4,    4,    8,    4,   20,   27,   38,
+ /*     0 */   -16,   -8,    0,    9,   17,   25,   46,  -17,  -17,   37, 
+ /*    10 */    67,    4,    4,    8,    4,   20,   27,   38, 
 };
 static const fts5YYACTIONTYPE fts5yy_default[] = {
  /*     0 */    80,   80,   80,   80,   80,   80,   95,   80,   80,  105,
@@ -216080,7 +216080,7 @@ struct fts5yyParser {
   int fts5yyerrcnt;                 /* Shifts left before out of the error */
 #endif
   sqlite3Fts5ParserARG_SDECL                /* A place to hold %extra_argument */
-  sqlite3Fts5ParserCTX_SDECL                /* A place to hold %extra_context */
+  sqlite3Fts5ParserCTX_SDECL                /* A place to hold %extra_context */ 
 #if fts5YYSTACKDEPTH<=0
   int fts5yystksz;                  /* Current side of the stack */
   fts5yyStackEntry *fts5yystack;        /* The parser's stack */
@@ -216145,17 +216145,17 @@ static const char *const fts5yyTokenName[] = {
   /*   13 */ "COMMA",
   /*   14 */ "PLUS",
   /*   15 */ "STAR",
-  /*   16 */ "input",
-  /*   17 */ "expr",
-  /*   18 */ "cnearset",
-  /*   19 */ "exprlist",
-  /*   20 */ "colset",
-  /*   21 */ "colsetlist",
-  /*   22 */ "nearset",
-  /*   23 */ "nearphrases",
-  /*   24 */ "phrase",
-  /*   25 */ "neardist_opt",
-  /*   26 */ "star_opt",
+  /*   16 */ "input", 
+  /*   17 */ "expr", 
+  /*   18 */ "cnearset", 
+  /*   19 */ "exprlist", 
+  /*   20 */ "colset", 
+  /*   21 */ "colsetlist", 
+  /*   22 */ "nearset", 
+  /*   23 */ "nearphrases", 
+  /*   24 */ "phrase", 
+  /*   25 */ "neardist_opt", 
+  /*   26 */ "star_opt", 
 };
 #endif /* defined(fts5YYCOVERAGE) || !defined(NDEBUG) */
 
@@ -216239,29 +216239,29 @@ static int fts5yyGrowStack(fts5yyParser *p){
 
 /* Initialize a new parser that has already been allocated.
 */
-static void sqlite3Fts5ParserInit(void *fts5yypRawParser sqlite3Fts5ParserCTX_PDECL){
-  fts5yyParser *fts5yypParser = (fts5yyParser*)fts5yypRawParser;
-  sqlite3Fts5ParserCTX_STORE
+static void sqlite3Fts5ParserInit(void *fts5yypRawParser sqlite3Fts5ParserCTX_PDECL){ 
+  fts5yyParser *fts5yypParser = (fts5yyParser*)fts5yypRawParser; 
+  sqlite3Fts5ParserCTX_STORE 
 #ifdef fts5YYTRACKMAXSTACKDEPTH
-  fts5yypParser->fts5yyhwm = 0;
+  fts5yypParser->fts5yyhwm = 0; 
 #endif
 #if fts5YYSTACKDEPTH<=0
-  fts5yypParser->fts5yytos = NULL;
-  fts5yypParser->fts5yystack = NULL;
-  fts5yypParser->fts5yystksz = 0;
-  if( fts5yyGrowStack(fts5yypParser) ){
-    fts5yypParser->fts5yystack = &fts5yypParser->fts5yystk0;
-    fts5yypParser->fts5yystksz = 1;
+  fts5yypParser->fts5yytos = NULL; 
+  fts5yypParser->fts5yystack = NULL; 
+  fts5yypParser->fts5yystksz = 0; 
+  if( fts5yyGrowStack(fts5yypParser) ){ 
+    fts5yypParser->fts5yystack = &fts5yypParser->fts5yystk0; 
+    fts5yypParser->fts5yystksz = 1; 
   }
 #endif
 #ifndef fts5YYNOERRORRECOVERY
-  fts5yypParser->fts5yyerrcnt = -1;
+  fts5yypParser->fts5yyerrcnt = -1; 
 #endif
-  fts5yypParser->fts5yytos = fts5yypParser->fts5yystack;
-  fts5yypParser->fts5yystack[0].stateno = 0;
-  fts5yypParser->fts5yystack[0].major = 0;
+  fts5yypParser->fts5yytos = fts5yypParser->fts5yystack; 
+  fts5yypParser->fts5yystack[0].stateno = 0; 
+  fts5yypParser->fts5yystack[0].major = 0; 
 #if fts5YYSTACKDEPTH>0
-  fts5yypParser->fts5yystackEnd = &fts5yypParser->fts5yystack[fts5YYSTACKDEPTH-1];
+  fts5yypParser->fts5yystackEnd = &fts5yypParser->fts5yystack[fts5YYSTACKDEPTH-1]; 
 #endif
 }
 
@@ -216278,14 +216278,14 @@ static void sqlite3Fts5ParserInit(void *fts5yypRawParser sqlite3Fts5ParserCTX_PD
 ** A pointer to a parser.  This pointer is used in subsequent calls
 ** to sqlite3Fts5Parser and sqlite3Fts5ParserFree.
 */
-static void *sqlite3Fts5ParserAlloc(void *(*mallocProc)(fts5YYMALLOCARGTYPE) sqlite3Fts5ParserCTX_PDECL){
-  fts5yyParser *fts5yypParser;
-  fts5yypParser = (fts5yyParser*)(*mallocProc)( (fts5YYMALLOCARGTYPE)sizeof(fts5yyParser) );
-  if( fts5yypParser ){
-    sqlite3Fts5ParserCTX_STORE
-    sqlite3Fts5ParserInit(fts5yypParser sqlite3Fts5ParserCTX_PARAM);
-  }
-  return (void*)fts5yypParser;
+static void *sqlite3Fts5ParserAlloc(void *(*mallocProc)(fts5YYMALLOCARGTYPE) sqlite3Fts5ParserCTX_PDECL){ 
+  fts5yyParser *fts5yypParser; 
+  fts5yypParser = (fts5yyParser*)(*mallocProc)( (fts5YYMALLOCARGTYPE)sizeof(fts5yyParser) ); 
+  if( fts5yypParser ){ 
+    sqlite3Fts5ParserCTX_STORE 
+    sqlite3Fts5ParserInit(fts5yypParser sqlite3Fts5ParserCTX_PARAM); 
+  } 
+  return (void*)fts5yypParser; 
 }
 #endif /* sqlite3Fts5Parser_ENGINEALWAYSONSTACK */
 
@@ -216302,8 +216302,8 @@ static void fts5yy_destructor(
   fts5YYCODETYPE fts5yymajor,     /* Type code for object to destroy */
   fts5YYMINORTYPE *fts5yypminor   /* The object to be destroyed */
 ){
-  sqlite3Fts5ParserARG_FETCH
-  sqlite3Fts5ParserCTX_FETCH
+  sqlite3Fts5ParserARG_FETCH 
+  sqlite3Fts5ParserCTX_FETCH 
   switch( fts5yymajor ){
     /* Here is inserted the actions which take place when a
     ** terminal or non-terminal is destroyed.  This can happen
@@ -216316,31 +216316,31 @@ static void fts5yy_destructor(
     ** inside the C code.
     */
 /********* Begin destructor definitions ***************************************/
-    case 16: /* input */
+    case 16: /* input */ 
 {
  (void)pParse;
 }
       break;
-    case 17: /* expr */
-    case 18: /* cnearset */
-    case 19: /* exprlist */
+    case 17: /* expr */ 
+    case 18: /* cnearset */ 
+    case 19: /* exprlist */ 
 {
  sqlite3Fts5ParseNodeFree((fts5yypminor->fts5yy24));
 }
       break;
-    case 20: /* colset */
-    case 21: /* colsetlist */
+    case 20: /* colset */ 
+    case 21: /* colsetlist */ 
 {
  sqlite3_free((fts5yypminor->fts5yy11));
 }
       break;
-    case 22: /* nearset */
-    case 23: /* nearphrases */
+    case 22: /* nearset */ 
+    case 23: /* nearphrases */ 
 {
  sqlite3Fts5ParseNearsetFree((fts5yypminor->fts5yy46));
 }
       break;
-    case 24: /* phrase */
+    case 24: /* phrase */ 
 {
  sqlite3Fts5ParsePhraseFree((fts5yypminor->fts5yy53));
 }
@@ -216454,12 +216454,12 @@ static int sqlite3Fts5ParserCoverage(FILE *out){
 ** Find the appropriate action for a parser given the terminal
 ** look-ahead token iLookAhead.
 */
-static fts5YYACTIONTYPE fts5yy_find_shift_action(
-  fts5YYCODETYPE iLookAhead,    /* The look-ahead token */
-  fts5YYACTIONTYPE stateno      /* Current state number */
+static fts5YYACTIONTYPE fts5yy_find_shift_action( 
+  fts5YYCODETYPE iLookAhead,    /* The look-ahead token */ 
+  fts5YYACTIONTYPE stateno      /* Current state number */ 
 ){
   int i;
-
+ 
   if( stateno>fts5YY_MAX_SHIFT ) return stateno;
   assert( stateno <= fts5YY_SHIFT_COUNT );
 #if defined(fts5YYCOVERAGE)
@@ -216467,7 +216467,7 @@ static fts5YYACTIONTYPE fts5yy_find_shift_action(
 #endif
   do{
     i = fts5yy_shift_ofst[stateno];
-    assert( i>=0 );
+    assert( i>=0 ); 
     assert( i<=fts5YY_ACTTAB_COUNT );
     assert( i+fts5YYNFTS5TOKEN<=(int)fts5YY_NLOOKAHEAD );
     assert( iLookAhead!=fts5YYNOCODE );
@@ -216519,8 +216519,8 @@ static fts5YYACTIONTYPE fts5yy_find_shift_action(
 ** Find the appropriate action for a parser given the non-terminal
 ** look-ahead token iLookAhead.
 */
-static fts5YYACTIONTYPE fts5yy_find_reduce_action(
-  fts5YYACTIONTYPE stateno,     /* Current state number */
+static fts5YYACTIONTYPE fts5yy_find_reduce_action( 
+  fts5YYACTIONTYPE stateno,     /* Current state number */ 
   fts5YYCODETYPE iLookAhead     /* The look-ahead token */
 ){
   int i;
@@ -216549,8 +216549,8 @@ static fts5YYACTIONTYPE fts5yy_find_reduce_action(
 ** The following routine is called if the stack overflows.
 */
 static void fts5yyStackOverflow(fts5yyParser *fts5yypParser){
-   sqlite3Fts5ParserARG_FETCH
-   sqlite3Fts5ParserCTX_FETCH
+   sqlite3Fts5ParserARG_FETCH 
+   sqlite3Fts5ParserCTX_FETCH 
 #ifndef NDEBUG
    if( fts5yyTraceFILE ){
      fprintf(fts5yyTraceFILE,"%sStack Overflow!\n",fts5yyTracePrompt);
@@ -216563,8 +216563,8 @@ static void fts5yyStackOverflow(fts5yyParser *fts5yypParser){
 
   sqlite3Fts5ParseError(pParse, "fts5: parser stack overflow");
 /******** End %stack_overflow code ********************************************/
-   sqlite3Fts5ParserARG_STORE /* Suppress warning about unused %extra_argument var */
-   sqlite3Fts5ParserCTX_STORE
+   sqlite3Fts5ParserARG_STORE /* Suppress warning about unused %extra_argument var */ 
+   sqlite3Fts5ParserCTX_STORE 
 }
 
 /*
@@ -216593,8 +216593,8 @@ static void fts5yyTraceShift(fts5yyParser *fts5yypParser, int fts5yyNewState, co
 */
 static void fts5yy_shift(
   fts5yyParser *fts5yypParser,          /* The parser to be shifted */
-  fts5YYACTIONTYPE fts5yyNewState,      /* The new state to shift in */
-  fts5YYCODETYPE fts5yyMajor,           /* The major token to shift in */
+  fts5YYACTIONTYPE fts5yyNewState,      /* The new state to shift in */ 
+  fts5YYCODETYPE fts5yyMajor,           /* The major token to shift in */ 
   sqlite3Fts5ParserFTS5TOKENTYPE fts5yyMinor        /* The minor token to shift in */
 ){
   fts5yyStackEntry *fts5yytos;
@@ -216624,78 +216624,78 @@ static void fts5yy_shift(
     fts5yyNewState += fts5YY_MIN_REDUCE - fts5YY_MIN_SHIFTREDUCE;
   }
   fts5yytos = fts5yypParser->fts5yytos;
-  fts5yytos->stateno = fts5yyNewState;
-  fts5yytos->major = fts5yyMajor;
+  fts5yytos->stateno = fts5yyNewState; 
+  fts5yytos->major = fts5yyMajor; 
   fts5yytos->minor.fts5yy0 = fts5yyMinor;
   fts5yyTraceShift(fts5yypParser, fts5yyNewState, "Shift");
 }
 
-/* For rule J, fts5yyRuleInfoLhs[J] contains the symbol on the left-hand side
-** of that rule */
-static const fts5YYCODETYPE fts5yyRuleInfoLhs[] = {
-    16,  /* (0) input ::= expr */
-    20,  /* (1) colset ::= MINUS LCP colsetlist RCP */
-    20,  /* (2) colset ::= LCP colsetlist RCP */
-    20,  /* (3) colset ::= STRING */
-    20,  /* (4) colset ::= MINUS STRING */
-    21,  /* (5) colsetlist ::= colsetlist STRING */
-    21,  /* (6) colsetlist ::= STRING */
-    17,  /* (7) expr ::= expr AND expr */
-    17,  /* (8) expr ::= expr OR expr */
-    17,  /* (9) expr ::= expr NOT expr */
-    17,  /* (10) expr ::= colset COLON LP expr RP */
-    17,  /* (11) expr ::= LP expr RP */
-    17,  /* (12) expr ::= exprlist */
-    19,  /* (13) exprlist ::= cnearset */
-    19,  /* (14) exprlist ::= exprlist cnearset */
-    18,  /* (15) cnearset ::= nearset */
-    18,  /* (16) cnearset ::= colset COLON nearset */
-    22,  /* (17) nearset ::= phrase */
-    22,  /* (18) nearset ::= CARET phrase */
-    22,  /* (19) nearset ::= STRING LP nearphrases neardist_opt RP */
-    23,  /* (20) nearphrases ::= phrase */
-    23,  /* (21) nearphrases ::= nearphrases phrase */
-    25,  /* (22) neardist_opt ::= */
-    25,  /* (23) neardist_opt ::= COMMA STRING */
-    24,  /* (24) phrase ::= phrase PLUS STRING star_opt */
-    24,  /* (25) phrase ::= STRING star_opt */
-    26,  /* (26) star_opt ::= STAR */
-    26,  /* (27) star_opt ::= */
-};
-
-/* For rule J, fts5yyRuleInfoNRhs[J] contains the negative of the number
-** of symbols on the right-hand side of that rule. */
-static const signed char fts5yyRuleInfoNRhs[] = {
-   -1,  /* (0) input ::= expr */
-   -4,  /* (1) colset ::= MINUS LCP colsetlist RCP */
-   -3,  /* (2) colset ::= LCP colsetlist RCP */
-   -1,  /* (3) colset ::= STRING */
-   -2,  /* (4) colset ::= MINUS STRING */
-   -2,  /* (5) colsetlist ::= colsetlist STRING */
-   -1,  /* (6) colsetlist ::= STRING */
-   -3,  /* (7) expr ::= expr AND expr */
-   -3,  /* (8) expr ::= expr OR expr */
-   -3,  /* (9) expr ::= expr NOT expr */
-   -5,  /* (10) expr ::= colset COLON LP expr RP */
-   -3,  /* (11) expr ::= LP expr RP */
-   -1,  /* (12) expr ::= exprlist */
-   -1,  /* (13) exprlist ::= cnearset */
-   -2,  /* (14) exprlist ::= exprlist cnearset */
-   -1,  /* (15) cnearset ::= nearset */
-   -3,  /* (16) cnearset ::= colset COLON nearset */
-   -1,  /* (17) nearset ::= phrase */
-   -2,  /* (18) nearset ::= CARET phrase */
-   -5,  /* (19) nearset ::= STRING LP nearphrases neardist_opt RP */
-   -1,  /* (20) nearphrases ::= phrase */
-   -2,  /* (21) nearphrases ::= nearphrases phrase */
-    0,  /* (22) neardist_opt ::= */
-   -2,  /* (23) neardist_opt ::= COMMA STRING */
-   -4,  /* (24) phrase ::= phrase PLUS STRING star_opt */
-   -2,  /* (25) phrase ::= STRING star_opt */
-   -1,  /* (26) star_opt ::= STAR */
-    0,  /* (27) star_opt ::= */
+/* For rule J, fts5yyRuleInfoLhs[J] contains the symbol on the left-hand side 
+** of that rule */ 
+static const fts5YYCODETYPE fts5yyRuleInfoLhs[] = { 
+    16,  /* (0) input ::= expr */ 
+    20,  /* (1) colset ::= MINUS LCP colsetlist RCP */ 
+    20,  /* (2) colset ::= LCP colsetlist RCP */ 
+    20,  /* (3) colset ::= STRING */ 
+    20,  /* (4) colset ::= MINUS STRING */ 
+    21,  /* (5) colsetlist ::= colsetlist STRING */ 
+    21,  /* (6) colsetlist ::= STRING */ 
+    17,  /* (7) expr ::= expr AND expr */ 
+    17,  /* (8) expr ::= expr OR expr */ 
+    17,  /* (9) expr ::= expr NOT expr */ 
+    17,  /* (10) expr ::= colset COLON LP expr RP */ 
+    17,  /* (11) expr ::= LP expr RP */ 
+    17,  /* (12) expr ::= exprlist */ 
+    19,  /* (13) exprlist ::= cnearset */ 
+    19,  /* (14) exprlist ::= exprlist cnearset */ 
+    18,  /* (15) cnearset ::= nearset */ 
+    18,  /* (16) cnearset ::= colset COLON nearset */ 
+    22,  /* (17) nearset ::= phrase */ 
+    22,  /* (18) nearset ::= CARET phrase */ 
+    22,  /* (19) nearset ::= STRING LP nearphrases neardist_opt RP */ 
+    23,  /* (20) nearphrases ::= phrase */ 
+    23,  /* (21) nearphrases ::= nearphrases phrase */ 
+    25,  /* (22) neardist_opt ::= */ 
+    25,  /* (23) neardist_opt ::= COMMA STRING */ 
+    24,  /* (24) phrase ::= phrase PLUS STRING star_opt */ 
+    24,  /* (25) phrase ::= STRING star_opt */ 
+    26,  /* (26) star_opt ::= STAR */ 
+    26,  /* (27) star_opt ::= */ 
 };
 
+/* For rule J, fts5yyRuleInfoNRhs[J] contains the negative of the number 
+** of symbols on the right-hand side of that rule. */ 
+static const signed char fts5yyRuleInfoNRhs[] = { 
+   -1,  /* (0) input ::= expr */ 
+   -4,  /* (1) colset ::= MINUS LCP colsetlist RCP */ 
+   -3,  /* (2) colset ::= LCP colsetlist RCP */ 
+   -1,  /* (3) colset ::= STRING */ 
+   -2,  /* (4) colset ::= MINUS STRING */ 
+   -2,  /* (5) colsetlist ::= colsetlist STRING */ 
+   -1,  /* (6) colsetlist ::= STRING */ 
+   -3,  /* (7) expr ::= expr AND expr */ 
+   -3,  /* (8) expr ::= expr OR expr */ 
+   -3,  /* (9) expr ::= expr NOT expr */ 
+   -5,  /* (10) expr ::= colset COLON LP expr RP */ 
+   -3,  /* (11) expr ::= LP expr RP */ 
+   -1,  /* (12) expr ::= exprlist */ 
+   -1,  /* (13) exprlist ::= cnearset */ 
+   -2,  /* (14) exprlist ::= exprlist cnearset */ 
+   -1,  /* (15) cnearset ::= nearset */ 
+   -3,  /* (16) cnearset ::= colset COLON nearset */ 
+   -1,  /* (17) nearset ::= phrase */ 
+   -2,  /* (18) nearset ::= CARET phrase */ 
+   -5,  /* (19) nearset ::= STRING LP nearphrases neardist_opt RP */ 
+   -1,  /* (20) nearphrases ::= phrase */ 
+   -2,  /* (21) nearphrases ::= nearphrases phrase */ 
+    0,  /* (22) neardist_opt ::= */ 
+   -2,  /* (23) neardist_opt ::= COMMA STRING */ 
+   -4,  /* (24) phrase ::= phrase PLUS STRING star_opt */ 
+   -2,  /* (25) phrase ::= STRING star_opt */ 
+   -1,  /* (26) star_opt ::= STAR */ 
+    0,  /* (27) star_opt ::= */ 
+}; 
+ 
 static void fts5yy_accept(fts5yyParser*);  /* Forward Declaration */
 
 /*
@@ -216708,18 +216708,18 @@ static void fts5yy_accept(fts5yyParser*);  /* Forward Declaration */
 ** only called from one place, optimizing compilers will in-line it, which
 ** means that the extra parameters have no performance impact.
 */
-static fts5YYACTIONTYPE fts5yy_reduce(
+static fts5YYACTIONTYPE fts5yy_reduce( 
   fts5yyParser *fts5yypParser,         /* The parser */
   unsigned int fts5yyruleno,       /* Number of the rule by which to reduce */
   int fts5yyLookahead,             /* Lookahead token, or fts5YYNOCODE if none */
   sqlite3Fts5ParserFTS5TOKENTYPE fts5yyLookaheadToken  /* Value of the lookahead token */
-  sqlite3Fts5ParserCTX_PDECL                   /* %extra_context */
+  sqlite3Fts5ParserCTX_PDECL                   /* %extra_context */ 
 ){
   int fts5yygoto;                     /* The next state */
-  fts5YYACTIONTYPE fts5yyact;             /* The next action */
+  fts5YYACTIONTYPE fts5yyact;             /* The next action */ 
   fts5yyStackEntry *fts5yymsp;            /* The top of the parser's stack */
   int fts5yysize;                     /* Amount to pop the stack */
-  sqlite3Fts5ParserARG_FETCH
+  sqlite3Fts5ParserARG_FETCH 
   (void)fts5yyLookahead;
   (void)fts5yyLookaheadToken;
   fts5yymsp = fts5yypParser->fts5yytos;
@@ -216736,120 +216736,120 @@ static fts5YYACTIONTYPE fts5yy_reduce(
 /********** Begin reduce actions **********************************************/
         fts5YYMINORTYPE fts5yylhsminor;
       case 0: /* input ::= expr */
-{ sqlite3Fts5ParseFinished(pParse, fts5yymsp[0].minor.fts5yy24); }
+{ sqlite3Fts5ParseFinished(pParse, fts5yymsp[0].minor.fts5yy24); } 
         break;
       case 1: /* colset ::= MINUS LCP colsetlist RCP */
 {
-    fts5yymsp[-3].minor.fts5yy11 = sqlite3Fts5ParseColsetInvert(pParse, fts5yymsp[-1].minor.fts5yy11);
+    fts5yymsp[-3].minor.fts5yy11 = sqlite3Fts5ParseColsetInvert(pParse, fts5yymsp[-1].minor.fts5yy11); 
 }
         break;
       case 2: /* colset ::= LCP colsetlist RCP */
-{ fts5yymsp[-2].minor.fts5yy11 = fts5yymsp[-1].minor.fts5yy11; }
+{ fts5yymsp[-2].minor.fts5yy11 = fts5yymsp[-1].minor.fts5yy11; } 
         break;
       case 3: /* colset ::= STRING */
 {
-  fts5yylhsminor.fts5yy11 = sqlite3Fts5ParseColset(pParse, 0, &fts5yymsp[0].minor.fts5yy0);
+  fts5yylhsminor.fts5yy11 = sqlite3Fts5ParseColset(pParse, 0, &fts5yymsp[0].minor.fts5yy0); 
 }
-  fts5yymsp[0].minor.fts5yy11 = fts5yylhsminor.fts5yy11;
+  fts5yymsp[0].minor.fts5yy11 = fts5yylhsminor.fts5yy11; 
         break;
       case 4: /* colset ::= MINUS STRING */
 {
-  fts5yymsp[-1].minor.fts5yy11 = sqlite3Fts5ParseColset(pParse, 0, &fts5yymsp[0].minor.fts5yy0);
-  fts5yymsp[-1].minor.fts5yy11 = sqlite3Fts5ParseColsetInvert(pParse, fts5yymsp[-1].minor.fts5yy11);
+  fts5yymsp[-1].minor.fts5yy11 = sqlite3Fts5ParseColset(pParse, 0, &fts5yymsp[0].minor.fts5yy0); 
+  fts5yymsp[-1].minor.fts5yy11 = sqlite3Fts5ParseColsetInvert(pParse, fts5yymsp[-1].minor.fts5yy11); 
 }
         break;
       case 5: /* colsetlist ::= colsetlist STRING */
 {
-  fts5yylhsminor.fts5yy11 = sqlite3Fts5ParseColset(pParse, fts5yymsp[-1].minor.fts5yy11, &fts5yymsp[0].minor.fts5yy0); }
-  fts5yymsp[-1].minor.fts5yy11 = fts5yylhsminor.fts5yy11;
+  fts5yylhsminor.fts5yy11 = sqlite3Fts5ParseColset(pParse, fts5yymsp[-1].minor.fts5yy11, &fts5yymsp[0].minor.fts5yy0); } 
+  fts5yymsp[-1].minor.fts5yy11 = fts5yylhsminor.fts5yy11; 
         break;
       case 6: /* colsetlist ::= STRING */
 {
   fts5yylhsminor.fts5yy11 = sqlite3Fts5ParseColset(pParse, 0, &fts5yymsp[0].minor.fts5yy0);
 }
-  fts5yymsp[0].minor.fts5yy11 = fts5yylhsminor.fts5yy11;
+  fts5yymsp[0].minor.fts5yy11 = fts5yylhsminor.fts5yy11; 
         break;
       case 7: /* expr ::= expr AND expr */
 {
-  fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_AND, fts5yymsp[-2].minor.fts5yy24, fts5yymsp[0].minor.fts5yy24, 0);
+  fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_AND, fts5yymsp[-2].minor.fts5yy24, fts5yymsp[0].minor.fts5yy24, 0); 
 }
-  fts5yymsp[-2].minor.fts5yy24 = fts5yylhsminor.fts5yy24;
+  fts5yymsp[-2].minor.fts5yy24 = fts5yylhsminor.fts5yy24; 
         break;
       case 8: /* expr ::= expr OR expr */
 {
-  fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_OR, fts5yymsp[-2].minor.fts5yy24, fts5yymsp[0].minor.fts5yy24, 0);
+  fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_OR, fts5yymsp[-2].minor.fts5yy24, fts5yymsp[0].minor.fts5yy24, 0); 
 }
-  fts5yymsp[-2].minor.fts5yy24 = fts5yylhsminor.fts5yy24;
+  fts5yymsp[-2].minor.fts5yy24 = fts5yylhsminor.fts5yy24; 
         break;
       case 9: /* expr ::= expr NOT expr */
 {
-  fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_NOT, fts5yymsp[-2].minor.fts5yy24, fts5yymsp[0].minor.fts5yy24, 0);
+  fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_NOT, fts5yymsp[-2].minor.fts5yy24, fts5yymsp[0].minor.fts5yy24, 0); 
 }
-  fts5yymsp[-2].minor.fts5yy24 = fts5yylhsminor.fts5yy24;
+  fts5yymsp[-2].minor.fts5yy24 = fts5yylhsminor.fts5yy24; 
         break;
       case 10: /* expr ::= colset COLON LP expr RP */
 {
-  sqlite3Fts5ParseSetColset(pParse, fts5yymsp[-1].minor.fts5yy24, fts5yymsp[-4].minor.fts5yy11);
-  fts5yylhsminor.fts5yy24 = fts5yymsp[-1].minor.fts5yy24;
+  sqlite3Fts5ParseSetColset(pParse, fts5yymsp[-1].minor.fts5yy24, fts5yymsp[-4].minor.fts5yy11); 
+  fts5yylhsminor.fts5yy24 = fts5yymsp[-1].minor.fts5yy24; 
 }
-  fts5yymsp[-4].minor.fts5yy24 = fts5yylhsminor.fts5yy24;
+  fts5yymsp[-4].minor.fts5yy24 = fts5yylhsminor.fts5yy24; 
         break;
       case 11: /* expr ::= LP expr RP */
-{fts5yymsp[-2].minor.fts5yy24 = fts5yymsp[-1].minor.fts5yy24;}
+{fts5yymsp[-2].minor.fts5yy24 = fts5yymsp[-1].minor.fts5yy24;} 
         break;
       case 12: /* expr ::= exprlist */
       case 13: /* exprlist ::= cnearset */ fts5yytestcase(fts5yyruleno==13);
-{fts5yylhsminor.fts5yy24 = fts5yymsp[0].minor.fts5yy24;}
-  fts5yymsp[0].minor.fts5yy24 = fts5yylhsminor.fts5yy24;
+{fts5yylhsminor.fts5yy24 = fts5yymsp[0].minor.fts5yy24;} 
+  fts5yymsp[0].minor.fts5yy24 = fts5yylhsminor.fts5yy24; 
         break;
       case 14: /* exprlist ::= exprlist cnearset */
 {
-  fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseImplicitAnd(pParse, fts5yymsp[-1].minor.fts5yy24, fts5yymsp[0].minor.fts5yy24);
+  fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseImplicitAnd(pParse, fts5yymsp[-1].minor.fts5yy24, fts5yymsp[0].minor.fts5yy24); 
 }
-  fts5yymsp[-1].minor.fts5yy24 = fts5yylhsminor.fts5yy24;
+  fts5yymsp[-1].minor.fts5yy24 = fts5yylhsminor.fts5yy24; 
         break;
       case 15: /* cnearset ::= nearset */
 {
   fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_STRING, 0, 0, fts5yymsp[0].minor.fts5yy46);
 }
-  fts5yymsp[0].minor.fts5yy24 = fts5yylhsminor.fts5yy24;
+  fts5yymsp[0].minor.fts5yy24 = fts5yylhsminor.fts5yy24; 
         break;
       case 16: /* cnearset ::= colset COLON nearset */
 {
   fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_STRING, 0, 0, fts5yymsp[0].minor.fts5yy46);
-  sqlite3Fts5ParseSetColset(pParse, fts5yylhsminor.fts5yy24, fts5yymsp[-2].minor.fts5yy11);
+  sqlite3Fts5ParseSetColset(pParse, fts5yylhsminor.fts5yy24, fts5yymsp[-2].minor.fts5yy11); 
 }
-  fts5yymsp[-2].minor.fts5yy24 = fts5yylhsminor.fts5yy24;
+  fts5yymsp[-2].minor.fts5yy24 = fts5yylhsminor.fts5yy24; 
         break;
       case 17: /* nearset ::= phrase */
-{ fts5yylhsminor.fts5yy46 = sqlite3Fts5ParseNearset(pParse, 0, fts5yymsp[0].minor.fts5yy53); }
-  fts5yymsp[0].minor.fts5yy46 = fts5yylhsminor.fts5yy46;
+{ fts5yylhsminor.fts5yy46 = sqlite3Fts5ParseNearset(pParse, 0, fts5yymsp[0].minor.fts5yy53); } 
+  fts5yymsp[0].minor.fts5yy46 = fts5yylhsminor.fts5yy46; 
         break;
       case 18: /* nearset ::= CARET phrase */
 {
-  sqlite3Fts5ParseSetCaret(fts5yymsp[0].minor.fts5yy53);
+  sqlite3Fts5ParseSetCaret(fts5yymsp[0].minor.fts5yy53); 
   fts5yymsp[-1].minor.fts5yy46 = sqlite3Fts5ParseNearset(pParse, 0, fts5yymsp[0].minor.fts5yy53);
 }
         break;
       case 19: /* nearset ::= STRING LP nearphrases neardist_opt RP */
 {
   sqlite3Fts5ParseNear(pParse, &fts5yymsp[-4].minor.fts5yy0);
-  sqlite3Fts5ParseSetDistance(pParse, fts5yymsp[-2].minor.fts5yy46, &fts5yymsp[-1].minor.fts5yy0);
-  fts5yylhsminor.fts5yy46 = fts5yymsp[-2].minor.fts5yy46;
+  sqlite3Fts5ParseSetDistance(pParse, fts5yymsp[-2].minor.fts5yy46, &fts5yymsp[-1].minor.fts5yy0); 
+  fts5yylhsminor.fts5yy46 = fts5yymsp[-2].minor.fts5yy46; 
 }
-  fts5yymsp[-4].minor.fts5yy46 = fts5yylhsminor.fts5yy46;
+  fts5yymsp[-4].minor.fts5yy46 = fts5yylhsminor.fts5yy46; 
         break;
       case 20: /* nearphrases ::= phrase */
 {
   fts5yylhsminor.fts5yy46 = sqlite3Fts5ParseNearset(pParse, 0, fts5yymsp[0].minor.fts5yy53);
 }
-  fts5yymsp[0].minor.fts5yy46 = fts5yylhsminor.fts5yy46;
+  fts5yymsp[0].minor.fts5yy46 = fts5yylhsminor.fts5yy46; 
         break;
       case 21: /* nearphrases ::= nearphrases phrase */
 {
-  fts5yylhsminor.fts5yy46 = sqlite3Fts5ParseNearset(pParse, fts5yymsp[-1].minor.fts5yy46, fts5yymsp[0].minor.fts5yy53);
+  fts5yylhsminor.fts5yy46 = sqlite3Fts5ParseNearset(pParse, fts5yymsp[-1].minor.fts5yy46, fts5yymsp[0].minor.fts5yy53); 
 }
-  fts5yymsp[-1].minor.fts5yy46 = fts5yylhsminor.fts5yy46;
+  fts5yymsp[-1].minor.fts5yy46 = fts5yylhsminor.fts5yy46; 
         break;
       case 22: /* neardist_opt ::= */
 { fts5yymsp[1].minor.fts5yy0.p = 0; fts5yymsp[1].minor.fts5yy0.n = 0; }
@@ -216859,15 +216859,15 @@ static fts5YYACTIONTYPE fts5yy_reduce(
         break;
       case 24: /* phrase ::= phrase PLUS STRING star_opt */
 {
-  fts5yylhsminor.fts5yy53 = sqlite3Fts5ParseTerm(pParse, fts5yymsp[-3].minor.fts5yy53, &fts5yymsp[-1].minor.fts5yy0, fts5yymsp[0].minor.fts5yy4);
+  fts5yylhsminor.fts5yy53 = sqlite3Fts5ParseTerm(pParse, fts5yymsp[-3].minor.fts5yy53, &fts5yymsp[-1].minor.fts5yy0, fts5yymsp[0].minor.fts5yy4); 
 }
-  fts5yymsp[-3].minor.fts5yy53 = fts5yylhsminor.fts5yy53;
+  fts5yymsp[-3].minor.fts5yy53 = fts5yylhsminor.fts5yy53; 
         break;
       case 25: /* phrase ::= STRING star_opt */
 {
-  fts5yylhsminor.fts5yy53 = sqlite3Fts5ParseTerm(pParse, 0, &fts5yymsp[-1].minor.fts5yy0, fts5yymsp[0].minor.fts5yy4);
+  fts5yylhsminor.fts5yy53 = sqlite3Fts5ParseTerm(pParse, 0, &fts5yymsp[-1].minor.fts5yy0, fts5yymsp[0].minor.fts5yy4); 
 }
-  fts5yymsp[-1].minor.fts5yy53 = fts5yylhsminor.fts5yy53;
+  fts5yymsp[-1].minor.fts5yy53 = fts5yylhsminor.fts5yy53; 
         break;
       case 26: /* star_opt ::= STAR */
 { fts5yymsp[0].minor.fts5yy4 = 1; }
@@ -216879,9 +216879,9 @@ static fts5YYACTIONTYPE fts5yy_reduce(
         break;
 /********** End reduce actions ************************************************/
   };
-  assert( fts5yyruleno<sizeof(fts5yyRuleInfoLhs)/sizeof(fts5yyRuleInfoLhs[0]) );
-  fts5yygoto = fts5yyRuleInfoLhs[fts5yyruleno];
-  fts5yysize = fts5yyRuleInfoNRhs[fts5yyruleno];
+  assert( fts5yyruleno<sizeof(fts5yyRuleInfoLhs)/sizeof(fts5yyRuleInfoLhs[0]) ); 
+  fts5yygoto = fts5yyRuleInfoLhs[fts5yyruleno]; 
+  fts5yysize = fts5yyRuleInfoNRhs[fts5yyruleno]; 
   fts5yyact = fts5yy_find_reduce_action(fts5yymsp[fts5yysize].stateno,(fts5YYCODETYPE)fts5yygoto);
 
   /* There are no SHIFTREDUCE actions on nonterminals because the table
@@ -216896,7 +216896,7 @@ static fts5YYACTIONTYPE fts5yy_reduce(
   fts5yymsp->stateno = (fts5YYACTIONTYPE)fts5yyact;
   fts5yymsp->major = (fts5YYCODETYPE)fts5yygoto;
   fts5yyTraceShift(fts5yypParser, fts5yyact, "... then shift");
-  return fts5yyact;
+  return fts5yyact; 
 }
 
 /*
@@ -216906,8 +216906,8 @@ static fts5YYACTIONTYPE fts5yy_reduce(
 static void fts5yy_parse_failed(
   fts5yyParser *fts5yypParser           /* The parser */
 ){
-  sqlite3Fts5ParserARG_FETCH
-  sqlite3Fts5ParserCTX_FETCH
+  sqlite3Fts5ParserARG_FETCH 
+  sqlite3Fts5ParserCTX_FETCH 
 #ifndef NDEBUG
   if( fts5yyTraceFILE ){
     fprintf(fts5yyTraceFILE,"%sFail!\n",fts5yyTracePrompt);
@@ -216918,8 +216918,8 @@ static void fts5yy_parse_failed(
   ** parser fails */
 /************ Begin %parse_failure code ***************************************/
 /************ End %parse_failure code *****************************************/
-  sqlite3Fts5ParserARG_STORE /* Suppress warning about unused %extra_argument variable */
-  sqlite3Fts5ParserCTX_STORE
+  sqlite3Fts5ParserARG_STORE /* Suppress warning about unused %extra_argument variable */ 
+  sqlite3Fts5ParserCTX_STORE 
 }
 #endif /* fts5YYNOERRORRECOVERY */
 
@@ -216931,8 +216931,8 @@ static void fts5yy_syntax_error(
   int fts5yymajor,                   /* The major type of the error token */
   sqlite3Fts5ParserFTS5TOKENTYPE fts5yyminor         /* The minor type of the error token */
 ){
-  sqlite3Fts5ParserARG_FETCH
-  sqlite3Fts5ParserCTX_FETCH
+  sqlite3Fts5ParserARG_FETCH 
+  sqlite3Fts5ParserCTX_FETCH 
 #define FTS5TOKEN fts5yyminor
 /************ Begin %syntax_error code ****************************************/
 
@@ -216941,8 +216941,8 @@ static void fts5yy_syntax_error(
     pParse, "fts5: syntax error near \"%.*s\"",FTS5TOKEN.n,FTS5TOKEN.p
   );
 /************ End %syntax_error code ******************************************/
-  sqlite3Fts5ParserARG_STORE /* Suppress warning about unused %extra_argument variable */
-  sqlite3Fts5ParserCTX_STORE
+  sqlite3Fts5ParserARG_STORE /* Suppress warning about unused %extra_argument variable */ 
+  sqlite3Fts5ParserCTX_STORE 
 }
 
 /*
@@ -216951,8 +216951,8 @@ static void fts5yy_syntax_error(
 static void fts5yy_accept(
   fts5yyParser *fts5yypParser           /* The parser */
 ){
-  sqlite3Fts5ParserARG_FETCH
-  sqlite3Fts5ParserCTX_FETCH
+  sqlite3Fts5ParserARG_FETCH 
+  sqlite3Fts5ParserCTX_FETCH 
 #ifndef NDEBUG
   if( fts5yyTraceFILE ){
     fprintf(fts5yyTraceFILE,"%sAccept!\n",fts5yyTracePrompt);
@@ -216966,8 +216966,8 @@ static void fts5yy_accept(
   ** parser accepts */
 /*********** Begin %parse_accept code *****************************************/
 /*********** End %parse_accept code *******************************************/
-  sqlite3Fts5ParserARG_STORE /* Suppress warning about unused %extra_argument variable */
-  sqlite3Fts5ParserCTX_STORE
+  sqlite3Fts5ParserARG_STORE /* Suppress warning about unused %extra_argument variable */ 
+  sqlite3Fts5ParserCTX_STORE 
 }
 
 /* The main parser program.
@@ -216996,39 +216996,39 @@ static void sqlite3Fts5Parser(
   sqlite3Fts5ParserARG_PDECL               /* Optional %extra_argument parameter */
 ){
   fts5YYMINORTYPE fts5yyminorunion;
-  fts5YYACTIONTYPE fts5yyact;   /* The parser action. */
+  fts5YYACTIONTYPE fts5yyact;   /* The parser action. */ 
 #if !defined(fts5YYERRORSYMBOL) && !defined(fts5YYNOERRORRECOVERY)
   int fts5yyendofinput;     /* True if we are at the end of input */
 #endif
 #ifdef fts5YYERRORSYMBOL
   int fts5yyerrorhit = 0;   /* True if fts5yymajor has invoked an error */
 #endif
-  fts5yyParser *fts5yypParser = (fts5yyParser*)fts5yyp;  /* The parser */
-  sqlite3Fts5ParserCTX_FETCH
-  sqlite3Fts5ParserARG_STORE
+  fts5yyParser *fts5yypParser = (fts5yyParser*)fts5yyp;  /* The parser */ 
+  sqlite3Fts5ParserCTX_FETCH 
+  sqlite3Fts5ParserARG_STORE 
 
   assert( fts5yypParser->fts5yytos!=0 );
 #if !defined(fts5YYERRORSYMBOL) && !defined(fts5YYNOERRORRECOVERY)
   fts5yyendofinput = (fts5yymajor==0);
 #endif
 
-  fts5yyact = fts5yypParser->fts5yytos->stateno;
+  fts5yyact = fts5yypParser->fts5yytos->stateno; 
 #ifndef NDEBUG
   if( fts5yyTraceFILE ){
-    if( fts5yyact < fts5YY_MIN_REDUCE ){
+    if( fts5yyact < fts5YY_MIN_REDUCE ){ 
       fprintf(fts5yyTraceFILE,"%sInput '%s' in state %d\n",
-              fts5yyTracePrompt,fts5yyTokenName[fts5yymajor],fts5yyact);
+              fts5yyTracePrompt,fts5yyTokenName[fts5yymajor],fts5yyact); 
     }else{
       fprintf(fts5yyTraceFILE,"%sInput '%s' with pending reduce %d\n",
-              fts5yyTracePrompt,fts5yyTokenName[fts5yymajor],fts5yyact-fts5YY_MIN_REDUCE);
+              fts5yyTracePrompt,fts5yyTokenName[fts5yymajor],fts5yyact-fts5YY_MIN_REDUCE); 
     }
   }
 #endif
 
   while(1){ /* Exit by "break" */
     assert( fts5yypParser->fts5yytos>=fts5yypParser->fts5yystack );
-    assert( fts5yyact==fts5yypParser->fts5yytos->stateno );
-    fts5yyact = fts5yy_find_shift_action((fts5YYCODETYPE)fts5yymajor,fts5yyact);
+    assert( fts5yyact==fts5yypParser->fts5yytos->stateno ); 
+    fts5yyact = fts5yy_find_shift_action((fts5YYCODETYPE)fts5yymajor,fts5yyact); 
     if( fts5yyact >= fts5YY_MIN_REDUCE ){
       unsigned int fts5yyruleno = fts5yyact - fts5YY_MIN_REDUCE; /* Reduce by this rule */
 #ifndef NDEBUG
@@ -217076,11 +217076,11 @@ static void sqlite3Fts5Parser(
       }
       fts5yyact = fts5yy_reduce(fts5yypParser,fts5yyruleno,fts5yymajor,fts5yyminor sqlite3Fts5ParserCTX_PARAM);
     }else if( fts5yyact <= fts5YY_MAX_SHIFTREDUCE ){
-      fts5yy_shift(fts5yypParser,fts5yyact,(fts5YYCODETYPE)fts5yymajor,fts5yyminor);
+      fts5yy_shift(fts5yypParser,fts5yyact,(fts5YYCODETYPE)fts5yymajor,fts5yyminor); 
 #ifndef fts5YYNOERRORRECOVERY
       fts5yypParser->fts5yyerrcnt--;
 #endif
-      break;
+      break; 
     }else if( fts5yyact==fts5YY_ACCEPT_ACTION ){
       fts5yypParser->fts5yytos--;
       fts5yy_accept(fts5yypParser);
@@ -217149,8 +217149,8 @@ static void sqlite3Fts5Parser(
       }
       fts5yypParser->fts5yyerrcnt = 3;
       fts5yyerrorhit = 1;
-      if( fts5yymajor==fts5YYNOCODE ) break;
-      fts5yyact = fts5yypParser->fts5yytos->stateno;
+      if( fts5yymajor==fts5YYNOCODE ) break; 
+      fts5yyact = fts5yypParser->fts5yytos->stateno; 
 #elif defined(fts5YYNOERRORRECOVERY)
       /* If the fts5YYNOERRORRECOVERY macro is defined, then do not attempt to
       ** do any kind of error recovery.  Instead, simply invoke the syntax
@@ -217161,7 +217161,7 @@ static void sqlite3Fts5Parser(
       */
       fts5yy_syntax_error(fts5yypParser,fts5yymajor, fts5yyminor);
       fts5yy_destructor(fts5yypParser,(fts5YYCODETYPE)fts5yymajor,&fts5yyminorunion);
-      break;
+      break; 
 #else  /* fts5YYERRORSYMBOL is not defined */
       /* This is what we do if the grammar does not define ERROR:
       **
@@ -217183,7 +217183,7 @@ static void sqlite3Fts5Parser(
         fts5yypParser->fts5yyerrcnt = -1;
 #endif
       }
-      break;
+      break; 
 #endif
     }
   }
@@ -217203,20 +217203,20 @@ static void sqlite3Fts5Parser(
 }
 
 /*
-** Return the fallback token corresponding to canonical token iToken, or
-** 0 if iToken has no fallback.
-*/
-static int sqlite3Fts5ParserFallback(int iToken){
-#ifdef fts5YYFALLBACK
+** Return the fallback token corresponding to canonical token iToken, or 
+** 0 if iToken has no fallback. 
+*/ 
+static int sqlite3Fts5ParserFallback(int iToken){ 
+#ifdef fts5YYFALLBACK 
   assert( iToken<(int)(sizeof(fts5yyFallback)/sizeof(fts5yyFallback[0])) );
   return fts5yyFallback[iToken];
-#else
-  (void)iToken;
+#else 
+  (void)iToken; 
   return 0;
-#endif
-}
-
-/*
+#endif 
+} 
+ 
+/* 
 ** 2014 May 31
 **
 ** The author disclaims copyright to this source code.  In place of
@@ -217354,7 +217354,7 @@ static void fts5HighlightAppend(
   HighlightContext *p,
   const char *z, int n
 ){
-  if( *pRc==SQLITE_OK && z ){
+  if( *pRc==SQLITE_OK && z ){ 
     if( n<0 ) n = (int)strlen(z);
     p->zOut = sqlite3_mprintf("%z%.*s", p->zOut, n, z);
     if( p->zOut==0 ) *pRc = SQLITE_NOMEM;
@@ -217486,7 +217486,7 @@ static int fts5SentenceFinderAdd(Fts5SFinder *p, int iAdd){
     int nNew = p->nFirstAlloc ? p->nFirstAlloc*2 : 64;
     int *aNew;
 
-    aNew = (int*)sqlite3_realloc64(p->aFirst, nNew*sizeof(int));
+    aNew = (int*)sqlite3_realloc64(p->aFirst, nNew*sizeof(int)); 
     if( aNew==0 ) return SQLITE_NOMEM;
     p->aFirst = aNew;
     p->nFirstAlloc = nNew;
@@ -217553,12 +217553,12 @@ static int fts5SnippetScore(
   int nInst;
   int nScore = 0;
   int iLast = 0;
-  sqlite3_int64 iEnd = (sqlite3_int64)iPos + nToken;
+  sqlite3_int64 iEnd = (sqlite3_int64)iPos + nToken; 
 
   rc = pApi->xInstCount(pFts, &nInst);
   for(i=0; i<nInst && rc==SQLITE_OK; i++){
     rc = pApi->xInst(pFts, i, &ip, &ic, &iOff);
-    if( rc==SQLITE_OK && ic==iCol && iOff>=iPos && iOff<iEnd ){
+    if( rc==SQLITE_OK && ic==iCol && iOff>=iPos && iOff<iEnd ){ 
       nScore += (aSeen[ip] ? 1 : 1000);
       aSeen[ip] = 1;
       if( iFirst<0 ) iFirst = iOff;
@@ -217568,10 +217568,10 @@ static int fts5SnippetScore(
 
   *pnScore = nScore;
   if( piPos ){
-    sqlite3_int64 iAdj = iFirst - (nToken - (iLast-iFirst)) / 2;
+    sqlite3_int64 iAdj = iFirst - (nToken - (iLast-iFirst)) / 2; 
     if( (iAdj+nToken)>nDocsize ) iAdj = nDocsize - nToken;
     if( iAdj<0 ) iAdj = 0;
-    *piPos = (int)iAdj;
+    *piPos = (int)iAdj; 
   }
 
   return rc;
@@ -217661,9 +217661,9 @@ static void fts5SnippetFunction(
         int jj;
 
         rc = pApi->xInst(pFts, ii, &ip, &ic, &io);
-        if( ic!=i ) continue;
-        if( io>nDocsize ) rc = FTS5_CORRUPT;
-        if( rc!=SQLITE_OK ) continue;
+        if( ic!=i ) continue; 
+        if( io>nDocsize ) rc = FTS5_CORRUPT; 
+        if( rc!=SQLITE_OK ) continue; 
         memset(aSeen, 0, nPhrase);
         rc = fts5SnippetScore(pApi, pFts, nDocsize, aSeen, i,
             io, nToken, &nScore, &iAdj
@@ -217789,17 +217789,17 @@ static int fts5Bm25GetData(
     int nPhrase;                  /* Number of phrases in query */
     sqlite3_int64 nRow = 0;       /* Number of rows in table */
     sqlite3_int64 nToken = 0;     /* Number of tokens in table */
-    sqlite3_int64 nByte;          /* Bytes of space to allocate */
+    sqlite3_int64 nByte;          /* Bytes of space to allocate */ 
     int i;
 
     /* Allocate the Fts5Bm25Data object */
     nPhrase = pApi->xPhraseCount(pFts);
     nByte = sizeof(Fts5Bm25Data) + nPhrase*2*sizeof(double);
-    p = (Fts5Bm25Data*)sqlite3_malloc64(nByte);
+    p = (Fts5Bm25Data*)sqlite3_malloc64(nByte); 
     if( p==0 ){
       rc = SQLITE_NOMEM;
     }else{
-      memset(p, 0, (size_t)nByte);
+      memset(p, 0, (size_t)nByte); 
       p->nPhrase = nPhrase;
       p->aIDF = (double*)&p[1];
       p->aFreq = &p->aIDF[nPhrase];
@@ -217807,7 +217807,7 @@ static int fts5Bm25GetData(
 
     /* Calculate the average document length for this FTS5 table */
     if( rc==SQLITE_OK ) rc = pApi->xRowCount(pFts, &nRow);
-    assert( rc!=SQLITE_OK || nRow>0 );
+    assert( rc!=SQLITE_OK || nRow>0 ); 
     if( rc==SQLITE_OK ) rc = pApi->xColumnTotalSize(pFts, -1, &nToken);
     if( rc==SQLITE_OK ) p->avgdl = (double)nToken  / (double)nRow;
 
@@ -217950,17 +217950,17 @@ static int sqlite3Fts5AuxInit(fts5_api *pApi){
 
 static int sqlite3Fts5BufferSize(int *pRc, Fts5Buffer *pBuf, u32 nByte){
   if( (u32)pBuf->nSpace<nByte ){
-    u64 nNew = pBuf->nSpace ? pBuf->nSpace : 64;
+    u64 nNew = pBuf->nSpace ? pBuf->nSpace : 64; 
     u8 *pNew;
     while( nNew<nByte ){
       nNew = nNew * 2;
     }
-    pNew = sqlite3_realloc64(pBuf->p, nNew);
+    pNew = sqlite3_realloc64(pBuf->p, nNew); 
     if( pNew==0 ){
       *pRc = SQLITE_NOMEM;
       return 1;
     }else{
-      pBuf->nSpace = (int)nNew;
+      pBuf->nSpace = (int)nNew; 
       pBuf->p = pNew;
     }
   }
@@ -217985,7 +217985,7 @@ static void sqlite3Fts5Put32(u8 *aBuf, int iVal){
 }
 
 static int sqlite3Fts5Get32(const u8 *aBuf){
-  return (int)((((u32)aBuf[0])<<24) + (aBuf[1]<<16) + (aBuf[2]<<8) + aBuf[3]);
+  return (int)((((u32)aBuf[0])<<24) + (aBuf[1]<<16) + (aBuf[2]<<8) + aBuf[3]); 
 }
 
 /*
@@ -218110,20 +218110,20 @@ static int sqlite3Fts5PoslistNext64(
     i64 iOff = *piOff;
     u32 iVal;
     fts5FastGetVarint32(a, i, iVal);
-    if( iVal<=1 ){
-      if( iVal==0 ){
-        *pi = i;
-        return 0;
-      }
+    if( iVal<=1 ){ 
+      if( iVal==0 ){ 
+        *pi = i; 
+        return 0; 
+      } 
       fts5FastGetVarint32(a, i, iVal);
       iOff = ((i64)iVal) << 32;
       assert( iOff>=0 );
       fts5FastGetVarint32(a, i, iVal);
-      if( iVal<2 ){
-        /* This is a corrupt record. So stop parsing it here. */
-        *piOff = -1;
-        return 1;
-      }
+      if( iVal<2 ){ 
+        /* This is a corrupt record. So stop parsing it here. */ 
+        *piOff = -1; 
+        return 1; 
+      } 
       *piOff = iOff + ((iVal-2) & 0x7FFFFFFF);
     }else{
       *piOff = (iOff & (i64)0x7FFFFFFF<<32)+((iOff + (iVal-2)) & 0x7FFFFFFF);
@@ -218191,14 +218191,14 @@ static int sqlite3Fts5PoslistWriterAppend(
   return SQLITE_OK;
 }
 
-static void *sqlite3Fts5MallocZero(int *pRc, sqlite3_int64 nByte){
+static void *sqlite3Fts5MallocZero(int *pRc, sqlite3_int64 nByte){ 
   void *pRet = 0;
   if( *pRc==SQLITE_OK ){
-    pRet = sqlite3_malloc64(nByte);
+    pRet = sqlite3_malloc64(nByte); 
     if( pRet==0 ){
       if( nByte>0 ) *pRc = SQLITE_NOMEM;
     }else{
-      memset(pRet, 0, (size_t)nByte);
+      memset(pRet, 0, (size_t)nByte); 
     }
   }
   return pRet;
@@ -218637,7 +218637,7 @@ static int fts5ConfigParseSpecial(
 
   if( sqlite3_strnicmp("tokenize", zCmd, nCmd)==0 ){
     const char *p = (const char*)zArg;
-    sqlite3_int64 nArg = strlen(zArg) + 1;
+    sqlite3_int64 nArg = strlen(zArg) + 1; 
     char **azArg = sqlite3Fts5MallocZero(&rc, sizeof(char*) * nArg);
     char *pDel = sqlite3Fts5MallocZero(&rc, nArg * 2);
     char *pSpace = pDel;
@@ -218765,8 +218765,8 @@ static const char *fts5ConfigGobbleWord(
 ){
   const char *zRet = 0;
 
-  sqlite3_int64 nIn = strlen(zIn);
-  char *zOut = sqlite3_malloc64(nIn+1);
+  sqlite3_int64 nIn = strlen(zIn); 
+  char *zOut = sqlite3_malloc64(nIn+1); 
 
   assert( *pRc==SQLITE_OK );
   *pbQuoted = 0;
@@ -218775,7 +218775,7 @@ static const char *fts5ConfigGobbleWord(
   if( zOut==0 ){
     *pRc = SQLITE_NOMEM;
   }else{
-    memcpy(zOut, zIn, (size_t)(nIn+1));
+    memcpy(zOut, zIn, (size_t)(nIn+1)); 
     if( fts5_isopenquote(zOut[0]) ){
       int ii = fts5Dequote(zOut);
       zRet = &zIn[ii];
@@ -218869,7 +218869,7 @@ static int sqlite3Fts5ConfigParse(
   int rc = SQLITE_OK;             /* Return code */
   Fts5Config *pRet;               /* New object to return */
   int i;
-  sqlite3_int64 nByte;
+  sqlite3_int64 nByte; 
 
   *ppOut = pRet = (Fts5Config*)sqlite3_malloc(sizeof(Fts5Config));
   if( pRet==0 ) return SQLITE_NOMEM;
@@ -219344,7 +219344,7 @@ static void sqlite3Fts5Parser(void*, int, Fts5Token, Fts5Parse*);
 /* #include <stdio.h> */
 static void sqlite3Fts5ParserTrace(FILE*, char*);
 #endif
-static int sqlite3Fts5ParserFallback(int);
+static int sqlite3Fts5ParserFallback(int); 
 
 
 struct Fts5Expr {
@@ -219521,7 +219521,7 @@ static int fts5ExprGetToken(
   return tok;
 }
 
-static void *fts5ParseAlloc(u64 t){ return sqlite3_malloc64((sqlite3_int64)t);}
+static void *fts5ParseAlloc(u64 t){ return sqlite3_malloc64((sqlite3_int64)t);} 
 static void fts5ParseFree(void *p){ sqlite3_free(p); }
 
 static int sqlite3Fts5ExprNew(
@@ -219781,8 +219781,8 @@ static int fts5ExprSynonymList(
     if( sqlite3Fts5IterEof(pIter)==0 && pIter->iRowid==iRowid ){
       if( pIter->nData==0 ) continue;
       if( nIter==nAlloc ){
-        sqlite3_int64 nByte = sizeof(Fts5PoslistReader) * nAlloc * 2;
-        Fts5PoslistReader *aNew = (Fts5PoslistReader*)sqlite3_malloc64(nByte);
+        sqlite3_int64 nByte = sizeof(Fts5PoslistReader) * nAlloc * 2; 
+        Fts5PoslistReader *aNew = (Fts5PoslistReader*)sqlite3_malloc64(nByte); 
         if( aNew==0 ){
           rc = SQLITE_NOMEM;
           goto synonym_poslist_out;
@@ -219862,8 +219862,8 @@ static int fts5ExprPhraseIsMatch(
   /* If the aStatic[] array is not large enough, allocate a large array
   ** using sqlite3_malloc(). This approach could be improved upon. */
   if( pPhrase->nTerm>ArraySize(aStatic) ){
-    sqlite3_int64 nByte = sizeof(Fts5PoslistReader) * pPhrase->nTerm;
-    aIter = (Fts5PoslistReader*)sqlite3_malloc64(nByte);
+    sqlite3_int64 nByte = sizeof(Fts5PoslistReader) * pPhrase->nTerm; 
+    aIter = (Fts5PoslistReader*)sqlite3_malloc64(nByte); 
     if( !aIter ) return SQLITE_NOMEM;
   }
   memset(aIter, 0, sizeof(Fts5PoslistReader) * pPhrase->nTerm);
@@ -219997,7 +219997,7 @@ static int fts5ExprNearIsMatch(int *pRc, Fts5ExprNearset *pNear){
   /* If the aStatic[] array is not large enough, allocate a large array
   ** using sqlite3_malloc(). This approach could be improved upon. */
   if( pNear->nPhrase>ArraySize(aStatic) ){
-    sqlite3_int64 nByte = sizeof(Fts5NearTrimmer) * pNear->nPhrase;
+    sqlite3_int64 nByte = sizeof(Fts5NearTrimmer) * pNear->nPhrase; 
     a = (Fts5NearTrimmer*)sqlite3Fts5MallocZero(&rc, nByte);
   }else{
     memset(aStatic, 0, sizeof(aStatic));
@@ -220906,20 +220906,20 @@ static Fts5ExprNearset *sqlite3Fts5ParseNearset(
       return pNear;
     }
     if( pNear==0 ){
-      sqlite3_int64 nByte;
-      nByte = sizeof(Fts5ExprNearset) + SZALLOC * sizeof(Fts5ExprPhrase*);
-      pRet = sqlite3_malloc64(nByte);
+      sqlite3_int64 nByte; 
+      nByte = sizeof(Fts5ExprNearset) + SZALLOC * sizeof(Fts5ExprPhrase*); 
+      pRet = sqlite3_malloc64(nByte); 
       if( pRet==0 ){
         pParse->rc = SQLITE_NOMEM;
       }else{
-        memset(pRet, 0, (size_t)nByte);
+        memset(pRet, 0, (size_t)nByte); 
       }
     }else if( (pNear->nPhrase % SZALLOC)==0 ){
       int nNew = pNear->nPhrase + SZALLOC;
-      sqlite3_int64 nByte;
+      sqlite3_int64 nByte; 
 
-      nByte = sizeof(Fts5ExprNearset) + nNew * sizeof(Fts5ExprPhrase*);
-      pRet = (Fts5ExprNearset*)sqlite3_realloc64(pNear, nByte);
+      nByte = sizeof(Fts5ExprNearset) + nNew * sizeof(Fts5ExprPhrase*); 
+      pRet = (Fts5ExprNearset*)sqlite3_realloc64(pNear, nByte); 
       if( pRet==0 ){
         pParse->rc = SQLITE_NOMEM;
       }
@@ -220983,12 +220983,12 @@ static int fts5ParseTokenize(
 
   if( pPhrase && pPhrase->nTerm>0 && (tflags & FTS5_TOKEN_COLOCATED) ){
     Fts5ExprTerm *pSyn;
-    sqlite3_int64 nByte = sizeof(Fts5ExprTerm) + sizeof(Fts5Buffer) + nToken+1;
-    pSyn = (Fts5ExprTerm*)sqlite3_malloc64(nByte);
+    sqlite3_int64 nByte = sizeof(Fts5ExprTerm) + sizeof(Fts5Buffer) + nToken+1; 
+    pSyn = (Fts5ExprTerm*)sqlite3_malloc64(nByte); 
     if( pSyn==0 ){
       rc = SQLITE_NOMEM;
     }else{
-      memset(pSyn, 0, (size_t)nByte);
+      memset(pSyn, 0, (size_t)nByte); 
       pSyn->zTerm = ((char*)pSyn) + sizeof(Fts5ExprTerm) + sizeof(Fts5Buffer);
       memcpy(pSyn->zTerm, pToken, nToken);
       pSyn->pSynonym = pPhrase->aTerm[pPhrase->nTerm-1].pSynonym;
@@ -221111,7 +221111,7 @@ static Fts5ExprPhrase *sqlite3Fts5ParseTerm(
       ** no token characters at all. (e.g ... MATCH '""'). */
       sCtx.pPhrase = sqlite3Fts5MallocZero(&pParse->rc, sizeof(Fts5ExprPhrase));
     }else if( sCtx.pPhrase->nTerm ){
-      sCtx.pPhrase->aTerm[sCtx.pPhrase->nTerm-1].bPrefix = (u8)bPrefix;
+      sCtx.pPhrase->aTerm[sCtx.pPhrase->nTerm-1].bPrefix = (u8)bPrefix; 
     }
     pParse->apPhrase[pParse->nPhrase-1] = sCtx.pPhrase;
   }
@@ -221150,12 +221150,12 @@ static int sqlite3Fts5ExprClonePhrase(
   if( rc==SQLITE_OK ){
     Fts5Colset *pColsetOrig = pOrig->pNode->pNear->pColset;
     if( pColsetOrig ){
-      sqlite3_int64 nByte;
-      Fts5Colset *pColset;
-      nByte = sizeof(Fts5Colset) + (pColsetOrig->nCol-1) * sizeof(int);
-      pColset = (Fts5Colset*)sqlite3Fts5MallocZero(&rc, nByte);
+      sqlite3_int64 nByte; 
+      Fts5Colset *pColset; 
+      nByte = sizeof(Fts5Colset) + (pColsetOrig->nCol-1) * sizeof(int); 
+      pColset = (Fts5Colset*)sqlite3Fts5MallocZero(&rc, nByte); 
       if( pColset ){
-        memcpy(pColset, pColsetOrig, (size_t)nByte);
+        memcpy(pColset, pColsetOrig, (size_t)nByte); 
       }
       pNew->pRoot->pNear->pColset = pColset;
     }
@@ -221273,7 +221273,7 @@ static Fts5Colset *fts5ParseColset(
   assert( pParse->rc==SQLITE_OK );
   assert( iCol>=0 && iCol<pParse->pConfig->nCol );
 
-  pNew = sqlite3_realloc64(p, sizeof(Fts5Colset) + sizeof(int)*nCol);
+  pNew = sqlite3_realloc64(p, sizeof(Fts5Colset) + sizeof(int)*nCol); 
   if( pNew==0 ){
     pParse->rc = SQLITE_NOMEM;
   }else{
@@ -221369,10 +221369,10 @@ static Fts5Colset *sqlite3Fts5ParseColset(
 static Fts5Colset *fts5CloneColset(int *pRc, Fts5Colset *pOrig){
   Fts5Colset *pRet;
   if( pOrig ){
-    sqlite3_int64 nByte = sizeof(Fts5Colset) + (pOrig->nCol-1) * sizeof(int);
+    sqlite3_int64 nByte = sizeof(Fts5Colset) + (pOrig->nCol-1) * sizeof(int); 
     pRet = (Fts5Colset*)sqlite3Fts5MallocZero(pRc, nByte);
     if( pRet ){
-      memcpy(pRet, pOrig, (size_t)nByte);
+      memcpy(pRet, pOrig, (size_t)nByte); 
     }
   }else{
     pRet = 0;
@@ -221583,7 +221583,7 @@ static Fts5ExprNode *sqlite3Fts5ParseNode(
 
   if( pParse->rc==SQLITE_OK ){
     int nChild = 0;               /* Number of children of returned node */
-    sqlite3_int64 nByte;          /* Bytes of space to allocate for this node */
+    sqlite3_int64 nByte;          /* Bytes of space to allocate for this node */ 
 
     assert( (eType!=FTS5_STRING && !pNear)
          || (eType==FTS5_STRING && !pLeft && !pRight)
@@ -221720,7 +221720,7 @@ static Fts5ExprNode *sqlite3Fts5ParseImplicitAnd(
 
 #ifdef SQLITE_TEST
 static char *fts5ExprTermPrint(Fts5ExprTerm *pTerm){
-  sqlite3_int64 nByte = 0;
+  sqlite3_int64 nByte = 0; 
   Fts5ExprTerm *p;
   char *zQuoted;
 
@@ -221728,7 +221728,7 @@ static char *fts5ExprTermPrint(Fts5ExprTerm *pTerm){
   for(p=pTerm; p; p=p->pSynonym){
     nByte += (int)strlen(pTerm->zTerm) * 2 + 3 + 2;
   }
-  zQuoted = sqlite3_malloc64(nByte);
+  zQuoted = sqlite3_malloc64(nByte); 
 
   if( zQuoted ){
     int i = 0;
@@ -221977,7 +221977,7 @@ static void fts5ExprFunction(
   }
 
   nConfig = 3 + (nArg-iArg);
-  azConfig = (const char**)sqlite3_malloc64(sizeof(char*) * nConfig);
+  azConfig = (const char**)sqlite3_malloc64(sizeof(char*) * nConfig); 
   if( azConfig==0 ){
     sqlite3_result_error_nomem(pCtx);
     return;
@@ -222053,19 +222053,19 @@ static void fts5ExprIsAlnum(
   sqlite3_value **apVal           /* Function arguments */
 ){
   int iCode;
-  u8 aArr[32];
+  u8 aArr[32]; 
   if( nArg!=1 ){
     sqlite3_result_error(pCtx,
         "wrong number of arguments to function fts5_isalnum", -1
     );
     return;
   }
-  memset(aArr, 0, sizeof(aArr));
-  sqlite3Fts5UnicodeCatParse("L*", aArr);
-  sqlite3Fts5UnicodeCatParse("N*", aArr);
-  sqlite3Fts5UnicodeCatParse("Co", aArr);
+  memset(aArr, 0, sizeof(aArr)); 
+  sqlite3Fts5UnicodeCatParse("L*", aArr); 
+  sqlite3Fts5UnicodeCatParse("N*", aArr); 
+  sqlite3Fts5UnicodeCatParse("Co", aArr); 
   iCode = sqlite3_value_int(apVal[0]);
-  sqlite3_result_int(pCtx, aArr[sqlite3Fts5UnicodeCategory((u32)iCode)]);
+  sqlite3_result_int(pCtx, aArr[sqlite3Fts5UnicodeCategory((u32)iCode)]); 
 }
 
 static void fts5ExprFold(
@@ -222115,12 +222115,12 @@ static int sqlite3Fts5ExprInit(Fts5Global *pGlobal, sqlite3 *db){
   UNUSED_PARAM2(pGlobal,db);
 #endif
 
-  /* Avoid warnings indicating that sqlite3Fts5ParserTrace() and
-  ** sqlite3Fts5ParserFallback() are unused */
+  /* Avoid warnings indicating that sqlite3Fts5ParserTrace() and 
+  ** sqlite3Fts5ParserFallback() are unused */ 
 #ifndef NDEBUG
   (void)sqlite3Fts5ParserTrace;
 #endif
-  (void)sqlite3Fts5ParserFallback;
+  (void)sqlite3Fts5ParserFallback; 
 
   return rc;
 }
@@ -222175,7 +222175,7 @@ struct Fts5PoslistPopulator {
 */
 static Fts5PoslistPopulator *sqlite3Fts5ExprClearPoslists(Fts5Expr *pExpr, int bLive){
   Fts5PoslistPopulator *pRet;
-  pRet = sqlite3_malloc64(sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
+  pRet = sqlite3_malloc64(sizeof(Fts5PoslistPopulator)*pExpr->nPhrase); 
   if( pRet ){
     int i;
     memset(pRet, 0, sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
@@ -222467,20 +222467,20 @@ static int sqlite3Fts5HashNew(Fts5Config *pConfig, Fts5Hash **ppNew, int *pnByte
   if( pNew==0 ){
     rc = SQLITE_NOMEM;
   }else{
-    sqlite3_int64 nByte;
+    sqlite3_int64 nByte; 
     memset(pNew, 0, sizeof(Fts5Hash));
     pNew->pnByte = pnByte;
     pNew->eDetail = pConfig->eDetail;
 
     pNew->nSlot = 1024;
     nByte = sizeof(Fts5HashEntry*) * pNew->nSlot;
-    pNew->aSlot = (Fts5HashEntry**)sqlite3_malloc64(nByte);
+    pNew->aSlot = (Fts5HashEntry**)sqlite3_malloc64(nByte); 
     if( pNew->aSlot==0 ){
       sqlite3_free(pNew);
       *ppNew = 0;
       rc = SQLITE_NOMEM;
     }else{
-      memset(pNew->aSlot, 0, (size_t)nByte);
+      memset(pNew->aSlot, 0, (size_t)nByte); 
     }
   }
   return rc;
@@ -222542,7 +222542,7 @@ static int fts5HashResize(Fts5Hash *pHash){
   Fts5HashEntry **apNew;
   Fts5HashEntry **apOld = pHash->aSlot;
 
-  apNew = (Fts5HashEntry**)sqlite3_malloc64(nNew*sizeof(Fts5HashEntry*));
+  apNew = (Fts5HashEntry**)sqlite3_malloc64(nNew*sizeof(Fts5HashEntry*)); 
   if( !apNew ) return SQLITE_NOMEM;
   memset(apNew, 0, nNew*sizeof(Fts5HashEntry*));
 
@@ -222564,25 +222564,25 @@ static int fts5HashResize(Fts5Hash *pHash){
   return SQLITE_OK;
 }
 
-static int fts5HashAddPoslistSize(
+static int fts5HashAddPoslistSize( 
   Fts5Hash *pHash,
-  Fts5HashEntry *p,
-  Fts5HashEntry *p2
-){
-  int nRet = 0;
+  Fts5HashEntry *p, 
+  Fts5HashEntry *p2 
+){ 
+  int nRet = 0; 
   if( p->iSzPoslist ){
-    u8 *pPtr = p2 ? (u8*)p2 : (u8*)p;
-    int nData = p->nData;
+    u8 *pPtr = p2 ? (u8*)p2 : (u8*)p; 
+    int nData = p->nData; 
     if( pHash->eDetail==FTS5_DETAIL_NONE ){
-      assert( nData==p->iSzPoslist );
+      assert( nData==p->iSzPoslist ); 
       if( p->bDel ){
-        pPtr[nData++] = 0x00;
+        pPtr[nData++] = 0x00; 
         if( p->bContent ){
-          pPtr[nData++] = 0x00;
+          pPtr[nData++] = 0x00; 
         }
       }
     }else{
-      int nSz = (nData - p->iSzPoslist - 1);       /* Size in bytes */
+      int nSz = (nData - p->iSzPoslist - 1);       /* Size in bytes */ 
       int nPos = nSz*2 + p->bDel;                     /* Value of nPos field */
 
       assert( p->bDel==0 || p->bDel==1 );
@@ -222592,19 +222592,19 @@ static int fts5HashAddPoslistSize(
         int nByte = sqlite3Fts5GetVarintLen((u32)nPos);
         memmove(&pPtr[p->iSzPoslist + nByte], &pPtr[p->iSzPoslist + 1], nSz);
         sqlite3Fts5PutVarint(&pPtr[p->iSzPoslist], nPos);
-        nData += (nByte-1);
+        nData += (nByte-1); 
       }
     }
 
-    nRet = nData - p->nData;
-    if( p2==0 ){
-      p->iSzPoslist = 0;
-      p->bDel = 0;
-      p->bContent = 0;
-      p->nData = nData;
-    }
+    nRet = nData - p->nData; 
+    if( p2==0 ){ 
+      p->iSzPoslist = 0; 
+      p->bDel = 0; 
+      p->bContent = 0; 
+      p->nData = nData; 
+    } 
   }
-  return nRet;
+  return nRet; 
 }
 
 /*
@@ -222647,7 +222647,7 @@ static int sqlite3Fts5HashWrite(
   if( p==0 ){
     /* Figure out how much space to allocate */
     char *zKey;
-    sqlite3_int64 nByte = sizeof(Fts5HashEntry) + (nToken+1) + 1 + 64;
+    sqlite3_int64 nByte = sizeof(Fts5HashEntry) + (nToken+1) + 1 + 64; 
     if( nByte<128 ) nByte = 128;
 
     /* Grow the Fts5Hash.aSlot[] array if necessary. */
@@ -222658,10 +222658,10 @@ static int sqlite3Fts5HashWrite(
     }
 
     /* Allocate new Fts5HashEntry and add it to the hash table. */
-    p = (Fts5HashEntry*)sqlite3_malloc64(nByte);
+    p = (Fts5HashEntry*)sqlite3_malloc64(nByte); 
     if( !p ) return SQLITE_NOMEM;
     memset(p, 0, sizeof(Fts5HashEntry));
-    p->nAlloc = (int)nByte;
+    p->nAlloc = (int)nByte; 
     zKey = fts5EntryKey(p);
     zKey[0] = bByte;
     memcpy(&zKey[1], pToken, nToken);
@@ -222696,12 +222696,12 @@ static int sqlite3Fts5HashWrite(
     **     + 5 bytes for the new position offset (32-bit max).
     */
     if( (p->nAlloc - p->nData) < (9 + 4 + 1 + 3 + 5) ){
-      sqlite3_int64 nNew = p->nAlloc * 2;
+      sqlite3_int64 nNew = p->nAlloc * 2; 
       Fts5HashEntry *pNew;
       Fts5HashEntry **pp;
-      pNew = (Fts5HashEntry*)sqlite3_realloc64(p, nNew);
+      pNew = (Fts5HashEntry*)sqlite3_realloc64(p, nNew); 
       if( pNew==0 ) return SQLITE_NOMEM;
-      pNew->nAlloc = (int)nNew;
+      pNew->nAlloc = (int)nNew; 
       for(pp=&pHash->aSlot[iHash]; *pp!=p; pp=&(*pp)->pHashNext);
       *pp = pNew;
       p = pNew;
@@ -222716,7 +222716,7 @@ static int sqlite3Fts5HashWrite(
   ** entry, and the new rowid for this entry.  */
   if( iRowid!=p->iRowid ){
     u64 iDiff = (u64)iRowid - (u64)p->iRowid;
-    fts5HashAddPoslistSize(pHash, p, 0);
+    fts5HashAddPoslistSize(pHash, p, 0); 
     p->nData += sqlite3Fts5PutVarint(&pPtr[p->nData], iDiff);
     p->iRowid = iRowid;
     bNew = 1;
@@ -222826,7 +222826,7 @@ static int fts5HashEntrySort(
   int i;
 
   *ppSorted = 0;
-  ap = sqlite3_malloc64(sizeof(Fts5HashEntry*) * nMergeSlot);
+  ap = sqlite3_malloc64(sizeof(Fts5HashEntry*) * nMergeSlot); 
   if( !ap ) return SQLITE_NOMEM;
   memset(ap, 0, sizeof(Fts5HashEntry*) * nMergeSlot);
 
@@ -222834,8 +222834,8 @@ static int fts5HashEntrySort(
     Fts5HashEntry *pIter;
     for(pIter=pHash->aSlot[iSlot]; pIter; pIter=pIter->pHashNext){
       if( pTerm==0
-       || (pIter->nKey+1>=nTerm && 0==memcmp(fts5EntryKey(pIter), pTerm, nTerm))
-      ){
+       || (pIter->nKey+1>=nTerm && 0==memcmp(fts5EntryKey(pIter), pTerm, nTerm)) 
+      ){ 
         Fts5HashEntry *pEntry = pIter;
         pEntry->pScanNext = 0;
         for(i=0; ap[i]; i++){
@@ -222863,9 +222863,9 @@ static int fts5HashEntrySort(
 */
 static int sqlite3Fts5HashQuery(
   Fts5Hash *pHash,                /* Hash table to query */
-  int nPre,
+  int nPre, 
   const char *pTerm, int nTerm,   /* Query term */
-  void **ppOut,                   /* OUT: Pointer to new object */
+  void **ppOut,                   /* OUT: Pointer to new object */ 
   int *pnDoclist                  /* OUT: Size of doclist in bytes */
 ){
   unsigned int iHash = fts5HashKey(pHash->nSlot, (const u8*)pTerm, nTerm);
@@ -222874,25 +222874,25 @@ static int sqlite3Fts5HashQuery(
 
   for(p=pHash->aSlot[iHash]; p; p=p->pHashNext){
     zKey = fts5EntryKey(p);
-    assert( p->nKey+1==(int)strlen(zKey) );
-    if( nTerm==p->nKey+1 && memcmp(zKey, pTerm, nTerm)==0 ) break;
+    assert( p->nKey+1==(int)strlen(zKey) ); 
+    if( nTerm==p->nKey+1 && memcmp(zKey, pTerm, nTerm)==0 ) break; 
   }
 
   if( p ){
-    int nHashPre = sizeof(Fts5HashEntry) + nTerm + 1;
-    int nList = p->nData - nHashPre;
-    u8 *pRet = (u8*)(*ppOut = sqlite3_malloc64(nPre + nList + 10));
-    if( pRet ){
-      Fts5HashEntry *pFaux = (Fts5HashEntry*)&pRet[nPre-nHashPre];
-      memcpy(&pRet[nPre], &((u8*)p)[nHashPre], nList);
-      nList += fts5HashAddPoslistSize(pHash, p, pFaux);
-      *pnDoclist = nList;
-    }else{
-      *pnDoclist = 0;
-      return SQLITE_NOMEM;
-    }
-  }else{
-    *ppOut = 0;
+    int nHashPre = sizeof(Fts5HashEntry) + nTerm + 1; 
+    int nList = p->nData - nHashPre; 
+    u8 *pRet = (u8*)(*ppOut = sqlite3_malloc64(nPre + nList + 10)); 
+    if( pRet ){ 
+      Fts5HashEntry *pFaux = (Fts5HashEntry*)&pRet[nPre-nHashPre]; 
+      memcpy(&pRet[nPre], &((u8*)p)[nHashPre], nList); 
+      nList += fts5HashAddPoslistSize(pHash, p, pFaux); 
+      *pnDoclist = nList; 
+    }else{ 
+      *pnDoclist = 0; 
+      return SQLITE_NOMEM; 
+    } 
+  }else{
+    *ppOut = 0; 
     *pnDoclist = 0;
   }
 
@@ -222925,7 +222925,7 @@ static void sqlite3Fts5HashScanEntry(
   if( (p = pHash->pScan) ){
     char *zKey = fts5EntryKey(p);
     int nTerm = (int)strlen(zKey);
-    fts5HashAddPoslistSize(pHash, p, 0);
+    fts5HashAddPoslistSize(pHash, p, 0); 
     *pzTerm = zKey;
     *ppDoclist = (const u8*)&zKey[nTerm+1];
     *pnDoclist = p->nData - (sizeof(Fts5HashEntry) + nTerm + 1);
@@ -223505,7 +223505,7 @@ static u16 fts5GetU16(const u8 *aIn){
 ** If an OOM error is encountered, return NULL and set the error code in
 ** the Fts5Index handle passed as the first argument.
 */
-static void *fts5IdxMalloc(Fts5Index *p, sqlite3_int64 nByte){
+static void *fts5IdxMalloc(Fts5Index *p, sqlite3_int64 nByte){ 
   return sqlite3Fts5MallocZero(&p->rc, nByte);
 }
 
@@ -223608,8 +223608,8 @@ static Fts5Data *fts5DataRead(Fts5Index *p, i64 iRowid){
     if( rc==SQLITE_OK ){
       u8 *aOut = 0;               /* Read blob data into this buffer */
       int nByte = sqlite3_blob_bytes(p->pReader);
-      sqlite3_int64 nAlloc = sizeof(Fts5Data) + nByte + FTS5_DATA_PADDING;
-      pRet = (Fts5Data*)sqlite3_malloc64(nAlloc);
+      sqlite3_int64 nAlloc = sizeof(Fts5Data) + nByte + FTS5_DATA_PADDING; 
+      pRet = (Fts5Data*)sqlite3_malloc64(nAlloc); 
       if( pRet ){
         pRet->nn = nByte;
         aOut = pRet->p = (u8*)&pRet[1];
@@ -223625,7 +223625,7 @@ static Fts5Data *fts5DataRead(Fts5Index *p, i64 iRowid){
         pRet = 0;
       }else{
         /* TODO1: Fix this */
-        pRet->p[nByte] = 0x00;
+        pRet->p[nByte] = 0x00; 
         pRet->p[nByte+1] = 0x00;
         pRet->szLeaf = fts5GetU16(&pRet->p[2]);
       }
@@ -223667,8 +223667,8 @@ static int fts5IndexPrepareStmt(
   if( p->rc==SQLITE_OK ){
     if( zSql ){
       p->rc = sqlite3_prepare_v3(p->pConfig->db, zSql, -1,
-          SQLITE_PREPARE_PERSISTENT|SQLITE_PREPARE_NO_VTAB,
-          ppStmt, 0);
+          SQLITE_PREPARE_PERSISTENT|SQLITE_PREPARE_NO_VTAB, 
+          ppStmt, 0); 
     }else{
       p->rc = SQLITE_NOMEM;
     }
@@ -223697,7 +223697,7 @@ static void fts5DataWrite(Fts5Index *p, i64 iRowid, const u8 *pData, int nData){
   sqlite3_bind_blob(p->pWriter, 2, pData, nData, SQLITE_STATIC);
   sqlite3_step(p->pWriter);
   p->rc = sqlite3_reset(p->pWriter);
-  sqlite3_bind_null(p->pWriter, 2);
+  sqlite3_bind_null(p->pWriter, 2); 
 }
 
 /*
@@ -223714,7 +223714,7 @@ static void fts5DataDelete(Fts5Index *p, i64 iFirst, i64 iLast){
         "DELETE FROM '%q'.'%q_data' WHERE id>=? AND id<=?",
           pConfig->zDb, pConfig->zName
     );
-    if( fts5IndexPrepareStmt(p, &p->pDeleter, zSql) ) return;
+    if( fts5IndexPrepareStmt(p, &p->pDeleter, zSql) ) return; 
   }
 
   sqlite3_bind_int64(p->pDeleter, 1, iFirst);
@@ -223838,7 +223838,7 @@ static int fts5StructureDecode(
   int iLvl;
   int nLevel = 0;
   int nSegment = 0;
-  sqlite3_int64 nByte;            /* Bytes of space to allocate at pRet */
+  sqlite3_int64 nByte;            /* Bytes of space to allocate at pRet */ 
   Fts5Structure *pRet = 0;        /* Structure object to return */
 
   /* Grab the cookie value */
@@ -223849,11 +223849,11 @@ static int fts5StructureDecode(
   ** structure record.  */
   i += fts5GetVarint32(&pData[i], nLevel);
   i += fts5GetVarint32(&pData[i], nSegment);
-  if( nLevel>FTS5_MAX_SEGMENT   || nLevel<0
-   || nSegment>FTS5_MAX_SEGMENT || nSegment<0
-  ){
-    return FTS5_CORRUPT;
-  }
+  if( nLevel>FTS5_MAX_SEGMENT   || nLevel<0 
+   || nSegment>FTS5_MAX_SEGMENT || nSegment<0 
+  ){ 
+    return FTS5_CORRUPT; 
+  } 
   nByte = (
       sizeof(Fts5Structure) +                    /* Main structure */
       sizeof(Fts5StructureLevel) * (nLevel-1)    /* aLevel[] array */
@@ -223876,35 +223876,35 @@ static int fts5StructureDecode(
       }else{
         i += fts5GetVarint32(&pData[i], pLvl->nMerge);
         i += fts5GetVarint32(&pData[i], nTotal);
-        if( nTotal<pLvl->nMerge ) rc = FTS5_CORRUPT;
+        if( nTotal<pLvl->nMerge ) rc = FTS5_CORRUPT; 
         pLvl->aSeg = (Fts5StructureSegment*)sqlite3Fts5MallocZero(&rc,
             nTotal * sizeof(Fts5StructureSegment)
         );
-        nSegment -= nTotal;
+        nSegment -= nTotal; 
       }
 
       if( rc==SQLITE_OK ){
         pLvl->nSeg = nTotal;
         for(iSeg=0; iSeg<nTotal; iSeg++){
-          Fts5StructureSegment *pSeg = &pLvl->aSeg[iSeg];
+          Fts5StructureSegment *pSeg = &pLvl->aSeg[iSeg]; 
           if( i>=nData ){
             rc = FTS5_CORRUPT;
             break;
           }
-          i += fts5GetVarint32(&pData[i], pSeg->iSegid);
-          i += fts5GetVarint32(&pData[i], pSeg->pgnoFirst);
-          i += fts5GetVarint32(&pData[i], pSeg->pgnoLast);
-          if( pSeg->pgnoLast<pSeg->pgnoFirst ){
-            rc = FTS5_CORRUPT;
-            break;
-          }
+          i += fts5GetVarint32(&pData[i], pSeg->iSegid); 
+          i += fts5GetVarint32(&pData[i], pSeg->pgnoFirst); 
+          i += fts5GetVarint32(&pData[i], pSeg->pgnoLast); 
+          if( pSeg->pgnoLast<pSeg->pgnoFirst ){ 
+            rc = FTS5_CORRUPT; 
+            break; 
+          } 
         }
-        if( iLvl>0 && pLvl[-1].nMerge && nTotal==0 ) rc = FTS5_CORRUPT;
-        if( iLvl==nLevel-1 && pLvl->nMerge ) rc = FTS5_CORRUPT;
+        if( iLvl>0 && pLvl[-1].nMerge && nTotal==0 ) rc = FTS5_CORRUPT; 
+        if( iLvl==nLevel-1 && pLvl->nMerge ) rc = FTS5_CORRUPT; 
       }
     }
-    if( nSegment!=0 && rc==SQLITE_OK ) rc = FTS5_CORRUPT;
-
+    if( nSegment!=0 && rc==SQLITE_OK ) rc = FTS5_CORRUPT; 
+ 
     if( rc!=SQLITE_OK ){
       fts5StructureRelease(pRet);
       pRet = 0;
@@ -223924,12 +223924,12 @@ static void fts5StructureAddLevel(int *pRc, Fts5Structure **ppStruct){
   if( *pRc==SQLITE_OK ){
     Fts5Structure *pStruct = *ppStruct;
     int nLevel = pStruct->nLevel;
-    sqlite3_int64 nByte = (
+    sqlite3_int64 nByte = ( 
         sizeof(Fts5Structure) +                  /* Main structure */
         sizeof(Fts5StructureLevel) * (nLevel+1)  /* aLevel[] array */
     );
 
-    pStruct = sqlite3_realloc64(pStruct, nByte);
+    pStruct = sqlite3_realloc64(pStruct, nByte); 
     if( pStruct ){
       memset(&pStruct->aLevel[nLevel], 0, sizeof(Fts5StructureLevel));
       pStruct->nLevel++;
@@ -223954,10 +223954,10 @@ static void fts5StructureExtendLevel(
   if( *pRc==SQLITE_OK ){
     Fts5StructureLevel *pLvl = &pStruct->aLevel[iLvl];
     Fts5StructureSegment *aNew;
-    sqlite3_int64 nByte;
+    sqlite3_int64 nByte; 
 
     nByte = (pLvl->nSeg + nExtra) * sizeof(Fts5StructureSegment);
-    aNew = sqlite3_realloc64(pLvl->aSeg, nByte);
+    aNew = sqlite3_realloc64(pLvl->aSeg, nByte); 
     if( aNew ){
       if( bInsert==0 ){
         memset(&aNew[pLvl->nSeg], 0, sizeof(Fts5StructureSegment) * nExtra);
@@ -223984,7 +223984,7 @@ static Fts5Structure *fts5StructureReadUncached(Fts5Index *p){
     /* TODO: Do we need this if the leaf-index is appended? Probably... */
     memset(&pData->p[pData->nn], 0, FTS5_DATA_PADDING);
     p->rc = fts5StructureDecode(pData->p, pData->nn, &iCookie, &pRet);
-    if( p->rc==SQLITE_OK && (pConfig->pgsz==0 || pConfig->iCookie!=iCookie) ){
+    if( p->rc==SQLITE_OK && (pConfig->pgsz==0 || pConfig->iCookie!=iCookie) ){ 
       p->rc = sqlite3Fts5ConfigLoad(pConfig, iCookie);
     }
     fts5DataRelease(pData);
@@ -224471,10 +224471,10 @@ static Fts5DlidxIter *fts5DlidxIterInit(
   int bDone = 0;
 
   for(i=0; p->rc==SQLITE_OK && bDone==0; i++){
-    sqlite3_int64 nByte = sizeof(Fts5DlidxIter) + i * sizeof(Fts5DlidxLvl);
+    sqlite3_int64 nByte = sizeof(Fts5DlidxIter) + i * sizeof(Fts5DlidxLvl); 
     Fts5DlidxIter *pNew;
 
-    pNew = (Fts5DlidxIter*)sqlite3_realloc64(pIter, nByte);
+    pNew = (Fts5DlidxIter*)sqlite3_realloc64(pIter, nByte); 
     if( pNew==0 ){
       p->rc = SQLITE_NOMEM;
     }else{
@@ -224644,13 +224644,13 @@ static void fts5SegIterLoadTerm(Fts5Index *p, Fts5SegIter *pIter, int nKeep){
   int nNew;                       /* Bytes of new data */
 
   iOff += fts5GetVarint32(&a[iOff], nNew);
-  if( iOff+nNew>pIter->pLeaf->szLeaf || nKeep>pIter->term.n || nNew==0 ){
+  if( iOff+nNew>pIter->pLeaf->szLeaf || nKeep>pIter->term.n || nNew==0 ){ 
     p->rc = FTS5_CORRUPT;
     return;
   }
   pIter->term.n = nKeep;
   fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
-  assert( pIter->term.n<=pIter->term.nSpace );
+  assert( pIter->term.n<=pIter->term.nSpace ); 
   iOff += nNew;
   pIter->iTermLeafOffset = iOff;
   pIter->iTermLeafPgno = pIter->iLeafPgno;
@@ -224716,7 +224716,7 @@ static void fts5SegIterInit(
     pIter->iLeafOffset = 4;
     assert( pIter->pLeaf!=0 );
     assert_nc( pIter->pLeaf->nn>4 );
-    assert_nc( fts5LeafFirstTermOff(pIter->pLeaf)==4 );
+    assert_nc( fts5LeafFirstTermOff(pIter->pLeaf)==4 ); 
     pIter->iPgidxOff = pIter->pLeaf->szLeaf+1;
     fts5SegIterLoadTerm(p, pIter, 0);
     fts5SegIterLoadNPos(p, pIter);
@@ -224772,7 +224772,7 @@ static void fts5SegIterReverseInitPage(Fts5Index *p, Fts5SegIter *pIter){
     /* If necessary, grow the pIter->aRowidOffset[] array. */
     if( iRowidOffset>=pIter->nRowidOffset ){
       int nNew = pIter->nRowidOffset + 8;
-      int *aNew = (int*)sqlite3_realloc64(pIter->aRowidOffset,nNew*sizeof(int));
+      int *aNew = (int*)sqlite3_realloc64(pIter->aRowidOffset,nNew*sizeof(int)); 
       if( aNew==0 ){
         p->rc = SQLITE_NOMEM;
         break;
@@ -225227,10 +225227,10 @@ static void fts5LeafSeek(
   const u8 *a = pIter->pLeaf->p;
   u32 n = (u32)pIter->pLeaf->nn;
 
-  u32 nMatch = 0;
-  u32 nKeep = 0;
-  u32 nNew = 0;
-  u32 iTermOff;
+  u32 nMatch = 0; 
+  u32 nKeep = 0; 
+  u32 nNew = 0; 
+  u32 iTermOff; 
   u32 iPgidx;                     /* Current offset in pgidx */
   int bEndOfPage = 0;
 
@@ -225254,15 +225254,15 @@ static void fts5LeafSeek(
 
     assert( nKeep>=nMatch );
     if( nKeep==nMatch ){
-      u32 nCmp;
-      u32 i;
-      nCmp = (u32)MIN(nNew, nTerm-nMatch);
+      u32 nCmp; 
+      u32 i; 
+      nCmp = (u32)MIN(nNew, nTerm-nMatch); 
       for(i=0; i<nCmp; i++){
         if( a[iOff+i]!=pTerm[nMatch+i] ) break;
       }
       nMatch += i;
 
-      if( (u32)nTerm==nMatch ){
+      if( (u32)nTerm==nMatch ){ 
         if( i==nNew ){
           goto search_success;
         }else{
@@ -225306,7 +225306,7 @@ static void fts5LeafSeek(
         iPgidx += fts5GetVarint32(&pIter->pLeaf->p[iPgidx], iOff);
         if( iOff<4 || (i64)iOff>=pIter->pLeaf->szLeaf ){
           p->rc = FTS5_CORRUPT;
-          return;
+          return; 
         }else{
           nKeep = 0;
           iTermOff = iOff;
@@ -225320,9 +225320,9 @@ static void fts5LeafSeek(
 
  search_success:
   if( (i64)iOff+nNew>n || nNew<1 ){
-    p->rc = FTS5_CORRUPT;
-    return;
-  }
+    p->rc = FTS5_CORRUPT; 
+    return; 
+  } 
   pIter->iLeafOffset = iOff + nNew;
   pIter->iTermLeafOffset = pIter->iLeafOffset;
   pIter->iTermLeafPgno = pIter->iLeafPgno;
@@ -225391,7 +225391,7 @@ static void fts5SegIterSeekInit(
     bDlidx = (val & 0x0001);
   }
   p->rc = sqlite3_reset(pIdxSelect);
-  sqlite3_bind_null(pIdxSelect, 2);
+  sqlite3_bind_null(pIdxSelect, 2); 
 
   if( iPg<pSeg->pgnoFirst ){
     iPg = pSeg->pgnoFirst;
@@ -225430,7 +225430,7 @@ static void fts5SegIterSeekInit(
   **   4) the FTS5INDEX_QUERY_SCAN flag was set and the iterator points
   **      to an entry with a term greater than or equal to (pTerm/nTerm).
   */
-  assert_nc( p->rc!=SQLITE_OK                                       /* 1 */
+  assert_nc( p->rc!=SQLITE_OK                                       /* 1 */ 
    || pIter->pLeaf==0                                               /* 2 */
    || fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)==0          /* 3 */
    || (bGe && fts5BufferCompareBlob(&pIter->term, pTerm, nTerm)>0)  /* 4 */
@@ -225454,36 +225454,36 @@ static void fts5SegIterHashInit(
   int nList = 0;
   const u8 *z = 0;
   int n = 0;
-  Fts5Data *pLeaf = 0;
+  Fts5Data *pLeaf = 0; 
 
   assert( p->pHash );
   assert( p->rc==SQLITE_OK );
 
   if( pTerm==0 || (flags & FTS5INDEX_QUERY_SCAN) ){
-    const u8 *pList = 0;
-
+    const u8 *pList = 0; 
+ 
     p->rc = sqlite3Fts5HashScanInit(p->pHash, (const char*)pTerm, nTerm);
     sqlite3Fts5HashScanEntry(p->pHash, (const char**)&z, &pList, &nList);
     n = (z ? (int)strlen((const char*)z) : 0);
-    if( pList ){
-      pLeaf = fts5IdxMalloc(p, sizeof(Fts5Data));
-      if( pLeaf ){
-        pLeaf->p = (u8*)pList;
-      }
-    }
+    if( pList ){ 
+      pLeaf = fts5IdxMalloc(p, sizeof(Fts5Data)); 
+      if( pLeaf ){ 
+        pLeaf->p = (u8*)pList; 
+      } 
+    } 
   }else{
     p->rc = sqlite3Fts5HashQuery(p->pHash, sizeof(Fts5Data),
-        (const char*)pTerm, nTerm, (void**)&pLeaf, &nList
-    );
-    if( pLeaf ){
-      pLeaf->p = (u8*)&pLeaf[1];
-    }
+        (const char*)pTerm, nTerm, (void**)&pLeaf, &nList 
+    ); 
+    if( pLeaf ){ 
+      pLeaf->p = (u8*)&pLeaf[1]; 
+    } 
     z = pTerm;
     n = nTerm;
-    pIter->flags |= FTS5_SEGITER_ONETERM;
+    pIter->flags |= FTS5_SEGITER_ONETERM; 
   }
 
-  if( pLeaf ){
+  if( pLeaf ){ 
     sqlite3Fts5BufferSet(&p->rc, &pIter->term, n, z);
     pLeaf->nn = pLeaf->szLeaf = nList;
     pIter->pLeaf = pLeaf;
@@ -225537,7 +225537,7 @@ static void fts5AssertComparisonResult(
       assert( pRes->iFirst==i1 );
     }else{
       int nMin = MIN(p1->term.n, p2->term.n);
-      int res = fts5Memcmp(p1->term.p, p2->term.p, nMin);
+      int res = fts5Memcmp(p1->term.p, p2->term.p, nMin); 
       if( res==0 ) res = p1->term.n - p2->term.n;
 
       if( res==0 ){
@@ -225637,8 +225637,8 @@ static int fts5MultiIterDoCompare(Fts5Iter *pIter, int iOut){
   }else{
     int res = fts5BufferCompare(&p1->term, &p2->term);
     if( res==0 ){
-      assert_nc( i2>i1 );
-      assert_nc( i2!=0 );
+      assert_nc( i2>i1 ); 
+      assert_nc( i2!=0 ); 
       pRes->bTermEq = 1;
       if( p1->iRowid==p2->iRowid ){
         p1->bDel = p2->bDel;
@@ -226112,10 +226112,10 @@ static void fts5SegiterPoslist(
 ){
   assert( pBuf!=0 );
   assert( pSeg!=0 );
-  if( 0==fts5BufferGrow(&p->rc, pBuf, pSeg->nPos+FTS5_DATA_ZERO_PADDING) ){
+  if( 0==fts5BufferGrow(&p->rc, pBuf, pSeg->nPos+FTS5_DATA_ZERO_PADDING) ){ 
     assert( pBuf->p!=0 );
     assert( pBuf->nSpace >= pBuf->n+pSeg->nPos+FTS5_DATA_ZERO_PADDING );
-    memset(&pBuf->p[pBuf->n+pSeg->nPos], 0, FTS5_DATA_ZERO_PADDING);
+    memset(&pBuf->p[pBuf->n+pSeg->nPos], 0, FTS5_DATA_ZERO_PADDING); 
     if( pColset==0 ){
       fts5ChunkIterate(p, pSeg, (void*)pBuf, fts5PoslistCallback);
     }else{
@@ -226599,24 +226599,24 @@ static int fts5AllocateSegid(Fts5Index *p, Fts5Structure *pStruct){
       for(iLvl=0; iLvl<pStruct->nLevel; iLvl++){
         for(iSeg=0; iSeg<pStruct->aLevel[iLvl].nSeg; iSeg++){
           int iId = pStruct->aLevel[iLvl].aSeg[iSeg].iSegid;
-          if( iId<=FTS5_MAX_SEGMENT && iId>0 ){
-            aUsed[(iId-1) / 32] |= (u32)1 << ((iId-1) % 32);
+          if( iId<=FTS5_MAX_SEGMENT && iId>0 ){ 
+            aUsed[(iId-1) / 32] |= (u32)1 << ((iId-1) % 32); 
           }
         }
       }
 
       for(i=0; aUsed[i]==0xFFFFFFFF; i++);
       mask = aUsed[i];
-      for(iSegid=0; mask & ((u32)1 << iSegid); iSegid++);
+      for(iSegid=0; mask & ((u32)1 << iSegid); iSegid++); 
       iSegid += 1 + i*32;
 
 #ifdef SQLITE_DEBUG
       for(iLvl=0; iLvl<pStruct->nLevel; iLvl++){
         for(iSeg=0; iSeg<pStruct->aLevel[iLvl].nSeg; iSeg++){
-          assert_nc( iSegid!=pStruct->aLevel[iLvl].aSeg[iSeg].iSegid );
+          assert_nc( iSegid!=pStruct->aLevel[iLvl].aSeg[iSeg].iSegid ); 
         }
       }
-      assert_nc( iSegid>0 && iSegid<=FTS5_MAX_SEGMENT );
+      assert_nc( iSegid>0 && iSegid<=FTS5_MAX_SEGMENT ); 
 
       {
         sqlite3_stmt *pIdxSelect = fts5IdxSelectStmt(p);
@@ -226624,9 +226624,9 @@ static int fts5AllocateSegid(Fts5Index *p, Fts5Structure *pStruct){
           u8 aBlob[2] = {0xff, 0xff};
           sqlite3_bind_int(pIdxSelect, 1, iSegid);
           sqlite3_bind_blob(pIdxSelect, 2, aBlob, 2, SQLITE_STATIC);
-          assert_nc( sqlite3_step(pIdxSelect)!=SQLITE_ROW );
+          assert_nc( sqlite3_step(pIdxSelect)!=SQLITE_ROW ); 
           p->rc = sqlite3_reset(pIdxSelect);
-          sqlite3_bind_null(pIdxSelect, 2);
+          sqlite3_bind_null(pIdxSelect, 2); 
         }
       }
 #endif
@@ -226694,13 +226694,13 @@ static int fts5WriteDlidxGrow(
   int nLvl
 ){
   if( p->rc==SQLITE_OK && nLvl>=pWriter->nDlidx ){
-    Fts5DlidxWriter *aDlidx = (Fts5DlidxWriter*)sqlite3_realloc64(
+    Fts5DlidxWriter *aDlidx = (Fts5DlidxWriter*)sqlite3_realloc64( 
         pWriter->aDlidx, sizeof(Fts5DlidxWriter) * nLvl
     );
     if( aDlidx==0 ){
       p->rc = SQLITE_NOMEM;
     }else{
-      size_t nByte = sizeof(Fts5DlidxWriter) * (nLvl - pWriter->nDlidx);
+      size_t nByte = sizeof(Fts5DlidxWriter) * (nLvl - pWriter->nDlidx); 
       memset(&aDlidx[pWriter->nDlidx], 0, nByte);
       pWriter->aDlidx = aDlidx;
       pWriter->nDlidx = nLvl;
@@ -226753,7 +226753,7 @@ static void fts5WriteFlushBtree(Fts5Index *p, Fts5SegWriter *pWriter){
     sqlite3_bind_int64(p->pIdxWriter, 3, bFlag + ((i64)pWriter->iBtPage<<1));
     sqlite3_step(p->pIdxWriter);
     p->rc = sqlite3_reset(p->pIdxWriter);
-    sqlite3_bind_null(p->pIdxWriter, 2);
+    sqlite3_bind_null(p->pIdxWriter, 2); 
   }
   pWriter->iBtPage = 0;
 }
@@ -226773,10 +226773,10 @@ static void fts5WriteBtreeTerm(
   int nTerm, const u8 *pTerm      /* First term on new page */
 ){
   fts5WriteFlushBtree(p, pWriter);
-  if( p->rc==SQLITE_OK ){
-    fts5BufferSet(&p->rc, &pWriter->btterm, nTerm, pTerm);
-    pWriter->iBtPage = pWriter->writer.pgno;
-  }
+  if( p->rc==SQLITE_OK ){ 
+    fts5BufferSet(&p->rc, &pWriter->btterm, nTerm, pTerm); 
+    pWriter->iBtPage = pWriter->writer.pgno; 
+  } 
 }
 
 /*
@@ -226927,7 +226927,7 @@ static void fts5WriteAppendTerm(
   int nPrefix;                    /* Bytes of prefix compression for term */
   Fts5PageWriter *pPage = &pWriter->writer;
   Fts5Buffer *pPgidx = &pWriter->writer.pgidx;
-  int nMin = MIN(pPage->term.n, nTerm);
+  int nMin = MIN(pPage->term.n, nTerm); 
 
   assert( p->rc==SQLITE_OK );
   assert( pPage->buf.n>=4 );
@@ -226937,7 +226937,7 @@ static void fts5WriteAppendTerm(
   if( (pPage->buf.n + pPgidx->n + nTerm + 2)>=p->pConfig->pgsz ){
     if( pPage->buf.n>4 ){
       fts5WriteFlushLeaf(p, pWriter);
-      if( p->rc!=SQLITE_OK ) return;
+      if( p->rc!=SQLITE_OK ) return; 
     }
     fts5BufferGrow(&p->rc, &pPage->buf, nTerm+FTS5_DATA_PADDING);
   }
@@ -226970,14 +226970,14 @@ static void fts5WriteAppendTerm(
       ** inefficient, but still correct.  */
       int n = nTerm;
       if( pPage->term.n ){
-        n = 1 + fts5PrefixCompress(nMin, pPage->term.p, pTerm);
+        n = 1 + fts5PrefixCompress(nMin, pPage->term.p, pTerm); 
       }
       fts5WriteBtreeTerm(p, pWriter, n, pTerm);
-      if( p->rc!=SQLITE_OK ) return;
+      if( p->rc!=SQLITE_OK ) return; 
       pPage = &pWriter->writer;
     }
   }else{
-    nPrefix = fts5PrefixCompress(nMin, pPage->term.p, pTerm);
+    nPrefix = fts5PrefixCompress(nMin, pPage->term.p, pTerm); 
     fts5BufferAppendVarint(&p->rc, &pPage->buf, nPrefix);
   }
 
@@ -227024,7 +227024,7 @@ static void fts5WriteAppendRowid(
     if( pWriter->bFirstRowidInDoclist || pWriter->bFirstRowidInPage ){
       fts5BufferAppendVarint(&p->rc, &pPage->buf, iRowid);
     }else{
-      assert_nc( p->rc || iRowid>pWriter->iPrevRowid );
+      assert_nc( p->rc || iRowid>pWriter->iPrevRowid ); 
       fts5BufferAppendVarint(&p->rc, &pPage->buf, iRowid - pWriter->iPrevRowid);
     }
     pWriter->iPrevRowid = iRowid;
@@ -227146,7 +227146,7 @@ static void fts5TrimSegments(Fts5Index *p, Fts5Iter *pIter){
   int i;
   Fts5Buffer buf;
   memset(&buf, 0, sizeof(Fts5Buffer));
-  for(i=0; i<pIter->nSeg && p->rc==SQLITE_OK; i++){
+  for(i=0; i<pIter->nSeg && p->rc==SQLITE_OK; i++){ 
     Fts5SegIter *pSeg = &pIter->aSeg[i];
     if( pSeg->pSeg==0 ){
       /* no-op */
@@ -227164,42 +227164,42 @@ static void fts5TrimSegments(Fts5Index *p, Fts5Iter *pIter){
       u8 aHdr[4] = {0x00, 0x00, 0x00, 0x00};
 
       iLeafRowid = FTS5_SEGMENT_ROWID(iId, pSeg->iTermLeafPgno);
-      pData = fts5LeafRead(p, iLeafRowid);
+      pData = fts5LeafRead(p, iLeafRowid); 
       if( pData ){
-        if( iOff>pData->szLeaf ){
-          /* This can occur if the pages that the segments occupy overlap - if
-          ** a single page has been assigned to more than one segment. In
-          ** this case a prior iteration of this loop may have corrupted the
-          ** segment currently being trimmed.  */
-          p->rc = FTS5_CORRUPT;
-        }else{
-          fts5BufferZero(&buf);
-          fts5BufferGrow(&p->rc, &buf, pData->nn);
-          fts5BufferAppendBlob(&p->rc, &buf, sizeof(aHdr), aHdr);
-          fts5BufferAppendVarint(&p->rc, &buf, pSeg->term.n);
-          fts5BufferAppendBlob(&p->rc, &buf, pSeg->term.n, pSeg->term.p);
-          fts5BufferAppendBlob(&p->rc, &buf, pData->szLeaf-iOff,&pData->p[iOff]);
-          if( p->rc==SQLITE_OK ){
-            /* Set the szLeaf field */
-            fts5PutU16(&buf.p[2], (u16)buf.n);
-          }
-
-          /* Set up the new page-index array */
-          fts5BufferAppendVarint(&p->rc, &buf, 4);
+        if( iOff>pData->szLeaf ){ 
+          /* This can occur if the pages that the segments occupy overlap - if 
+          ** a single page has been assigned to more than one segment. In 
+          ** this case a prior iteration of this loop may have corrupted the 
+          ** segment currently being trimmed.  */ 
+          p->rc = FTS5_CORRUPT; 
+        }else{ 
+          fts5BufferZero(&buf); 
+          fts5BufferGrow(&p->rc, &buf, pData->nn); 
+          fts5BufferAppendBlob(&p->rc, &buf, sizeof(aHdr), aHdr); 
+          fts5BufferAppendVarint(&p->rc, &buf, pSeg->term.n); 
+          fts5BufferAppendBlob(&p->rc, &buf, pSeg->term.n, pSeg->term.p); 
+          fts5BufferAppendBlob(&p->rc, &buf, pData->szLeaf-iOff,&pData->p[iOff]); 
+          if( p->rc==SQLITE_OK ){ 
+            /* Set the szLeaf field */ 
+            fts5PutU16(&buf.p[2], (u16)buf.n); 
+          } 
+
+          /* Set up the new page-index array */ 
+          fts5BufferAppendVarint(&p->rc, &buf, 4); 
           if( pSeg->iLeafPgno==pSeg->iTermLeafPgno
-           && pSeg->iEndofDoclist<pData->szLeaf
-           && pSeg->iPgidxOff<=pData->nn
-          ){
-            int nDiff = pData->szLeaf - pSeg->iEndofDoclist;
-            fts5BufferAppendVarint(&p->rc, &buf, buf.n - 1 - nDiff - 4);
+           && pSeg->iEndofDoclist<pData->szLeaf 
+           && pSeg->iPgidxOff<=pData->nn 
+          ){ 
+            int nDiff = pData->szLeaf - pSeg->iEndofDoclist; 
+            fts5BufferAppendVarint(&p->rc, &buf, buf.n - 1 - nDiff - 4); 
             fts5BufferAppendBlob(&p->rc, &buf,
-                pData->nn - pSeg->iPgidxOff, &pData->p[pSeg->iPgidxOff]
-            );
-          }
-
-          pSeg->pSeg->pgnoFirst = pSeg->iTermLeafPgno;
-          fts5DataDelete(p, FTS5_SEGMENT_ROWID(iId, 1), iLeafRowid);
-          fts5DataWrite(p, iLeafRowid, buf.p, buf.n);
+                pData->nn - pSeg->iPgidxOff, &pData->p[pSeg->iPgidxOff] 
+            ); 
+          } 
+ 
+          pSeg->pSeg->pgnoFirst = pSeg->iTermLeafPgno; 
+          fts5DataDelete(p, FTS5_SEGMENT_ROWID(iId, 1), iLeafRowid); 
+          fts5DataWrite(p, iLeafRowid, buf.p, buf.n); 
         }
         fts5DataRelease(pData);
       }
@@ -227293,7 +227293,7 @@ static void fts5IndexMergeLevel(
     const u8 *pTerm;
 
     pTerm = fts5MultiIterTerm(pIter, &nTerm);
-    if( nTerm!=term.n || fts5Memcmp(pTerm, term.p, nTerm) ){
+    if( nTerm!=term.n || fts5Memcmp(pTerm, term.p, nTerm) ){ 
       if( pnRem && writer.nLeafWritten>nRem ){
         break;
       }
@@ -227549,7 +227549,7 @@ static void fts5FlushOneHash(Fts5Index *p){
       /* Write the term for this entry to disk. */
       sqlite3Fts5HashScanEntry(pHash, &zTerm, &pDoclist, &nDoclist);
       fts5WriteAppendTerm(p, &writer, (int)strlen(zTerm), (const u8*)zTerm);
-      if( p->rc!=SQLITE_OK ) break;
+      if( p->rc!=SQLITE_OK ) break; 
 
       assert( writer.bFirstRowidInPage==0 );
       if( pgsz>=(pBuf->n + pPgidx->n + nDoclist + 1) ){
@@ -227572,7 +227572,7 @@ static void fts5FlushOneHash(Fts5Index *p){
             pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], iRowid);
             writer.bFirstRowidInPage = 0;
             fts5WriteDlidxAppend(p, &writer, iRowid);
-            if( p->rc!=SQLITE_OK ) break;
+            if( p->rc!=SQLITE_OK ) break; 
           }else{
             pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], iDelta);
           }
@@ -227630,7 +227630,7 @@ static void fts5FlushOneHash(Fts5Index *p){
       /* TODO2: Doclist terminator written here. */
       /* pBuf->p[pBuf->n++] = '\0'; */
       assert( pBuf->n<=pBuf->nSpace );
-      if( p->rc==SQLITE_OK ) sqlite3Fts5HashScanNext(pHash);
+      if( p->rc==SQLITE_OK ) sqlite3Fts5HashScanNext(pHash); 
     }
     sqlite3Fts5HashClear(pHash);
     fts5WriteFinish(p, &writer, &pgnoLast);
@@ -227674,7 +227674,7 @@ static Fts5Structure *fts5IndexOptimizeStruct(
   Fts5Structure *pStruct
 ){
   Fts5Structure *pNew = 0;
-  sqlite3_int64 nByte = sizeof(Fts5Structure);
+  sqlite3_int64 nByte = sizeof(Fts5Structure); 
   int nSeg = pStruct->nSegment;
   int i;
 
@@ -227804,13 +227804,13 @@ static void fts5AppendPoslist(
   Fts5Buffer *pBuf
 ){
   int nData = pMulti->base.nData;
-  int nByte = nData + 9 + 9 + FTS5_DATA_ZERO_PADDING;
+  int nByte = nData + 9 + 9 + FTS5_DATA_ZERO_PADDING; 
   assert( nData>0 );
-  if( p->rc==SQLITE_OK && 0==fts5BufferGrow(&p->rc, pBuf, nByte) ){
+  if( p->rc==SQLITE_OK && 0==fts5BufferGrow(&p->rc, pBuf, nByte) ){ 
     fts5BufferSafeAppendVarint(pBuf, iDelta);
     fts5BufferSafeAppendVarint(pBuf, nData*2);
     fts5BufferSafeAppendBlob(pBuf, pMulti->base.pData, nData);
-    memset(&pBuf->p[pBuf->n], 0, FTS5_DATA_ZERO_PADDING);
+    memset(&pBuf->p[pBuf->n], 0, FTS5_DATA_ZERO_PADDING); 
   }
 }
 
@@ -228251,7 +228251,7 @@ static void fts5SetupPrefixIter(
     }
     fts5MultiIterFree(p1);
 
-    pData = fts5IdxMalloc(p, sizeof(Fts5Data)+doclist.n+FTS5_DATA_ZERO_PADDING);
+    pData = fts5IdxMalloc(p, sizeof(Fts5Data)+doclist.n+FTS5_DATA_ZERO_PADDING); 
     if( pData ){
       pData->p = (u8*)&pData[1];
       pData->nn = pData->szLeaf = doclist.n;
@@ -228412,13 +228412,13 @@ static int sqlite3Fts5IndexCharlenToBytelen(
     if( n>=nByte ) return 0;      /* Input contains fewer than nChar chars */
     if( (unsigned char)p[n++]>=0xc0 ){
       if( n>=nByte ) return 0;
-      while( (p[n] & 0xc0)==0x80 ){
-        n++;
+      while( (p[n] & 0xc0)==0x80 ){ 
+        n++; 
         if( n>=nByte ){
           if( i+1==nChar ) break;
           return 0;
         }
-      }
+      } 
     }
   }
   return n;
@@ -228562,7 +228562,7 @@ static int sqlite3Fts5IndexQuery(
       sqlite3Fts5IndexCloseReader(p);
     }
 
-    *ppIter = (Fts5IndexIter*)pRet;
+    *ppIter = (Fts5IndexIter*)pRet; 
     sqlite3Fts5BufferFree(&buf);
   }
   return fts5IndexReturn(p);
@@ -229063,11 +229063,11 @@ static void fts5IndexIntegrityCheckSegment(
 
       iOff = fts5LeafFirstTermOff(pLeaf);
       iRowidOff = fts5LeafFirstRowidOff(pLeaf);
-      if( iRowidOff>=iOff || iOff>=pLeaf->szLeaf ){
+      if( iRowidOff>=iOff || iOff>=pLeaf->szLeaf ){ 
         p->rc = FTS5_CORRUPT;
       }else{
         iOff += fts5GetVarint32(&pLeaf->p[iOff], nTerm);
-        res = fts5Memcmp(&pLeaf->p[iOff], zIdxTerm, MIN(nTerm, nIdxTerm));
+        res = fts5Memcmp(&pLeaf->p[iOff], zIdxTerm, MIN(nTerm, nIdxTerm)); 
         if( res==0 ) res = nTerm - nIdxTerm;
         if( res<0 ) p->rc = FTS5_CORRUPT;
       }
@@ -229482,7 +229482,7 @@ static void fts5DecodeFunction(
   u8 *a = 0;
   Fts5Buffer s;                   /* Build up text to return here */
   int rc = SQLITE_OK;             /* Return code */
-  sqlite3_int64 nSpace = 0;
+  sqlite3_int64 nSpace = 0; 
   int eDetailNone = (sqlite3_user_data(pCtx)!=0);
 
   assert( nArg==2 );
@@ -229498,7 +229498,7 @@ static void fts5DecodeFunction(
   nSpace = n + FTS5_DATA_ZERO_PADDING;
   a = (u8*)sqlite3Fts5MallocZero(&rc, nSpace);
   if( a==0 ) goto decode_out;
-  if( n>0 ) memcpy(a, aBlob, n);
+  if( n>0 ) memcpy(a, aBlob, n); 
 
   fts5DecodeRowid(iRowid, &iSegid, &bDlidx, &iHeight, &iPgno);
 
@@ -229593,9 +229593,9 @@ static void fts5DecodeFunction(
       iPgidxOff = szLeaf = fts5GetU16(&a[2]);
       if( iPgidxOff<n ){
         fts5GetVarint32(&a[iPgidxOff], iTermOff);
-      }else if( iPgidxOff>n ){
-        rc = FTS5_CORRUPT;
-        goto decode_out;
+      }else if( iPgidxOff>n ){ 
+        rc = FTS5_CORRUPT; 
+        goto decode_out; 
       }
     }
 
@@ -229607,22 +229607,22 @@ static void fts5DecodeFunction(
     }else{
       iOff = szLeaf;
     }
-    if( iOff>n ){
-      rc = FTS5_CORRUPT;
-      goto decode_out;
-    }
+    if( iOff>n ){ 
+      rc = FTS5_CORRUPT; 
+      goto decode_out; 
+    } 
     fts5DecodePoslist(&rc, &s, &a[4], iOff-4);
 
     /* Decode any more doclist data that appears on the page before the
     ** first term. */
     nDoclist = (iTermOff ? iTermOff : szLeaf) - iOff;
-    if( nDoclist+iOff>n ){
-      rc = FTS5_CORRUPT;
-      goto decode_out;
-    }
+    if( nDoclist+iOff>n ){ 
+      rc = FTS5_CORRUPT; 
+      goto decode_out; 
+    } 
     fts5DecodeDoclist(&rc, &s, &a[iOff], nDoclist);
 
-    while( iPgidxOff<n && rc==SQLITE_OK ){
+    while( iPgidxOff<n && rc==SQLITE_OK ){ 
       int bFirst = (iPgidxOff==szLeaf);     /* True for first term on page */
       int nByte;                            /* Bytes of data */
       int iEnd;
@@ -229637,24 +229637,24 @@ static void fts5DecodeFunction(
       }else{
         iEnd = szLeaf;
       }
-      if( iEnd>szLeaf ){
-        rc = FTS5_CORRUPT;
-        break;
-      }
+      if( iEnd>szLeaf ){ 
+        rc = FTS5_CORRUPT; 
+        break; 
+      } 
 
       if( bFirst==0 ){
         iOff += fts5GetVarint32(&a[iOff], nByte);
-        if( nByte>term.n ){
-          rc = FTS5_CORRUPT;
-          break;
-        }
+        if( nByte>term.n ){ 
+          rc = FTS5_CORRUPT; 
+          break; 
+        } 
         term.n = nByte;
       }
       iOff += fts5GetVarint32(&a[iOff], nByte);
-      if( iOff+nByte>n ){
-        rc = FTS5_CORRUPT;
-        break;
-      }
+      if( iOff+nByte>n ){ 
+        rc = FTS5_CORRUPT; 
+        break; 
+      } 
       fts5BufferAppendBlob(&rc, &term, nByte, &a[iOff]);
       iOff += nByte;
 
@@ -229788,7 +229788,7 @@ SQLITE_API int sqlite3_fts5_may_be_corrupt = 1;
 typedef struct Fts5Auxdata Fts5Auxdata;
 typedef struct Fts5Auxiliary Fts5Auxiliary;
 typedef struct Fts5Cursor Fts5Cursor;
-typedef struct Fts5FullTable Fts5FullTable;
+typedef struct Fts5FullTable Fts5FullTable; 
 typedef struct Fts5Sorter Fts5Sorter;
 typedef struct Fts5TokenizerModule Fts5TokenizerModule;
 
@@ -229870,8 +229870,8 @@ struct Fts5TokenizerModule {
   Fts5TokenizerModule *pNext;     /* Next registered tokenizer module */
 };
 
-struct Fts5FullTable {
-  Fts5Table p;                    /* Public class members from fts5Int.h */
+struct Fts5FullTable { 
+  Fts5Table p;                    /* Public class members from fts5Int.h */ 
   Fts5Storage *pStorage;          /* Document store */
   Fts5Global *pGlobal;            /* Global (connection wide) data */
   Fts5Cursor *pSortCsr;           /* Sort data from this cursor */
@@ -230009,7 +230009,7 @@ struct Fts5Auxdata {
 #define FTS5_SAVEPOINT  5
 #define FTS5_RELEASE    6
 #define FTS5_ROLLBACKTO 7
-static void fts5CheckTransactionState(Fts5FullTable *p, int op, int iSavepoint){
+static void fts5CheckTransactionState(Fts5FullTable *p, int op, int iSavepoint){ 
   switch( op ){
     case FTS5_BEGIN:
       assert( p->ts.eState==0 );
@@ -230035,7 +230035,7 @@ static void fts5CheckTransactionState(Fts5FullTable *p, int op, int iSavepoint){
     case FTS5_SAVEPOINT:
       assert( p->ts.eState==1 );
       assert( iSavepoint>=0 );
-      assert( iSavepoint>=p->ts.iSavepoint );
+      assert( iSavepoint>=p->ts.iSavepoint ); 
       p->ts.iSavepoint = iSavepoint;
       break;
 
@@ -230048,7 +230048,7 @@ static void fts5CheckTransactionState(Fts5FullTable *p, int op, int iSavepoint){
 
     case FTS5_ROLLBACKTO:
       assert( p->ts.eState==1 );
-      assert( iSavepoint>=-1 );
+      assert( iSavepoint>=-1 ); 
       /* The following assert() can fail if another vtab strikes an error
       ** within an xSavepoint() call then SQLite calls xRollbackTo() - without
       ** having called xSavepoint() on this vtab.  */
@@ -230064,18 +230064,18 @@ static void fts5CheckTransactionState(Fts5FullTable *p, int op, int iSavepoint){
 /*
 ** Return true if pTab is a contentless table.
 */
-static int fts5IsContentless(Fts5FullTable *pTab){
-  return pTab->p.pConfig->eContent==FTS5_CONTENT_NONE;
+static int fts5IsContentless(Fts5FullTable *pTab){ 
+  return pTab->p.pConfig->eContent==FTS5_CONTENT_NONE; 
 }
 
 /*
 ** Delete a virtual table handle allocated by fts5InitVtab().
 */
-static void fts5FreeVtab(Fts5FullTable *pTab){
+static void fts5FreeVtab(Fts5FullTable *pTab){ 
   if( pTab ){
-    sqlite3Fts5IndexClose(pTab->p.pIndex);
+    sqlite3Fts5IndexClose(pTab->p.pIndex); 
     sqlite3Fts5StorageClose(pTab->pStorage);
-    sqlite3Fts5ConfigFree(pTab->p.pConfig);
+    sqlite3Fts5ConfigFree(pTab->p.pConfig); 
     sqlite3_free(pTab);
   }
 }
@@ -230084,7 +230084,7 @@ static void fts5FreeVtab(Fts5FullTable *pTab){
 ** The xDisconnect() virtual table method.
 */
 static int fts5DisconnectMethod(sqlite3_vtab *pVtab){
-  fts5FreeVtab((Fts5FullTable*)pVtab);
+  fts5FreeVtab((Fts5FullTable*)pVtab); 
   return SQLITE_OK;
 }
 
@@ -230095,7 +230095,7 @@ static int fts5DestroyMethod(sqlite3_vtab *pVtab){
   Fts5Table *pTab = (Fts5Table*)pVtab;
   int rc = sqlite3Fts5DropAll(pTab->pConfig);
   if( rc==SQLITE_OK ){
-    fts5FreeVtab((Fts5FullTable*)pVtab);
+    fts5FreeVtab((Fts5FullTable*)pVtab); 
   }
   return rc;
 }
@@ -230124,28 +230124,28 @@ static int fts5InitVtab(
   const char **azConfig = (const char**)argv;
   int rc = SQLITE_OK;             /* Return code */
   Fts5Config *pConfig = 0;        /* Results of parsing argc/argv */
-  Fts5FullTable *pTab = 0;        /* New virtual table object */
+  Fts5FullTable *pTab = 0;        /* New virtual table object */ 
 
   /* Allocate the new vtab object and parse the configuration */
-  pTab = (Fts5FullTable*)sqlite3Fts5MallocZero(&rc, sizeof(Fts5FullTable));
+  pTab = (Fts5FullTable*)sqlite3Fts5MallocZero(&rc, sizeof(Fts5FullTable)); 
   if( rc==SQLITE_OK ){
     rc = sqlite3Fts5ConfigParse(pGlobal, db, argc, azConfig, &pConfig, pzErr);
     assert( (rc==SQLITE_OK && *pzErr==0) || pConfig==0 );
   }
   if( rc==SQLITE_OK ){
-    pTab->p.pConfig = pConfig;
+    pTab->p.pConfig = pConfig; 
     pTab->pGlobal = pGlobal;
   }
 
   /* Open the index sub-system */
   if( rc==SQLITE_OK ){
-    rc = sqlite3Fts5IndexOpen(pConfig, bCreate, &pTab->p.pIndex, pzErr);
+    rc = sqlite3Fts5IndexOpen(pConfig, bCreate, &pTab->p.pIndex, pzErr); 
   }
 
   /* Open the storage sub-system */
   if( rc==SQLITE_OK ){
     rc = sqlite3Fts5StorageOpen(
-        pConfig, pTab->p.pIndex, bCreate, &pTab->pStorage, pzErr
+        pConfig, pTab->p.pIndex, bCreate, &pTab->pStorage, pzErr 
     );
   }
 
@@ -230158,8 +230158,8 @@ static int fts5InitVtab(
   if( rc==SQLITE_OK ){
     assert( pConfig->pzErrmsg==0 );
     pConfig->pzErrmsg = pzErr;
-    rc = sqlite3Fts5IndexLoadConfig(pTab->p.pIndex);
-    sqlite3Fts5IndexRollback(pTab->p.pIndex);
+    rc = sqlite3Fts5IndexLoadConfig(pTab->p.pIndex); 
+    sqlite3Fts5IndexRollback(pTab->p.pIndex); 
     pConfig->pzErrmsg = 0;
   }
 
@@ -230320,12 +230320,12 @@ static int fts5BestIndexMethod(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){
   int bSeenRank = 0;
 
 
-  assert( SQLITE_INDEX_CONSTRAINT_EQ<SQLITE_INDEX_CONSTRAINT_MATCH );
-  assert( SQLITE_INDEX_CONSTRAINT_GT<SQLITE_INDEX_CONSTRAINT_MATCH );
-  assert( SQLITE_INDEX_CONSTRAINT_LE<SQLITE_INDEX_CONSTRAINT_MATCH );
-  assert( SQLITE_INDEX_CONSTRAINT_GE<SQLITE_INDEX_CONSTRAINT_MATCH );
-  assert( SQLITE_INDEX_CONSTRAINT_LE<SQLITE_INDEX_CONSTRAINT_MATCH );
-
+  assert( SQLITE_INDEX_CONSTRAINT_EQ<SQLITE_INDEX_CONSTRAINT_MATCH ); 
+  assert( SQLITE_INDEX_CONSTRAINT_GT<SQLITE_INDEX_CONSTRAINT_MATCH ); 
+  assert( SQLITE_INDEX_CONSTRAINT_LE<SQLITE_INDEX_CONSTRAINT_MATCH ); 
+  assert( SQLITE_INDEX_CONSTRAINT_GE<SQLITE_INDEX_CONSTRAINT_MATCH ); 
+  assert( SQLITE_INDEX_CONSTRAINT_LE<SQLITE_INDEX_CONSTRAINT_MATCH ); 
+ 
   if( pConfig->bLock ){
     pTab->base.zErrMsg = sqlite3_mprintf(
         "recursively defined fts5 content table"
@@ -230437,7 +230437,7 @@ static int fts5BestIndexMethod(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){
   return SQLITE_OK;
 }
 
-static int fts5NewTransaction(Fts5FullTable *pTab){
+static int fts5NewTransaction(Fts5FullTable *pTab){ 
   Fts5Cursor *pCsr;
   for(pCsr=pTab->pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
     if( pCsr->base.pVtab==(sqlite3_vtab*)pTab ) return SQLITE_OK;
@@ -230449,19 +230449,19 @@ static int fts5NewTransaction(Fts5FullTable *pTab){
 ** Implementation of xOpen method.
 */
 static int fts5OpenMethod(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCsr){
-  Fts5FullTable *pTab = (Fts5FullTable*)pVTab;
-  Fts5Config *pConfig = pTab->p.pConfig;
+  Fts5FullTable *pTab = (Fts5FullTable*)pVTab; 
+  Fts5Config *pConfig = pTab->p.pConfig; 
   Fts5Cursor *pCsr = 0;           /* New cursor object */
-  sqlite3_int64 nByte;            /* Bytes of space to allocate */
+  sqlite3_int64 nByte;            /* Bytes of space to allocate */ 
   int rc;                         /* Return code */
 
   rc = fts5NewTransaction(pTab);
   if( rc==SQLITE_OK ){
     nByte = sizeof(Fts5Cursor) + pConfig->nCol * sizeof(int);
-    pCsr = (Fts5Cursor*)sqlite3_malloc64(nByte);
+    pCsr = (Fts5Cursor*)sqlite3_malloc64(nByte); 
     if( pCsr ){
       Fts5Global *pGlobal = pTab->pGlobal;
-      memset(pCsr, 0, (size_t)nByte);
+      memset(pCsr, 0, (size_t)nByte); 
       pCsr->aColumnSize = (int*)&pCsr[1];
       pCsr->pNext = pGlobal->pCsr;
       pGlobal->pCsr = pCsr;
@@ -230496,7 +230496,7 @@ static void fts5CsrNewrow(Fts5Cursor *pCsr){
 }
 
 static void fts5FreeCursorComponents(Fts5Cursor *pCsr){
-  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
+  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab); 
   Fts5Auxdata *pData;
   Fts5Auxdata *pNext;
 
@@ -230541,7 +230541,7 @@ static void fts5FreeCursorComponents(Fts5Cursor *pCsr){
 */
 static int fts5CloseMethod(sqlite3_vtab_cursor *pCursor){
   if( pCursor ){
-    Fts5FullTable *pTab = (Fts5FullTable*)(pCursor->pVtab);
+    Fts5FullTable *pTab = (Fts5FullTable*)(pCursor->pVtab); 
     Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
     Fts5Cursor **pp;
 
@@ -230598,7 +230598,7 @@ static int fts5SorterNext(Fts5Cursor *pCsr){
 ** Set the FTS5CSR_REQUIRE_RESEEK flag on all FTS5_PLAN_MATCH cursors
 ** open on table pTab.
 */
-static void fts5TripCursors(Fts5FullTable *pTab){
+static void fts5TripCursors(Fts5FullTable *pTab){ 
   Fts5Cursor *pCsr;
   for(pCsr=pTab->pGlobal->pCsr; pCsr; pCsr=pCsr->pNext){
     if( pCsr->ePlan==FTS5_PLAN_MATCH
@@ -230625,11 +230625,11 @@ static int fts5CursorReseek(Fts5Cursor *pCsr, int *pbSkip){
   int rc = SQLITE_OK;
   assert( *pbSkip==0 );
   if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_RESEEK) ){
-    Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
+    Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab); 
     int bDesc = pCsr->bDesc;
     i64 iRowid = sqlite3Fts5ExprRowid(pCsr->pExpr);
 
-    rc = sqlite3Fts5ExprFirst(pCsr->pExpr, pTab->p.pIndex, iRowid, bDesc);
+    rc = sqlite3Fts5ExprFirst(pCsr->pExpr, pTab->p.pIndex, iRowid, bDesc); 
     if( rc==SQLITE_OK &&  iRowid!=sqlite3Fts5ExprRowid(pCsr->pExpr) ){
       *pbSkip = 1;
     }
@@ -230735,24 +230735,24 @@ static int fts5PrepareStatement(
   return rc;
 }
 
-static int fts5CursorFirstSorted(
+static int fts5CursorFirstSorted( 
   Fts5FullTable *pTab,
   Fts5Cursor *pCsr,
-  int bDesc
-){
-  Fts5Config *pConfig = pTab->p.pConfig;
+  int bDesc 
+){ 
+  Fts5Config *pConfig = pTab->p.pConfig; 
   Fts5Sorter *pSorter;
   int nPhrase;
-  sqlite3_int64 nByte;
+  sqlite3_int64 nByte; 
   int rc;
   const char *zRank = pCsr->zRank;
   const char *zRankArgs = pCsr->zRankArgs;
 
   nPhrase = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
   nByte = sizeof(Fts5Sorter) + sizeof(int) * (nPhrase-1);
-  pSorter = (Fts5Sorter*)sqlite3_malloc64(nByte);
+  pSorter = (Fts5Sorter*)sqlite3_malloc64(nByte); 
   if( pSorter==0 ) return SQLITE_NOMEM;
-  memset(pSorter, 0, (size_t)nByte);
+  memset(pSorter, 0, (size_t)nByte); 
   pSorter->nIdx = nPhrase;
 
   /* TODO: It would be better to have some system for reusing statement
@@ -230787,10 +230787,10 @@ static int fts5CursorFirstSorted(
   return rc;
 }
 
-static int fts5CursorFirst(Fts5FullTable *pTab, Fts5Cursor *pCsr, int bDesc){
+static int fts5CursorFirst(Fts5FullTable *pTab, Fts5Cursor *pCsr, int bDesc){ 
   int rc;
   Fts5Expr *pExpr = pCsr->pExpr;
-  rc = sqlite3Fts5ExprFirst(pExpr, pTab->p.pIndex, pCsr->iFirstRowid, bDesc);
+  rc = sqlite3Fts5ExprFirst(pExpr, pTab->p.pIndex, pCsr->iFirstRowid, bDesc); 
   if( sqlite3Fts5ExprEof(pExpr) ){
     CsrFlagSet(pCsr, FTS5CSR_EOF);
   }
@@ -230816,18 +230816,18 @@ static int fts5SpecialMatch(
   while( z[0]==' ' ) z++;
   for(n=0; z[n] && z[n]!=' '; n++);
 
-  assert( pTab->p.base.zErrMsg==0 );
+  assert( pTab->p.base.zErrMsg==0 ); 
   pCsr->ePlan = FTS5_PLAN_SPECIAL;
 
   if( n==5 && 0==sqlite3_strnicmp("reads", z, n) ){
-    pCsr->iSpecial = sqlite3Fts5IndexReads(pTab->p.pIndex);
+    pCsr->iSpecial = sqlite3Fts5IndexReads(pTab->p.pIndex); 
   }
   else if( n==2 && 0==sqlite3_strnicmp("id", z, n) ){
     pCsr->iSpecial = pCsr->iCsrId;
   }
   else{
     /* An unrecognized directive. Return an error message. */
-    pTab->p.base.zErrMsg = sqlite3_mprintf("unknown special query: %.*s", n, z);
+    pTab->p.base.zErrMsg = sqlite3_mprintf("unknown special query: %.*s", n, z); 
     rc = SQLITE_ERROR;
   }
 
@@ -230839,7 +230839,7 @@ static int fts5SpecialMatch(
 ** pTab. If one is found, return a pointer to the corresponding Fts5Auxiliary
 ** structure. Otherwise, if no such function exists, return NULL.
 */
-static Fts5Auxiliary *fts5FindAuxiliary(Fts5FullTable *pTab, const char *zName){
+static Fts5Auxiliary *fts5FindAuxiliary(Fts5FullTable *pTab, const char *zName){ 
   Fts5Auxiliary *pAux;
 
   for(pAux=pTab->pGlobal->pAux; pAux; pAux=pAux->pNext){
@@ -230852,8 +230852,8 @@ static Fts5Auxiliary *fts5FindAuxiliary(Fts5FullTable *pTab, const char *zName){
 
 
 static int fts5FindRankFunction(Fts5Cursor *pCsr){
-  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
-  Fts5Config *pConfig = pTab->p.pConfig;
+  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab); 
+  Fts5Config *pConfig = pTab->p.pConfig; 
   int rc = SQLITE_OK;
   Fts5Auxiliary *pAux = 0;
   const char *zRank = pCsr->zRank;
@@ -230869,7 +230869,7 @@ static int fts5FindRankFunction(Fts5Cursor *pCsr){
       assert( rc==SQLITE_OK || pCsr->pRankArgStmt==0 );
       if( rc==SQLITE_OK ){
         if( SQLITE_ROW==sqlite3_step(pStmt) ){
-          sqlite3_int64 nByte;
+          sqlite3_int64 nByte; 
           pCsr->nRankArg = sqlite3_column_count(pStmt);
           nByte = sizeof(sqlite3_value*)*pCsr->nRankArg;
           pCsr->apRankArg = (sqlite3_value**)sqlite3Fts5MallocZero(&rc, nByte);
@@ -230891,8 +230891,8 @@ static int fts5FindRankFunction(Fts5Cursor *pCsr){
   if( rc==SQLITE_OK ){
     pAux = fts5FindAuxiliary(pTab, zRank);
     if( pAux==0 ){
-      assert( pTab->p.base.zErrMsg==0 );
-      pTab->p.base.zErrMsg = sqlite3_mprintf("no such function: %s", zRank);
+      assert( pTab->p.base.zErrMsg==0 ); 
+      pTab->p.base.zErrMsg = sqlite3_mprintf("no such function: %s", zRank); 
       rc = SQLITE_ERROR;
     }
   }
@@ -230967,8 +230967,8 @@ static int fts5FilterMethod(
   int nVal,                       /* Number of elements in apVal */
   sqlite3_value **apVal           /* Arguments for the indexing scheme */
 ){
-  Fts5FullTable *pTab = (Fts5FullTable*)(pCursor->pVtab);
-  Fts5Config *pConfig = pTab->p.pConfig;
+  Fts5FullTable *pTab = (Fts5FullTable*)(pCursor->pVtab); 
+  Fts5Config *pConfig = pTab->p.pConfig; 
   Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
   int rc = SQLITE_OK;             /* Error code */
   int bDesc;                      /* True if ORDER BY [rank|rowid] DESC */
@@ -231003,8 +231003,8 @@ static int fts5FilterMethod(
   assert( pCsr->zRankArgs==0 );
   assert( pTab->pSortCsr==0 || nVal==0 );
 
-  assert( pzErrmsg==0 || pzErrmsg==&pTab->p.base.zErrMsg );
-  pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
+  assert( pzErrmsg==0 || pzErrmsg==&pTab->p.base.zErrMsg ); 
+  pConfig->pzErrmsg = &pTab->p.base.zErrMsg; 
 
   /* Decode the arguments passed through to this function. */
   for(i=0; i<nVal; i++){
@@ -231098,13 +231098,13 @@ static int fts5FilterMethod(
     assert( nVal==0 && bOrderByRank==0 && bDesc==0 );
     assert( pCsr->iLastRowid==LARGEST_INT64 );
     assert( pCsr->iFirstRowid==SMALLEST_INT64 );
-    if( pTab->pSortCsr->bDesc ){
-      pCsr->iLastRowid = pTab->pSortCsr->iFirstRowid;
-      pCsr->iFirstRowid = pTab->pSortCsr->iLastRowid;
-    }else{
-      pCsr->iLastRowid = pTab->pSortCsr->iLastRowid;
-      pCsr->iFirstRowid = pTab->pSortCsr->iFirstRowid;
-    }
+    if( pTab->pSortCsr->bDesc ){ 
+      pCsr->iLastRowid = pTab->pSortCsr->iFirstRowid; 
+      pCsr->iFirstRowid = pTab->pSortCsr->iLastRowid; 
+    }else{ 
+      pCsr->iLastRowid = pTab->pSortCsr->iLastRowid; 
+      pCsr->iFirstRowid = pTab->pSortCsr->iFirstRowid; 
+    } 
     pCsr->ePlan = FTS5_PLAN_SOURCE;
     pCsr->pExpr = pTab->pSortCsr->pExpr;
     rc = fts5CursorFirst(pTab, pCsr, bDesc);
@@ -231129,7 +231129,7 @@ static int fts5FilterMethod(
     ** by rowid (ePlan==FTS5_PLAN_ROWID).  */
     pCsr->ePlan = (pRowidEq ? FTS5_PLAN_ROWID : FTS5_PLAN_SCAN);
     rc = sqlite3Fts5StorageStmt(
-        pTab->pStorage, fts5StmtType(pCsr), &pCsr->pStmt, &pTab->p.base.zErrMsg
+        pTab->pStorage, fts5StmtType(pCsr), &pCsr->pStmt, &pTab->p.base.zErrMsg 
     );
     if( rc==SQLITE_OK ){
       if( pRowidEq!=0 ){
@@ -231215,12 +231215,12 @@ static int fts5SeekCursor(Fts5Cursor *pCsr, int bErrormsg){
 
   /* If the cursor does not yet have a statement handle, obtain one now. */
   if( pCsr->pStmt==0 ){
-    Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
+    Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab); 
     int eStmt = fts5StmtType(pCsr);
     rc = sqlite3Fts5StorageStmt(
-        pTab->pStorage, eStmt, &pCsr->pStmt, (bErrormsg?&pTab->p.base.zErrMsg:0)
+        pTab->pStorage, eStmt, &pCsr->pStmt, (bErrormsg?&pTab->p.base.zErrMsg:0) 
     );
-    assert( rc!=SQLITE_OK || pTab->p.base.zErrMsg==0 );
+    assert( rc!=SQLITE_OK || pTab->p.base.zErrMsg==0 ); 
     assert( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_CONTENT) );
   }
 
@@ -231249,11 +231249,11 @@ static int fts5SeekCursor(Fts5Cursor *pCsr, int bErrormsg){
   return rc;
 }
 
-static void fts5SetVtabError(Fts5FullTable *p, const char *zFormat, ...){
+static void fts5SetVtabError(Fts5FullTable *p, const char *zFormat, ...){ 
   va_list ap;                     /* ... printf arguments */
   va_start(ap, zFormat);
-  assert( p->p.base.zErrMsg==0 );
-  p->p.base.zErrMsg = sqlite3_vmprintf(zFormat, ap);
+  assert( p->p.base.zErrMsg==0 ); 
+  p->p.base.zErrMsg = sqlite3_vmprintf(zFormat, ap); 
   va_end(ap);
 }
 
@@ -231273,11 +231273,11 @@ static void fts5SetVtabError(Fts5FullTable *p, const char *zFormat, ...){
 ** more commands are added to this function.
 */
 static int fts5SpecialInsert(
-  Fts5FullTable *pTab,            /* Fts5 table object */
+  Fts5FullTable *pTab,            /* Fts5 table object */ 
   const char *zCmd,               /* Text inserted into table-name column */
   sqlite3_value *pVal             /* Value inserted into rank column */
 ){
-  Fts5Config *pConfig = pTab->p.pConfig;
+  Fts5Config *pConfig = pTab->p.pConfig; 
   int rc = SQLITE_OK;
   int bError = 0;
 
@@ -231313,9 +231313,9 @@ static int fts5SpecialInsert(
     pConfig->bPrefixIndex = sqlite3_value_int(pVal);
 #endif
   }else{
-    rc = sqlite3Fts5IndexLoadConfig(pTab->p.pIndex);
+    rc = sqlite3Fts5IndexLoadConfig(pTab->p.pIndex); 
     if( rc==SQLITE_OK ){
-      rc = sqlite3Fts5ConfigSetValue(pTab->p.pConfig, zCmd, pVal, &bError);
+      rc = sqlite3Fts5ConfigSetValue(pTab->p.pConfig, zCmd, pVal, &bError); 
     }
     if( rc==SQLITE_OK ){
       if( bError ){
@@ -231377,8 +231377,8 @@ static int fts5UpdateMethod(
   sqlite3_value **apVal,          /* Array of arguments */
   sqlite_int64 *pRowid            /* OUT: The affected (or effected) rowid */
 ){
-  Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
-  Fts5Config *pConfig = pTab->p.pConfig;
+  Fts5FullTable *pTab = (Fts5FullTable*)pVtab; 
+  Fts5Config *pConfig = pTab->p.pConfig; 
   int eType0;                     /* value_type() of apVal[0] */
   int rc = SQLITE_OK;             /* Return code */
 
@@ -231390,8 +231390,8 @@ static int fts5UpdateMethod(
   assert( sqlite3_value_type(apVal[0])==SQLITE_INTEGER
        || sqlite3_value_type(apVal[0])==SQLITE_NULL
   );
-  assert( pTab->p.pConfig->pzErrmsg==0 );
-  pTab->p.pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
+  assert( pTab->p.pConfig->pzErrmsg==0 ); 
+  pTab->p.pConfig->pzErrmsg = &pTab->p.base.zErrMsg; 
 
   /* Put any active cursors into REQUIRE_SEEK state. */
   fts5TripCursors(pTab);
@@ -231432,7 +231432,7 @@ static int fts5UpdateMethod(
     /* Filter out attempts to run UPDATE or DELETE on contentless tables.
     ** This is not suported.  */
     if( eType0==SQLITE_INTEGER && fts5IsContentless(pTab) ){
-      pTab->p.base.zErrMsg = sqlite3_mprintf(
+      pTab->p.base.zErrMsg = sqlite3_mprintf( 
           "cannot %s contentless fts5 table: %s",
           (nArg>1 ? "UPDATE" : "DELETE from"), pConfig->zName
       );
@@ -231445,44 +231445,44 @@ static int fts5UpdateMethod(
       rc = sqlite3Fts5StorageDelete(pTab->pStorage, iDel, 0);
     }
 
-    /* INSERT or UPDATE */
-    else{
-      int eType1 = sqlite3_value_numeric_type(apVal[1]);
-
-      if( eType1!=SQLITE_INTEGER && eType1!=SQLITE_NULL ){
-        rc = SQLITE_MISMATCH;
+    /* INSERT or UPDATE */ 
+    else{ 
+      int eType1 = sqlite3_value_numeric_type(apVal[1]); 
+ 
+      if( eType1!=SQLITE_INTEGER && eType1!=SQLITE_NULL ){ 
+        rc = SQLITE_MISMATCH; 
       }
 
       else if( eType0!=SQLITE_INTEGER ){
-        /* If this is a REPLACE, first remove the current entry (if any) */
-        if( eConflict==SQLITE_REPLACE && eType1==SQLITE_INTEGER ){
-          i64 iNew = sqlite3_value_int64(apVal[1]);  /* Rowid to delete */
-          rc = sqlite3Fts5StorageDelete(pTab->pStorage, iNew, 0);
-        }
-        fts5StorageInsert(&rc, pTab, apVal, pRowid);
-      }
-
-      /* UPDATE */
-      else{
-        i64 iOld = sqlite3_value_int64(apVal[0]);  /* Old rowid */
-        i64 iNew = sqlite3_value_int64(apVal[1]);  /* New rowid */
-        if( eType1==SQLITE_INTEGER && iOld!=iNew ){
-          if( eConflict==SQLITE_REPLACE ){
-            rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0);
-            if( rc==SQLITE_OK ){
-              rc = sqlite3Fts5StorageDelete(pTab->pStorage, iNew, 0);
-            }
-            fts5StorageInsert(&rc, pTab, apVal, pRowid);
-          }else{
-            rc = sqlite3Fts5StorageContentInsert(pTab->pStorage, apVal, pRowid);
-            if( rc==SQLITE_OK ){
-              rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0);
-            }
-            if( rc==SQLITE_OK ){
-              rc = sqlite3Fts5StorageIndexInsert(pTab->pStorage, apVal,*pRowid);
-            }
-          }
-        }else{
+        /* If this is a REPLACE, first remove the current entry (if any) */ 
+        if( eConflict==SQLITE_REPLACE && eType1==SQLITE_INTEGER ){ 
+          i64 iNew = sqlite3_value_int64(apVal[1]);  /* Rowid to delete */ 
+          rc = sqlite3Fts5StorageDelete(pTab->pStorage, iNew, 0); 
+        } 
+        fts5StorageInsert(&rc, pTab, apVal, pRowid); 
+      } 
+ 
+      /* UPDATE */ 
+      else{ 
+        i64 iOld = sqlite3_value_int64(apVal[0]);  /* Old rowid */ 
+        i64 iNew = sqlite3_value_int64(apVal[1]);  /* New rowid */ 
+        if( eType1==SQLITE_INTEGER && iOld!=iNew ){ 
+          if( eConflict==SQLITE_REPLACE ){ 
+            rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0); 
+            if( rc==SQLITE_OK ){ 
+              rc = sqlite3Fts5StorageDelete(pTab->pStorage, iNew, 0); 
+            } 
+            fts5StorageInsert(&rc, pTab, apVal, pRowid); 
+          }else{ 
+            rc = sqlite3Fts5StorageContentInsert(pTab->pStorage, apVal, pRowid); 
+            if( rc==SQLITE_OK ){ 
+              rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0); 
+            } 
+            if( rc==SQLITE_OK ){ 
+              rc = sqlite3Fts5StorageIndexInsert(pTab->pStorage, apVal,*pRowid); 
+            } 
+          } 
+        }else{ 
           rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0);
           fts5StorageInsert(&rc, pTab, apVal, pRowid);
         }
@@ -231490,7 +231490,7 @@ static int fts5UpdateMethod(
     }
   }
 
-  pTab->p.pConfig->pzErrmsg = 0;
+  pTab->p.pConfig->pzErrmsg = 0; 
   return rc;
 }
 
@@ -231499,12 +231499,12 @@ static int fts5UpdateMethod(
 */
 static int fts5SyncMethod(sqlite3_vtab *pVtab){
   int rc;
-  Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
+  Fts5FullTable *pTab = (Fts5FullTable*)pVtab; 
   fts5CheckTransactionState(pTab, FTS5_SYNC, 0);
-  pTab->p.pConfig->pzErrmsg = &pTab->p.base.zErrMsg;
+  pTab->p.pConfig->pzErrmsg = &pTab->p.base.zErrMsg; 
   fts5TripCursors(pTab);
   rc = sqlite3Fts5StorageSync(pTab->pStorage);
-  pTab->p.pConfig->pzErrmsg = 0;
+  pTab->p.pConfig->pzErrmsg = 0; 
   return rc;
 }
 
@@ -231512,8 +231512,8 @@ static int fts5SyncMethod(sqlite3_vtab *pVtab){
 ** Implementation of xBegin() method.
 */
 static int fts5BeginMethod(sqlite3_vtab *pVtab){
-  fts5CheckTransactionState((Fts5FullTable*)pVtab, FTS5_BEGIN, 0);
-  fts5NewTransaction((Fts5FullTable*)pVtab);
+  fts5CheckTransactionState((Fts5FullTable*)pVtab, FTS5_BEGIN, 0); 
+  fts5NewTransaction((Fts5FullTable*)pVtab); 
   return SQLITE_OK;
 }
 
@@ -231524,7 +231524,7 @@ static int fts5BeginMethod(sqlite3_vtab *pVtab){
 */
 static int fts5CommitMethod(sqlite3_vtab *pVtab){
   UNUSED_PARAM(pVtab);  /* Call below is a no-op for NDEBUG builds */
-  fts5CheckTransactionState((Fts5FullTable*)pVtab, FTS5_COMMIT, 0);
+  fts5CheckTransactionState((Fts5FullTable*)pVtab, FTS5_COMMIT, 0); 
   return SQLITE_OK;
 }
 
@@ -231534,7 +231534,7 @@ static int fts5CommitMethod(sqlite3_vtab *pVtab){
 */
 static int fts5RollbackMethod(sqlite3_vtab *pVtab){
   int rc;
-  Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
+  Fts5FullTable *pTab = (Fts5FullTable*)pVtab; 
   fts5CheckTransactionState(pTab, FTS5_ROLLBACK, 0);
   rc = sqlite3Fts5StorageRollback(pTab->pStorage);
   return rc;
@@ -231558,13 +231558,13 @@ static int fts5ApiColumnTotalSize(
   sqlite3_int64 *pnToken
 ){
   Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
+  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab); 
   return sqlite3Fts5StorageSize(pTab->pStorage, iCol, pnToken);
 }
 
 static int fts5ApiRowCount(Fts5Context *pCtx, i64 *pnRow){
   Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
+  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab); 
   return sqlite3Fts5StorageRowCount(pTab->pStorage, pnRow);
 }
 
@@ -231601,7 +231601,7 @@ static int fts5ApiColumnText(
   Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
   if( fts5IsContentless((Fts5FullTable*)(pCsr->base.pVtab))
    || pCsr->ePlan==FTS5_PLAN_SPECIAL
-  ){
+  ){ 
     *pz = 0;
     *pn = 0;
   }else{
@@ -231670,11 +231670,11 @@ static int fts5CacheInstArray(Fts5Cursor *pCsr){
   int rc = SQLITE_OK;
   Fts5PoslistReader *aIter;       /* One iterator for each phrase */
   int nIter;                      /* Number of iterators/phrases */
-  int nCol = ((Fts5Table*)pCsr->base.pVtab)->pConfig->nCol;
+  int nCol = ((Fts5Table*)pCsr->base.pVtab)->pConfig->nCol; 
 
   nIter = sqlite3Fts5ExprPhraseCount(pCsr->pExpr);
   if( pCsr->aInstIter==0 ){
-    sqlite3_int64 nByte = sizeof(Fts5PoslistReader) * nIter;
+    sqlite3_int64 nByte = sizeof(Fts5PoslistReader) * nIter; 
     pCsr->aInstIter = (Fts5PoslistReader*)sqlite3Fts5MallocZero(&rc, nByte);
   }
   aIter = pCsr->aInstIter;
@@ -231709,7 +231709,7 @@ static int fts5CacheInstArray(Fts5Cursor *pCsr){
         nInst++;
         if( nInst>=pCsr->nInstAlloc ){
           int nNewSize = pCsr->nInstAlloc ? pCsr->nInstAlloc*2 : 32;
-          aInst = (int*)sqlite3_realloc64(
+          aInst = (int*)sqlite3_realloc64( 
               pCsr->aInst, nNewSize*sizeof(int)*3
               );
           if( aInst ){
@@ -231726,10 +231726,10 @@ static int fts5CacheInstArray(Fts5Cursor *pCsr){
         aInst[0] = iBest;
         aInst[1] = FTS5_POS2COLUMN(aIter[iBest].iPos);
         aInst[2] = FTS5_POS2OFFSET(aIter[iBest].iPos);
-        if( aInst[1]<0 || aInst[1]>=nCol ){
-          rc = FTS5_CORRUPT;
-          break;
-        }
+        if( aInst[1]<0 || aInst[1]>=nCol ){ 
+          rc = FTS5_CORRUPT; 
+          break; 
+        } 
         sqlite3Fts5PoslistReaderNext(&aIter[iBest]);
       }
     }
@@ -231802,8 +231802,8 @@ static int fts5ColumnSizeCb(
 
 static int fts5ApiColumnSize(Fts5Context *pCtx, int iCol, int *pnToken){
   Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
-  Fts5Config *pConfig = pTab->p.pConfig;
+  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab); 
+  Fts5Config *pConfig = pTab->p.pConfig; 
   int rc = SQLITE_OK;
 
   if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_DOCSIZE) ){
@@ -232062,7 +232062,7 @@ static int fts5ApiQueryPhrase(
   int(*xCallback)(const Fts5ExtensionApi*, Fts5Context*, void*)
 ){
   Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab);
+  Fts5FullTable *pTab = (Fts5FullTable*)(pCsr->base.pVtab); 
   int rc;
   Fts5Cursor *pNew = 0;
 
@@ -232142,16 +232142,16 @@ static void fts5ApiCallback(
 ** Given cursor id iId, return a pointer to the corresponding Fts5Table
 ** object. Or NULL If the cursor id does not exist.
 */
-static Fts5Table *sqlite3Fts5TableFromCsrid(
+static Fts5Table *sqlite3Fts5TableFromCsrid( 
   Fts5Global *pGlobal,            /* FTS5 global context for db handle */
-  i64 iCsrId                      /* Id of cursor to find */
+  i64 iCsrId                      /* Id of cursor to find */ 
 ){
   Fts5Cursor *pCsr;
   pCsr = fts5CursorFromCsrid(pGlobal, iCsrId);
-  if( pCsr ){
-    return (Fts5Table*)pCsr->base.pVtab;
-  }
-  return 0;
+  if( pCsr ){ 
+    return (Fts5Table*)pCsr->base.pVtab; 
+  } 
+  return 0; 
 }
 
 /*
@@ -232231,8 +232231,8 @@ static int fts5ColumnMethod(
   sqlite3_context *pCtx,          /* Context for sqlite3_result_xxx() calls */
   int iCol                        /* Index of column to read value from */
 ){
-  Fts5FullTable *pTab = (Fts5FullTable*)(pCursor->pVtab);
-  Fts5Config *pConfig = pTab->p.pConfig;
+  Fts5FullTable *pTab = (Fts5FullTable*)(pCursor->pVtab); 
+  Fts5Config *pConfig = pTab->p.pConfig; 
   Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
   int rc = SQLITE_OK;
 
@@ -232286,7 +232286,7 @@ static int fts5FindFunctionMethod(
   void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), /* OUT: Result */
   void **ppArg                    /* OUT: User data for *pxFunc */
 ){
-  Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
+  Fts5FullTable *pTab = (Fts5FullTable*)pVtab; 
   Fts5Auxiliary *pAux;
 
   UNUSED_PARAM(nUnused);
@@ -232308,15 +232308,15 @@ static int fts5RenameMethod(
   sqlite3_vtab *pVtab,            /* Virtual table handle */
   const char *zName               /* New name of table */
 ){
-  Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
+  Fts5FullTable *pTab = (Fts5FullTable*)pVtab; 
   return sqlite3Fts5StorageRename(pTab->pStorage, zName);
 }
 
-static int sqlite3Fts5FlushToDisk(Fts5Table *pTab){
-  fts5TripCursors((Fts5FullTable*)pTab);
-  return sqlite3Fts5StorageSync(((Fts5FullTable*)pTab)->pStorage);
-}
-
+static int sqlite3Fts5FlushToDisk(Fts5Table *pTab){ 
+  fts5TripCursors((Fts5FullTable*)pTab); 
+  return sqlite3Fts5StorageSync(((Fts5FullTable*)pTab)->pStorage); 
+} 
+ 
 /*
 ** The xSavepoint() method.
 **
@@ -232324,8 +232324,8 @@ static int sqlite3Fts5FlushToDisk(Fts5Table *pTab){
 */
 static int fts5SavepointMethod(sqlite3_vtab *pVtab, int iSavepoint){
   UNUSED_PARAM(iSavepoint);  /* Call below is a no-op for NDEBUG builds */
-  fts5CheckTransactionState((Fts5FullTable*)pVtab, FTS5_SAVEPOINT, iSavepoint);
-  return sqlite3Fts5FlushToDisk((Fts5Table*)pVtab);
+  fts5CheckTransactionState((Fts5FullTable*)pVtab, FTS5_SAVEPOINT, iSavepoint); 
+  return sqlite3Fts5FlushToDisk((Fts5Table*)pVtab); 
 }
 
 /*
@@ -232335,8 +232335,8 @@ static int fts5SavepointMethod(sqlite3_vtab *pVtab, int iSavepoint){
 */
 static int fts5ReleaseMethod(sqlite3_vtab *pVtab, int iSavepoint){
   UNUSED_PARAM(iSavepoint);  /* Call below is a no-op for NDEBUG builds */
-  fts5CheckTransactionState((Fts5FullTable*)pVtab, FTS5_RELEASE, iSavepoint);
-  return sqlite3Fts5FlushToDisk((Fts5Table*)pVtab);
+  fts5CheckTransactionState((Fts5FullTable*)pVtab, FTS5_RELEASE, iSavepoint); 
+  return sqlite3Fts5FlushToDisk((Fts5Table*)pVtab); 
 }
 
 /*
@@ -232345,7 +232345,7 @@ static int fts5ReleaseMethod(sqlite3_vtab *pVtab, int iSavepoint){
 ** Discard the contents of the pending terms table.
 */
 static int fts5RollbackToMethod(sqlite3_vtab *pVtab, int iSavepoint){
-  Fts5FullTable *pTab = (Fts5FullTable*)pVtab;
+  Fts5FullTable *pTab = (Fts5FullTable*)pVtab; 
   UNUSED_PARAM(iSavepoint);  /* Call below is a no-op for NDEBUG builds */
   fts5CheckTransactionState(pTab, FTS5_ROLLBACKTO, iSavepoint);
   fts5TripCursors(pTab);
@@ -232366,14 +232366,14 @@ static int fts5CreateAux(
   int rc = sqlite3_overload_function(pGlobal->db, zName, -1);
   if( rc==SQLITE_OK ){
     Fts5Auxiliary *pAux;
-    sqlite3_int64 nName;            /* Size of zName in bytes, including \0 */
-    sqlite3_int64 nByte;            /* Bytes of space to allocate */
+    sqlite3_int64 nName;            /* Size of zName in bytes, including \0 */ 
+    sqlite3_int64 nByte;            /* Bytes of space to allocate */ 
 
-    nName = strlen(zName) + 1;
+    nName = strlen(zName) + 1; 
     nByte = sizeof(Fts5Auxiliary) + nName;
-    pAux = (Fts5Auxiliary*)sqlite3_malloc64(nByte);
+    pAux = (Fts5Auxiliary*)sqlite3_malloc64(nByte); 
     if( pAux ){
-      memset(pAux, 0, (size_t)nByte);
+      memset(pAux, 0, (size_t)nByte); 
       pAux->zFunc = (char*)&pAux[1];
       memcpy(pAux->zFunc, zName, nName);
       pAux->pGlobal = pGlobal;
@@ -232403,15 +232403,15 @@ static int fts5CreateTokenizer(
 ){
   Fts5Global *pGlobal = (Fts5Global*)pApi;
   Fts5TokenizerModule *pNew;
-  sqlite3_int64 nName;            /* Size of zName and its \0 terminator */
-  sqlite3_int64 nByte;            /* Bytes of space to allocate */
+  sqlite3_int64 nName;            /* Size of zName and its \0 terminator */ 
+  sqlite3_int64 nByte;            /* Bytes of space to allocate */ 
   int rc = SQLITE_OK;
 
-  nName = strlen(zName) + 1;
+  nName = strlen(zName) + 1; 
   nByte = sizeof(Fts5TokenizerModule) + nName;
-  pNew = (Fts5TokenizerModule*)sqlite3_malloc64(nByte);
+  pNew = (Fts5TokenizerModule*)sqlite3_malloc64(nByte); 
   if( pNew ){
-    memset(pNew, 0, (size_t)nByte);
+    memset(pNew, 0, (size_t)nByte); 
     pNew->zName = (char*)&pNew[1];
     memcpy(pNew->zName, zName, nName);
     pNew->pUserData = pUserData;
@@ -232554,24 +232554,24 @@ static void fts5SourceIdFunc(
   sqlite3_result_text(pCtx, "fts5: 2022-01-06 13:25:41 872ba256cbf61d9290b571c0e6d82a20c224ca3ad82971edc46b29818d5d17a0", -1, SQLITE_TRANSIENT);
 }
 
-/*
-** Return true if zName is the extension on one of the shadow tables used
-** by this module.
-*/
-static int fts5ShadowName(const char *zName){
-  static const char *azName[] = {
-    "config", "content", "data", "docsize", "idx"
-  };
-  unsigned int i;
-  for(i=0; i<sizeof(azName)/sizeof(azName[0]); i++){
-    if( sqlite3_stricmp(zName, azName[i])==0 ) return 1;
-  }
-  return 0;
-}
-
+/* 
+** Return true if zName is the extension on one of the shadow tables used 
+** by this module. 
+*/ 
+static int fts5ShadowName(const char *zName){ 
+  static const char *azName[] = { 
+    "config", "content", "data", "docsize", "idx" 
+  }; 
+  unsigned int i; 
+  for(i=0; i<sizeof(azName)/sizeof(azName[0]); i++){ 
+    if( sqlite3_stricmp(zName, azName[i])==0 ) return 1; 
+  } 
+  return 0; 
+} 
+ 
 static int fts5Init(sqlite3 *db){
   static const sqlite3_module fts5Mod = {
-    /* iVersion      */ 3,
+    /* iVersion      */ 3, 
     /* xCreate       */ fts5CreateMethod,
     /* xConnect      */ fts5ConnectMethod,
     /* xBestIndex    */ fts5BestIndexMethod,
@@ -232594,7 +232594,7 @@ static int fts5Init(sqlite3 *db){
     /* xSavepoint    */ fts5SavepointMethod,
     /* xRelease      */ fts5ReleaseMethod,
     /* xRollbackTo   */ fts5RollbackToMethod,
-    /* xShadowName   */ fts5ShadowName
+    /* xShadowName   */ fts5ShadowName 
   };
 
   int rc;
@@ -232800,7 +232800,7 @@ static int fts5StorageGetStmt(
         char *zBind;
         int i;
 
-        zBind = sqlite3_malloc64(1 + nCol*2);
+        zBind = sqlite3_malloc64(1 + nCol*2); 
         if( zBind ){
           for(i=0; i<nCol; i++){
             zBind[i*2] = '?';
@@ -232821,10 +232821,10 @@ static int fts5StorageGetStmt(
     if( zSql==0 ){
       rc = SQLITE_NOMEM;
     }else{
-      int f = SQLITE_PREPARE_PERSISTENT;
-      if( eStmt>FTS5_STMT_LOOKUP ) f |= SQLITE_PREPARE_NO_VTAB;
+      int f = SQLITE_PREPARE_PERSISTENT; 
+      if( eStmt>FTS5_STMT_LOOKUP ) f |= SQLITE_PREPARE_NO_VTAB; 
       p->pConfig->bLock++;
-      rc = sqlite3_prepare_v3(pC->db, zSql, -1, f, &p->aStmt[eStmt], 0);
+      rc = sqlite3_prepare_v3(pC->db, zSql, -1, f, &p->aStmt[eStmt], 0); 
       p->pConfig->bLock--;
       sqlite3_free(zSql);
       if( rc!=SQLITE_OK && pzErrMsg ){
@@ -232969,14 +232969,14 @@ static int sqlite3Fts5StorageOpen(
 ){
   int rc = SQLITE_OK;
   Fts5Storage *p;                 /* New object */
-  sqlite3_int64 nByte;            /* Bytes of space to allocate */
+  sqlite3_int64 nByte;            /* Bytes of space to allocate */ 
 
   nByte = sizeof(Fts5Storage)               /* Fts5Storage object */
         + pConfig->nCol * sizeof(i64);      /* Fts5Storage.aTotalSize[] */
-  *pp = p = (Fts5Storage*)sqlite3_malloc64(nByte);
+  *pp = p = (Fts5Storage*)sqlite3_malloc64(nByte); 
   if( !p ) return SQLITE_NOMEM;
 
-  memset(p, 0, (size_t)nByte);
+  memset(p, 0, (size_t)nByte); 
   p->aTotalSize = (i64*)&p[1];
   p->pConfig = pConfig;
   p->pIndex = pIndex;
@@ -232984,7 +232984,7 @@ static int sqlite3Fts5StorageOpen(
   if( bCreate ){
     if( pConfig->eContent==FTS5_CONTENT_NORMAL ){
       int nDefn = 32 + pConfig->nCol*10;
-      char *zDefn = sqlite3_malloc64(32 + (sqlite3_int64)pConfig->nCol * 10);
+      char *zDefn = sqlite3_malloc64(32 + (sqlite3_int64)pConfig->nCol * 10); 
       if( zDefn==0 ){
         rc = SQLITE_NOMEM;
       }else{
@@ -233157,7 +233157,7 @@ static int fts5StorageInsertDocsize(
       sqlite3_bind_blob(pReplace, 2, pBuf->p, pBuf->n, SQLITE_STATIC);
       sqlite3_step(pReplace);
       rc = sqlite3_reset(pReplace);
-      sqlite3_bind_null(pReplace, 2);
+      sqlite3_bind_null(pReplace, 2); 
     }
   }
   return rc;
@@ -233288,7 +233288,7 @@ static int sqlite3Fts5StorageRebuild(Fts5Storage *p){
   Fts5Config *pConfig = p->pConfig;
   sqlite3_stmt *pScan = 0;
   Fts5InsertCtx ctx;
-  int rc, rc2;
+  int rc, rc2; 
 
   memset(&ctx, 0, sizeof(Fts5InsertCtx));
   ctx.pStorage = p;
@@ -233328,8 +233328,8 @@ static int sqlite3Fts5StorageRebuild(Fts5Storage *p){
     }
   }
   sqlite3_free(buf.p);
-  rc2 = sqlite3_reset(pScan);
-  if( rc==SQLITE_OK ) rc = rc2;
+  rc2 = sqlite3_reset(pScan); 
+  if( rc==SQLITE_OK ) rc = rc2; 
 
   /* Write the averages record */
   if( rc==SQLITE_OK ){
@@ -233581,7 +233581,7 @@ static int sqlite3Fts5StorageIntegrity(Fts5Storage *p, int iArg){
 
   memset(&ctx, 0, sizeof(Fts5IntegrityCtx));
   ctx.pConfig = p->pConfig;
-  aTotalSize = (i64*)sqlite3_malloc64(pConfig->nCol*(sizeof(int)+sizeof(i64)));
+  aTotalSize = (i64*)sqlite3_malloc64(pConfig->nCol*(sizeof(int)+sizeof(i64))); 
   if( !aTotalSize ) return SQLITE_NOMEM;
   aColSize = (int*)&aTotalSize[pConfig->nCol];
   memset(aTotalSize, 0, sizeof(i64) * pConfig->nCol);
@@ -233791,12 +233791,12 @@ static int sqlite3Fts5StorageRowCount(Fts5Storage *p, i64 *pnRow){
   int rc = fts5StorageLoadTotals(p, 0);
   if( rc==SQLITE_OK ){
     /* nTotalRow being zero does not necessarily indicate a corrupt
-    ** database - it might be that the FTS5 table really does contain zero
-    ** rows. However this function is only called from the xRowCount() API,
-    ** and there is no way for that API to be invoked if the table contains
-    ** no rows. Hence the FTS5_CORRUPT return.  */
+    ** database - it might be that the FTS5 table really does contain zero 
+    ** rows. However this function is only called from the xRowCount() API, 
+    ** and there is no way for that API to be invoked if the table contains 
+    ** no rows. Hence the FTS5_CORRUPT return.  */ 
     *pnRow = p->nTotalRow;
-    if( p->nTotalRow<=0 ) rc = FTS5_CORRUPT;
+    if( p->nTotalRow<=0 ) rc = FTS5_CORRUPT; 
   }
   return rc;
 }
@@ -233840,7 +233840,7 @@ static int sqlite3Fts5StorageConfigValue(
     }
     sqlite3_step(pReplace);
     rc = sqlite3_reset(pReplace);
-    sqlite3_bind_null(pReplace, 1);
+    sqlite3_bind_null(pReplace, 1); 
   }
   if( rc==SQLITE_OK && pVal ){
     int iNew = p->pConfig->iCookie + 1;
@@ -234006,7 +234006,7 @@ static int fts5AsciiTokenize(
     nByte = ie-is;
     if( nByte>nFold ){
       if( pFold!=aFold ) sqlite3_free(pFold);
-      pFold = sqlite3_malloc64((sqlite3_int64)nByte*2);
+      pFold = sqlite3_malloc64((sqlite3_int64)nByte*2); 
       if( pFold==0 ){
         rc = SQLITE_NOMEM;
         break;
@@ -234088,18 +234088,18 @@ struct Unicode61Tokenizer {
   unsigned char aTokenChar[128];  /* ASCII range token characters */
   char *aFold;                    /* Buffer to fold text into */
   int nFold;                      /* Size of aFold[] in bytes */
-  int eRemoveDiacritic;           /* True if remove_diacritics=1 is set */
+  int eRemoveDiacritic;           /* True if remove_diacritics=1 is set */ 
   int nException;
   int *aiException;
-
-  unsigned char aCategory[32];    /* True for token char categories */
+ 
+  unsigned char aCategory[32];    /* True for token char categories */ 
 };
 
-/* Values for eRemoveDiacritic (must match internals of fts5_unicode2.c) */
-#define FTS5_REMOVE_DIACRITICS_NONE    0
-#define FTS5_REMOVE_DIACRITICS_SIMPLE  1
-#define FTS5_REMOVE_DIACRITICS_COMPLEX 2
-
+/* Values for eRemoveDiacritic (must match internals of fts5_unicode2.c) */ 
+#define FTS5_REMOVE_DIACRITICS_NONE    0 
+#define FTS5_REMOVE_DIACRITICS_SIMPLE  1 
+#define FTS5_REMOVE_DIACRITICS_COMPLEX 2 
+ 
 static int fts5UnicodeAddExceptions(
   Unicode61Tokenizer *p,          /* Tokenizer object */
   const char *z,                  /* Characters to treat as exceptions */
@@ -234110,26 +234110,26 @@ static int fts5UnicodeAddExceptions(
   int *aNew;
 
   if( n>0 ){
-    aNew = (int*)sqlite3_realloc64(p->aiException,
-                                   (n+p->nException)*sizeof(int));
+    aNew = (int*)sqlite3_realloc64(p->aiException, 
+                                   (n+p->nException)*sizeof(int)); 
     if( aNew ){
       int nNew = p->nException;
       const unsigned char *zCsr = (const unsigned char*)z;
       const unsigned char *zTerm = (const unsigned char*)&z[n];
       while( zCsr<zTerm ){
-        u32 iCode;
+        u32 iCode; 
         int bToken;
         READ_UTF8(zCsr, zTerm, iCode);
         if( iCode<128 ){
           p->aTokenChar[iCode] = (unsigned char)bTokenChars;
         }else{
-          bToken = p->aCategory[sqlite3Fts5UnicodeCategory(iCode)];
+          bToken = p->aCategory[sqlite3Fts5UnicodeCategory(iCode)]; 
           assert( (bToken==0 || bToken==1) );
           assert( (bTokenChars==0 || bTokenChars==1) );
           if( bToken!=bTokenChars && sqlite3Fts5UnicodeIsdiacritic(iCode)==0 ){
             int i;
             for(i=0; i<nNew; i++){
-              if( (u32)aNew[i]>iCode ) break;
+              if( (u32)aNew[i]>iCode ) break; 
             }
             memmove(&aNew[i+1], &aNew[i], (nNew-i)*sizeof(int));
             aNew[i] = iCode;
@@ -234184,21 +234184,21 @@ static void fts5UnicodeDelete(Fts5Tokenizer *pTok){
   return;
 }
 
-static int unicodeSetCategories(Unicode61Tokenizer *p, const char *zCat){
-  const char *z = zCat;
-
-  while( *z ){
-    while( *z==' ' || *z=='\t' ) z++;
-    if( *z && sqlite3Fts5UnicodeCatParse(z, p->aCategory) ){
-      return SQLITE_ERROR;
-    }
-    while( *z!=' ' && *z!='\t' && *z!='\0' ) z++;
-  }
-
-  sqlite3Fts5UnicodeAscii(p->aCategory, p->aTokenChar);
-  return SQLITE_OK;
-}
-
+static int unicodeSetCategories(Unicode61Tokenizer *p, const char *zCat){ 
+  const char *z = zCat; 
+ 
+  while( *z ){ 
+    while( *z==' ' || *z=='\t' ) z++; 
+    if( *z && sqlite3Fts5UnicodeCatParse(z, p->aCategory) ){ 
+      return SQLITE_ERROR; 
+    } 
+    while( *z!=' ' && *z!='\t' && *z!='\0' ) z++; 
+  } 
+ 
+  sqlite3Fts5UnicodeAscii(p->aCategory, p->aTokenChar); 
+  return SQLITE_OK; 
+} 
+ 
 /*
 ** Create a "unicode61" tokenizer.
 */
@@ -234217,39 +234217,39 @@ static int fts5UnicodeCreate(
   }else{
     p = (Unicode61Tokenizer*)sqlite3_malloc(sizeof(Unicode61Tokenizer));
     if( p ){
-      const char *zCat = "L* N* Co";
+      const char *zCat = "L* N* Co"; 
       int i;
       memset(p, 0, sizeof(Unicode61Tokenizer));
-
-      p->eRemoveDiacritic = FTS5_REMOVE_DIACRITICS_SIMPLE;
+ 
+      p->eRemoveDiacritic = FTS5_REMOVE_DIACRITICS_SIMPLE; 
       p->nFold = 64;
-      p->aFold = sqlite3_malloc64(p->nFold * sizeof(char));
+      p->aFold = sqlite3_malloc64(p->nFold * sizeof(char)); 
       if( p->aFold==0 ){
         rc = SQLITE_NOMEM;
       }
-
-      /* Search for a "categories" argument */
-      for(i=0; rc==SQLITE_OK && i<nArg; i+=2){
-        if( 0==sqlite3_stricmp(azArg[i], "categories") ){
-          zCat = azArg[i+1];
-        }
-      }
-
-      if( rc==SQLITE_OK ){
-        rc = unicodeSetCategories(p, zCat);
-      }
-
+ 
+      /* Search for a "categories" argument */ 
       for(i=0; rc==SQLITE_OK && i<nArg; i+=2){
+        if( 0==sqlite3_stricmp(azArg[i], "categories") ){ 
+          zCat = azArg[i+1]; 
+        } 
+      } 
+ 
+      if( rc==SQLITE_OK ){ 
+        rc = unicodeSetCategories(p, zCat); 
+      } 
+ 
+      for(i=0; rc==SQLITE_OK && i<nArg; i+=2){ 
         const char *zArg = azArg[i+1];
         if( 0==sqlite3_stricmp(azArg[i], "remove_diacritics") ){
-          if( (zArg[0]!='0' && zArg[0]!='1' && zArg[0]!='2') || zArg[1] ){
+          if( (zArg[0]!='0' && zArg[0]!='1' && zArg[0]!='2') || zArg[1] ){ 
             rc = SQLITE_ERROR;
-          }else{
-            p->eRemoveDiacritic = (zArg[0] - '0');
-            assert( p->eRemoveDiacritic==FTS5_REMOVE_DIACRITICS_NONE
-                 || p->eRemoveDiacritic==FTS5_REMOVE_DIACRITICS_SIMPLE
-                 || p->eRemoveDiacritic==FTS5_REMOVE_DIACRITICS_COMPLEX
-            );
+          }else{ 
+            p->eRemoveDiacritic = (zArg[0] - '0'); 
+            assert( p->eRemoveDiacritic==FTS5_REMOVE_DIACRITICS_NONE 
+                 || p->eRemoveDiacritic==FTS5_REMOVE_DIACRITICS_SIMPLE 
+                 || p->eRemoveDiacritic==FTS5_REMOVE_DIACRITICS_COMPLEX 
+            ); 
           }
         }else
         if( 0==sqlite3_stricmp(azArg[i], "tokenchars") ){
@@ -234257,14 +234257,14 @@ static int fts5UnicodeCreate(
         }else
         if( 0==sqlite3_stricmp(azArg[i], "separators") ){
           rc = fts5UnicodeAddExceptions(p, zArg, 0);
-        }else
-        if( 0==sqlite3_stricmp(azArg[i], "categories") ){
-          /* no-op */
+        }else 
+        if( 0==sqlite3_stricmp(azArg[i], "categories") ){ 
+          /* no-op */ 
         }else{
           rc = SQLITE_ERROR;
         }
       }
-
+ 
     }else{
       rc = SQLITE_NOMEM;
     }
@@ -234283,10 +234283,10 @@ static int fts5UnicodeCreate(
 ** character (not a separator).
 */
 static int fts5UnicodeIsAlnum(Unicode61Tokenizer *p, int iCode){
-  return (
-    p->aCategory[sqlite3Fts5UnicodeCategory((u32)iCode)]
-    ^ fts5UnicodeIsException(p, iCode)
-  );
+  return ( 
+    p->aCategory[sqlite3Fts5UnicodeCategory((u32)iCode)] 
+    ^ fts5UnicodeIsException(p, iCode) 
+  ); 
 }
 
 static int fts5UnicodeTokenize(
@@ -234313,7 +234313,7 @@ static int fts5UnicodeTokenize(
   /* Each iteration of this loop gobbles up a contiguous run of separators,
   ** then the next token.  */
   while( rc==SQLITE_OK ){
-    u32 iCode;                    /* non-ASCII codepoint read from input */
+    u32 iCode;                    /* non-ASCII codepoint read from input */ 
     char *zOut = aFold;
     int is;
     int ie;
@@ -234345,7 +234345,7 @@ static int fts5UnicodeTokenize(
       /* Grow the output buffer so that there is sufficient space to fit the
       ** largest possible utf-8 character.  */
       if( zOut>pEnd ){
-        aFold = sqlite3_malloc64((sqlite3_int64)nFold*2);
+        aFold = sqlite3_malloc64((sqlite3_int64)nFold*2); 
         if( aFold==0 ){
           rc = SQLITE_NOMEM;
           goto tokenize_done;
@@ -234364,7 +234364,7 @@ static int fts5UnicodeTokenize(
         READ_UTF8(zCsr, zTerm, iCode);
         if( fts5UnicodeIsAlnum(p,iCode)||sqlite3Fts5UnicodeIsdiacritic(iCode) ){
  non_ascii_tokenchar:
-          iCode = sqlite3Fts5UnicodeFold(iCode, p->eRemoveDiacritic);
+          iCode = sqlite3Fts5UnicodeFold(iCode, p->eRemoveDiacritic); 
           if( iCode ) WRITE_UTF8(zOut, iCode);
         }else{
           break;
@@ -235269,7 +235269,7 @@ static int sqlite3Fts5TokenizerInit(fts5_api *pApi){
 }
 
 /*
-** 2012-05-25
+** 2012-05-25 
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
@@ -235298,7 +235298,7 @@ static int sqlite3Fts5TokenizerInit(fts5_api *pApi){
 ** E"). The resuls of passing a codepoint that corresponds to an
 ** uppercase letter are undefined.
 */
-static int fts5_remove_diacritic(int c, int bComplex){
+static int fts5_remove_diacritic(int c, int bComplex){ 
   unsigned short aDia[] = {
         0,  1797,  1848,  1859,  1891,  1928,  1940,  1995,
      2024,  2040,  2060,  2110,  2168,  2206,  2264,  2286,
@@ -235317,8 +235317,8 @@ static int fts5_remove_diacritic(int c, int bComplex){
     62830, 62890, 62924, 62974, 63032, 63050, 63082, 63118,
     63182, 63242, 63274, 63310, 63368, 63390,
   };
-#define HIBIT ((unsigned char)0x80)
-  unsigned char aChar[] = {
+#define HIBIT ((unsigned char)0x80) 
+  unsigned char aChar[] = { 
     '\0',      'a',       'c',       'e',       'i',       'n',
     'o',       'u',       'y',       'y',       'a',       'c',
     'd',       'e',       'e',       'g',       'h',       'i',
@@ -235356,8 +235356,8 @@ static int fts5_remove_diacritic(int c, int bComplex){
     }
   }
   assert( key>=aDia[iRes] );
-  if( bComplex==0 && (aChar[iRes] & 0x80) ) return c;
-  return (c > (aDia[iRes]>>3) + (aDia[iRes]&0x07)) ? c : ((int)aChar[iRes] & 0x7F);
+  if( bComplex==0 && (aChar[iRes] & 0x80) ) return c; 
+  return (c > (aDia[iRes]>>3) + (aDia[iRes]&0x07)) ? c : ((int)aChar[iRes] & 0x7F); 
 }
 
 
@@ -235370,8 +235370,8 @@ static int sqlite3Fts5UnicodeIsdiacritic(int c){
   unsigned int mask1 = 0x000361F8;
   if( c<768 || c>817 ) return 0;
   return (c < 768+32) ?
-      (mask0 & ((unsigned int)1 << (c-768))) :
-      (mask1 & ((unsigned int)1 << (c-768-32)));
+      (mask0 & ((unsigned int)1 << (c-768))) : 
+      (mask1 & ((unsigned int)1 << (c-768-32))); 
 }
 
 
@@ -235384,7 +235384,7 @@ static int sqlite3Fts5UnicodeIsdiacritic(int c){
 ** The results are undefined if the value passed to this function
 ** is less than zero.
 */
-static int sqlite3Fts5UnicodeFold(int c, int eRemoveDiacritic){
+static int sqlite3Fts5UnicodeFold(int c, int eRemoveDiacritic){ 
   /* Each entry in the following array defines a rule for folding a range
   ** of codepoints to lower case. The rule applies to a range of nRange
   ** codepoints starting at codepoint iCode.
@@ -235507,9 +235507,9 @@ static int sqlite3Fts5UnicodeFold(int c, int eRemoveDiacritic){
       assert( ret>0 );
     }
 
-    if( eRemoveDiacritic ){
-      ret = fts5_remove_diacritic(ret, eRemoveDiacritic==2);
-    }
+    if( eRemoveDiacritic ){ 
+      ret = fts5_remove_diacritic(ret, eRemoveDiacritic==2); 
+    } 
   }
 
   else if( c>=66560 && c<66600 ){
@@ -235519,130 +235519,130 @@ static int sqlite3Fts5UnicodeFold(int c, int eRemoveDiacritic){
   return ret;
 }
 
-
+ 
 static int sqlite3Fts5UnicodeCatParse(const char *zCat, u8 *aArray){
-  aArray[0] = 1;
-  switch( zCat[0] ){
-    case 'C':
-          switch( zCat[1] ){
-            case 'c': aArray[1] = 1; break;
-            case 'f': aArray[2] = 1; break;
-            case 'n': aArray[3] = 1; break;
-            case 's': aArray[4] = 1; break;
-            case 'o': aArray[31] = 1; break;
+  aArray[0] = 1; 
+  switch( zCat[0] ){ 
+    case 'C': 
+          switch( zCat[1] ){ 
+            case 'c': aArray[1] = 1; break; 
+            case 'f': aArray[2] = 1; break; 
+            case 'n': aArray[3] = 1; break; 
+            case 's': aArray[4] = 1; break; 
+            case 'o': aArray[31] = 1; break; 
             case '*':
-              aArray[1] = 1;
-              aArray[2] = 1;
-              aArray[3] = 1;
-              aArray[4] = 1;
-              aArray[31] = 1;
-              break;
-            default: return 1;          }
-          break;
-
-    case 'L':
-          switch( zCat[1] ){
-            case 'l': aArray[5] = 1; break;
-            case 'm': aArray[6] = 1; break;
-            case 'o': aArray[7] = 1; break;
-            case 't': aArray[8] = 1; break;
-            case 'u': aArray[9] = 1; break;
-            case 'C': aArray[30] = 1; break;
+              aArray[1] = 1; 
+              aArray[2] = 1; 
+              aArray[3] = 1; 
+              aArray[4] = 1; 
+              aArray[31] = 1; 
+              break; 
+            default: return 1;          } 
+          break; 
+ 
+    case 'L': 
+          switch( zCat[1] ){ 
+            case 'l': aArray[5] = 1; break; 
+            case 'm': aArray[6] = 1; break; 
+            case 'o': aArray[7] = 1; break; 
+            case 't': aArray[8] = 1; break; 
+            case 'u': aArray[9] = 1; break; 
+            case 'C': aArray[30] = 1; break; 
             case '*':
-              aArray[5] = 1;
-              aArray[6] = 1;
-              aArray[7] = 1;
-              aArray[8] = 1;
-              aArray[9] = 1;
-              aArray[30] = 1;
-              break;
-            default: return 1;          }
-          break;
-
-    case 'M':
-          switch( zCat[1] ){
-            case 'c': aArray[10] = 1; break;
-            case 'e': aArray[11] = 1; break;
-            case 'n': aArray[12] = 1; break;
+              aArray[5] = 1; 
+              aArray[6] = 1; 
+              aArray[7] = 1; 
+              aArray[8] = 1; 
+              aArray[9] = 1; 
+              aArray[30] = 1; 
+              break; 
+            default: return 1;          } 
+          break; 
+ 
+    case 'M': 
+          switch( zCat[1] ){ 
+            case 'c': aArray[10] = 1; break; 
+            case 'e': aArray[11] = 1; break; 
+            case 'n': aArray[12] = 1; break; 
             case '*':
-              aArray[10] = 1;
-              aArray[11] = 1;
-              aArray[12] = 1;
-              break;
-            default: return 1;          }
-          break;
-
-    case 'N':
-          switch( zCat[1] ){
-            case 'd': aArray[13] = 1; break;
-            case 'l': aArray[14] = 1; break;
-            case 'o': aArray[15] = 1; break;
+              aArray[10] = 1; 
+              aArray[11] = 1; 
+              aArray[12] = 1; 
+              break; 
+            default: return 1;          } 
+          break; 
+ 
+    case 'N': 
+          switch( zCat[1] ){ 
+            case 'd': aArray[13] = 1; break; 
+            case 'l': aArray[14] = 1; break; 
+            case 'o': aArray[15] = 1; break; 
             case '*':
-              aArray[13] = 1;
-              aArray[14] = 1;
-              aArray[15] = 1;
-              break;
-            default: return 1;          }
-          break;
-
-    case 'P':
-          switch( zCat[1] ){
-            case 'c': aArray[16] = 1; break;
-            case 'd': aArray[17] = 1; break;
-            case 'e': aArray[18] = 1; break;
-            case 'f': aArray[19] = 1; break;
-            case 'i': aArray[20] = 1; break;
-            case 'o': aArray[21] = 1; break;
-            case 's': aArray[22] = 1; break;
+              aArray[13] = 1; 
+              aArray[14] = 1; 
+              aArray[15] = 1; 
+              break; 
+            default: return 1;          } 
+          break; 
+ 
+    case 'P': 
+          switch( zCat[1] ){ 
+            case 'c': aArray[16] = 1; break; 
+            case 'd': aArray[17] = 1; break; 
+            case 'e': aArray[18] = 1; break; 
+            case 'f': aArray[19] = 1; break; 
+            case 'i': aArray[20] = 1; break; 
+            case 'o': aArray[21] = 1; break; 
+            case 's': aArray[22] = 1; break; 
             case '*':
-              aArray[16] = 1;
-              aArray[17] = 1;
-              aArray[18] = 1;
-              aArray[19] = 1;
-              aArray[20] = 1;
-              aArray[21] = 1;
-              aArray[22] = 1;
-              break;
-            default: return 1;          }
-          break;
-
-    case 'S':
-          switch( zCat[1] ){
-            case 'c': aArray[23] = 1; break;
-            case 'k': aArray[24] = 1; break;
-            case 'm': aArray[25] = 1; break;
-            case 'o': aArray[26] = 1; break;
+              aArray[16] = 1; 
+              aArray[17] = 1; 
+              aArray[18] = 1; 
+              aArray[19] = 1; 
+              aArray[20] = 1; 
+              aArray[21] = 1; 
+              aArray[22] = 1; 
+              break; 
+            default: return 1;          } 
+          break; 
+ 
+    case 'S': 
+          switch( zCat[1] ){ 
+            case 'c': aArray[23] = 1; break; 
+            case 'k': aArray[24] = 1; break; 
+            case 'm': aArray[25] = 1; break; 
+            case 'o': aArray[26] = 1; break; 
             case '*':
-              aArray[23] = 1;
-              aArray[24] = 1;
-              aArray[25] = 1;
-              aArray[26] = 1;
-              break;
-            default: return 1;          }
-          break;
-
-    case 'Z':
-          switch( zCat[1] ){
-            case 'l': aArray[27] = 1; break;
-            case 'p': aArray[28] = 1; break;
-            case 's': aArray[29] = 1; break;
+              aArray[23] = 1; 
+              aArray[24] = 1; 
+              aArray[25] = 1; 
+              aArray[26] = 1; 
+              break; 
+            default: return 1;          } 
+          break; 
+ 
+    case 'Z': 
+          switch( zCat[1] ){ 
+            case 'l': aArray[27] = 1; break; 
+            case 'p': aArray[28] = 1; break; 
+            case 's': aArray[29] = 1; break; 
             case '*':
-              aArray[27] = 1;
-              aArray[28] = 1;
-              aArray[29] = 1;
-              break;
-            default: return 1;          }
-          break;
-
-  }
-  return 0;
-}
-
-static u16 aFts5UnicodeBlock[] = {
+              aArray[27] = 1; 
+              aArray[28] = 1; 
+              aArray[29] = 1; 
+              break; 
+            default: return 1;          } 
+          break; 
+ 
+  } 
+  return 0; 
+} 
+ 
+static u16 aFts5UnicodeBlock[] = { 
     0,     1471,  1753,  1760,  1760,  1760,  1760,  1760,  1760,  1760,
     1760,  1760,  1760,  1760,  1760,  1763,  1765,
-  };
-static u16 aFts5UnicodeMap[] = {
+  }; 
+static u16 aFts5UnicodeMap[] = { 
     0,     32,    33,    36,    37,    40,    41,    42,    43,    44,
     45,    46,    48,    58,    60,    63,    65,    91,    92,    93,
     94,    95,    96,    97,    123,   124,   125,   126,   127,   160,
@@ -235820,8 +235820,8 @@ static u16 aFts5UnicodeMap[] = {
     62406, 62432, 62464, 62528, 62530, 62713, 62720, 62784, 62800, 62971,
     63045, 63104, 63232, 0,     42710, 42752, 46900, 46912, 47133, 63488,
     1,     32,    256,   0,     65533,
-  };
-static u16 aFts5UnicodeData[] = {
+  }; 
+static u16 aFts5UnicodeData[] = { 
     1025,  61,    117,   55,    117,   54,    50,    53,    57,    53,
     49,    85,    333,   85,    121,   85,    841,   54,    53,    50,
     56,    48,    56,    837,   54,    57,    50,    57,    1057,  61,
@@ -235999,53 +235999,53 @@ static u16 aFts5UnicodeData[] = {
     186,   570,   2042,  58,    5850,  154,   2010,  154,   794,   2266,
     378,   2266,  3738,  39,    39,    39,    39,    39,    39,    17351,
     34,    3074,  7692,  63,    63,
-  };
-
+  }; 
+ 
 static int sqlite3Fts5UnicodeCategory(u32 iCode) {
-  int iRes = -1;
-  int iHi;
-  int iLo;
-  int ret;
-  u16 iKey;
-
-  if( iCode>=(1<<20) ){
-    return 0;
-  }
-  iLo = aFts5UnicodeBlock[(iCode>>16)];
-  iHi = aFts5UnicodeBlock[1+(iCode>>16)];
-  iKey = (iCode & 0xFFFF);
-  while( iHi>iLo ){
-    int iTest = (iHi + iLo) / 2;
-    assert( iTest>=iLo && iTest<iHi );
-    if( iKey>=aFts5UnicodeMap[iTest] ){
-      iRes = iTest;
-      iLo = iTest+1;
-    }else{
-      iHi = iTest;
-    }
-  }
-
-  if( iRes<0 ) return 0;
-  if( iKey>=(aFts5UnicodeMap[iRes]+(aFts5UnicodeData[iRes]>>5)) ) return 0;
-  ret = aFts5UnicodeData[iRes] & 0x1F;
-  if( ret!=30 ) return ret;
-  return ((iKey - aFts5UnicodeMap[iRes]) & 0x01) ? 5 : 9;
-}
-
-static void sqlite3Fts5UnicodeAscii(u8 *aArray, u8 *aAscii){
-  int i = 0;
-  int iTbl = 0;
-  while( i<128 ){
-    int bToken = aArray[ aFts5UnicodeData[iTbl] & 0x1F ];
-    int n = (aFts5UnicodeData[iTbl] >> 5) + i;
-    for(; i<128 && i<n; i++){
-      aAscii[i] = (u8)bToken;
-    }
-    iTbl++;
-  }
+  int iRes = -1; 
+  int iHi; 
+  int iLo; 
+  int ret; 
+  u16 iKey; 
+ 
+  if( iCode>=(1<<20) ){ 
+    return 0; 
+  } 
+  iLo = aFts5UnicodeBlock[(iCode>>16)]; 
+  iHi = aFts5UnicodeBlock[1+(iCode>>16)]; 
+  iKey = (iCode & 0xFFFF); 
+  while( iHi>iLo ){ 
+    int iTest = (iHi + iLo) / 2; 
+    assert( iTest>=iLo && iTest<iHi ); 
+    if( iKey>=aFts5UnicodeMap[iTest] ){ 
+      iRes = iTest; 
+      iLo = iTest+1; 
+    }else{ 
+      iHi = iTest; 
+    } 
+  } 
+ 
+  if( iRes<0 ) return 0; 
+  if( iKey>=(aFts5UnicodeMap[iRes]+(aFts5UnicodeData[iRes]>>5)) ) return 0; 
+  ret = aFts5UnicodeData[iRes] & 0x1F; 
+  if( ret!=30 ) return ret; 
+  return ((iKey - aFts5UnicodeMap[iRes]) & 0x01) ? 5 : 9; 
+} 
+ 
+static void sqlite3Fts5UnicodeAscii(u8 *aArray, u8 *aAscii){ 
+  int i = 0; 
+  int iTbl = 0; 
+  while( i<128 ){ 
+    int bToken = aArray[ aFts5UnicodeData[iTbl] & 0x1F ]; 
+    int n = (aFts5UnicodeData[iTbl] >> 5) + i; 
+    for(; i<128 && i<n; i++){ 
+      aAscii[i] = (u8)bToken; 
+    } 
+    iTbl++; 
+  } 
   aAscii[0] = 0;                  /* 0x00 is never a token character */
-}
-
+} 
+ 
 
 /*
 ** 2015 May 30
@@ -236125,7 +236125,7 @@ static int sqlite3Fts5GetVarint32(const unsigned char *p, u32 *v){
     u8 n;
     p -= 2;
     n = sqlite3Fts5GetVarint(p, &v64);
-    *v = ((u32)v64) & 0x7FFFFFFF;
+    *v = ((u32)v64) & 0x7FFFFFFF; 
     assert( n>3 && n<=9 );
     return n;
   }
@@ -236450,7 +236450,7 @@ struct Fts5VocabTable {
 struct Fts5VocabCursor {
   sqlite3_vtab_cursor base;
   sqlite3_stmt *pStmt;            /* Statement holding lock on pIndex */
-  Fts5Table *pFts5;               /* Associated FTS5 table */
+  Fts5Table *pFts5;               /* Associated FTS5 table */ 
 
   int bEof;                       /* True if this cursor is at EOF */
   Fts5IndexIter *pIter;           /* Term/rowid iterator object */
@@ -236722,7 +236722,7 @@ static int fts5VocabOpenMethod(
   sqlite3_vtab_cursor **ppCsr
 ){
   Fts5VocabTable *pTab = (Fts5VocabTable*)pVTab;
-  Fts5Table *pFts5 = 0;
+  Fts5Table *pFts5 = 0; 
   Fts5VocabCursor *pCsr = 0;
   int rc = SQLITE_OK;
   sqlite3_stmt *pStmt = 0;
@@ -236748,22 +236748,22 @@ static int fts5VocabOpenMethod(
   pTab->bBusy = 1;
   if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
     i64 iId = sqlite3_column_int64(pStmt, 0);
-    pFts5 = sqlite3Fts5TableFromCsrid(pTab->pGlobal, iId);
+    pFts5 = sqlite3Fts5TableFromCsrid(pTab->pGlobal, iId); 
   }
   pTab->bBusy = 0;
 
-  if( rc==SQLITE_OK ){
-    if( pFts5==0 ){
-      rc = sqlite3_finalize(pStmt);
-      pStmt = 0;
-      if( rc==SQLITE_OK ){
-        pVTab->zErrMsg = sqlite3_mprintf(
-            "no such fts5 table: %s.%s", pTab->zFts5Db, pTab->zFts5Tbl
-            );
-        rc = SQLITE_ERROR;
-      }
-    }else{
-      rc = sqlite3Fts5FlushToDisk(pFts5);
+  if( rc==SQLITE_OK ){ 
+    if( pFts5==0 ){ 
+      rc = sqlite3_finalize(pStmt); 
+      pStmt = 0; 
+      if( rc==SQLITE_OK ){ 
+        pVTab->zErrMsg = sqlite3_mprintf( 
+            "no such fts5 table: %s.%s", pTab->zFts5Db, pTab->zFts5Tbl 
+            ); 
+        rc = SQLITE_ERROR; 
+      } 
+    }else{ 
+      rc = sqlite3Fts5FlushToDisk(pFts5); 
     }
   }
 
@@ -236773,10 +236773,10 @@ static int fts5VocabOpenMethod(
   }
 
   if( pCsr ){
-    pCsr->pFts5 = pFts5;
+    pCsr->pFts5 = pFts5; 
     pCsr->pStmt = pStmt;
     pCsr->aCnt = (i64*)&pCsr[1];
-    pCsr->aDoc = &pCsr->aCnt[pFts5->pConfig->nCol];
+    pCsr->aDoc = &pCsr->aCnt[pFts5->pConfig->nCol]; 
   }else{
     sqlite3_finalize(pStmt);
   }
@@ -236794,7 +236794,7 @@ static void fts5VocabResetCursor(Fts5VocabCursor *pCsr){
   sqlite3_free(pCsr->zLeTerm);
   pCsr->nLeTerm = -1;
   pCsr->zLeTerm = 0;
-  pCsr->bEof = 0;
+  pCsr->bEof = 0; 
 }
 
 /*
@@ -236833,14 +236833,14 @@ static int fts5VocabInstanceNewTerm(Fts5VocabCursor *pCsr){
 }
 
 static int fts5VocabInstanceNext(Fts5VocabCursor *pCsr){
-  int eDetail = pCsr->pFts5->pConfig->eDetail;
+  int eDetail = pCsr->pFts5->pConfig->eDetail; 
   int rc = SQLITE_OK;
   Fts5IndexIter *pIter = pCsr->pIter;
   i64 *pp = &pCsr->iInstPos;
   int *po = &pCsr->iInstOff;
 
-  assert( sqlite3Fts5IterEof(pIter)==0 );
-  assert( pCsr->bEof==0 );
+  assert( sqlite3Fts5IterEof(pIter)==0 ); 
+  assert( pCsr->bEof==0 ); 
   while( eDetail==FTS5_DETAIL_NONE
       || sqlite3Fts5PoslistNext64(pIter->pData, pIter->nData, po, pp)
   ){
@@ -236850,7 +236850,7 @@ static int fts5VocabInstanceNext(Fts5VocabCursor *pCsr){
     rc = sqlite3Fts5IterNextScan(pCsr->pIter);
     if( rc==SQLITE_OK ){
       rc = fts5VocabInstanceNewTerm(pCsr);
-      if( pCsr->bEof || eDetail==FTS5_DETAIL_NONE ) break;
+      if( pCsr->bEof || eDetail==FTS5_DETAIL_NONE ) break; 
     }
     if( rc ){
       pCsr->bEof = 1;
@@ -236867,7 +236867,7 @@ static int fts5VocabInstanceNext(Fts5VocabCursor *pCsr){
 static int fts5VocabNextMethod(sqlite3_vtab_cursor *pCursor){
   Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
   Fts5VocabTable *pTab = (Fts5VocabTable*)pCursor->pVtab;
-  int nCol = pCsr->pFts5->pConfig->nCol;
+  int nCol = pCsr->pFts5->pConfig->nCol; 
   int rc;
 
   rc = sqlite3Fts5StructureTest(pCsr->pFts5->pIndex, pCsr->pStruct);
@@ -236892,7 +236892,7 @@ static int fts5VocabNextMethod(sqlite3_vtab_cursor *pCursor){
       int nTerm;
 
       zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
-      assert( nTerm>=0 );
+      assert( nTerm>=0 ); 
       if( pCsr->nLeTerm>=0 ){
         int nCmp = MIN(nTerm, pCsr->nLeTerm);
         int bCmp = memcmp(pCsr->zLeTerm, zTerm, nCmp);
@@ -236909,7 +236909,7 @@ static int fts5VocabNextMethod(sqlite3_vtab_cursor *pCursor){
 
       assert( pTab->eType==FTS5_VOCAB_COL || pTab->eType==FTS5_VOCAB_ROW );
       while( rc==SQLITE_OK ){
-        int eDetail = pCsr->pFts5->pConfig->eDetail;
+        int eDetail = pCsr->pFts5->pConfig->eDetail; 
         const u8 *pPos; int nPos;   /* Position list */
         i64 iPos = 0;               /* 64-bit position read from poslist */
         int iOff = 0;               /* Current offset within position list */
@@ -236940,7 +236940,7 @@ static int fts5VocabNextMethod(sqlite3_vtab_cursor *pCursor){
                   pCsr->aDoc[ii]++;
                   iCol = ii;
                 }
-                pCsr->aCnt[ii]++;
+                pCsr->aCnt[ii]++; 
               }
             }else if( eDetail==FTS5_DETAIL_COLUMNS ){
               while( 0==sqlite3Fts5PoslistNext64(pPos, nPos, &iOff,&iPos) ){
@@ -236971,7 +236971,7 @@ static int fts5VocabNextMethod(sqlite3_vtab_cursor *pCursor){
           zTerm = sqlite3Fts5IterTerm(pCsr->pIter, &nTerm);
           if( nTerm!=pCsr->term.n
           || (nTerm>0 && memcmp(zTerm, pCsr->term.p, nTerm))
-          ){
+          ){ 
             break;
           }
           if( sqlite3Fts5IterEof(pCsr->pIter) ) break;
@@ -236981,10 +236981,10 @@ static int fts5VocabNextMethod(sqlite3_vtab_cursor *pCursor){
   }
 
   if( rc==SQLITE_OK && pCsr->bEof==0 && pTab->eType==FTS5_VOCAB_COL ){
-    for(/* noop */; pCsr->iCol<nCol && pCsr->aDoc[pCsr->iCol]==0; pCsr->iCol++);
-    if( pCsr->iCol==nCol ){
-      rc = FTS5_CORRUPT;
-    }
+    for(/* noop */; pCsr->iCol<nCol && pCsr->aDoc[pCsr->iCol]==0; pCsr->iCol++); 
+    if( pCsr->iCol==nCol ){ 
+      rc = FTS5_CORRUPT; 
+    } 
   }
   return rc;
 }
@@ -237031,7 +237031,7 @@ static int fts5VocabFilterMethod(
     }
     if( pLe ){
       const char *zCopy = (const char *)sqlite3_value_text(pLe);
-      if( zCopy==0 ) zCopy = "";
+      if( zCopy==0 ) zCopy = ""; 
       pCsr->nLeTerm = sqlite3_value_bytes(pLe);
       pCsr->zLeTerm = sqlite3_malloc(pCsr->nLeTerm+1);
       if( pCsr->zLeTerm==0 ){
@@ -237043,8 +237043,8 @@ static int fts5VocabFilterMethod(
   }
 
   if( rc==SQLITE_OK ){
-    Fts5Index *pIndex = pCsr->pFts5->pIndex;
-    rc = sqlite3Fts5IndexQuery(pIndex, zTerm, nTerm, f, 0, &pCsr->pIter);
+    Fts5Index *pIndex = pCsr->pFts5->pIndex; 
+    rc = sqlite3Fts5IndexQuery(pIndex, zTerm, nTerm, f, 0, &pCsr->pIter); 
     if( rc==SQLITE_OK ){
       pCsr->pStruct = sqlite3Fts5StructureRef(pIndex);
     }
@@ -237054,7 +237054,7 @@ static int fts5VocabFilterMethod(
   }
   if( rc==SQLITE_OK && !pCsr->bEof
    && (eType!=FTS5_VOCAB_INSTANCE
-    || pCsr->pFts5->pConfig->eDetail!=FTS5_DETAIL_NONE)
+    || pCsr->pFts5->pConfig->eDetail!=FTS5_DETAIL_NONE) 
   ){
     rc = fts5VocabNextMethod(pCursor);
   }
@@ -237077,7 +237077,7 @@ static int fts5VocabColumnMethod(
   int iCol                        /* Index of column to read value from */
 ){
   Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
-  int eDetail = pCsr->pFts5->pConfig->eDetail;
+  int eDetail = pCsr->pFts5->pConfig->eDetail; 
   int eType = ((Fts5VocabTable*)(pCursor->pVtab))->eType;
   i64 iVal = 0;
 
@@ -237089,7 +237089,7 @@ static int fts5VocabColumnMethod(
     assert( iCol==1 || iCol==2 || iCol==3 );
     if( iCol==1 ){
       if( eDetail!=FTS5_DETAIL_NONE ){
-        const char *z = pCsr->pFts5->pConfig->azCol[pCsr->iCol];
+        const char *z = pCsr->pFts5->pConfig->azCol[pCsr->iCol]; 
         sqlite3_result_text(pCtx, z, -1, SQLITE_STATIC);
       }
     }else if( iCol==2 ){
@@ -237117,8 +237117,8 @@ static int fts5VocabColumnMethod(
         }else if( eDetail==FTS5_DETAIL_COLUMNS ){
           ii = (int)pCsr->iInstPos;
         }
-        if( ii>=0 && ii<pCsr->pFts5->pConfig->nCol ){
-          const char *z = pCsr->pFts5->pConfig->azCol[ii];
+        if( ii>=0 && ii<pCsr->pFts5->pConfig->nCol ){ 
+          const char *z = pCsr->pFts5->pConfig->azCol[ii]; 
           sqlite3_result_text(pCtx, z, -1, SQLITE_STATIC);
         }
         break;
@@ -237177,7 +237177,7 @@ static int sqlite3Fts5VocabInit(Fts5Global *pGlobal, sqlite3 *db){
     /* xSavepoint    */ 0,
     /* xRelease      */ 0,
     /* xRollbackTo   */ 0,
-    /* xShadowName   */ 0
+    /* xShadowName   */ 0 
   };
   void *p = (void*)pGlobal;
 
@@ -237459,7 +237459,7 @@ static sqlite3_module stmtModule = {
   0,                         /* xSavepoint */
   0,                         /* xRelease */
   0,                         /* xRollbackTo */
-  0,                         /* xShadowName */
+  0,                         /* xShadowName */ 
 };
 
 #endif /* SQLITE_OMIT_VIRTUALTABLE */
diff --git a/contrib/libs/sqlite3/sqlite3.h b/contrib/libs/sqlite3/sqlite3.h
index 4463e8ec13..bb8bf85f86 100644
--- a/contrib/libs/sqlite3/sqlite3.h
+++ b/contrib/libs/sqlite3/sqlite3.h
@@ -212,9 +212,9 @@ SQLITE_API int sqlite3_libversion_number(void);
 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
 SQLITE_API int sqlite3_compileoption_used(const char *zOptName);
 SQLITE_API const char *sqlite3_compileoption_get(int N);
-#else
-# define sqlite3_compileoption_used(X) 0
-# define sqlite3_compileoption_get(X)  ((void*)0)
+#else 
+# define sqlite3_compileoption_used(X) 0 
+# define sqlite3_compileoption_get(X)  ((void*)0) 
 #endif
 
 /*
@@ -494,7 +494,7 @@ SQLITE_API int sqlite3_exec(
 */
 #define SQLITE_ERROR_MISSING_COLLSEQ   (SQLITE_ERROR | (1<<8))
 #define SQLITE_ERROR_RETRY             (SQLITE_ERROR | (2<<8))
-#define SQLITE_ERROR_SNAPSHOT          (SQLITE_ERROR | (3<<8))
+#define SQLITE_ERROR_SNAPSHOT          (SQLITE_ERROR | (3<<8)) 
 #define SQLITE_IOERR_READ              (SQLITE_IOERR | (1<<8))
 #define SQLITE_IOERR_SHORT_READ        (SQLITE_IOERR | (2<<8))
 #define SQLITE_IOERR_WRITE             (SQLITE_IOERR | (3<<8))
@@ -529,7 +529,7 @@ SQLITE_API int sqlite3_exec(
 #define SQLITE_IOERR_DATA              (SQLITE_IOERR | (32<<8))
 #define SQLITE_IOERR_CORRUPTFS         (SQLITE_IOERR | (33<<8))
 #define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED |  (1<<8))
-#define SQLITE_LOCKED_VTAB             (SQLITE_LOCKED |  (2<<8))
+#define SQLITE_LOCKED_VTAB             (SQLITE_LOCKED |  (2<<8)) 
 #define SQLITE_BUSY_RECOVERY           (SQLITE_BUSY   |  (1<<8))
 #define SQLITE_BUSY_SNAPSHOT           (SQLITE_BUSY   |  (2<<8))
 #define SQLITE_BUSY_TIMEOUT            (SQLITE_BUSY   |  (3<<8))
@@ -537,10 +537,10 @@ SQLITE_API int sqlite3_exec(
 #define SQLITE_CANTOPEN_ISDIR          (SQLITE_CANTOPEN | (2<<8))
 #define SQLITE_CANTOPEN_FULLPATH       (SQLITE_CANTOPEN | (3<<8))
 #define SQLITE_CANTOPEN_CONVPATH       (SQLITE_CANTOPEN | (4<<8))
-#define SQLITE_CANTOPEN_DIRTYWAL       (SQLITE_CANTOPEN | (5<<8)) /* Not Used */
+#define SQLITE_CANTOPEN_DIRTYWAL       (SQLITE_CANTOPEN | (5<<8)) /* Not Used */ 
 #define SQLITE_CANTOPEN_SYMLINK        (SQLITE_CANTOPEN | (6<<8))
 #define SQLITE_CORRUPT_VTAB            (SQLITE_CORRUPT | (1<<8))
-#define SQLITE_CORRUPT_SEQUENCE        (SQLITE_CORRUPT | (2<<8))
+#define SQLITE_CORRUPT_SEQUENCE        (SQLITE_CORRUPT | (2<<8)) 
 #define SQLITE_CORRUPT_INDEX           (SQLITE_CORRUPT | (3<<8))
 #define SQLITE_READONLY_RECOVERY       (SQLITE_READONLY | (1<<8))
 #define SQLITE_READONLY_CANTLOCK       (SQLITE_READONLY | (2<<8))
@@ -871,15 +871,15 @@ struct sqlite3_io_methods {
 ** file space based on this hint in order to help writes to the database
 ** file run faster.
 **
-** <li>[[SQLITE_FCNTL_SIZE_LIMIT]]
-** The [SQLITE_FCNTL_SIZE_LIMIT] opcode is used by in-memory VFS that
-** implements [sqlite3_deserialize()] to set an upper bound on the size
-** of the in-memory database.  The argument is a pointer to a [sqlite3_int64].
-** If the integer pointed to is negative, then it is filled in with the
-** current limit.  Otherwise the limit is set to the larger of the value
-** of the integer pointed to and the current database size.  The integer
-** pointed to is set to the new limit.
-**
+** <li>[[SQLITE_FCNTL_SIZE_LIMIT]] 
+** The [SQLITE_FCNTL_SIZE_LIMIT] opcode is used by in-memory VFS that 
+** implements [sqlite3_deserialize()] to set an upper bound on the size 
+** of the in-memory database.  The argument is a pointer to a [sqlite3_int64]. 
+** If the integer pointed to is negative, then it is filled in with the 
+** current limit.  Otherwise the limit is set to the larger of the value 
+** of the integer pointed to and the current database size.  The integer 
+** pointed to is set to the new limit. 
+** 
 ** <li>[[SQLITE_FCNTL_CHUNK_SIZE]]
 ** The [SQLITE_FCNTL_CHUNK_SIZE] opcode is used to request that the VFS
 ** extends and truncates the database file in chunks of a size specified
@@ -945,8 +945,8 @@ struct sqlite3_io_methods {
 ** <li>[[SQLITE_FCNTL_PERSIST_WAL]]
 ** ^The [SQLITE_FCNTL_PERSIST_WAL] opcode is used to set or query the
 ** persistent [WAL | Write Ahead Log] setting.  By default, the auxiliary
-** write ahead log ([WAL file]) and shared memory
-** files used for transaction control
+** write ahead log ([WAL file]) and shared memory 
+** files used for transaction control 
 ** are automatically deleted when the latest connection to the database
 ** closes.  Setting persistent WAL mode causes those files to persist after
 ** close.  Persisting the files is useful when other processes that do not
@@ -1126,34 +1126,34 @@ struct sqlite3_io_methods {
 ** so that all subsequent write operations are independent.
 ** ^SQLite will never invoke SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE without
 ** a prior successful call to [SQLITE_FCNTL_BEGIN_ATOMIC_WRITE].
-**
-** <li>[[SQLITE_FCNTL_LOCK_TIMEOUT]]
+** 
+** <li>[[SQLITE_FCNTL_LOCK_TIMEOUT]] 
 ** The [SQLITE_FCNTL_LOCK_TIMEOUT] opcode is used to configure a VFS
 ** to block for up to M milliseconds before failing when attempting to
 ** obtain a file lock using the xLock or xShmLock methods of the VFS.
 ** The parameter is a pointer to a 32-bit signed integer that contains
 ** the value that M is to be set to. Before returning, the 32-bit signed
 ** integer is overwritten with the previous value of M.
-**
-** <li>[[SQLITE_FCNTL_DATA_VERSION]]
-** The [SQLITE_FCNTL_DATA_VERSION] opcode is used to detect changes to
-** a database file.  The argument is a pointer to a 32-bit unsigned integer.
-** The "data version" for the pager is written into the pointer.  The
-** "data version" changes whenever any change occurs to the corresponding
-** database file, either through SQL statements on the same database
-** connection or through transactions committed by separate database
-** connections possibly in other processes. The [sqlite3_total_changes()]
-** interface can be used to find if any database on the connection has changed,
-** but that interface responds to changes on TEMP as well as MAIN and does
-** not provide a mechanism to detect changes to MAIN only.  Also, the
-** [sqlite3_total_changes()] interface responds to internal changes only and
-** omits changes made by other database connections.  The
+** 
+** <li>[[SQLITE_FCNTL_DATA_VERSION]] 
+** The [SQLITE_FCNTL_DATA_VERSION] opcode is used to detect changes to 
+** a database file.  The argument is a pointer to a 32-bit unsigned integer. 
+** The "data version" for the pager is written into the pointer.  The 
+** "data version" changes whenever any change occurs to the corresponding 
+** database file, either through SQL statements on the same database 
+** connection or through transactions committed by separate database 
+** connections possibly in other processes. The [sqlite3_total_changes()] 
+** interface can be used to find if any database on the connection has changed, 
+** but that interface responds to changes on TEMP as well as MAIN and does 
+** not provide a mechanism to detect changes to MAIN only.  Also, the 
+** [sqlite3_total_changes()] interface responds to internal changes only and 
+** omits changes made by other database connections.  The 
 ** [PRAGMA data_version] command provides a mechanism to detect changes to
-** a single attached database that occur due to other database connections,
-** but omits changes implemented by the database connection on which it is
-** called.  This file control is the only mechanism to detect changes that
-** happen either internally or externally and that are associated with
-** a particular attached database.
+** a single attached database that occur due to other database connections, 
+** but omits changes implemented by the database connection on which it is 
+** called.  This file control is the only mechanism to detect changes that 
+** happen either internally or externally and that are associated with 
+** a particular attached database. 
 **
 ** <li>[[SQLITE_FCNTL_CKPT_START]]
 ** The [SQLITE_FCNTL_CKPT_START] opcode is invoked from within a checkpoint
@@ -1216,9 +1216,9 @@ struct sqlite3_io_methods {
 #define SQLITE_FCNTL_BEGIN_ATOMIC_WRITE     31
 #define SQLITE_FCNTL_COMMIT_ATOMIC_WRITE    32
 #define SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE  33
-#define SQLITE_FCNTL_LOCK_TIMEOUT           34
-#define SQLITE_FCNTL_DATA_VERSION           35
-#define SQLITE_FCNTL_SIZE_LIMIT             36
+#define SQLITE_FCNTL_LOCK_TIMEOUT           34 
+#define SQLITE_FCNTL_DATA_VERSION           35 
+#define SQLITE_FCNTL_SIZE_LIMIT             36 
 #define SQLITE_FCNTL_CKPT_DONE              37
 #define SQLITE_FCNTL_RESERVE_BYTES          38
 #define SQLITE_FCNTL_CKPT_START             39
@@ -1376,13 +1376,13 @@ typedef struct sqlite3_api_routines sqlite3_api_routines;
 ** ^The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS]
 ** to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to
 ** test whether a file is readable and writable, or [SQLITE_ACCESS_READ]
-** to test whether a file is at least readable.  The SQLITE_ACCESS_READ
-** flag is never actually used and is not implemented in the built-in
-** VFSes of SQLite.  The file is named by the second argument and can be a
-** directory. The xAccess method returns [SQLITE_OK] on success or some
-** non-zero error code if there is an I/O error or if the name of
-** the file given in the second argument is illegal.  If SQLITE_OK
-** is returned, then non-zero or zero is written into *pResOut to indicate
+** to test whether a file is at least readable.  The SQLITE_ACCESS_READ 
+** flag is never actually used and is not implemented in the built-in 
+** VFSes of SQLite.  The file is named by the second argument and can be a 
+** directory. The xAccess method returns [SQLITE_OK] on success or some 
+** non-zero error code if there is an I/O error or if the name of 
+** the file given in the second argument is illegal.  If SQLITE_OK 
+** is returned, then non-zero or zero is written into *pResOut to indicate 
 ** whether or not the file is accessible.
 **
 ** ^SQLite will always allocate at least mxPathname+1 bytes for the
@@ -2056,33 +2056,33 @@ struct sqlite3_mem_methods {
 ** I/O required to support statement rollback.
 ** The default value for this setting is controlled by the
 ** [SQLITE_STMTJRNL_SPILL] compile-time option.
-**
-** [[SQLITE_CONFIG_SORTERREF_SIZE]]
-** <dt>SQLITE_CONFIG_SORTERREF_SIZE
-** <dd>The SQLITE_CONFIG_SORTERREF_SIZE option accepts a single parameter
-** of type (int) - the new value of the sorter-reference size threshold.
-** Usually, when SQLite uses an external sort to order records according
-** to an ORDER BY clause, all fields required by the caller are present in the
-** sorted records. However, if SQLite determines based on the declared type
-** of a table column that its values are likely to be very large - larger
-** than the configured sorter-reference size threshold - then a reference
-** is stored in each sorted record and the required column values loaded
-** from the database as records are returned in sorted order. The default
+** 
+** [[SQLITE_CONFIG_SORTERREF_SIZE]] 
+** <dt>SQLITE_CONFIG_SORTERREF_SIZE 
+** <dd>The SQLITE_CONFIG_SORTERREF_SIZE option accepts a single parameter 
+** of type (int) - the new value of the sorter-reference size threshold. 
+** Usually, when SQLite uses an external sort to order records according 
+** to an ORDER BY clause, all fields required by the caller are present in the 
+** sorted records. However, if SQLite determines based on the declared type 
+** of a table column that its values are likely to be very large - larger 
+** than the configured sorter-reference size threshold - then a reference 
+** is stored in each sorted record and the required column values loaded 
+** from the database as records are returned in sorted order. The default 
 ** value for this option is to never use this optimization. Specifying a
-** negative value for this option restores the default behaviour.
-** This option is only available if SQLite is compiled with the
-** [SQLITE_ENABLE_SORTER_REFERENCES] compile-time option.
-**
-** [[SQLITE_CONFIG_MEMDB_MAXSIZE]]
-** <dt>SQLITE_CONFIG_MEMDB_MAXSIZE
-** <dd>The SQLITE_CONFIG_MEMDB_MAXSIZE option accepts a single parameter
-** [sqlite3_int64] parameter which is the default maximum size for an in-memory
-** database created using [sqlite3_deserialize()].  This default maximum
-** size can be adjusted up or down for individual databases using the
-** [SQLITE_FCNTL_SIZE_LIMIT] [sqlite3_file_control|file-control].  If this
-** configuration setting is never used, then the default maximum is determined
-** by the [SQLITE_MEMDB_DEFAULT_MAXSIZE] compile-time option.  If that
-** compile-time option is not set, then the default maximum is 1073741824.
+** negative value for this option restores the default behaviour. 
+** This option is only available if SQLite is compiled with the 
+** [SQLITE_ENABLE_SORTER_REFERENCES] compile-time option. 
+** 
+** [[SQLITE_CONFIG_MEMDB_MAXSIZE]] 
+** <dt>SQLITE_CONFIG_MEMDB_MAXSIZE 
+** <dd>The SQLITE_CONFIG_MEMDB_MAXSIZE option accepts a single parameter 
+** [sqlite3_int64] parameter which is the default maximum size for an in-memory 
+** database created using [sqlite3_deserialize()].  This default maximum 
+** size can be adjusted up or down for individual databases using the 
+** [SQLITE_FCNTL_SIZE_LIMIT] [sqlite3_file_control|file-control].  If this 
+** configuration setting is never used, then the default maximum is determined 
+** by the [SQLITE_MEMDB_DEFAULT_MAXSIZE] compile-time option.  If that 
+** compile-time option is not set, then the default maximum is 1073741824. 
 ** </dl>
 */
 #define SQLITE_CONFIG_SINGLETHREAD  1  /* nil */
@@ -2112,8 +2112,8 @@ struct sqlite3_mem_methods {
 #define SQLITE_CONFIG_PMASZ               25  /* unsigned int szPma */
 #define SQLITE_CONFIG_STMTJRNL_SPILL      26  /* int nByte */
 #define SQLITE_CONFIG_SMALL_MALLOC        27  /* boolean */
-#define SQLITE_CONFIG_SORTERREF_SIZE      28  /* int nByte */
-#define SQLITE_CONFIG_MEMDB_MAXSIZE       29  /* sqlite3_int64 */
+#define SQLITE_CONFIG_SORTERREF_SIZE      28  /* int nByte */ 
+#define SQLITE_CONFIG_MEMDB_MAXSIZE       29  /* sqlite3_int64 */ 
 
 /*
 ** CAPI3REF: Database Connection Configuration Options
@@ -2129,7 +2129,7 @@ struct sqlite3_mem_methods {
 ** is invoked.
 **
 ** <dl>
-** [[SQLITE_DBCONFIG_LOOKASIDE]]
+** [[SQLITE_DBCONFIG_LOOKASIDE]] 
 ** <dt>SQLITE_DBCONFIG_LOOKASIDE</dt>
 ** <dd> ^This option takes three additional arguments that determine the
 ** [lookaside memory allocator] configuration for the [database connection].
@@ -2152,7 +2152,7 @@ struct sqlite3_mem_methods {
 ** memory is in use leaves the configuration unchanged and returns
 ** [SQLITE_BUSY].)^</dd>
 **
-** [[SQLITE_DBCONFIG_ENABLE_FKEY]]
+** [[SQLITE_DBCONFIG_ENABLE_FKEY]] 
 ** <dt>SQLITE_DBCONFIG_ENABLE_FKEY</dt>
 ** <dd> ^This option is used to enable or disable the enforcement of
 ** [foreign key constraints].  There should be two additional arguments.
@@ -2163,7 +2163,7 @@ struct sqlite3_mem_methods {
 ** following this call.  The second parameter may be a NULL pointer, in
 ** which case the FK enforcement setting is not reported back. </dd>
 **
-** [[SQLITE_DBCONFIG_ENABLE_TRIGGER]]
+** [[SQLITE_DBCONFIG_ENABLE_TRIGGER]] 
 ** <dt>SQLITE_DBCONFIG_ENABLE_TRIGGER</dt>
 ** <dd> ^This option is used to enable or disable [CREATE TRIGGER | triggers].
 ** There should be two additional arguments.
@@ -2197,10 +2197,10 @@ struct sqlite3_mem_methods {
 ** views in the main database schema or in the schemas of ATTACH-ed
 ** databases.)^ </dd>
 **
-** [[SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER]]
+** [[SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER]] 
 ** <dt>SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER</dt>
-** <dd> ^This option is used to enable or disable the
-** [fts3_tokenizer()] function which is part of the
+** <dd> ^This option is used to enable or disable the 
+** [fts3_tokenizer()] function which is part of the 
 ** [FTS3] full-text search engine extension.
 ** There should be two additional arguments.
 ** The first argument is an integer which is 0 to disable fts3_tokenizer() or
@@ -2211,7 +2211,7 @@ struct sqlite3_mem_methods {
 ** following this call.  The second parameter may be a NULL pointer, in
 ** which case the new setting is not reported back. </dd>
 **
-** [[SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION]]
+** [[SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION]] 
 ** <dt>SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION</dt>
 ** <dd> ^This option is used to enable or disable the [sqlite3_load_extension()]
 ** interface independently of the [load_extension()] SQL function.
@@ -2229,7 +2229,7 @@ struct sqlite3_mem_methods {
 ** be a NULL pointer, in which case the new setting is not reported back.
 ** </dd>
 **
-** [[SQLITE_DBCONFIG_MAINDBNAME]] <dt>SQLITE_DBCONFIG_MAINDBNAME</dt>
+** [[SQLITE_DBCONFIG_MAINDBNAME]] <dt>SQLITE_DBCONFIG_MAINDBNAME</dt> 
 ** <dd> ^This option is used to change the name of the "main" database
 ** schema.  ^The sole argument is a pointer to a constant UTF8 string
 ** which will become the new schema name in place of "main".  ^SQLite
@@ -2245,14 +2245,14 @@ struct sqlite3_mem_methods {
 ** connections at all to the database. If so, it performs a checkpoint
 ** operation before closing the connection. This option may be used to
 ** override this behaviour. The first parameter passed to this operation
-** is an integer - positive to disable checkpoints-on-close, or zero (the
-** default) to enable them, and negative to leave the setting unchanged.
-** The second parameter is a pointer to an integer
+** is an integer - positive to disable checkpoints-on-close, or zero (the 
+** default) to enable them, and negative to leave the setting unchanged. 
+** The second parameter is a pointer to an integer 
 ** into which is written 0 or 1 to indicate whether checkpoints-on-close
 ** have been disabled - 0 if they are not disabled, 1 if they are.
 ** </dd>
-**
-** [[SQLITE_DBCONFIG_ENABLE_QPSG]] <dt>SQLITE_DBCONFIG_ENABLE_QPSG</dt>
+** 
+** [[SQLITE_DBCONFIG_ENABLE_QPSG]] <dt>SQLITE_DBCONFIG_ENABLE_QPSG</dt> 
 ** <dd>^(The SQLITE_DBCONFIG_ENABLE_QPSG option activates or deactivates
 ** the [query planner stability guarantee] (QPSG).  When the QPSG is active,
 ** a single SQL query statement will always use the same algorithm regardless
@@ -2262,96 +2262,96 @@ struct sqlite3_mem_methods {
 ** the QPSG active, SQLite will always use the same query plan in the field as
 ** was used during testing in the lab.
 ** The first argument to this setting is an integer which is 0 to disable
-** the QPSG, positive to enable QPSG, or negative to leave the setting
-** unchanged. The second parameter is a pointer to an integer into which
-** is written 0 or 1 to indicate whether the QPSG is disabled or enabled
-** following this call.
+** the QPSG, positive to enable QPSG, or negative to leave the setting 
+** unchanged. The second parameter is a pointer to an integer into which 
+** is written 0 or 1 to indicate whether the QPSG is disabled or enabled 
+** following this call. 
 ** </dd>
-**
-** [[SQLITE_DBCONFIG_TRIGGER_EQP]] <dt>SQLITE_DBCONFIG_TRIGGER_EQP</dt>
+** 
+** [[SQLITE_DBCONFIG_TRIGGER_EQP]] <dt>SQLITE_DBCONFIG_TRIGGER_EQP</dt> 
 ** <dd> By default, the output of EXPLAIN QUERY PLAN commands does not
 ** include output for any operations performed by trigger programs. This
 ** option is used to set or clear (the default) a flag that governs this
 ** behavior. The first parameter passed to this operation is an integer -
-** positive to enable output for trigger programs, or zero to disable it,
-** or negative to leave the setting unchanged.
+** positive to enable output for trigger programs, or zero to disable it, 
+** or negative to leave the setting unchanged. 
 ** The second parameter is a pointer to an integer into which is written
 ** 0 or 1 to indicate whether output-for-triggers has been disabled - 0 if
 ** it is not disabled, 1 if it is.
 ** </dd>
-**
-** [[SQLITE_DBCONFIG_RESET_DATABASE]] <dt>SQLITE_DBCONFIG_RESET_DATABASE</dt>
-** <dd> Set the SQLITE_DBCONFIG_RESET_DATABASE flag and then run
-** [VACUUM] in order to reset a database back to an empty database
-** with no schema and no content. The following process works even for
-** a badly corrupted database file:
-** <ol>
-** <li> If the database connection is newly opened, make sure it has read the
-**      database schema by preparing then discarding some query against the
-**      database, or calling sqlite3_table_column_metadata(), ignoring any
-**      errors.  This step is only necessary if the application desires to keep
-**      the database in WAL mode after the reset if it was in WAL mode before
+** 
+** [[SQLITE_DBCONFIG_RESET_DATABASE]] <dt>SQLITE_DBCONFIG_RESET_DATABASE</dt> 
+** <dd> Set the SQLITE_DBCONFIG_RESET_DATABASE flag and then run 
+** [VACUUM] in order to reset a database back to an empty database 
+** with no schema and no content. The following process works even for 
+** a badly corrupted database file: 
+** <ol> 
+** <li> If the database connection is newly opened, make sure it has read the 
+**      database schema by preparing then discarding some query against the 
+**      database, or calling sqlite3_table_column_metadata(), ignoring any 
+**      errors.  This step is only necessary if the application desires to keep 
+**      the database in WAL mode after the reset if it was in WAL mode before 
 **      the reset.
-** <li> sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 1, 0);
-** <li> [sqlite3_exec](db, "[VACUUM]", 0, 0, 0);
-** <li> sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 0, 0);
-** </ol>
-** Because resetting a database is destructive and irreversible, the
-** process requires the use of this obscure API and multiple steps to help
-** ensure that it does not happen by accident.
-**
-** [[SQLITE_DBCONFIG_DEFENSIVE]] <dt>SQLITE_DBCONFIG_DEFENSIVE</dt>
-** <dd>The SQLITE_DBCONFIG_DEFENSIVE option activates or deactivates the
-** "defensive" flag for a database connection.  When the defensive
+** <li> sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 1, 0); 
+** <li> [sqlite3_exec](db, "[VACUUM]", 0, 0, 0); 
+** <li> sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 0, 0); 
+** </ol> 
+** Because resetting a database is destructive and irreversible, the 
+** process requires the use of this obscure API and multiple steps to help 
+** ensure that it does not happen by accident. 
+** 
+** [[SQLITE_DBCONFIG_DEFENSIVE]] <dt>SQLITE_DBCONFIG_DEFENSIVE</dt> 
+** <dd>The SQLITE_DBCONFIG_DEFENSIVE option activates or deactivates the 
+** "defensive" flag for a database connection.  When the defensive 
 ** flag is enabled, language features that allow ordinary SQL to
-** deliberately corrupt the database file are disabled.  The disabled
-** features include but are not limited to the following:
-** <ul>
-** <li> The [PRAGMA writable_schema=ON] statement.
-** <li> The [PRAGMA journal_mode=OFF] statement.
-** <li> Writes to the [sqlite_dbpage] virtual table.
-** <li> Direct writes to [shadow tables].
-** </ul>
-** </dd>
-**
-** [[SQLITE_DBCONFIG_WRITABLE_SCHEMA]] <dt>SQLITE_DBCONFIG_WRITABLE_SCHEMA</dt>
-** <dd>The SQLITE_DBCONFIG_WRITABLE_SCHEMA option activates or deactivates the
-** "writable_schema" flag. This has the same effect and is logically equivalent
-** to setting [PRAGMA writable_schema=ON] or [PRAGMA writable_schema=OFF].
+** deliberately corrupt the database file are disabled.  The disabled 
+** features include but are not limited to the following: 
+** <ul> 
+** <li> The [PRAGMA writable_schema=ON] statement. 
+** <li> The [PRAGMA journal_mode=OFF] statement. 
+** <li> Writes to the [sqlite_dbpage] virtual table. 
+** <li> Direct writes to [shadow tables]. 
+** </ul> 
+** </dd> 
+** 
+** [[SQLITE_DBCONFIG_WRITABLE_SCHEMA]] <dt>SQLITE_DBCONFIG_WRITABLE_SCHEMA</dt> 
+** <dd>The SQLITE_DBCONFIG_WRITABLE_SCHEMA option activates or deactivates the 
+** "writable_schema" flag. This has the same effect and is logically equivalent 
+** to setting [PRAGMA writable_schema=ON] or [PRAGMA writable_schema=OFF]. 
 ** The first argument to this setting is an integer which is 0 to disable
-** the writable_schema, positive to enable writable_schema, or negative to
-** leave the setting unchanged. The second parameter is a pointer to an
-** integer into which is written 0 or 1 to indicate whether the writable_schema
-** is enabled or disabled following this call.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_LEGACY_ALTER_TABLE]]
-** <dt>SQLITE_DBCONFIG_LEGACY_ALTER_TABLE</dt>
-** <dd>The SQLITE_DBCONFIG_LEGACY_ALTER_TABLE option activates or deactivates
-** the legacy behavior of the [ALTER TABLE RENAME] command such it
-** behaves as it did prior to [version 3.24.0] (2018-06-04).  See the
-** "Compatibility Notice" on the [ALTER TABLE RENAME documentation] for
-** additional information. This feature can also be turned on and off
-** using the [PRAGMA legacy_alter_table] statement.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_DQS_DML]]
-** <dt>SQLITE_DBCONFIG_DQS_DML</td>
-** <dd>The SQLITE_DBCONFIG_DQS_DML option activates or deactivates
+** the writable_schema, positive to enable writable_schema, or negative to 
+** leave the setting unchanged. The second parameter is a pointer to an 
+** integer into which is written 0 or 1 to indicate whether the writable_schema 
+** is enabled or disabled following this call. 
+** </dd> 
+** 
+** [[SQLITE_DBCONFIG_LEGACY_ALTER_TABLE]] 
+** <dt>SQLITE_DBCONFIG_LEGACY_ALTER_TABLE</dt> 
+** <dd>The SQLITE_DBCONFIG_LEGACY_ALTER_TABLE option activates or deactivates 
+** the legacy behavior of the [ALTER TABLE RENAME] command such it 
+** behaves as it did prior to [version 3.24.0] (2018-06-04).  See the 
+** "Compatibility Notice" on the [ALTER TABLE RENAME documentation] for 
+** additional information. This feature can also be turned on and off 
+** using the [PRAGMA legacy_alter_table] statement. 
+** </dd> 
+** 
+** [[SQLITE_DBCONFIG_DQS_DML]] 
+** <dt>SQLITE_DBCONFIG_DQS_DML</td> 
+** <dd>The SQLITE_DBCONFIG_DQS_DML option activates or deactivates 
 ** the legacy [double-quoted string literal] misfeature for DML statements
-** only, that is DELETE, INSERT, SELECT, and UPDATE statements. The
-** default value of this setting is determined by the [-DSQLITE_DQS]
-** compile-time option.
-** </dd>
-**
-** [[SQLITE_DBCONFIG_DQS_DDL]]
-** <dt>SQLITE_DBCONFIG_DQS_DDL</td>
-** <dd>The SQLITE_DBCONFIG_DQS option activates or deactivates
-** the legacy [double-quoted string literal] misfeature for DDL statements,
-** such as CREATE TABLE and CREATE INDEX. The
-** default value of this setting is determined by the [-DSQLITE_DQS]
-** compile-time option.
-** </dd>
+** only, that is DELETE, INSERT, SELECT, and UPDATE statements. The 
+** default value of this setting is determined by the [-DSQLITE_DQS] 
+** compile-time option. 
+** </dd> 
+** 
+** [[SQLITE_DBCONFIG_DQS_DDL]] 
+** <dt>SQLITE_DBCONFIG_DQS_DDL</td> 
+** <dd>The SQLITE_DBCONFIG_DQS option activates or deactivates 
+** the legacy [double-quoted string literal] misfeature for DDL statements, 
+** such as CREATE TABLE and CREATE INDEX. The 
+** default value of this setting is determined by the [-DSQLITE_DQS] 
+** compile-time option. 
+** </dd> 
 **
 ** [[SQLITE_DBCONFIG_TRUSTED_SCHEMA]]
 ** <dt>SQLITE_DBCONFIG_TRUSTED_SCHEMA</td>
@@ -2405,12 +2405,12 @@ struct sqlite3_mem_methods {
 #define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE      1006 /* int int* */
 #define SQLITE_DBCONFIG_ENABLE_QPSG           1007 /* int int* */
 #define SQLITE_DBCONFIG_TRIGGER_EQP           1008 /* int int* */
-#define SQLITE_DBCONFIG_RESET_DATABASE        1009 /* int int* */
-#define SQLITE_DBCONFIG_DEFENSIVE             1010 /* int int* */
-#define SQLITE_DBCONFIG_WRITABLE_SCHEMA       1011 /* int int* */
-#define SQLITE_DBCONFIG_LEGACY_ALTER_TABLE    1012 /* int int* */
-#define SQLITE_DBCONFIG_DQS_DML               1013 /* int int* */
-#define SQLITE_DBCONFIG_DQS_DDL               1014 /* int int* */
+#define SQLITE_DBCONFIG_RESET_DATABASE        1009 /* int int* */ 
+#define SQLITE_DBCONFIG_DEFENSIVE             1010 /* int int* */ 
+#define SQLITE_DBCONFIG_WRITABLE_SCHEMA       1011 /* int int* */ 
+#define SQLITE_DBCONFIG_LEGACY_ALTER_TABLE    1012 /* int int* */ 
+#define SQLITE_DBCONFIG_DQS_DML               1013 /* int int* */ 
+#define SQLITE_DBCONFIG_DQS_DDL               1014 /* int int* */ 
 #define SQLITE_DBCONFIG_ENABLE_VIEW           1015 /* int int* */
 #define SQLITE_DBCONFIG_LEGACY_FILE_FORMAT    1016 /* int int* */
 #define SQLITE_DBCONFIG_TRUSTED_SCHEMA        1017 /* int int* */
@@ -2548,14 +2548,14 @@ SQLITE_API void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64);
 ** If a separate thread makes changes on the same database connection
 ** while [sqlite3_changes()] is running then the value returned
 ** is unpredictable and not meaningful.
-**
-** See also:
-** <ul>
-** <li> the [sqlite3_total_changes()] interface
-** <li> the [count_changes pragma]
-** <li> the [changes() SQL function]
-** <li> the [data_version pragma]
-** </ul>
+** 
+** See also: 
+** <ul> 
+** <li> the [sqlite3_total_changes()] interface 
+** <li> the [count_changes pragma] 
+** <li> the [changes() SQL function] 
+** <li> the [data_version pragma] 
+** </ul> 
 */
 SQLITE_API int sqlite3_changes(sqlite3*);
 SQLITE_API sqlite3_int64 sqlite3_changes64(sqlite3*);
@@ -2578,26 +2578,26 @@ SQLITE_API sqlite3_int64 sqlite3_changes64(sqlite3*);
 ** count, but those made as part of REPLACE constraint resolution are
 ** not. ^Changes to a view that are intercepted by INSTEAD OF triggers
 ** are not counted.
-**
-** The [sqlite3_total_changes(D)] interface only reports the number
-** of rows that changed due to SQL statement run against database
-** connection D.  Any changes by other database connections are ignored.
-** To detect changes against a database file from other database
-** connections use the [PRAGMA data_version] command or the
-** [SQLITE_FCNTL_DATA_VERSION] [file control].
+** 
+** The [sqlite3_total_changes(D)] interface only reports the number 
+** of rows that changed due to SQL statement run against database 
+** connection D.  Any changes by other database connections are ignored. 
+** To detect changes against a database file from other database 
+** connections use the [PRAGMA data_version] command or the 
+** [SQLITE_FCNTL_DATA_VERSION] [file control]. 
 **
 ** If a separate thread makes changes on the same database connection
 ** while [sqlite3_total_changes()] is running then the value
 ** returned is unpredictable and not meaningful.
-**
-** See also:
-** <ul>
-** <li> the [sqlite3_changes()] interface
-** <li> the [count_changes pragma]
-** <li> the [changes() SQL function]
-** <li> the [data_version pragma]
-** <li> the [SQLITE_FCNTL_DATA_VERSION] [file control]
-** </ul>
+** 
+** See also: 
+** <ul> 
+** <li> the [sqlite3_changes()] interface 
+** <li> the [count_changes pragma] 
+** <li> the [changes() SQL function] 
+** <li> the [data_version pragma] 
+** <li> the [SQLITE_FCNTL_DATA_VERSION] [file control] 
+** </ul> 
 */
 SQLITE_API int sqlite3_total_changes(sqlite3*);
 SQLITE_API sqlite3_int64 sqlite3_total_changes64(sqlite3*);
@@ -2847,16 +2847,16 @@ SQLITE_API void sqlite3_free_table(char **result);
 **
 ** These routines are work-alikes of the "printf()" family of functions
 ** from the standard C library.
-** These routines understand most of the common formatting options from
+** These routines understand most of the common formatting options from 
 ** the standard library printf()
-** plus some additional non-standard formats ([%q], [%Q], [%w], and [%z]).
-** See the [built-in printf()] documentation for details.
+** plus some additional non-standard formats ([%q], [%Q], [%w], and [%z]). 
+** See the [built-in printf()] documentation for details. 
 **
 ** ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their
-** results into memory obtained from [sqlite3_malloc64()].
+** results into memory obtained from [sqlite3_malloc64()]. 
 ** The strings returned by these two routines should be
 ** released by [sqlite3_free()].  ^Both routines return a
-** NULL pointer if [sqlite3_malloc64()] is unable to allocate enough
+** NULL pointer if [sqlite3_malloc64()] is unable to allocate enough 
 ** memory to hold the resulting string.
 **
 ** ^(The sqlite3_snprintf() routine is similar to "snprintf()" from
@@ -2880,7 +2880,7 @@ SQLITE_API void sqlite3_free_table(char **result);
 **
 ** ^The sqlite3_vsnprintf() routine is a varargs version of sqlite3_snprintf().
 **
-** See also:  [built-in printf()], [printf() SQL function]
+** See also:  [built-in printf()], [printf() SQL function] 
 */
 SQLITE_API char *sqlite3_mprintf(const char*,...);
 SQLITE_API char *sqlite3_vmprintf(const char*, va_list);
@@ -3211,9 +3211,9 @@ SQLITE_API int sqlite3_set_authorizer(
 ** time is in units of nanoseconds, however the current implementation
 ** is only capable of millisecond resolution so the six least significant
 ** digits in the time are meaningless.  Future versions of SQLite
-** might provide greater resolution on the profiler callback.  Invoking
-** either [sqlite3_trace()] or [sqlite3_trace_v2()] will cancel the
-** profile callback.
+** might provide greater resolution on the profiler callback.  Invoking 
+** either [sqlite3_trace()] or [sqlite3_trace_v2()] will cancel the 
+** profile callback. 
 */
 SQLITE_API SQLITE_DEPRECATED void *sqlite3_trace(sqlite3*,
    void(*xTrace)(void*,const char*), void*);
@@ -3687,7 +3687,7 @@ SQLITE_API int sqlite3_open_v2(
 ** is not a database file pathname pointer that the SQLite core passed
 ** into the xOpen VFS method, then the behavior of this routine is undefined
 ** and probably undesirable.
-**
+** 
 ** Beginning with SQLite [version 3.31.0] ([dateof:3.31.0]) the input F
 ** parameter can also be the name of a rollback journal file or WAL file
 ** in addition to the main database file.  Prior to version 3.31.0, these
@@ -3696,7 +3696,7 @@ SQLITE_API int sqlite3_open_v2(
 ** it has access to all the same query parameters as were found on the
 ** main database file.
 **
-** See the [URI filename] documentation for additional information.
+** See the [URI filename] documentation for additional information. 
 */
 SQLITE_API const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam);
 SQLITE_API int sqlite3_uri_boolean(const char *zFile, const char *zParam, int bDefault);
@@ -3820,19 +3820,19 @@ SQLITE_API void sqlite3_free_filename(char*);
 ** [extended result code] even when extended result codes are
 ** disabled.
 **
-** The values returned by sqlite3_errcode() and/or
-** sqlite3_extended_errcode() might change with each API call.
-** Except, there are some interfaces that are guaranteed to never
-** change the value of the error code.  The error-code preserving
-** interfaces are:
-**
-** <ul>
-** <li> sqlite3_errcode()
-** <li> sqlite3_extended_errcode()
-** <li> sqlite3_errmsg()
-** <li> sqlite3_errmsg16()
-** </ul>
-**
+** The values returned by sqlite3_errcode() and/or 
+** sqlite3_extended_errcode() might change with each API call. 
+** Except, there are some interfaces that are guaranteed to never 
+** change the value of the error code.  The error-code preserving 
+** interfaces are: 
+** 
+** <ul> 
+** <li> sqlite3_errcode() 
+** <li> sqlite3_extended_errcode() 
+** <li> sqlite3_errmsg() 
+** <li> sqlite3_errmsg16() 
+** </ul> 
+** 
 ** ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language
 ** text that describes the error, as either UTF-8 or UTF-16 respectively.
 ** ^(Memory to hold the error message string is managed internally.
@@ -4022,24 +4022,24 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
 ** on this hint by avoiding the use of [lookaside memory] so as not to
 ** deplete the limited store of lookaside memory. Future versions of
 ** SQLite may act on this hint differently.
-**
-** [[SQLITE_PREPARE_NORMALIZE]] <dt>SQLITE_PREPARE_NORMALIZE</dt>
-** <dd>The SQLITE_PREPARE_NORMALIZE flag is a no-op. This flag used
-** to be required for any prepared statement that wanted to use the
-** [sqlite3_normalized_sql()] interface.  However, the
-** [sqlite3_normalized_sql()] interface is now available to all
-** prepared statements, regardless of whether or not they use this
-** flag.
-**
-** [[SQLITE_PREPARE_NO_VTAB]] <dt>SQLITE_PREPARE_NO_VTAB</dt>
-** <dd>The SQLITE_PREPARE_NO_VTAB flag causes the SQL compiler
-** to return an error (error code SQLITE_ERROR) if the statement uses
-** any virtual tables.
+** 
+** [[SQLITE_PREPARE_NORMALIZE]] <dt>SQLITE_PREPARE_NORMALIZE</dt> 
+** <dd>The SQLITE_PREPARE_NORMALIZE flag is a no-op. This flag used 
+** to be required for any prepared statement that wanted to use the 
+** [sqlite3_normalized_sql()] interface.  However, the 
+** [sqlite3_normalized_sql()] interface is now available to all 
+** prepared statements, regardless of whether or not they use this 
+** flag. 
+** 
+** [[SQLITE_PREPARE_NO_VTAB]] <dt>SQLITE_PREPARE_NO_VTAB</dt> 
+** <dd>The SQLITE_PREPARE_NO_VTAB flag causes the SQL compiler 
+** to return an error (error code SQLITE_ERROR) if the statement uses 
+** any virtual tables. 
 ** </dl>
 */
 #define SQLITE_PREPARE_PERSISTENT              0x01
-#define SQLITE_PREPARE_NORMALIZE               0x02
-#define SQLITE_PREPARE_NO_VTAB                 0x04
+#define SQLITE_PREPARE_NORMALIZE               0x02 
+#define SQLITE_PREPARE_NO_VTAB                 0x04 
 
 /*
 ** CAPI3REF: Compiling An SQL Statement
@@ -4133,7 +4133,7 @@ SQLITE_API int sqlite3_limit(sqlite3*, int id, int newVal);
 ** or [GLOB] operator or if the parameter is compared to an indexed column
 ** and the [SQLITE_ENABLE_STAT4] compile-time option is enabled.
 ** </li>
-** </ol>
+** </ol> 
 **
 ** <p>^sqlite3_prepare_v3() differs from sqlite3_prepare_v2() only in having
 ** the extra prepFlags parameter, which is a bit array consisting of zero or
@@ -4197,11 +4197,11 @@ SQLITE_API int sqlite3_prepare16_v3(
 ** ^The sqlite3_expanded_sql(P) interface returns a pointer to a UTF-8
 ** string containing the SQL text of prepared statement P with
 ** [bound parameters] expanded.
-** ^The sqlite3_normalized_sql(P) interface returns a pointer to a UTF-8
-** string containing the normalized SQL text of prepared statement P.  The
-** semantics used to normalize a SQL statement are unspecified and subject
-** to change.  At a minimum, literal values will be replaced with suitable
-** placeholders.
+** ^The sqlite3_normalized_sql(P) interface returns a pointer to a UTF-8 
+** string containing the normalized SQL text of prepared statement P.  The 
+** semantics used to normalize a SQL statement are unspecified and subject 
+** to change.  At a minimum, literal values will be replaced with suitable 
+** placeholders. 
 **
 ** ^(For example, if a prepared statement is created using the SQL
 ** text "SELECT $abc,:xyz" and if parameter $abc is bound to integer 2345
@@ -4217,9 +4217,9 @@ SQLITE_API int sqlite3_prepare16_v3(
 ** bound parameter expansions.  ^The [SQLITE_OMIT_TRACE] compile-time
 ** option causes sqlite3_expanded_sql() to always return NULL.
 **
-** ^The strings returned by sqlite3_sql(P) and sqlite3_normalized_sql(P)
-** are managed by SQLite and are automatically freed when the prepared
-** statement is finalized.
+** ^The strings returned by sqlite3_sql(P) and sqlite3_normalized_sql(P) 
+** are managed by SQLite and are automatically freed when the prepared 
+** statement is finalized. 
 ** ^The string returned by sqlite3_expanded_sql(P), on the other hand,
 ** is obtained from [sqlite3_malloc()] and must be freed by the application
 ** by passing it to [sqlite3_free()].
@@ -4230,7 +4230,7 @@ SQLITE_API int sqlite3_prepare16_v3(
 SQLITE_API const char *sqlite3_sql(sqlite3_stmt *pStmt);
 SQLITE_API char *sqlite3_expanded_sql(sqlite3_stmt *pStmt);
 #ifdef SQLITE_ENABLE_NORMALIZE
-SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt);
+SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt); 
 #endif
 
 /*
@@ -4279,18 +4279,18 @@ SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt);
 SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
 
 /*
-** CAPI3REF: Query The EXPLAIN Setting For A Prepared Statement
-** METHOD: sqlite3_stmt
-**
-** ^The sqlite3_stmt_isexplain(S) interface returns 1 if the
-** prepared statement S is an EXPLAIN statement, or 2 if the
-** statement S is an EXPLAIN QUERY PLAN.
-** ^The sqlite3_stmt_isexplain(S) interface returns 0 if S is
-** an ordinary statement or a NULL pointer.
-*/
-SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt);
-
-/*
+** CAPI3REF: Query The EXPLAIN Setting For A Prepared Statement 
+** METHOD: sqlite3_stmt 
+** 
+** ^The sqlite3_stmt_isexplain(S) interface returns 1 if the 
+** prepared statement S is an EXPLAIN statement, or 2 if the 
+** statement S is an EXPLAIN QUERY PLAN. 
+** ^The sqlite3_stmt_isexplain(S) interface returns 0 if S is 
+** an ordinary statement or a NULL pointer. 
+*/ 
+SQLITE_API int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt); 
+ 
+/* 
 ** CAPI3REF: Determine If A Prepared Statement Has Been Reset
 ** METHOD: sqlite3_stmt
 **
@@ -5054,25 +5054,25 @@ SQLITE_API int sqlite3_data_count(sqlite3_stmt *pStmt);
 ** from [sqlite3_column_blob()], [sqlite3_column_text()], etc. into
 ** [sqlite3_free()].
 **
-** As long as the input parameters are correct, these routines will only
-** fail if an out-of-memory error occurs during a format conversion.
-** Only the following subset of interfaces are subject to out-of-memory
-** errors:
-**
-** <ul>
-** <li> sqlite3_column_blob()
-** <li> sqlite3_column_text()
-** <li> sqlite3_column_text16()
-** <li> sqlite3_column_bytes()
-** <li> sqlite3_column_bytes16()
-** </ul>
-**
-** If an out-of-memory error occurs, then the return value from these
-** routines is the same as if the column had contained an SQL NULL value.
-** Valid SQL NULL returns can be distinguished from out-of-memory errors
-** by invoking the [sqlite3_errcode()] immediately after the suspect
-** return value is obtained and before any
-** other SQLite interface is called on the same [database connection].
+** As long as the input parameters are correct, these routines will only 
+** fail if an out-of-memory error occurs during a format conversion. 
+** Only the following subset of interfaces are subject to out-of-memory 
+** errors: 
+** 
+** <ul> 
+** <li> sqlite3_column_blob() 
+** <li> sqlite3_column_text() 
+** <li> sqlite3_column_text16() 
+** <li> sqlite3_column_bytes() 
+** <li> sqlite3_column_bytes16() 
+** </ul> 
+** 
+** If an out-of-memory error occurs, then the return value from these 
+** routines is the same as if the column had contained an SQL NULL value. 
+** Valid SQL NULL returns can be distinguished from out-of-memory errors 
+** by invoking the [sqlite3_errcode()] immediately after the suspect 
+** return value is obtained and before any 
+** other SQLite interface is called on the same [database connection]. 
 */
 SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
 SQLITE_API double sqlite3_column_double(sqlite3_stmt*, int iCol);
@@ -5147,13 +5147,13 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
 **
 ** ^These functions (collectively known as "function creation routines")
 ** are used to add SQL functions or aggregates or to redefine the behavior
-** of existing SQL functions or aggregates. The only differences between
+** of existing SQL functions or aggregates. The only differences between 
 ** the three "sqlite3_create_function*" routines are the text encoding
 ** expected for the second parameter (the name of the function being
-** created) and the presence or absence of a destructor callback for
-** the application data pointer. Function sqlite3_create_window_function()
-** is similar, but allows the user to supply the extra callback functions
-** needed by [aggregate window functions].
+** created) and the presence or absence of a destructor callback for 
+** the application data pointer. Function sqlite3_create_window_function() 
+** is similar, but allows the user to supply the extra callback functions 
+** needed by [aggregate window functions]. 
 **
 ** ^The first parameter is the [database connection] to which the SQL
 ** function is to be added.  ^If an application uses more than one database
@@ -5214,8 +5214,8 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
 ** ^(The fifth parameter is an arbitrary pointer.  The implementation of the
 ** function can gain access to this pointer using [sqlite3_user_data()].)^
 **
-** ^The sixth, seventh and eighth parameters passed to the three
-** "sqlite3_create_function*" functions, xFunc, xStep and xFinal, are
+** ^The sixth, seventh and eighth parameters passed to the three 
+** "sqlite3_create_function*" functions, xFunc, xStep and xFinal, are 
 ** pointers to C-language functions that implement the SQL function or
 ** aggregate. ^A scalar SQL function requires an implementation of the xFunc
 ** callback only; NULL pointers must be passed as the xStep and xFinal
@@ -5225,24 +5225,24 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
 ** callbacks.
 **
 ** ^The sixth, seventh, eighth and ninth parameters (xStep, xFinal, xValue
-** and xInverse) passed to sqlite3_create_window_function are pointers to
-** C-language callbacks that implement the new function. xStep and xFinal
-** must both be non-NULL. xValue and xInverse may either both be NULL, in
+** and xInverse) passed to sqlite3_create_window_function are pointers to 
+** C-language callbacks that implement the new function. xStep and xFinal 
+** must both be non-NULL. xValue and xInverse may either both be NULL, in 
 ** which case a regular aggregate function is created, or must both be
-** non-NULL, in which case the new function may be used as either an aggregate
-** or aggregate window function. More details regarding the implementation
+** non-NULL, in which case the new function may be used as either an aggregate 
+** or aggregate window function. More details regarding the implementation 
 ** of aggregate window functions are
-** [user-defined window functions|available here].
+** [user-defined window functions|available here]. 
 **
-** ^(If the final parameter to sqlite3_create_function_v2() or
-** sqlite3_create_window_function() is not NULL, then it is destructor for
+** ^(If the final parameter to sqlite3_create_function_v2() or 
+** sqlite3_create_window_function() is not NULL, then it is destructor for 
 ** the application data pointer. The destructor is invoked when the function
 ** is deleted, either by being overloaded or when the database connection
 ** closes.)^ ^The destructor is also invoked if the call to
-** sqlite3_create_function_v2() fails.  ^When the destructor callback is
-** invoked, it is passed a single argument which is a copy of the application
-** data pointer which was the fifth parameter to sqlite3_create_function_v2().
-**
+** sqlite3_create_function_v2() fails.  ^When the destructor callback is 
+** invoked, it is passed a single argument which is a copy of the application 
+** data pointer which was the fifth parameter to sqlite3_create_function_v2(). 
+** 
 ** ^It is permitted to register multiple implementations of the same
 ** functions with the same name but with either differing numbers of
 ** arguments or differing preferred text encodings.  ^SQLite will use
@@ -5294,18 +5294,18 @@ SQLITE_API int sqlite3_create_function_v2(
   void (*xFinal)(sqlite3_context*),
   void(*xDestroy)(void*)
 );
-SQLITE_API int sqlite3_create_window_function(
-  sqlite3 *db,
-  const char *zFunctionName,
-  int nArg,
-  int eTextRep,
-  void *pApp,
-  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
-  void (*xFinal)(sqlite3_context*),
-  void (*xValue)(sqlite3_context*),
-  void (*xInverse)(sqlite3_context*,int,sqlite3_value**),
-  void(*xDestroy)(void*)
-);
+SQLITE_API int sqlite3_create_window_function( 
+  sqlite3 *db, 
+  const char *zFunctionName, 
+  int nArg, 
+  int eTextRep, 
+  void *pApp, 
+  void (*xStep)(sqlite3_context*,int,sqlite3_value**), 
+  void (*xFinal)(sqlite3_context*), 
+  void (*xValue)(sqlite3_context*), 
+  void (*xInverse)(sqlite3_context*,int,sqlite3_value**), 
+  void(*xDestroy)(void*) 
+); 
 
 /*
 ** CAPI3REF: Text Encodings
@@ -5439,8 +5439,8 @@ SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int6
 ** <tr><td><b>sqlite3_value_nochange&nbsp;&nbsp;</b>
 ** <td>&rarr;&nbsp;&nbsp;<td>True if the column is unchanged in an UPDATE
 ** against a virtual table.
-** <tr><td><b>sqlite3_value_frombind&nbsp;&nbsp;</b>
-** <td>&rarr;&nbsp;&nbsp;<td>True if value originated from a [bound parameter]
+** <tr><td><b>sqlite3_value_frombind&nbsp;&nbsp;</b> 
+** <td>&rarr;&nbsp;&nbsp;<td>True if value originated from a [bound parameter] 
 ** </table></blockquote>
 **
 ** <b>Details:</b>
@@ -5502,11 +5502,11 @@ SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int6
 ** than within an [xUpdate] method call for an UPDATE statement, then
 ** the return value is arbitrary and meaningless.
 **
-** ^The sqlite3_value_frombind(X) interface returns non-zero if the
-** value X originated from one of the [sqlite3_bind_int|sqlite3_bind()]
-** interfaces.  ^If X comes from an SQL literal value, or a table column,
+** ^The sqlite3_value_frombind(X) interface returns non-zero if the 
+** value X originated from one of the [sqlite3_bind_int|sqlite3_bind()] 
+** interfaces.  ^If X comes from an SQL literal value, or a table column, 
 ** or an expression, then sqlite3_value_frombind(X) returns zero.
-**
+** 
 ** Please pay particular attention to the fact that the pointer returned
 ** from [sqlite3_value_blob()], [sqlite3_value_text()], or
 ** [sqlite3_value_text16()] can be invalidated by a subsequent call to
@@ -5515,28 +5515,28 @@ SQLITE_API SQLITE_DEPRECATED int sqlite3_memory_alarm(void(*)(void*,sqlite3_int6
 **
 ** These routines must be called from the same thread as
 ** the SQL function that supplied the [sqlite3_value*] parameters.
-**
-** As long as the input parameter is correct, these routines can only
-** fail if an out-of-memory error occurs during a format conversion.
-** Only the following subset of interfaces are subject to out-of-memory
-** errors:
-**
-** <ul>
-** <li> sqlite3_value_blob()
-** <li> sqlite3_value_text()
-** <li> sqlite3_value_text16()
-** <li> sqlite3_value_text16le()
-** <li> sqlite3_value_text16be()
-** <li> sqlite3_value_bytes()
-** <li> sqlite3_value_bytes16()
-** </ul>
-**
-** If an out-of-memory error occurs, then the return value from these
-** routines is the same as if the column had contained an SQL NULL value.
-** Valid SQL NULL returns can be distinguished from out-of-memory errors
-** by invoking the [sqlite3_errcode()] immediately after the suspect
-** return value is obtained and before any
-** other SQLite interface is called on the same [database connection].
+** 
+** As long as the input parameter is correct, these routines can only 
+** fail if an out-of-memory error occurs during a format conversion. 
+** Only the following subset of interfaces are subject to out-of-memory 
+** errors: 
+** 
+** <ul> 
+** <li> sqlite3_value_blob() 
+** <li> sqlite3_value_text() 
+** <li> sqlite3_value_text16() 
+** <li> sqlite3_value_text16le() 
+** <li> sqlite3_value_text16be() 
+** <li> sqlite3_value_bytes() 
+** <li> sqlite3_value_bytes16() 
+** </ul> 
+** 
+** If an out-of-memory error occurs, then the return value from these 
+** routines is the same as if the column had contained an SQL NULL value. 
+** Valid SQL NULL returns can be distinguished from out-of-memory errors 
+** by invoking the [sqlite3_errcode()] immediately after the suspect 
+** return value is obtained and before any 
+** other SQLite interface is called on the same [database connection]. 
 */
 SQLITE_API const void *sqlite3_value_blob(sqlite3_value*);
 SQLITE_API double sqlite3_value_double(sqlite3_value*);
@@ -5552,7 +5552,7 @@ SQLITE_API int sqlite3_value_bytes16(sqlite3_value*);
 SQLITE_API int sqlite3_value_type(sqlite3_value*);
 SQLITE_API int sqlite3_value_numeric_type(sqlite3_value*);
 SQLITE_API int sqlite3_value_nochange(sqlite3_value*);
-SQLITE_API int sqlite3_value_frombind(sqlite3_value*);
+SQLITE_API int sqlite3_value_frombind(sqlite3_value*); 
 
 /*
 ** CAPI3REF: Finding The Subtype Of SQL Values
@@ -6185,41 +6185,41 @@ SQLITE_API SQLITE_EXTERN char *sqlite3_temp_directory;
 SQLITE_API SQLITE_EXTERN char *sqlite3_data_directory;
 
 /*
-** CAPI3REF: Win32 Specific Interface
-**
-** These interfaces are available only on Windows.  The
-** [sqlite3_win32_set_directory] interface is used to set the value associated
-** with the [sqlite3_temp_directory] or [sqlite3_data_directory] variable, to
-** zValue, depending on the value of the type parameter.  The zValue parameter
-** should be NULL to cause the previous value to be freed via [sqlite3_free];
-** a non-NULL value will be copied into memory obtained from [sqlite3_malloc]
-** prior to being used.  The [sqlite3_win32_set_directory] interface returns
-** [SQLITE_OK] to indicate success, [SQLITE_ERROR] if the type is unsupported,
-** or [SQLITE_NOMEM] if memory could not be allocated.  The value of the
-** [sqlite3_data_directory] variable is intended to act as a replacement for
-** the current directory on the sub-platforms of Win32 where that concept is
-** not present, e.g. WinRT and UWP.  The [sqlite3_win32_set_directory8] and
-** [sqlite3_win32_set_directory16] interfaces behave exactly the same as the
-** sqlite3_win32_set_directory interface except the string parameter must be
-** UTF-8 or UTF-16, respectively.
-*/
-SQLITE_API int sqlite3_win32_set_directory(
-  unsigned long type, /* Identifier for directory being set or reset */
-  void *zValue        /* New value for directory being set or reset */
-);
-SQLITE_API int sqlite3_win32_set_directory8(unsigned long type, const char *zValue);
-SQLITE_API int sqlite3_win32_set_directory16(unsigned long type, const void *zValue);
-
-/*
-** CAPI3REF: Win32 Directory Types
-**
-** These macros are only available on Windows.  They define the allowed values
-** for the type argument to the [sqlite3_win32_set_directory] interface.
-*/
-#define SQLITE_WIN32_DATA_DIRECTORY_TYPE  1
-#define SQLITE_WIN32_TEMP_DIRECTORY_TYPE  2
-
-/*
+** CAPI3REF: Win32 Specific Interface 
+** 
+** These interfaces are available only on Windows.  The 
+** [sqlite3_win32_set_directory] interface is used to set the value associated 
+** with the [sqlite3_temp_directory] or [sqlite3_data_directory] variable, to 
+** zValue, depending on the value of the type parameter.  The zValue parameter 
+** should be NULL to cause the previous value to be freed via [sqlite3_free]; 
+** a non-NULL value will be copied into memory obtained from [sqlite3_malloc] 
+** prior to being used.  The [sqlite3_win32_set_directory] interface returns 
+** [SQLITE_OK] to indicate success, [SQLITE_ERROR] if the type is unsupported, 
+** or [SQLITE_NOMEM] if memory could not be allocated.  The value of the 
+** [sqlite3_data_directory] variable is intended to act as a replacement for 
+** the current directory on the sub-platforms of Win32 where that concept is 
+** not present, e.g. WinRT and UWP.  The [sqlite3_win32_set_directory8] and 
+** [sqlite3_win32_set_directory16] interfaces behave exactly the same as the 
+** sqlite3_win32_set_directory interface except the string parameter must be 
+** UTF-8 or UTF-16, respectively. 
+*/ 
+SQLITE_API int sqlite3_win32_set_directory( 
+  unsigned long type, /* Identifier for directory being set or reset */ 
+  void *zValue        /* New value for directory being set or reset */ 
+); 
+SQLITE_API int sqlite3_win32_set_directory8(unsigned long type, const char *zValue); 
+SQLITE_API int sqlite3_win32_set_directory16(unsigned long type, const void *zValue); 
+ 
+/* 
+** CAPI3REF: Win32 Directory Types 
+** 
+** These macros are only available on Windows.  They define the allowed values 
+** for the type argument to the [sqlite3_win32_set_directory] interface. 
+*/ 
+#define SQLITE_WIN32_DATA_DIRECTORY_TYPE  1 
+#define SQLITE_WIN32_TEMP_DIRECTORY_TYPE  2 
+ 
+/* 
 ** CAPI3REF: Test For Auto-Commit Mode
 ** KEYWORDS: {autocommit mode}
 ** METHOD: sqlite3
@@ -6264,7 +6264,7 @@ SQLITE_API sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
 ** associated with database N of connection D.
 ** ^If there is no attached database N on the database
 ** connection D, or if database N is a temporary or in-memory database, then
-** this function will return either a NULL pointer or an empty string.
+** this function will return either a NULL pointer or an empty string. 
 **
 ** ^The string value returned by this routine is owned and managed by
 ** the database connection.  ^The value will be valid until the database N
@@ -6969,9 +6969,9 @@ struct sqlite3_module {
   int (*xSavepoint)(sqlite3_vtab *pVTab, int);
   int (*xRelease)(sqlite3_vtab *pVTab, int);
   int (*xRollbackTo)(sqlite3_vtab *pVTab, int);
-  /* The methods above are in versions 1 and 2 of the sqlite_module object.
-  ** Those below are for version 3 and greater. */
-  int (*xShadowName)(const char*);
+  /* The methods above are in versions 1 and 2 of the sqlite_module object. 
+  ** Those below are for version 3 and greater. */ 
+  int (*xShadowName)(const char*); 
 };
 
 /*
@@ -7110,10 +7110,10 @@ struct sqlite3_index_info {
 
 /*
 ** CAPI3REF: Virtual Table Scan Flags
-**
+** 
 ** Virtual table implementations are allowed to set the
-** [sqlite3_index_info].idxFlags field to some combination of
-** these bits.
+** [sqlite3_index_info].idxFlags field to some combination of 
+** these bits. 
 */
 #define SQLITE_INDEX_SCAN_UNIQUE      1     /* Scan visits at most 1 row */
 
@@ -7139,7 +7139,7 @@ struct sqlite3_index_info {
 #define SQLITE_INDEX_CONSTRAINT_ISNOTNULL 70
 #define SQLITE_INDEX_CONSTRAINT_ISNULL    71
 #define SQLITE_INDEX_CONSTRAINT_IS        72
-#define SQLITE_INDEX_CONSTRAINT_FUNCTION 150
+#define SQLITE_INDEX_CONSTRAINT_FUNCTION 150 
 
 /*
 ** CAPI3REF: Register A Virtual Table Implementation
@@ -7843,7 +7843,7 @@ SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*);
 /*
 ** CAPI3REF: Low-Level Control Of Database Files
 ** METHOD: sqlite3
-** KEYWORDS: {file control}
+** KEYWORDS: {file control} 
 **
 ** ^The [sqlite3_file_control()] interface makes a direct call to the
 ** xFileControl method for the [sqlite3_io_methods] object associated
@@ -7858,18 +7858,18 @@ SQLITE_API sqlite3_mutex *sqlite3_db_mutex(sqlite3*);
 ** the xFileControl method.  ^The return value of the xFileControl
 ** method becomes the return value of this routine.
 **
-** A few opcodes for [sqlite3_file_control()] are handled directly
+** A few opcodes for [sqlite3_file_control()] are handled directly 
 ** by the SQLite core and never invoke the
-** sqlite3_io_methods.xFileControl method.
+** sqlite3_io_methods.xFileControl method. 
 ** ^The [SQLITE_FCNTL_FILE_POINTER] value for the op parameter causes
 ** a pointer to the underlying [sqlite3_file] object to be written into
-** the space pointed to by the 4th parameter.  The
-** [SQLITE_FCNTL_JOURNAL_POINTER] works similarly except that it returns
-** the [sqlite3_file] object associated with the journal file instead of
-** the main database.  The [SQLITE_FCNTL_VFS_POINTER] opcode returns
-** a pointer to the underlying [sqlite3_vfs] object for the file.
-** The [SQLITE_FCNTL_DATA_VERSION] returns the data version counter
-** from the pager.
+** the space pointed to by the 4th parameter.  The 
+** [SQLITE_FCNTL_JOURNAL_POINTER] works similarly except that it returns 
+** the [sqlite3_file] object associated with the journal file instead of 
+** the main database.  The [SQLITE_FCNTL_VFS_POINTER] opcode returns 
+** a pointer to the underlying [sqlite3_vfs] object for the file. 
+** The [SQLITE_FCNTL_DATA_VERSION] returns the data version counter 
+** from the pager. 
 **
 ** ^If the second parameter (zDbName) does not match the name of any
 ** open database file, then SQLITE_ERROR is returned.  ^This error
@@ -7925,9 +7925,9 @@ SQLITE_API int sqlite3_test_control(int op, ...);
 #define SQLITE_TESTCTRL_ALWAYS                  13
 #define SQLITE_TESTCTRL_RESERVE                 14  /* NOT USED */
 #define SQLITE_TESTCTRL_OPTIMIZATIONS           15
-#define SQLITE_TESTCTRL_ISKEYWORD               16  /* NOT USED */
+#define SQLITE_TESTCTRL_ISKEYWORD               16  /* NOT USED */ 
 #define SQLITE_TESTCTRL_SCRATCHMALLOC           17  /* NOT USED */
-#define SQLITE_TESTCTRL_INTERNAL_FUNCTIONS      17
+#define SQLITE_TESTCTRL_INTERNAL_FUNCTIONS      17 
 #define SQLITE_TESTCTRL_LOCALTIME_FAULT         18
 #define SQLITE_TESTCTRL_EXPLAIN_STMT            19  /* NOT USED */
 #define SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD    19
@@ -7938,7 +7938,7 @@ SQLITE_API int sqlite3_test_control(int op, ...);
 #define SQLITE_TESTCTRL_SORTER_MMAP             24
 #define SQLITE_TESTCTRL_IMPOSTER                25
 #define SQLITE_TESTCTRL_PARSER_COVERAGE         26
-#define SQLITE_TESTCTRL_RESULT_INTREAL          27
+#define SQLITE_TESTCTRL_RESULT_INTREAL          27 
 #define SQLITE_TESTCTRL_PRNG_SEED               28
 #define SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS     29
 #define SQLITE_TESTCTRL_SEEK_COUNT              30
@@ -7947,189 +7947,189 @@ SQLITE_API int sqlite3_test_control(int op, ...);
 #define SQLITE_TESTCTRL_LAST                    32  /* Largest TESTCTRL */
 
 /*
-** CAPI3REF: SQL Keyword Checking
-**
+** CAPI3REF: SQL Keyword Checking 
+** 
 ** These routines provide access to the set of SQL language keywords
-** recognized by SQLite.  Applications can uses these routines to determine
-** whether or not a specific identifier needs to be escaped (for example,
-** by enclosing in double-quotes) so as not to confuse the parser.
-**
-** The sqlite3_keyword_count() interface returns the number of distinct
-** keywords understood by SQLite.
-**
-** The sqlite3_keyword_name(N,Z,L) interface finds the N-th keyword and
-** makes *Z point to that keyword expressed as UTF8 and writes the number
-** of bytes in the keyword into *L.  The string that *Z points to is not
-** zero-terminated.  The sqlite3_keyword_name(N,Z,L) routine returns
-** SQLITE_OK if N is within bounds and SQLITE_ERROR if not. If either Z
-** or L are NULL or invalid pointers then calls to
-** sqlite3_keyword_name(N,Z,L) result in undefined behavior.
-**
-** The sqlite3_keyword_check(Z,L) interface checks to see whether or not
-** the L-byte UTF8 identifier that Z points to is a keyword, returning non-zero
-** if it is and zero if not.
-**
-** The parser used by SQLite is forgiving.  It is often possible to use
-** a keyword as an identifier as long as such use does not result in a
-** parsing ambiguity.  For example, the statement
-** "CREATE TABLE BEGIN(REPLACE,PRAGMA,END);" is accepted by SQLite, and
-** creates a new table named "BEGIN" with three columns named
-** "REPLACE", "PRAGMA", and "END".  Nevertheless, best practice is to avoid
-** using keywords as identifiers.  Common techniques used to avoid keyword
-** name collisions include:
-** <ul>
-** <li> Put all identifier names inside double-quotes.  This is the official
-**      SQL way to escape identifier names.
-** <li> Put identifier names inside &#91;...&#93;.  This is not standard SQL,
-**      but it is what SQL Server does and so lots of programmers use this
-**      technique.
-** <li> Begin every identifier with the letter "Z" as no SQL keywords start
-**      with "Z".
-** <li> Include a digit somewhere in every identifier name.
-** </ul>
-**
-** Note that the number of keywords understood by SQLite can depend on
-** compile-time options.  For example, "VACUUM" is not a keyword if
-** SQLite is compiled with the [-DSQLITE_OMIT_VACUUM] option.  Also,
-** new keywords may be added to future releases of SQLite.
-*/
-SQLITE_API int sqlite3_keyword_count(void);
-SQLITE_API int sqlite3_keyword_name(int,const char**,int*);
-SQLITE_API int sqlite3_keyword_check(const char*,int);
-
-/*
-** CAPI3REF: Dynamic String Object
-** KEYWORDS: {dynamic string}
-**
-** An instance of the sqlite3_str object contains a dynamically-sized
-** string under construction.
-**
-** The lifecycle of an sqlite3_str object is as follows:
-** <ol>
-** <li> ^The sqlite3_str object is created using [sqlite3_str_new()].
-** <li> ^Text is appended to the sqlite3_str object using various
-** methods, such as [sqlite3_str_appendf()].
-** <li> ^The sqlite3_str object is destroyed and the string it created
-** is returned using the [sqlite3_str_finish()] interface.
-** </ol>
-*/
-typedef struct sqlite3_str sqlite3_str;
-
-/*
-** CAPI3REF: Create A New Dynamic String Object
-** CONSTRUCTOR: sqlite3_str
-**
-** ^The [sqlite3_str_new(D)] interface allocates and initializes
-** a new [sqlite3_str] object.  To avoid memory leaks, the object returned by
+** recognized by SQLite.  Applications can uses these routines to determine 
+** whether or not a specific identifier needs to be escaped (for example, 
+** by enclosing in double-quotes) so as not to confuse the parser. 
+** 
+** The sqlite3_keyword_count() interface returns the number of distinct 
+** keywords understood by SQLite. 
+** 
+** The sqlite3_keyword_name(N,Z,L) interface finds the N-th keyword and 
+** makes *Z point to that keyword expressed as UTF8 and writes the number 
+** of bytes in the keyword into *L.  The string that *Z points to is not 
+** zero-terminated.  The sqlite3_keyword_name(N,Z,L) routine returns 
+** SQLITE_OK if N is within bounds and SQLITE_ERROR if not. If either Z 
+** or L are NULL or invalid pointers then calls to 
+** sqlite3_keyword_name(N,Z,L) result in undefined behavior. 
+** 
+** The sqlite3_keyword_check(Z,L) interface checks to see whether or not 
+** the L-byte UTF8 identifier that Z points to is a keyword, returning non-zero 
+** if it is and zero if not. 
+** 
+** The parser used by SQLite is forgiving.  It is often possible to use 
+** a keyword as an identifier as long as such use does not result in a 
+** parsing ambiguity.  For example, the statement 
+** "CREATE TABLE BEGIN(REPLACE,PRAGMA,END);" is accepted by SQLite, and 
+** creates a new table named "BEGIN" with three columns named 
+** "REPLACE", "PRAGMA", and "END".  Nevertheless, best practice is to avoid 
+** using keywords as identifiers.  Common techniques used to avoid keyword 
+** name collisions include: 
+** <ul> 
+** <li> Put all identifier names inside double-quotes.  This is the official 
+**      SQL way to escape identifier names. 
+** <li> Put identifier names inside &#91;...&#93;.  This is not standard SQL, 
+**      but it is what SQL Server does and so lots of programmers use this 
+**      technique. 
+** <li> Begin every identifier with the letter "Z" as no SQL keywords start 
+**      with "Z". 
+** <li> Include a digit somewhere in every identifier name. 
+** </ul> 
+** 
+** Note that the number of keywords understood by SQLite can depend on 
+** compile-time options.  For example, "VACUUM" is not a keyword if 
+** SQLite is compiled with the [-DSQLITE_OMIT_VACUUM] option.  Also, 
+** new keywords may be added to future releases of SQLite. 
+*/ 
+SQLITE_API int sqlite3_keyword_count(void); 
+SQLITE_API int sqlite3_keyword_name(int,const char**,int*); 
+SQLITE_API int sqlite3_keyword_check(const char*,int); 
+ 
+/* 
+** CAPI3REF: Dynamic String Object 
+** KEYWORDS: {dynamic string} 
+** 
+** An instance of the sqlite3_str object contains a dynamically-sized 
+** string under construction. 
+** 
+** The lifecycle of an sqlite3_str object is as follows: 
+** <ol> 
+** <li> ^The sqlite3_str object is created using [sqlite3_str_new()]. 
+** <li> ^Text is appended to the sqlite3_str object using various 
+** methods, such as [sqlite3_str_appendf()]. 
+** <li> ^The sqlite3_str object is destroyed and the string it created 
+** is returned using the [sqlite3_str_finish()] interface. 
+** </ol> 
+*/ 
+typedef struct sqlite3_str sqlite3_str; 
+ 
+/* 
+** CAPI3REF: Create A New Dynamic String Object 
+** CONSTRUCTOR: sqlite3_str 
+** 
+** ^The [sqlite3_str_new(D)] interface allocates and initializes 
+** a new [sqlite3_str] object.  To avoid memory leaks, the object returned by 
 ** [sqlite3_str_new()] must be freed by a subsequent call to
-** [sqlite3_str_finish(X)].
-**
-** ^The [sqlite3_str_new(D)] interface always returns a pointer to a
-** valid [sqlite3_str] object, though in the event of an out-of-memory
-** error the returned object might be a special singleton that will
+** [sqlite3_str_finish(X)]. 
+** 
+** ^The [sqlite3_str_new(D)] interface always returns a pointer to a 
+** valid [sqlite3_str] object, though in the event of an out-of-memory 
+** error the returned object might be a special singleton that will 
 ** silently reject new text, always return SQLITE_NOMEM from
 ** [sqlite3_str_errcode()], always return 0 for
-** [sqlite3_str_length()], and always return NULL from
-** [sqlite3_str_finish(X)].  It is always safe to use the value
-** returned by [sqlite3_str_new(D)] as the sqlite3_str parameter
-** to any of the other [sqlite3_str] methods.
-**
-** The D parameter to [sqlite3_str_new(D)] may be NULL.  If the
-** D parameter in [sqlite3_str_new(D)] is not NULL, then the maximum
-** length of the string contained in the [sqlite3_str] object will be
-** the value set for [sqlite3_limit](D,[SQLITE_LIMIT_LENGTH]) instead
-** of [SQLITE_MAX_LENGTH].
-*/
-SQLITE_API sqlite3_str *sqlite3_str_new(sqlite3*);
-
-/*
-** CAPI3REF: Finalize A Dynamic String
-** DESTRUCTOR: sqlite3_str
-**
-** ^The [sqlite3_str_finish(X)] interface destroys the sqlite3_str object X
-** and returns a pointer to a memory buffer obtained from [sqlite3_malloc64()]
-** that contains the constructed string.  The calling application should
-** pass the returned value to [sqlite3_free()] to avoid a memory leak.
-** ^The [sqlite3_str_finish(X)] interface may return a NULL pointer if any
-** errors were encountered during construction of the string.  ^The
-** [sqlite3_str_finish(X)] interface will also return a NULL pointer if the
-** string in [sqlite3_str] object X is zero bytes long.
-*/
-SQLITE_API char *sqlite3_str_finish(sqlite3_str*);
-
-/*
-** CAPI3REF: Add Content To A Dynamic String
-** METHOD: sqlite3_str
-**
-** These interfaces add content to an sqlite3_str object previously obtained
-** from [sqlite3_str_new()].
-**
+** [sqlite3_str_length()], and always return NULL from 
+** [sqlite3_str_finish(X)].  It is always safe to use the value 
+** returned by [sqlite3_str_new(D)] as the sqlite3_str parameter 
+** to any of the other [sqlite3_str] methods. 
+** 
+** The D parameter to [sqlite3_str_new(D)] may be NULL.  If the 
+** D parameter in [sqlite3_str_new(D)] is not NULL, then the maximum 
+** length of the string contained in the [sqlite3_str] object will be 
+** the value set for [sqlite3_limit](D,[SQLITE_LIMIT_LENGTH]) instead 
+** of [SQLITE_MAX_LENGTH]. 
+*/ 
+SQLITE_API sqlite3_str *sqlite3_str_new(sqlite3*); 
+ 
+/* 
+** CAPI3REF: Finalize A Dynamic String 
+** DESTRUCTOR: sqlite3_str 
+** 
+** ^The [sqlite3_str_finish(X)] interface destroys the sqlite3_str object X 
+** and returns a pointer to a memory buffer obtained from [sqlite3_malloc64()] 
+** that contains the constructed string.  The calling application should 
+** pass the returned value to [sqlite3_free()] to avoid a memory leak. 
+** ^The [sqlite3_str_finish(X)] interface may return a NULL pointer if any 
+** errors were encountered during construction of the string.  ^The 
+** [sqlite3_str_finish(X)] interface will also return a NULL pointer if the 
+** string in [sqlite3_str] object X is zero bytes long. 
+*/ 
+SQLITE_API char *sqlite3_str_finish(sqlite3_str*); 
+ 
+/* 
+** CAPI3REF: Add Content To A Dynamic String 
+** METHOD: sqlite3_str 
+** 
+** These interfaces add content to an sqlite3_str object previously obtained 
+** from [sqlite3_str_new()]. 
+** 
 ** ^The [sqlite3_str_appendf(X,F,...)] and
-** [sqlite3_str_vappendf(X,F,V)] interfaces uses the [built-in printf]
+** [sqlite3_str_vappendf(X,F,V)] interfaces uses the [built-in printf] 
 ** functionality of SQLite to append formatted text onto the end of
-** [sqlite3_str] object X.
-**
-** ^The [sqlite3_str_append(X,S,N)] method appends exactly N bytes from string S
-** onto the end of the [sqlite3_str] object X.  N must be non-negative.
-** S must contain at least N non-zero bytes of content.  To append a
-** zero-terminated string in its entirety, use the [sqlite3_str_appendall()]
-** method instead.
-**
-** ^The [sqlite3_str_appendall(X,S)] method appends the complete content of
-** zero-terminated string S onto the end of [sqlite3_str] object X.
-**
-** ^The [sqlite3_str_appendchar(X,N,C)] method appends N copies of the
-** single-byte character C onto the end of [sqlite3_str] object X.
-** ^This method can be used, for example, to add whitespace indentation.
-**
-** ^The [sqlite3_str_reset(X)] method resets the string under construction
+** [sqlite3_str] object X. 
+** 
+** ^The [sqlite3_str_append(X,S,N)] method appends exactly N bytes from string S 
+** onto the end of the [sqlite3_str] object X.  N must be non-negative. 
+** S must contain at least N non-zero bytes of content.  To append a 
+** zero-terminated string in its entirety, use the [sqlite3_str_appendall()] 
+** method instead. 
+** 
+** ^The [sqlite3_str_appendall(X,S)] method appends the complete content of 
+** zero-terminated string S onto the end of [sqlite3_str] object X. 
+** 
+** ^The [sqlite3_str_appendchar(X,N,C)] method appends N copies of the 
+** single-byte character C onto the end of [sqlite3_str] object X. 
+** ^This method can be used, for example, to add whitespace indentation. 
+** 
+** ^The [sqlite3_str_reset(X)] method resets the string under construction 
 ** inside [sqlite3_str] object X back to zero bytes in length.
-**
-** These methods do not return a result code.  ^If an error occurs, that fact
-** is recorded in the [sqlite3_str] object and can be recovered by a
-** subsequent call to [sqlite3_str_errcode(X)].
-*/
-SQLITE_API void sqlite3_str_appendf(sqlite3_str*, const char *zFormat, ...);
-SQLITE_API void sqlite3_str_vappendf(sqlite3_str*, const char *zFormat, va_list);
-SQLITE_API void sqlite3_str_append(sqlite3_str*, const char *zIn, int N);
-SQLITE_API void sqlite3_str_appendall(sqlite3_str*, const char *zIn);
-SQLITE_API void sqlite3_str_appendchar(sqlite3_str*, int N, char C);
-SQLITE_API void sqlite3_str_reset(sqlite3_str*);
-
-/*
-** CAPI3REF: Status Of A Dynamic String
-** METHOD: sqlite3_str
-**
-** These interfaces return the current status of an [sqlite3_str] object.
-**
-** ^If any prior errors have occurred while constructing the dynamic string
-** in sqlite3_str X, then the [sqlite3_str_errcode(X)] method will return
-** an appropriate error code.  ^The [sqlite3_str_errcode(X)] method returns
-** [SQLITE_NOMEM] following any out-of-memory error, or
-** [SQLITE_TOOBIG] if the size of the dynamic string exceeds
-** [SQLITE_MAX_LENGTH], or [SQLITE_OK] if there have been no errors.
-**
-** ^The [sqlite3_str_length(X)] method returns the current length, in bytes,
-** of the dynamic string under construction in [sqlite3_str] object X.
-** ^The length returned by [sqlite3_str_length(X)] does not include the
-** zero-termination byte.
-**
-** ^The [sqlite3_str_value(X)] method returns a pointer to the current
-** content of the dynamic string under construction in X.  The value
-** returned by [sqlite3_str_value(X)] is managed by the sqlite3_str object X
-** and might be freed or altered by any subsequent method on the same
-** [sqlite3_str] object.  Applications must not used the pointer returned
-** [sqlite3_str_value(X)] after any subsequent method call on the same
-** object.  ^Applications may change the content of the string returned
-** by [sqlite3_str_value(X)] as long as they do not write into any bytes
-** outside the range of 0 to [sqlite3_str_length(X)] and do not read or
-** write any byte after any subsequent sqlite3_str method call.
-*/
-SQLITE_API int sqlite3_str_errcode(sqlite3_str*);
-SQLITE_API int sqlite3_str_length(sqlite3_str*);
-SQLITE_API char *sqlite3_str_value(sqlite3_str*);
-
-/*
+** 
+** These methods do not return a result code.  ^If an error occurs, that fact 
+** is recorded in the [sqlite3_str] object and can be recovered by a 
+** subsequent call to [sqlite3_str_errcode(X)]. 
+*/ 
+SQLITE_API void sqlite3_str_appendf(sqlite3_str*, const char *zFormat, ...); 
+SQLITE_API void sqlite3_str_vappendf(sqlite3_str*, const char *zFormat, va_list); 
+SQLITE_API void sqlite3_str_append(sqlite3_str*, const char *zIn, int N); 
+SQLITE_API void sqlite3_str_appendall(sqlite3_str*, const char *zIn); 
+SQLITE_API void sqlite3_str_appendchar(sqlite3_str*, int N, char C); 
+SQLITE_API void sqlite3_str_reset(sqlite3_str*); 
+ 
+/* 
+** CAPI3REF: Status Of A Dynamic String 
+** METHOD: sqlite3_str 
+** 
+** These interfaces return the current status of an [sqlite3_str] object. 
+** 
+** ^If any prior errors have occurred while constructing the dynamic string 
+** in sqlite3_str X, then the [sqlite3_str_errcode(X)] method will return 
+** an appropriate error code.  ^The [sqlite3_str_errcode(X)] method returns 
+** [SQLITE_NOMEM] following any out-of-memory error, or 
+** [SQLITE_TOOBIG] if the size of the dynamic string exceeds 
+** [SQLITE_MAX_LENGTH], or [SQLITE_OK] if there have been no errors. 
+** 
+** ^The [sqlite3_str_length(X)] method returns the current length, in bytes, 
+** of the dynamic string under construction in [sqlite3_str] object X. 
+** ^The length returned by [sqlite3_str_length(X)] does not include the 
+** zero-termination byte. 
+** 
+** ^The [sqlite3_str_value(X)] method returns a pointer to the current 
+** content of the dynamic string under construction in X.  The value 
+** returned by [sqlite3_str_value(X)] is managed by the sqlite3_str object X 
+** and might be freed or altered by any subsequent method on the same 
+** [sqlite3_str] object.  Applications must not used the pointer returned 
+** [sqlite3_str_value(X)] after any subsequent method call on the same 
+** object.  ^Applications may change the content of the string returned 
+** by [sqlite3_str_value(X)] as long as they do not write into any bytes 
+** outside the range of 0 to [sqlite3_str_length(X)] and do not read or 
+** write any byte after any subsequent sqlite3_str method call. 
+*/ 
+SQLITE_API int sqlite3_str_errcode(sqlite3_str*); 
+SQLITE_API int sqlite3_str_length(sqlite3_str*); 
+SQLITE_API char *sqlite3_str_value(sqlite3_str*); 
+ 
+/* 
 ** CAPI3REF: SQLite Runtime Status
 **
 ** ^These interfaces are used to retrieve runtime status information
@@ -8362,15 +8362,15 @@ SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int r
 ** highwater mark associated with SQLITE_DBSTATUS_CACHE_WRITE is always 0.
 ** </dd>
 **
-** [[SQLITE_DBSTATUS_CACHE_SPILL]] ^(<dt>SQLITE_DBSTATUS_CACHE_SPILL</dt>
-** <dd>This parameter returns the number of dirty cache entries that have
-** been written to disk in the middle of a transaction due to the page
-** cache overflowing. Transactions are more efficient if they are written
-** to disk all at once. When pages spill mid-transaction, that introduces
-** additional overhead. This parameter can be used help identify
+** [[SQLITE_DBSTATUS_CACHE_SPILL]] ^(<dt>SQLITE_DBSTATUS_CACHE_SPILL</dt> 
+** <dd>This parameter returns the number of dirty cache entries that have 
+** been written to disk in the middle of a transaction due to the page 
+** cache overflowing. Transactions are more efficient if they are written 
+** to disk all at once. When pages spill mid-transaction, that introduces 
+** additional overhead. This parameter can be used help identify 
 ** inefficiencies that can be resolved by increasing the cache size.
-** </dd>
-**
+** </dd> 
+** 
 ** [[SQLITE_DBSTATUS_DEFERRED_FKS]] ^(<dt>SQLITE_DBSTATUS_DEFERRED_FKS</dt>
 ** <dd>This parameter returns zero for the current value if and only if
 ** all foreign key constraints (deferred or immediate) have been
@@ -8390,8 +8390,8 @@ SQLITE_API int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int r
 #define SQLITE_DBSTATUS_CACHE_WRITE          9
 #define SQLITE_DBSTATUS_DEFERRED_FKS        10
 #define SQLITE_DBSTATUS_CACHE_USED_SHARED   11
-#define SQLITE_DBSTATUS_CACHE_SPILL         12
-#define SQLITE_DBSTATUS_MAX                 12   /* Largest defined DBSTATUS */
+#define SQLITE_DBSTATUS_CACHE_SPILL         12 
+#define SQLITE_DBSTATUS_MAX                 12   /* Largest defined DBSTATUS */ 
 
 
 /*
@@ -9353,7 +9353,7 @@ SQLITE_API int sqlite3_vtab_config(sqlite3*, int op, ...);
 ** can use to customize and optimize their behavior.
 **
 ** <dl>
-** [[SQLITE_VTAB_CONSTRAINT_SUPPORT]]
+** [[SQLITE_VTAB_CONSTRAINT_SUPPORT]] 
 ** <dt>SQLITE_VTAB_CONSTRAINT_SUPPORT</dt>
 ** <dd>Calls of the form
 ** [sqlite3_vtab_config](db,SQLITE_VTAB_CONSTRAINT_SUPPORT,X) are supported,
@@ -9430,10 +9430,10 @@ SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *);
 ** column value will not change.  The virtual table implementation can use
 ** this hint as permission to substitute a return value that is less
 ** expensive to compute and that the corresponding
-** [xUpdate] method understands as a "no-change" value.
+** [xUpdate] method understands as a "no-change" value. 
 **
 ** If the [xColumn] method calls sqlite3_vtab_nochange() and finds that
-** the column is not changed by the UPDATE statement, then the xColumn
+** the column is not changed by the UPDATE statement, then the xColumn 
 ** method can optionally return without setting a result, without calling
 ** any of the [sqlite3_result_int|sqlite3_result_xxxxx() interfaces].
 ** In that case, [sqlite3_value_nochange(X)] will return true for the
@@ -9768,7 +9768,7 @@ typedef struct sqlite3_snapshot {
 
 /*
 ** CAPI3REF: Record A Database Snapshot
-** CONSTRUCTOR: sqlite3_snapshot
+** CONSTRUCTOR: sqlite3_snapshot 
 **
 ** ^The [sqlite3_snapshot_get(D,S,P)] interface attempts to make a
 ** new [sqlite3_snapshot] object that records the current state of
@@ -9784,7 +9784,7 @@ typedef struct sqlite3_snapshot {
 ** in this case.
 **
 ** <ul>
-**   <li> The database handle must not be in [autocommit mode].
+**   <li> The database handle must not be in [autocommit mode]. 
 **
 **   <li> Schema S of [database connection] D must be a [WAL mode] database.
 **
@@ -9807,7 +9807,7 @@ typedef struct sqlite3_snapshot {
 ** to avoid a memory leak.
 **
 ** The [sqlite3_snapshot_get()] interface is only available when the
-** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
+** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. 
 */
 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_get(
   sqlite3 *db,
@@ -9817,35 +9817,35 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_get(
 
 /*
 ** CAPI3REF: Start a read transaction on an historical snapshot
-** METHOD: sqlite3_snapshot
+** METHOD: sqlite3_snapshot 
 **
 ** ^The [sqlite3_snapshot_open(D,S,P)] interface either starts a new read
 ** transaction or upgrades an existing one for schema S of
 ** [database connection] D such that the read transaction refers to
 ** historical [snapshot] P, rather than the most recent change to the
 ** database. ^The [sqlite3_snapshot_open()] interface returns SQLITE_OK
-** on success or an appropriate [error code] if it fails.
+** on success or an appropriate [error code] if it fails. 
 **
 ** ^In order to succeed, the database connection must not be in
-** [autocommit mode] when [sqlite3_snapshot_open(D,S,P)] is called. If there
-** is already a read transaction open on schema S, then the database handle
-** must have no active statements (SELECT statements that have been passed
+** [autocommit mode] when [sqlite3_snapshot_open(D,S,P)] is called. If there 
+** is already a read transaction open on schema S, then the database handle 
+** must have no active statements (SELECT statements that have been passed 
 ** to sqlite3_step() but not sqlite3_reset() or sqlite3_finalize()).
-** SQLITE_ERROR is returned if either of these conditions is violated, or
-** if schema S does not exist, or if the snapshot object is invalid.
-**
-** ^A call to sqlite3_snapshot_open() will fail to open if the specified
+** SQLITE_ERROR is returned if either of these conditions is violated, or 
+** if schema S does not exist, or if the snapshot object is invalid. 
+** 
+** ^A call to sqlite3_snapshot_open() will fail to open if the specified 
 ** snapshot has been overwritten by a [checkpoint]. In this case
-** SQLITE_ERROR_SNAPSHOT is returned.
-**
+** SQLITE_ERROR_SNAPSHOT is returned. 
+** 
 ** If there is already a read transaction open when this function is
-** invoked, then the same read transaction remains open (on the same
-** database snapshot) if SQLITE_ERROR, SQLITE_BUSY or SQLITE_ERROR_SNAPSHOT
-** is returned. If another error code - for example SQLITE_PROTOCOL or an
-** SQLITE_IOERR error code - is returned, then the final state of the
+** invoked, then the same read transaction remains open (on the same 
+** database snapshot) if SQLITE_ERROR, SQLITE_BUSY or SQLITE_ERROR_SNAPSHOT 
+** is returned. If another error code - for example SQLITE_PROTOCOL or an 
+** SQLITE_IOERR error code - is returned, then the final state of the 
 ** read transaction is undefined. If SQLITE_OK is returned, then the
-** read transaction is now open on database snapshot P.
-**
+** read transaction is now open on database snapshot P. 
+** 
 ** ^(A call to [sqlite3_snapshot_open(D,S,P)] will fail if the
 ** database connection D does not know that the database file for
 ** schema S is in [WAL mode].  A database connection might not know
@@ -9856,7 +9856,7 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_get(
 ** database connection in order to make it ready to use snapshots.)
 **
 ** The [sqlite3_snapshot_open()] interface is only available when the
-** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
+** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. 
 */
 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_open(
   sqlite3 *db,
@@ -9866,20 +9866,20 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_open(
 
 /*
 ** CAPI3REF: Destroy a snapshot
-** DESTRUCTOR: sqlite3_snapshot
+** DESTRUCTOR: sqlite3_snapshot 
 **
 ** ^The [sqlite3_snapshot_free(P)] interface destroys [sqlite3_snapshot] P.
 ** The application must eventually free every [sqlite3_snapshot] object
 ** using this routine to avoid a memory leak.
 **
 ** The [sqlite3_snapshot_free()] interface is only available when the
-** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used.
+** [SQLITE_ENABLE_SNAPSHOT] compile-time option is used. 
 */
 SQLITE_API SQLITE_EXPERIMENTAL void sqlite3_snapshot_free(sqlite3_snapshot*);
 
 /*
 ** CAPI3REF: Compare the ages of two snapshot handles.
-** METHOD: sqlite3_snapshot
+** METHOD: sqlite3_snapshot 
 **
 ** The sqlite3_snapshot_cmp(P1, P2) interface is used to compare the ages
 ** of two valid snapshot handles.
@@ -9898,9 +9898,9 @@ SQLITE_API SQLITE_EXPERIMENTAL void sqlite3_snapshot_free(sqlite3_snapshot*);
 ** Otherwise, this API returns a negative value if P1 refers to an older
 ** snapshot than P2, zero if the two handles refer to the same database
 ** snapshot, and a positive value if P1 is a newer snapshot than P2.
-**
-** This interface is only available if SQLite is compiled with the
-** [SQLITE_ENABLE_SNAPSHOT] option.
+** 
+** This interface is only available if SQLite is compiled with the 
+** [SQLITE_ENABLE_SNAPSHOT] option. 
 */
 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_cmp(
   sqlite3_snapshot *p1,
@@ -9909,156 +9909,156 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_cmp(
 
 /*
 ** CAPI3REF: Recover snapshots from a wal file
-** METHOD: sqlite3_snapshot
+** METHOD: sqlite3_snapshot 
 **
-** If a [WAL file] remains on disk after all database connections close
-** (either through the use of the [SQLITE_FCNTL_PERSIST_WAL] [file control]
-** or because the last process to have the database opened exited without
-** calling [sqlite3_close()]) and a new connection is subsequently opened
-** on that database and [WAL file], the [sqlite3_snapshot_open()] interface
-** will only be able to open the last transaction added to the WAL file
-** even though the WAL file contains other valid transactions.
+** If a [WAL file] remains on disk after all database connections close 
+** (either through the use of the [SQLITE_FCNTL_PERSIST_WAL] [file control] 
+** or because the last process to have the database opened exited without 
+** calling [sqlite3_close()]) and a new connection is subsequently opened 
+** on that database and [WAL file], the [sqlite3_snapshot_open()] interface 
+** will only be able to open the last transaction added to the WAL file 
+** even though the WAL file contains other valid transactions. 
 **
-** This function attempts to scan the WAL file associated with database zDb
+** This function attempts to scan the WAL file associated with database zDb 
 ** of database handle db and make all valid snapshots available to
 ** sqlite3_snapshot_open(). It is an error if there is already a read
-** transaction open on the database, or if the database is not a WAL mode
+** transaction open on the database, or if the database is not a WAL mode 
 ** database.
 **
 ** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
-**
-** This interface is only available if SQLite is compiled with the
-** [SQLITE_ENABLE_SNAPSHOT] option.
+** 
+** This interface is only available if SQLite is compiled with the 
+** [SQLITE_ENABLE_SNAPSHOT] option. 
 */
 SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb);
 
 /*
-** CAPI3REF: Serialize a database
-**
-** The sqlite3_serialize(D,S,P,F) interface returns a pointer to memory
-** that is a serialization of the S database on [database connection] D.
-** If P is not a NULL pointer, then the size of the database in bytes
-** is written into *P.
-**
-** For an ordinary on-disk database file, the serialization is just a
-** copy of the disk file.  For an in-memory database or a "TEMP" database,
-** the serialization is the same sequence of bytes which would be written
-** to disk if that database where backed up to disk.
-**
-** The usual case is that sqlite3_serialize() copies the serialization of
-** the database into memory obtained from [sqlite3_malloc64()] and returns
-** a pointer to that memory.  The caller is responsible for freeing the
-** returned value to avoid a memory leak.  However, if the F argument
-** contains the SQLITE_SERIALIZE_NOCOPY bit, then no memory allocations
-** are made, and the sqlite3_serialize() function will return a pointer
-** to the contiguous memory representation of the database that SQLite
-** is currently using for that database, or NULL if the no such contiguous
-** memory representation of the database exists.  A contiguous memory
-** representation of the database will usually only exist if there has
-** been a prior call to [sqlite3_deserialize(D,S,...)] with the same
-** values of D and S.
+** CAPI3REF: Serialize a database 
+** 
+** The sqlite3_serialize(D,S,P,F) interface returns a pointer to memory 
+** that is a serialization of the S database on [database connection] D. 
+** If P is not a NULL pointer, then the size of the database in bytes 
+** is written into *P. 
+** 
+** For an ordinary on-disk database file, the serialization is just a 
+** copy of the disk file.  For an in-memory database or a "TEMP" database, 
+** the serialization is the same sequence of bytes which would be written 
+** to disk if that database where backed up to disk. 
+** 
+** The usual case is that sqlite3_serialize() copies the serialization of 
+** the database into memory obtained from [sqlite3_malloc64()] and returns 
+** a pointer to that memory.  The caller is responsible for freeing the 
+** returned value to avoid a memory leak.  However, if the F argument 
+** contains the SQLITE_SERIALIZE_NOCOPY bit, then no memory allocations 
+** are made, and the sqlite3_serialize() function will return a pointer 
+** to the contiguous memory representation of the database that SQLite 
+** is currently using for that database, or NULL if the no such contiguous 
+** memory representation of the database exists.  A contiguous memory 
+** representation of the database will usually only exist if there has 
+** been a prior call to [sqlite3_deserialize(D,S,...)] with the same 
+** values of D and S. 
 ** The size of the database is written into *P even if the
-** SQLITE_SERIALIZE_NOCOPY bit is set but no contiguous copy
-** of the database exists.
-**
-** A call to sqlite3_serialize(D,S,P,F) might return NULL even if the
-** SQLITE_SERIALIZE_NOCOPY bit is omitted from argument F if a memory
-** allocation error occurs.
-**
+** SQLITE_SERIALIZE_NOCOPY bit is set but no contiguous copy 
+** of the database exists. 
+** 
+** A call to sqlite3_serialize(D,S,P,F) might return NULL even if the 
+** SQLITE_SERIALIZE_NOCOPY bit is omitted from argument F if a memory 
+** allocation error occurs. 
+** 
 ** This interface is omitted if SQLite is compiled with the
 ** [SQLITE_OMIT_DESERIALIZE] option.
-*/
-SQLITE_API unsigned char *sqlite3_serialize(
-  sqlite3 *db,           /* The database connection */
-  const char *zSchema,   /* Which DB to serialize. ex: "main", "temp", ... */
-  sqlite3_int64 *piSize, /* Write size of the DB here, if not NULL */
-  unsigned int mFlags    /* Zero or more SQLITE_SERIALIZE_* flags */
-);
-
-/*
-** CAPI3REF: Flags for sqlite3_serialize
-**
-** Zero or more of the following constants can be OR-ed together for
-** the F argument to [sqlite3_serialize(D,S,P,F)].
-**
-** SQLITE_SERIALIZE_NOCOPY means that [sqlite3_serialize()] will return
-** a pointer to contiguous in-memory database that it is currently using,
-** without making a copy of the database.  If SQLite is not currently using
-** a contiguous in-memory database, then this option causes
-** [sqlite3_serialize()] to return a NULL pointer.  SQLite will only be
-** using a contiguous in-memory database if it has been initialized by a
-** prior call to [sqlite3_deserialize()].
-*/
-#define SQLITE_SERIALIZE_NOCOPY 0x001   /* Do no memory allocations */
-
-/*
-** CAPI3REF: Deserialize a database
-**
+*/ 
+SQLITE_API unsigned char *sqlite3_serialize( 
+  sqlite3 *db,           /* The database connection */ 
+  const char *zSchema,   /* Which DB to serialize. ex: "main", "temp", ... */ 
+  sqlite3_int64 *piSize, /* Write size of the DB here, if not NULL */ 
+  unsigned int mFlags    /* Zero or more SQLITE_SERIALIZE_* flags */ 
+); 
+ 
+/* 
+** CAPI3REF: Flags for sqlite3_serialize 
+** 
+** Zero or more of the following constants can be OR-ed together for 
+** the F argument to [sqlite3_serialize(D,S,P,F)]. 
+** 
+** SQLITE_SERIALIZE_NOCOPY means that [sqlite3_serialize()] will return 
+** a pointer to contiguous in-memory database that it is currently using, 
+** without making a copy of the database.  If SQLite is not currently using 
+** a contiguous in-memory database, then this option causes 
+** [sqlite3_serialize()] to return a NULL pointer.  SQLite will only be 
+** using a contiguous in-memory database if it has been initialized by a 
+** prior call to [sqlite3_deserialize()]. 
+*/ 
+#define SQLITE_SERIALIZE_NOCOPY 0x001   /* Do no memory allocations */ 
+ 
+/* 
+** CAPI3REF: Deserialize a database 
+** 
 ** The sqlite3_deserialize(D,S,P,N,M,F) interface causes the
-** [database connection] D to disconnect from database S and then
-** reopen S as an in-memory database based on the serialization contained
-** in P.  The serialized database P is N bytes in size.  M is the size of
-** the buffer P, which might be larger than N.  If M is larger than N, and
-** the SQLITE_DESERIALIZE_READONLY bit is not set in F, then SQLite is
-** permitted to add content to the in-memory database as long as the total
-** size does not exceed M bytes.
-**
-** If the SQLITE_DESERIALIZE_FREEONCLOSE bit is set in F, then SQLite will
-** invoke sqlite3_free() on the serialization buffer when the database
-** connection closes.  If the SQLITE_DESERIALIZE_RESIZEABLE bit is set, then
-** SQLite will try to increase the buffer size using sqlite3_realloc64()
-** if writes on the database cause it to grow larger than M bytes.
-**
-** The sqlite3_deserialize() interface will fail with SQLITE_BUSY if the
-** database is currently in a read transaction or is involved in a backup
-** operation.
-**
+** [database connection] D to disconnect from database S and then 
+** reopen S as an in-memory database based on the serialization contained 
+** in P.  The serialized database P is N bytes in size.  M is the size of 
+** the buffer P, which might be larger than N.  If M is larger than N, and 
+** the SQLITE_DESERIALIZE_READONLY bit is not set in F, then SQLite is 
+** permitted to add content to the in-memory database as long as the total 
+** size does not exceed M bytes. 
+** 
+** If the SQLITE_DESERIALIZE_FREEONCLOSE bit is set in F, then SQLite will 
+** invoke sqlite3_free() on the serialization buffer when the database 
+** connection closes.  If the SQLITE_DESERIALIZE_RESIZEABLE bit is set, then 
+** SQLite will try to increase the buffer size using sqlite3_realloc64() 
+** if writes on the database cause it to grow larger than M bytes. 
+** 
+** The sqlite3_deserialize() interface will fail with SQLITE_BUSY if the 
+** database is currently in a read transaction or is involved in a backup 
+** operation. 
+** 
 ** It is not possible to deserialized into the TEMP database.  If the
 ** S argument to sqlite3_deserialize(D,S,P,N,M,F) is "temp" then the
 ** function returns SQLITE_ERROR.
 **
 ** If sqlite3_deserialize(D,S,P,N,M,F) fails for any reason and if the
-** SQLITE_DESERIALIZE_FREEONCLOSE bit is set in argument F, then
-** [sqlite3_free()] is invoked on argument P prior to returning.
-**
+** SQLITE_DESERIALIZE_FREEONCLOSE bit is set in argument F, then 
+** [sqlite3_free()] is invoked on argument P prior to returning. 
+** 
 ** This interface is omitted if SQLite is compiled with the
 ** [SQLITE_OMIT_DESERIALIZE] option.
-*/
-SQLITE_API int sqlite3_deserialize(
-  sqlite3 *db,            /* The database connection */
-  const char *zSchema,    /* Which DB to reopen with the deserialization */
-  unsigned char *pData,   /* The serialized database content */
-  sqlite3_int64 szDb,     /* Number bytes in the deserialization */
-  sqlite3_int64 szBuf,    /* Total size of buffer pData[] */
-  unsigned mFlags         /* Zero or more SQLITE_DESERIALIZE_* flags */
-);
-
-/*
-** CAPI3REF: Flags for sqlite3_deserialize()
-**
-** The following are allowed values for 6th argument (the F argument) to
-** the [sqlite3_deserialize(D,S,P,N,M,F)] interface.
-**
-** The SQLITE_DESERIALIZE_FREEONCLOSE means that the database serialization
-** in the P argument is held in memory obtained from [sqlite3_malloc64()]
-** and that SQLite should take ownership of this memory and automatically
-** free it when it has finished using it.  Without this flag, the caller
-** is responsible for freeing any dynamically allocated memory.
-**
-** The SQLITE_DESERIALIZE_RESIZEABLE flag means that SQLite is allowed to
-** grow the size of the database using calls to [sqlite3_realloc64()].  This
-** flag should only be used if SQLITE_DESERIALIZE_FREEONCLOSE is also used.
-** Without this flag, the deserialized database cannot increase in size beyond
-** the number of bytes specified by the M parameter.
-**
-** The SQLITE_DESERIALIZE_READONLY flag means that the deserialized database
-** should be treated as read-only.
-*/
-#define SQLITE_DESERIALIZE_FREEONCLOSE 1 /* Call sqlite3_free() on close */
-#define SQLITE_DESERIALIZE_RESIZEABLE  2 /* Resize using sqlite3_realloc64() */
-#define SQLITE_DESERIALIZE_READONLY    4 /* Database is read-only */
-
-/*
+*/ 
+SQLITE_API int sqlite3_deserialize( 
+  sqlite3 *db,            /* The database connection */ 
+  const char *zSchema,    /* Which DB to reopen with the deserialization */ 
+  unsigned char *pData,   /* The serialized database content */ 
+  sqlite3_int64 szDb,     /* Number bytes in the deserialization */ 
+  sqlite3_int64 szBuf,    /* Total size of buffer pData[] */ 
+  unsigned mFlags         /* Zero or more SQLITE_DESERIALIZE_* flags */ 
+); 
+ 
+/* 
+** CAPI3REF: Flags for sqlite3_deserialize() 
+** 
+** The following are allowed values for 6th argument (the F argument) to 
+** the [sqlite3_deserialize(D,S,P,N,M,F)] interface. 
+** 
+** The SQLITE_DESERIALIZE_FREEONCLOSE means that the database serialization 
+** in the P argument is held in memory obtained from [sqlite3_malloc64()] 
+** and that SQLite should take ownership of this memory and automatically 
+** free it when it has finished using it.  Without this flag, the caller 
+** is responsible for freeing any dynamically allocated memory. 
+** 
+** The SQLITE_DESERIALIZE_RESIZEABLE flag means that SQLite is allowed to 
+** grow the size of the database using calls to [sqlite3_realloc64()].  This 
+** flag should only be used if SQLITE_DESERIALIZE_FREEONCLOSE is also used. 
+** Without this flag, the deserialized database cannot increase in size beyond 
+** the number of bytes specified by the M parameter. 
+** 
+** The SQLITE_DESERIALIZE_READONLY flag means that the deserialized database 
+** should be treated as read-only. 
+*/ 
+#define SQLITE_DESERIALIZE_FREEONCLOSE 1 /* Call sqlite3_free() on close */ 
+#define SQLITE_DESERIALIZE_RESIZEABLE  2 /* Resize using sqlite3_realloc64() */ 
+#define SQLITE_DESERIALIZE_READONLY    4 /* Database is read-only */ 
+ 
+/* 
 ** Undo the hack that converts floating point types to integer for
 ** builds on processors without floating point support.
 */
@@ -10169,7 +10169,7 @@ struct sqlite3_rtree_query_info {
   sqlite3_int64 iRowid;             /* Rowid for current entry */
   sqlite3_rtree_dbl rParentScore;   /* Score of parent node */
   int eParentWithin;                /* Visibility of parent node */
-  int eWithin;                      /* OUT: Visibility */
+  int eWithin;                      /* OUT: Visibility */ 
   sqlite3_rtree_dbl rScore;         /* OUT: Write the score here */
   /* The following fields are only available in 3.8.11 and later */
   sqlite3_value **apSqlParam;       /* Original SQL values of parameters */
@@ -10205,23 +10205,23 @@ extern "C" {
 
 /*
 ** CAPI3REF: Session Object Handle
-**
-** An instance of this object is a [session] that can be used to
-** record changes to a database.
+** 
+** An instance of this object is a [session] that can be used to 
+** record changes to a database. 
 */
 typedef struct sqlite3_session sqlite3_session;
 
 /*
 ** CAPI3REF: Changeset Iterator Handle
-**
-** An instance of this object acts as a cursor for iterating
-** over the elements of a [changeset] or [patchset].
+** 
+** An instance of this object acts as a cursor for iterating 
+** over the elements of a [changeset] or [patchset]. 
 */
 typedef struct sqlite3_changeset_iter sqlite3_changeset_iter;
 
 /*
 ** CAPI3REF: Create A New Session Object
-** CONSTRUCTOR: sqlite3_session
+** CONSTRUCTOR: sqlite3_session 
 **
 ** Create a new session object attached to database handle db. If successful,
 ** a pointer to the new object is written to *ppSession and SQLITE_OK is
@@ -10258,7 +10258,7 @@ SQLITE_API int sqlite3session_create(
 
 /*
 ** CAPI3REF: Delete A Session Object
-** DESTRUCTOR: sqlite3_session
+** DESTRUCTOR: sqlite3_session 
 **
 ** Delete a session object previously allocated using
 ** [sqlite3session_create()]. Once a session object has been deleted, the
@@ -10306,7 +10306,7 @@ SQLITE_API int sqlite3session_object_config(sqlite3_session*, int op, void *pArg
 
 /*
 ** CAPI3REF: Enable Or Disable A Session Object
-** METHOD: sqlite3_session
+** METHOD: sqlite3_session 
 **
 ** Enable or disable the recording of changes by a session object. When
 ** enabled, a session object records changes made to the database. When
@@ -10326,7 +10326,7 @@ SQLITE_API int sqlite3session_enable(sqlite3_session *pSession, int bEnable);
 
 /*
 ** CAPI3REF: Set Or Clear the Indirect Change Flag
-** METHOD: sqlite3_session
+** METHOD: sqlite3_session 
 **
 ** Each change recorded by a session object is marked as either direct or
 ** indirect. A change is marked as indirect if either:
@@ -10356,7 +10356,7 @@ SQLITE_API int sqlite3session_indirect(sqlite3_session *pSession, int bIndirect)
 
 /*
 ** CAPI3REF: Attach A Table To A Session Object
-** METHOD: sqlite3_session
+** METHOD: sqlite3_session 
 **
 ** If argument zTab is not NULL, then it is the name of a table to attach
 ** to the session object passed as the first argument. All subsequent changes
@@ -10419,7 +10419,7 @@ SQLITE_API int sqlite3session_attach(
 
 /*
 ** CAPI3REF: Set a table filter on a Session Object.
-** METHOD: sqlite3_session
+** METHOD: sqlite3_session 
 **
 ** The second argument (xFilter) is the "filter callback". For changes to rows
 ** in tables that are not attached to the Session object, the filter is called
@@ -10438,7 +10438,7 @@ SQLITE_API void sqlite3session_table_filter(
 
 /*
 ** CAPI3REF: Generate A Changeset From A Session Object
-** METHOD: sqlite3_session
+** METHOD: sqlite3_session 
 **
 ** Obtain a changeset containing changes to the tables attached to the
 ** session object passed as the first argument. If successful,
@@ -10564,8 +10564,8 @@ SQLITE_API int sqlite3session_changeset(
 SQLITE_API sqlite3_int64 sqlite3session_changeset_size(sqlite3_session *pSession);
 
 /*
-** CAPI3REF: Load The Difference Between Tables Into A Session
-** METHOD: sqlite3_session
+** CAPI3REF: Load The Difference Between Tables Into A Session 
+** METHOD: sqlite3_session 
 **
 ** If it is not already attached to the session object passed as the first
 ** argument, this function attaches table zTbl in the same manner as the
@@ -10630,7 +10630,7 @@ SQLITE_API int sqlite3session_diff(
 
 /*
 ** CAPI3REF: Generate A Patchset From A Session Object
-** METHOD: sqlite3_session
+** METHOD: sqlite3_session 
 **
 ** The differences between a patchset and a changeset are that:
 **
@@ -10690,7 +10690,7 @@ SQLITE_API sqlite3_int64 sqlite3session_memory_used(sqlite3_session *pSession);
 
 /*
 ** CAPI3REF: Create An Iterator To Traverse A Changeset
-** CONSTRUCTOR: sqlite3_changeset_iter
+** CONSTRUCTOR: sqlite3_changeset_iter 
 **
 ** Create an iterator used to iterate through the contents of a changeset.
 ** If successful, *pp is set to point to the iterator handle and SQLITE_OK
@@ -10721,43 +10721,43 @@ SQLITE_API sqlite3_int64 sqlite3session_memory_used(sqlite3_session *pSession);
 ** consecutively. There is no chance that the iterator will visit a change
 ** the applies to table X, then one for table Y, and then later on visit
 ** another change for table X.
-**
-** The behavior of sqlite3changeset_start_v2() and its streaming equivalent
-** may be modified by passing a combination of
-** [SQLITE_CHANGESETSTART_INVERT | supported flags] as the 4th parameter.
-**
-** Note that the sqlite3changeset_start_v2() API is still <b>experimental</b>
-** and therefore subject to change.
+** 
+** The behavior of sqlite3changeset_start_v2() and its streaming equivalent 
+** may be modified by passing a combination of 
+** [SQLITE_CHANGESETSTART_INVERT | supported flags] as the 4th parameter. 
+** 
+** Note that the sqlite3changeset_start_v2() API is still <b>experimental</b> 
+** and therefore subject to change. 
 */
 SQLITE_API int sqlite3changeset_start(
   sqlite3_changeset_iter **pp,    /* OUT: New changeset iterator handle */
   int nChangeset,                 /* Size of changeset blob in bytes */
   void *pChangeset                /* Pointer to blob containing changeset */
 );
-SQLITE_API int sqlite3changeset_start_v2(
-  sqlite3_changeset_iter **pp,    /* OUT: New changeset iterator handle */
-  int nChangeset,                 /* Size of changeset blob in bytes */
-  void *pChangeset,               /* Pointer to blob containing changeset */
-  int flags                       /* SESSION_CHANGESETSTART_* flags */
-);
-
-/*
-** CAPI3REF: Flags for sqlite3changeset_start_v2
-**
-** The following flags may passed via the 4th parameter to
-** [sqlite3changeset_start_v2] and [sqlite3changeset_start_v2_strm]:
-**
-** <dt>SQLITE_CHANGESETAPPLY_INVERT <dd>
-**   Invert the changeset while iterating through it. This is equivalent to
-**   inverting a changeset using sqlite3changeset_invert() before applying it.
-**   It is an error to specify this flag with a patchset.
-*/
-#define SQLITE_CHANGESETSTART_INVERT        0x0002
-
-
+SQLITE_API int sqlite3changeset_start_v2( 
+  sqlite3_changeset_iter **pp,    /* OUT: New changeset iterator handle */ 
+  int nChangeset,                 /* Size of changeset blob in bytes */ 
+  void *pChangeset,               /* Pointer to blob containing changeset */ 
+  int flags                       /* SESSION_CHANGESETSTART_* flags */ 
+); 
+
+/* 
+** CAPI3REF: Flags for sqlite3changeset_start_v2 
+** 
+** The following flags may passed via the 4th parameter to 
+** [sqlite3changeset_start_v2] and [sqlite3changeset_start_v2_strm]: 
+** 
+** <dt>SQLITE_CHANGESETAPPLY_INVERT <dd> 
+**   Invert the changeset while iterating through it. This is equivalent to 
+**   inverting a changeset using sqlite3changeset_invert() before applying it. 
+**   It is an error to specify this flag with a patchset. 
+*/ 
+#define SQLITE_CHANGESETSTART_INVERT        0x0002 
+
+ 
 /*
 ** CAPI3REF: Advance A Changeset Iterator
-** METHOD: sqlite3_changeset_iter
+** METHOD: sqlite3_changeset_iter 
 **
 ** This function may only be used with iterators created by the function
 ** [sqlite3changeset_start()]. If it is called on an iterator passed to
@@ -10782,7 +10782,7 @@ SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *pIter);
 
 /*
 ** CAPI3REF: Obtain The Current Operation From A Changeset Iterator
-** METHOD: sqlite3_changeset_iter
+** METHOD: sqlite3_changeset_iter 
 **
 ** The pIter argument passed to this function may either be an iterator
 ** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator
@@ -10822,7 +10822,7 @@ SQLITE_API int sqlite3changeset_op(
 
 /*
 ** CAPI3REF: Obtain The Primary Key Definition Of A Table
-** METHOD: sqlite3_changeset_iter
+** METHOD: sqlite3_changeset_iter 
 **
 ** For each modified table, a changeset includes the following:
 **
@@ -10854,7 +10854,7 @@ SQLITE_API int sqlite3changeset_pk(
 
 /*
 ** CAPI3REF: Obtain old.* Values From A Changeset Iterator
-** METHOD: sqlite3_changeset_iter
+** METHOD: sqlite3_changeset_iter 
 **
 ** The pIter argument passed to this function may either be an iterator
 ** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator
@@ -10885,7 +10885,7 @@ SQLITE_API int sqlite3changeset_old(
 
 /*
 ** CAPI3REF: Obtain new.* Values From A Changeset Iterator
-** METHOD: sqlite3_changeset_iter
+** METHOD: sqlite3_changeset_iter 
 **
 ** The pIter argument passed to this function may either be an iterator
 ** passed to a conflict-handler by [sqlite3changeset_apply()], or an iterator
@@ -10919,7 +10919,7 @@ SQLITE_API int sqlite3changeset_new(
 
 /*
 ** CAPI3REF: Obtain Conflicting Row Values From A Changeset Iterator
-** METHOD: sqlite3_changeset_iter
+** METHOD: sqlite3_changeset_iter 
 **
 ** This function should only be used with iterator objects passed to a
 ** conflict-handler callback by [sqlite3changeset_apply()] with either
@@ -10947,7 +10947,7 @@ SQLITE_API int sqlite3changeset_conflict(
 
 /*
 ** CAPI3REF: Determine The Number Of Foreign Key Constraint Violations
-** METHOD: sqlite3_changeset_iter
+** METHOD: sqlite3_changeset_iter 
 **
 ** This function may only be called with an iterator passed to an
 ** SQLITE_CHANGESET_FOREIGN_KEY conflict handler callback. In this case
@@ -10964,7 +10964,7 @@ SQLITE_API int sqlite3changeset_fk_conflicts(
 
 /*
 ** CAPI3REF: Finalize A Changeset Iterator
-** METHOD: sqlite3_changeset_iter
+** METHOD: sqlite3_changeset_iter 
 **
 ** This function is used to finalize an iterator allocated with
 ** [sqlite3changeset_start()].
@@ -10981,7 +10981,7 @@ SQLITE_API int sqlite3changeset_fk_conflicts(
 ** to that error is returned by this function. Otherwise, SQLITE_OK is
 ** returned. This is to allow the following pattern (pseudo-code):
 **
-** <pre>
+** <pre> 
 **   sqlite3changeset_start();
 **   while( SQLITE_ROW==sqlite3changeset_next() ){
 **     // Do something with change.
@@ -10990,7 +10990,7 @@ SQLITE_API int sqlite3changeset_fk_conflicts(
 **   if( rc!=SQLITE_OK ){
 **     // An error has occurred
 **   }
-** </pre>
+** </pre> 
 */
 SQLITE_API int sqlite3changeset_finalize(sqlite3_changeset_iter *pIter);
 
@@ -11038,7 +11038,7 @@ SQLITE_API int sqlite3changeset_invert(
 ** sqlite3_changegroup object. Calling it produces similar results as the
 ** following code fragment:
 **
-** <pre>
+** <pre> 
 **   sqlite3_changegroup *pGrp;
 **   rc = sqlite3_changegroup_new(&pGrp);
 **   if( rc==SQLITE_OK ) rc = sqlite3changegroup_add(pGrp, nA, pA);
@@ -11049,7 +11049,7 @@ SQLITE_API int sqlite3changeset_invert(
 **     *ppOut = 0;
 **     *pnOut = 0;
 **   }
-** </pre>
+** </pre> 
 **
 ** Refer to the sqlite3_changegroup documentation below for details.
 */
@@ -11065,15 +11065,15 @@ SQLITE_API int sqlite3changeset_concat(
 
 /*
 ** CAPI3REF: Changegroup Handle
-**
+** 
 ** A changegroup is an object used to combine two or more
-** [changesets] or [patchsets]
+** [changesets] or [patchsets] 
 */
 typedef struct sqlite3_changegroup sqlite3_changegroup;
 
 /*
 ** CAPI3REF: Create A New Changegroup Object
-** CONSTRUCTOR: sqlite3_changegroup
+** CONSTRUCTOR: sqlite3_changegroup 
 **
 ** An sqlite3_changegroup object is used to combine two or more changesets
 ** (or patchsets) into a single changeset (or patchset). A single changegroup
@@ -11111,7 +11111,7 @@ SQLITE_API int sqlite3changegroup_new(sqlite3_changegroup **pp);
 
 /*
 ** CAPI3REF: Add A Changeset To A Changegroup
-** METHOD: sqlite3_changegroup
+** METHOD: sqlite3_changegroup 
 **
 ** Add all changes within the changeset (or patchset) in buffer pData (size
 ** nData bytes) to the changegroup.
@@ -11189,7 +11189,7 @@ SQLITE_API int sqlite3changegroup_add(sqlite3_changegroup*, int nData, void *pDa
 
 /*
 ** CAPI3REF: Obtain A Composite Changeset From A Changegroup
-** METHOD: sqlite3_changegroup
+** METHOD: sqlite3_changegroup 
 **
 ** Obtain a buffer containing a changeset (or patchset) representing the
 ** current contents of the changegroup. If the inputs to the changegroup
@@ -11220,25 +11220,25 @@ SQLITE_API int sqlite3changegroup_output(
 
 /*
 ** CAPI3REF: Delete A Changegroup Object
-** DESTRUCTOR: sqlite3_changegroup
+** DESTRUCTOR: sqlite3_changegroup 
 */
 SQLITE_API void sqlite3changegroup_delete(sqlite3_changegroup*);
 
 /*
 ** CAPI3REF: Apply A Changeset To A Database
 **
-** Apply a changeset or patchset to a database. These functions attempt to
-** update the "main" database attached to handle db with the changes found in
+** Apply a changeset or patchset to a database. These functions attempt to 
+** update the "main" database attached to handle db with the changes found in 
 ** the changeset passed via the second and third arguments.
 **
-** The fourth argument (xFilter) passed to these functions is the "filter
+** The fourth argument (xFilter) passed to these functions is the "filter 
 ** callback". If it is not NULL, then for each table affected by at least one
 ** change in the changeset, the filter callback is invoked with
 ** the table name as the second argument, and a copy of the context pointer
-** passed as the sixth argument as the first. If the "filter callback"
-** returns zero, then no attempt is made to apply any changes to the table.
-** Otherwise, if the return value is non-zero or the xFilter argument to
-** is NULL, all changes related to the table are attempted.
+** passed as the sixth argument as the first. If the "filter callback" 
+** returns zero, then no attempt is made to apply any changes to the table. 
+** Otherwise, if the return value is non-zero or the xFilter argument to 
+** is NULL, all changes related to the table are attempted. 
 **
 ** For each table that is not excluded by the filter callback, this function
 ** tests that the target database contains a compatible table. A table is
@@ -11359,28 +11359,28 @@ SQLITE_API void sqlite3changegroup_delete(sqlite3_changegroup*);
 ** This can be used to further customize the application's conflict
 ** resolution strategy.
 **
-** All changes made by these functions are enclosed in a savepoint transaction.
+** All changes made by these functions are enclosed in a savepoint transaction. 
 ** If any other error (aside from a constraint failure when attempting to
 ** write to the target database) occurs, then the savepoint transaction is
 ** rolled back, restoring the target database to its original state, and an
 ** SQLite error code returned.
-**
-** If the output parameters (ppRebase) and (pnRebase) are non-NULL and
-** the input is a changeset (not a patchset), then sqlite3changeset_apply_v2()
+** 
+** If the output parameters (ppRebase) and (pnRebase) are non-NULL and 
+** the input is a changeset (not a patchset), then sqlite3changeset_apply_v2() 
 ** may set (*ppRebase) to point to a "rebase" that may be used with the
-** sqlite3_rebaser APIs buffer before returning. In this case (*pnRebase)
-** is set to the size of the buffer in bytes. It is the responsibility of the
-** caller to eventually free any such buffer using sqlite3_free(). The buffer
-** is only allocated and populated if one or more conflicts were encountered
-** while applying the patchset. See comments surrounding the sqlite3_rebaser
-** APIs for further details.
-**
-** The behavior of sqlite3changeset_apply_v2() and its streaming equivalent
-** may be modified by passing a combination of
-** [SQLITE_CHANGESETAPPLY_NOSAVEPOINT | supported flags] as the 9th parameter.
-**
-** Note that the sqlite3changeset_apply_v2() API is still <b>experimental</b>
-** and therefore subject to change.
+** sqlite3_rebaser APIs buffer before returning. In this case (*pnRebase) 
+** is set to the size of the buffer in bytes. It is the responsibility of the 
+** caller to eventually free any such buffer using sqlite3_free(). The buffer 
+** is only allocated and populated if one or more conflicts were encountered 
+** while applying the patchset. See comments surrounding the sqlite3_rebaser 
+** APIs for further details. 
+** 
+** The behavior of sqlite3changeset_apply_v2() and its streaming equivalent 
+** may be modified by passing a combination of 
+** [SQLITE_CHANGESETAPPLY_NOSAVEPOINT | supported flags] as the 9th parameter. 
+** 
+** Note that the sqlite3changeset_apply_v2() API is still <b>experimental</b> 
+** and therefore subject to change. 
 */
 SQLITE_API int sqlite3changeset_apply(
   sqlite3 *db,                    /* Apply change to "main" db of this handle */
@@ -11397,48 +11397,48 @@ SQLITE_API int sqlite3changeset_apply(
   ),
   void *pCtx                      /* First argument passed to xConflict */
 );
-SQLITE_API int sqlite3changeset_apply_v2(
-  sqlite3 *db,                    /* Apply change to "main" db of this handle */
-  int nChangeset,                 /* Size of changeset in bytes */
-  void *pChangeset,               /* Changeset blob */
-  int(*xFilter)(
-    void *pCtx,                   /* Copy of sixth arg to _apply() */
-    const char *zTab              /* Table name */
-  ),
-  int(*xConflict)(
-    void *pCtx,                   /* Copy of sixth arg to _apply() */
-    int eConflict,                /* DATA, MISSING, CONFLICT, CONSTRAINT */
-    sqlite3_changeset_iter *p     /* Handle describing change and conflict */
-  ),
-  void *pCtx,                     /* First argument passed to xConflict */
-  void **ppRebase, int *pnRebase, /* OUT: Rebase data */
-  int flags                       /* SESSION_CHANGESETAPPLY_* flags */
-);
-
-/*
-** CAPI3REF: Flags for sqlite3changeset_apply_v2
-**
-** The following flags may passed via the 9th parameter to
-** [sqlite3changeset_apply_v2] and [sqlite3changeset_apply_v2_strm]:
-**
-** <dl>
-** <dt>SQLITE_CHANGESETAPPLY_NOSAVEPOINT <dd>
-**   Usually, the sessions module encloses all operations performed by
-**   a single call to apply_v2() or apply_v2_strm() in a [SAVEPOINT]. The
-**   SAVEPOINT is committed if the changeset or patchset is successfully
-**   applied, or rolled back if an error occurs. Specifying this flag
-**   causes the sessions module to omit this savepoint. In this case, if the
+SQLITE_API int sqlite3changeset_apply_v2( 
+  sqlite3 *db,                    /* Apply change to "main" db of this handle */ 
+  int nChangeset,                 /* Size of changeset in bytes */ 
+  void *pChangeset,               /* Changeset blob */ 
+  int(*xFilter)( 
+    void *pCtx,                   /* Copy of sixth arg to _apply() */ 
+    const char *zTab              /* Table name */ 
+  ), 
+  int(*xConflict)( 
+    void *pCtx,                   /* Copy of sixth arg to _apply() */ 
+    int eConflict,                /* DATA, MISSING, CONFLICT, CONSTRAINT */ 
+    sqlite3_changeset_iter *p     /* Handle describing change and conflict */ 
+  ), 
+  void *pCtx,                     /* First argument passed to xConflict */ 
+  void **ppRebase, int *pnRebase, /* OUT: Rebase data */ 
+  int flags                       /* SESSION_CHANGESETAPPLY_* flags */ 
+); 
+
+/* 
+** CAPI3REF: Flags for sqlite3changeset_apply_v2 
+** 
+** The following flags may passed via the 9th parameter to 
+** [sqlite3changeset_apply_v2] and [sqlite3changeset_apply_v2_strm]: 
+** 
+** <dl> 
+** <dt>SQLITE_CHANGESETAPPLY_NOSAVEPOINT <dd> 
+**   Usually, the sessions module encloses all operations performed by 
+**   a single call to apply_v2() or apply_v2_strm() in a [SAVEPOINT]. The 
+**   SAVEPOINT is committed if the changeset or patchset is successfully 
+**   applied, or rolled back if an error occurs. Specifying this flag 
+**   causes the sessions module to omit this savepoint. In this case, if the 
 **   caller has an open transaction or savepoint when apply_v2() is called,
-**   it may revert the partially applied changeset by rolling it back.
-**
-** <dt>SQLITE_CHANGESETAPPLY_INVERT <dd>
-**   Invert the changeset before applying it. This is equivalent to inverting
-**   a changeset using sqlite3changeset_invert() before applying it. It is
-**   an error to specify this flag with a patchset.
-*/
-#define SQLITE_CHANGESETAPPLY_NOSAVEPOINT   0x0001
-#define SQLITE_CHANGESETAPPLY_INVERT        0x0002
-
+**   it may revert the partially applied changeset by rolling it back. 
+** 
+** <dt>SQLITE_CHANGESETAPPLY_INVERT <dd> 
+**   Invert the changeset before applying it. This is equivalent to inverting 
+**   a changeset using sqlite3changeset_invert() before applying it. It is 
+**   an error to specify this flag with a patchset. 
+*/ 
+#define SQLITE_CHANGESETAPPLY_NOSAVEPOINT   0x0001 
+#define SQLITE_CHANGESETAPPLY_INVERT        0x0002 
+ 
 /*
 ** CAPI3REF: Constants Passed To The Conflict Handler
 **
@@ -11536,161 +11536,161 @@ SQLITE_API int sqlite3changeset_apply_v2(
 #define SQLITE_CHANGESET_ABORT      2
 
 /*
-** CAPI3REF: Rebasing changesets
-** EXPERIMENTAL
-**
-** Suppose there is a site hosting a database in state S0. And that
-** modifications are made that move that database to state S1 and a
-** changeset recorded (the "local" changeset). Then, a changeset based
+** CAPI3REF: Rebasing changesets 
+** EXPERIMENTAL 
+** 
+** Suppose there is a site hosting a database in state S0. And that 
+** modifications are made that move that database to state S1 and a 
+** changeset recorded (the "local" changeset). Then, a changeset based 
 ** on S0 is received from another site (the "remote" changeset) and
 ** applied to the database. The database is then in state
-** (S1+"remote"), where the exact state depends on any conflict
-** resolution decisions (OMIT or REPLACE) made while applying "remote".
+** (S1+"remote"), where the exact state depends on any conflict 
+** resolution decisions (OMIT or REPLACE) made while applying "remote". 
 ** Rebasing a changeset is to update it to take those conflict
-** resolution decisions into account, so that the same conflicts
+** resolution decisions into account, so that the same conflicts 
 ** do not have to be resolved elsewhere in the network.
-**
-** For example, if both the local and remote changesets contain an
-** INSERT of the same key on "CREATE TABLE t1(a PRIMARY KEY, b)":
-**
-**   local:  INSERT INTO t1 VALUES(1, 'v1');
-**   remote: INSERT INTO t1 VALUES(1, 'v2');
-**
-** and the conflict resolution is REPLACE, then the INSERT change is
-** removed from the local changeset (it was overridden). Or, if the
-** conflict resolution was "OMIT", then the local changeset is modified
-** to instead contain:
-**
-**           UPDATE t1 SET b = 'v2' WHERE a=1;
-**
-** Changes within the local changeset are rebased as follows:
-**
-** <dl>
-** <dt>Local INSERT<dd>
+** 
+** For example, if both the local and remote changesets contain an 
+** INSERT of the same key on "CREATE TABLE t1(a PRIMARY KEY, b)": 
+** 
+**   local:  INSERT INTO t1 VALUES(1, 'v1'); 
+**   remote: INSERT INTO t1 VALUES(1, 'v2'); 
+** 
+** and the conflict resolution is REPLACE, then the INSERT change is 
+** removed from the local changeset (it was overridden). Or, if the 
+** conflict resolution was "OMIT", then the local changeset is modified 
+** to instead contain: 
+** 
+**           UPDATE t1 SET b = 'v2' WHERE a=1; 
+** 
+** Changes within the local changeset are rebased as follows: 
+** 
+** <dl> 
+** <dt>Local INSERT<dd> 
 **   This may only conflict with a remote INSERT. If the conflict
-**   resolution was OMIT, then add an UPDATE change to the rebased
-**   changeset. Or, if the conflict resolution was REPLACE, add
-**   nothing to the rebased changeset.
-**
-** <dt>Local DELETE<dd>
-**   This may conflict with a remote UPDATE or DELETE. In both cases the
-**   only possible resolution is OMIT. If the remote operation was a
-**   DELETE, then add no change to the rebased changeset. If the remote
-**   operation was an UPDATE, then the old.* fields of change are updated
-**   to reflect the new.* values in the UPDATE.
-**
-** <dt>Local UPDATE<dd>
-**   This may conflict with a remote UPDATE or DELETE. If it conflicts
-**   with a DELETE, and the conflict resolution was OMIT, then the update
-**   is changed into an INSERT. Any undefined values in the new.* record
-**   from the update change are filled in using the old.* values from
-**   the conflicting DELETE. Or, if the conflict resolution was REPLACE,
-**   the UPDATE change is simply omitted from the rebased changeset.
-**
-**   If conflict is with a remote UPDATE and the resolution is OMIT, then
-**   the old.* values are rebased using the new.* values in the remote
-**   change. Or, if the resolution is REPLACE, then the change is copied
-**   into the rebased changeset with updates to columns also updated by
+**   resolution was OMIT, then add an UPDATE change to the rebased 
+**   changeset. Or, if the conflict resolution was REPLACE, add 
+**   nothing to the rebased changeset. 
+** 
+** <dt>Local DELETE<dd> 
+**   This may conflict with a remote UPDATE or DELETE. In both cases the 
+**   only possible resolution is OMIT. If the remote operation was a 
+**   DELETE, then add no change to the rebased changeset. If the remote 
+**   operation was an UPDATE, then the old.* fields of change are updated 
+**   to reflect the new.* values in the UPDATE. 
+** 
+** <dt>Local UPDATE<dd> 
+**   This may conflict with a remote UPDATE or DELETE. If it conflicts 
+**   with a DELETE, and the conflict resolution was OMIT, then the update 
+**   is changed into an INSERT. Any undefined values in the new.* record 
+**   from the update change are filled in using the old.* values from 
+**   the conflicting DELETE. Or, if the conflict resolution was REPLACE, 
+**   the UPDATE change is simply omitted from the rebased changeset. 
+** 
+**   If conflict is with a remote UPDATE and the resolution is OMIT, then 
+**   the old.* values are rebased using the new.* values in the remote 
+**   change. Or, if the resolution is REPLACE, then the change is copied 
+**   into the rebased changeset with updates to columns also updated by 
 **   the conflicting remote UPDATE removed. If this means no columns would
-**   be updated, the change is omitted.
-** </dl>
-**
+**   be updated, the change is omitted. 
+** </dl> 
+** 
 ** A local change may be rebased against multiple remote changes
 ** simultaneously. If a single key is modified by multiple remote
-** changesets, they are combined as follows before the local changeset
-** is rebased:
-**
-** <ul>
-**    <li> If there has been one or more REPLACE resolutions on a
-**         key, it is rebased according to a REPLACE.
-**
-**    <li> If there have been no REPLACE resolutions on a key, then
-**         the local changeset is rebased according to the most recent
-**         of the OMIT resolutions.
-** </ul>
-**
+** changesets, they are combined as follows before the local changeset 
+** is rebased: 
+** 
+** <ul> 
+**    <li> If there has been one or more REPLACE resolutions on a 
+**         key, it is rebased according to a REPLACE. 
+** 
+**    <li> If there have been no REPLACE resolutions on a key, then 
+**         the local changeset is rebased according to the most recent 
+**         of the OMIT resolutions. 
+** </ul> 
+** 
 ** Note that conflict resolutions from multiple remote changesets are
 ** combined on a per-field basis, not per-row. This means that in the
 ** case of multiple remote UPDATE operations, some fields of a single
 ** local change may be rebased for REPLACE while others are rebased for
-** OMIT.
-**
-** In order to rebase a local changeset, the remote changeset must first
-** be applied to the local database using sqlite3changeset_apply_v2() and
-** the buffer of rebase information captured. Then:
-**
-** <ol>
+** OMIT. 
+** 
+** In order to rebase a local changeset, the remote changeset must first 
+** be applied to the local database using sqlite3changeset_apply_v2() and 
+** the buffer of rebase information captured. Then: 
+** 
+** <ol> 
 **   <li> An sqlite3_rebaser object is created by calling
-**        sqlite3rebaser_create().
-**   <li> The new object is configured with the rebase buffer obtained from
-**        sqlite3changeset_apply_v2() by calling sqlite3rebaser_configure().
-**        If the local changeset is to be rebased against multiple remote
-**        changesets, then sqlite3rebaser_configure() should be called
-**        multiple times, in the same order that the multiple
-**        sqlite3changeset_apply_v2() calls were made.
-**   <li> Each local changeset is rebased by calling sqlite3rebaser_rebase().
-**   <li> The sqlite3_rebaser object is deleted by calling
-**        sqlite3rebaser_delete().
-** </ol>
-*/
-typedef struct sqlite3_rebaser sqlite3_rebaser;
-
-/*
-** CAPI3REF: Create a changeset rebaser object.
-** EXPERIMENTAL
-**
-** Allocate a new changeset rebaser object. If successful, set (*ppNew) to
-** point to the new object and return SQLITE_OK. Otherwise, if an error
+**        sqlite3rebaser_create(). 
+**   <li> The new object is configured with the rebase buffer obtained from 
+**        sqlite3changeset_apply_v2() by calling sqlite3rebaser_configure(). 
+**        If the local changeset is to be rebased against multiple remote 
+**        changesets, then sqlite3rebaser_configure() should be called 
+**        multiple times, in the same order that the multiple 
+**        sqlite3changeset_apply_v2() calls were made. 
+**   <li> Each local changeset is rebased by calling sqlite3rebaser_rebase(). 
+**   <li> The sqlite3_rebaser object is deleted by calling 
+**        sqlite3rebaser_delete(). 
+** </ol> 
+*/ 
+typedef struct sqlite3_rebaser sqlite3_rebaser; 
+ 
+/*
+** CAPI3REF: Create a changeset rebaser object. 
+** EXPERIMENTAL 
+** 
+** Allocate a new changeset rebaser object. If successful, set (*ppNew) to 
+** point to the new object and return SQLITE_OK. Otherwise, if an error 
 ** occurs, return an SQLite error code (e.g. SQLITE_NOMEM) and set (*ppNew)
 ** to NULL.
-*/
-SQLITE_API int sqlite3rebaser_create(sqlite3_rebaser **ppNew);
-
-/*
-** CAPI3REF: Configure a changeset rebaser object.
-** EXPERIMENTAL
-**
-** Configure the changeset rebaser object to rebase changesets according
-** to the conflict resolutions described by buffer pRebase (size nRebase
-** bytes), which must have been obtained from a previous call to
-** sqlite3changeset_apply_v2().
-*/
-SQLITE_API int sqlite3rebaser_configure(
+*/ 
+SQLITE_API int sqlite3rebaser_create(sqlite3_rebaser **ppNew); 
+ 
+/* 
+** CAPI3REF: Configure a changeset rebaser object. 
+** EXPERIMENTAL 
+** 
+** Configure the changeset rebaser object to rebase changesets according 
+** to the conflict resolutions described by buffer pRebase (size nRebase 
+** bytes), which must have been obtained from a previous call to 
+** sqlite3changeset_apply_v2(). 
+*/ 
+SQLITE_API int sqlite3rebaser_configure( 
   sqlite3_rebaser*,
-  int nRebase, const void *pRebase
+  int nRebase, const void *pRebase 
 );
-
-/*
-** CAPI3REF: Rebase a changeset
-** EXPERIMENTAL
-**
-** Argument pIn must point to a buffer containing a changeset nIn bytes
-** in size. This function allocates and populates a buffer with a copy
+ 
+/* 
+** CAPI3REF: Rebase a changeset 
+** EXPERIMENTAL 
+** 
+** Argument pIn must point to a buffer containing a changeset nIn bytes 
+** in size. This function allocates and populates a buffer with a copy 
 ** of the changeset rebased according to the configuration of the
-** rebaser object passed as the first argument. If successful, (*ppOut)
+** rebaser object passed as the first argument. If successful, (*ppOut) 
 ** is set to point to the new buffer containing the rebased changeset and
-** (*pnOut) to its size in bytes and SQLITE_OK returned. It is the
-** responsibility of the caller to eventually free the new buffer using
-** sqlite3_free(). Otherwise, if an error occurs, (*ppOut) and (*pnOut)
-** are set to zero and an SQLite error code returned.
-*/
-SQLITE_API int sqlite3rebaser_rebase(
-  sqlite3_rebaser*,
+** (*pnOut) to its size in bytes and SQLITE_OK returned. It is the 
+** responsibility of the caller to eventually free the new buffer using 
+** sqlite3_free(). Otherwise, if an error occurs, (*ppOut) and (*pnOut) 
+** are set to zero and an SQLite error code returned. 
+*/ 
+SQLITE_API int sqlite3rebaser_rebase( 
+  sqlite3_rebaser*, 
   int nIn, const void *pIn,
   int *pnOut, void **ppOut
-);
-
-/*
-** CAPI3REF: Delete a changeset rebaser object.
-** EXPERIMENTAL
-**
-** Delete the changeset rebaser object and all associated resources. There
-** should be one call to this function for each successful invocation
-** of sqlite3rebaser_create().
-*/
+); 
+ 
+/* 
+** CAPI3REF: Delete a changeset rebaser object. 
+** EXPERIMENTAL 
+** 
+** Delete the changeset rebaser object and all associated resources. There 
+** should be one call to this function for each successful invocation 
+** of sqlite3rebaser_create(). 
+*/ 
 SQLITE_API void sqlite3rebaser_delete(sqlite3_rebaser *p);
-
-/*
+ 
+/* 
 ** CAPI3REF: Streaming Versions of API functions.
 **
 ** The six streaming API xxx_strm() functions serve similar purposes to the
@@ -11795,23 +11795,23 @@ SQLITE_API int sqlite3changeset_apply_strm(
   ),
   void *pCtx                      /* First argument passed to xConflict */
 );
-SQLITE_API int sqlite3changeset_apply_v2_strm(
-  sqlite3 *db,                    /* Apply change to "main" db of this handle */
-  int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */
-  void *pIn,                                          /* First arg for xInput */
-  int(*xFilter)(
-    void *pCtx,                   /* Copy of sixth arg to _apply() */
-    const char *zTab              /* Table name */
-  ),
-  int(*xConflict)(
-    void *pCtx,                   /* Copy of sixth arg to _apply() */
-    int eConflict,                /* DATA, MISSING, CONFLICT, CONSTRAINT */
-    sqlite3_changeset_iter *p     /* Handle describing change and conflict */
-  ),
-  void *pCtx,                     /* First argument passed to xConflict */
-  void **ppRebase, int *pnRebase,
-  int flags
-);
+SQLITE_API int sqlite3changeset_apply_v2_strm( 
+  sqlite3 *db,                    /* Apply change to "main" db of this handle */ 
+  int (*xInput)(void *pIn, void *pData, int *pnData), /* Input function */ 
+  void *pIn,                                          /* First arg for xInput */ 
+  int(*xFilter)( 
+    void *pCtx,                   /* Copy of sixth arg to _apply() */ 
+    const char *zTab              /* Table name */ 
+  ), 
+  int(*xConflict)( 
+    void *pCtx,                   /* Copy of sixth arg to _apply() */ 
+    int eConflict,                /* DATA, MISSING, CONFLICT, CONSTRAINT */ 
+    sqlite3_changeset_iter *p     /* Handle describing change and conflict */ 
+  ), 
+  void *pCtx,                     /* First argument passed to xConflict */ 
+  void **ppRebase, int *pnRebase, 
+  int flags 
+); 
 SQLITE_API int sqlite3changeset_concat_strm(
   int (*xInputA)(void *pIn, void *pData, int *pnData),
   void *pInA,
@@ -11831,12 +11831,12 @@ SQLITE_API int sqlite3changeset_start_strm(
   int (*xInput)(void *pIn, void *pData, int *pnData),
   void *pIn
 );
-SQLITE_API int sqlite3changeset_start_v2_strm(
-  sqlite3_changeset_iter **pp,
-  int (*xInput)(void *pIn, void *pData, int *pnData),
-  void *pIn,
-  int flags
-);
+SQLITE_API int sqlite3changeset_start_v2_strm( 
+  sqlite3_changeset_iter **pp, 
+  int (*xInput)(void *pIn, void *pData, int *pnData), 
+  void *pIn, 
+  int flags 
+); 
 SQLITE_API int sqlite3session_changeset_strm(
   sqlite3_session *pSession,
   int (*xOutput)(void *pOut, const void *pData, int nData),
@@ -11855,55 +11855,55 @@ SQLITE_API int sqlite3changegroup_output_strm(sqlite3_changegroup*,
     int (*xOutput)(void *pOut, const void *pData, int nData),
     void *pOut
 );
-SQLITE_API int sqlite3rebaser_rebase_strm(
-  sqlite3_rebaser *pRebaser,
-  int (*xInput)(void *pIn, void *pData, int *pnData),
-  void *pIn,
-  int (*xOutput)(void *pOut, const void *pData, int nData),
-  void *pOut
-);
-
-/*
-** CAPI3REF: Configure global parameters
-**
-** The sqlite3session_config() interface is used to make global configuration
+SQLITE_API int sqlite3rebaser_rebase_strm( 
+  sqlite3_rebaser *pRebaser, 
+  int (*xInput)(void *pIn, void *pData, int *pnData), 
+  void *pIn, 
+  int (*xOutput)(void *pOut, const void *pData, int nData), 
+  void *pOut 
+); 
+
+/* 
+** CAPI3REF: Configure global parameters 
+** 
+** The sqlite3session_config() interface is used to make global configuration 
 ** changes to the sessions module in order to tune it to the specific needs
-** of the application.
-**
-** The sqlite3session_config() interface is not threadsafe. If it is invoked
-** while any other thread is inside any other sessions method then the
-** results are undefined. Furthermore, if it is invoked after any sessions
+** of the application. 
+** 
+** The sqlite3session_config() interface is not threadsafe. If it is invoked 
+** while any other thread is inside any other sessions method then the 
+** results are undefined. Furthermore, if it is invoked after any sessions 
 ** related objects have been created, the results are also undefined.
-**
-** The first argument to the sqlite3session_config() function must be one
+** 
+** The first argument to the sqlite3session_config() function must be one 
 ** of the SQLITE_SESSION_CONFIG_XXX constants defined below. The
-** interpretation of the (void*) value passed as the second parameter and
-** the effect of calling this function depends on the value of the first
-** parameter.
-**
-** <dl>
-** <dt>SQLITE_SESSION_CONFIG_STRMSIZE<dd>
-**    By default, the sessions module streaming interfaces attempt to input
-**    and output data in approximately 1 KiB chunks. This operand may be used
-**    to set and query the value of this configuration setting. The pointer
-**    passed as the second argument must point to a value of type (int).
-**    If this value is greater than 0, it is used as the new streaming data
-**    chunk size for both input and output. Before returning, the (int) value
-**    pointed to by pArg is set to the final value of the streaming interface
-**    chunk size.
-** </dl>
-**
-** This function returns SQLITE_OK if successful, or an SQLite error code
-** otherwise.
-*/
-SQLITE_API int sqlite3session_config(int op, void *pArg);
-
-/*
-** CAPI3REF: Values for sqlite3session_config().
-*/
-#define SQLITE_SESSION_CONFIG_STRMSIZE 1
-
-/*
+** interpretation of the (void*) value passed as the second parameter and 
+** the effect of calling this function depends on the value of the first 
+** parameter. 
+** 
+** <dl> 
+** <dt>SQLITE_SESSION_CONFIG_STRMSIZE<dd> 
+**    By default, the sessions module streaming interfaces attempt to input 
+**    and output data in approximately 1 KiB chunks. This operand may be used 
+**    to set and query the value of this configuration setting. The pointer 
+**    passed as the second argument must point to a value of type (int). 
+**    If this value is greater than 0, it is used as the new streaming data 
+**    chunk size for both input and output. Before returning, the (int) value 
+**    pointed to by pArg is set to the final value of the streaming interface 
+**    chunk size. 
+** </dl> 
+** 
+** This function returns SQLITE_OK if successful, or an SQLite error code 
+** otherwise. 
+*/ 
+SQLITE_API int sqlite3session_config(int op, void *pArg); 
+
+/*
+** CAPI3REF: Values for sqlite3session_config(). 
+*/ 
+#define SQLITE_SESSION_CONFIG_STRMSIZE 1 
+ 
+/* 
 ** Make sure we can call this stuff from C++.
 */
 #ifdef __cplusplus
@@ -12035,8 +12035,8 @@ struct Fts5PhraseIter {
 **
 **   Usually, output parameter *piPhrase is set to the phrase number, *piCol
 **   to the column in which it occurs and *piOff the token offset of the
-**   first token of the phrase. Returns SQLITE_OK if successful, or an error
-**   code (i.e. SQLITE_NOMEM) if an error occurs.
+**   first token of the phrase. Returns SQLITE_OK if successful, or an error 
+**   code (i.e. SQLITE_NOMEM) if an error occurs. 
 **
 **   This API can be quite slow if used with an FTS5 table created with the
 **   "detail=none" or "detail=column" option.
@@ -12077,7 +12077,7 @@ struct Fts5PhraseIter {
 **   Save the pointer passed as the second argument as the extension function's
 **   "auxiliary data". The pointer may then be retrieved by the current or any
 **   future invocation of the same fts5 extension function made as part of
-**   the same MATCH query using the xGetAuxdata() API.
+**   the same MATCH query using the xGetAuxdata() API. 
 **
 **   Each extension function is allocated a single auxiliary data slot for
 **   each FTS query (MATCH expression). If the extension function is invoked
@@ -12092,7 +12092,7 @@ struct Fts5PhraseIter {
 **   The xDelete callback, if one is specified, is also invoked on the
 **   auxiliary data pointer after the FTS5 query has finished.
 **
-**   If an error (e.g. an OOM condition) occurs within this function,
+**   If an error (e.g. an OOM condition) occurs within this function, 
 **   the auxiliary data is set to NULL and an error code returned. If the
 **   xDelete parameter was not NULL, it is invoked on the auxiliary data
 **   pointer before returning.
@@ -12325,11 +12325,11 @@ struct Fts5ExtensionApi {
 **            the tokenizer substitutes "first" for "1st" and the query works
 **            as expected.
 **
-**       <li> By querying the index for all synonyms of each query term
-**            separately. In this case, when tokenizing query text, the
+**       <li> By querying the index for all synonyms of each query term 
+**            separately. In this case, when tokenizing query text, the 
 **            tokenizer may provide multiple synonyms for a single term
 **            within the document. FTS5 then queries the index for each
-**            synonym individually. For example, faced with the query:
+**            synonym individually. For example, faced with the query: 
 **
 **   <codeblock>
 **     ... MATCH 'first place'</codeblock>
@@ -12353,9 +12353,9 @@ struct Fts5ExtensionApi {
 **            "place".
 **
 **            This way, even if the tokenizer does not provide synonyms
-**            when tokenizing query text (it should not - to do so would be
+**            when tokenizing query text (it should not - to do so would be 
 **            inefficient), it doesn't matter if the user queries for
-**            'first + place' or '1st + place', as there are entries in the
+**            'first + place' or '1st + place', as there are entries in the 
 **            FTS index corresponding to both forms of the first token.
 **   </ol>
 **
@@ -12383,7 +12383,7 @@ struct Fts5ExtensionApi {
 **   extra data to the FTS index or require FTS5 to query for multiple terms,
 **   so it is efficient in terms of disk space and query speed. However, it
 **   does not support prefix queries very well. If, as suggested above, the
-**   token "first" is substituted for "1st" by the tokenizer, then the query:
+**   token "first" is substituted for "1st" by the tokenizer, then the query: 
 **
 **   <codeblock>
 **     ... MATCH '1s*'</codeblock>
diff --git a/contrib/libs/sqlite3/sqlite3ext.h b/contrib/libs/sqlite3/sqlite3ext.h
index 9767daa01d..6735d67b62 100644
--- a/contrib/libs/sqlite3/sqlite3ext.h
+++ b/contrib/libs/sqlite3/sqlite3ext.h
@@ -295,33 +295,33 @@ struct sqlite3_api_routines {
   int (*vtab_nochange)(sqlite3_context*);
   int (*value_nochange)(sqlite3_value*);
   const char *(*vtab_collation)(sqlite3_index_info*,int);
-  /* Version 3.24.0 and later */
-  int (*keyword_count)(void);
-  int (*keyword_name)(int,const char**,int*);
-  int (*keyword_check)(const char*,int);
-  sqlite3_str *(*str_new)(sqlite3*);
-  char *(*str_finish)(sqlite3_str*);
-  void (*str_appendf)(sqlite3_str*, const char *zFormat, ...);
-  void (*str_vappendf)(sqlite3_str*, const char *zFormat, va_list);
-  void (*str_append)(sqlite3_str*, const char *zIn, int N);
-  void (*str_appendall)(sqlite3_str*, const char *zIn);
-  void (*str_appendchar)(sqlite3_str*, int N, char C);
-  void (*str_reset)(sqlite3_str*);
-  int (*str_errcode)(sqlite3_str*);
-  int (*str_length)(sqlite3_str*);
-  char *(*str_value)(sqlite3_str*);
-  /* Version 3.25.0 and later */
-  int (*create_window_function)(sqlite3*,const char*,int,int,void*,
-                            void (*xStep)(sqlite3_context*,int,sqlite3_value**),
-                            void (*xFinal)(sqlite3_context*),
-                            void (*xValue)(sqlite3_context*),
-                            void (*xInv)(sqlite3_context*,int,sqlite3_value**),
-                            void(*xDestroy)(void*));
-  /* Version 3.26.0 and later */
-  const char *(*normalized_sql)(sqlite3_stmt*);
-  /* Version 3.28.0 and later */
-  int (*stmt_isexplain)(sqlite3_stmt*);
-  int (*value_frombind)(sqlite3_value*);
+  /* Version 3.24.0 and later */ 
+  int (*keyword_count)(void); 
+  int (*keyword_name)(int,const char**,int*); 
+  int (*keyword_check)(const char*,int); 
+  sqlite3_str *(*str_new)(sqlite3*); 
+  char *(*str_finish)(sqlite3_str*); 
+  void (*str_appendf)(sqlite3_str*, const char *zFormat, ...); 
+  void (*str_vappendf)(sqlite3_str*, const char *zFormat, va_list); 
+  void (*str_append)(sqlite3_str*, const char *zIn, int N); 
+  void (*str_appendall)(sqlite3_str*, const char *zIn); 
+  void (*str_appendchar)(sqlite3_str*, int N, char C); 
+  void (*str_reset)(sqlite3_str*); 
+  int (*str_errcode)(sqlite3_str*); 
+  int (*str_length)(sqlite3_str*); 
+  char *(*str_value)(sqlite3_str*); 
+  /* Version 3.25.0 and later */ 
+  int (*create_window_function)(sqlite3*,const char*,int,int,void*, 
+                            void (*xStep)(sqlite3_context*,int,sqlite3_value**), 
+                            void (*xFinal)(sqlite3_context*), 
+                            void (*xValue)(sqlite3_context*), 
+                            void (*xInv)(sqlite3_context*,int,sqlite3_value**), 
+                            void(*xDestroy)(void*)); 
+  /* Version 3.26.0 and later */ 
+  const char *(*normalized_sql)(sqlite3_stmt*); 
+  /* Version 3.28.0 and later */ 
+  int (*stmt_isexplain)(sqlite3_stmt*); 
+  int (*value_frombind)(sqlite3_value*); 
   /* Version 3.30.0 and later */
   int (*drop_modules)(sqlite3*,const char**);
   /* Version 3.31.0 and later */
@@ -612,28 +612,28 @@ typedef int (*sqlite3_loadext_entry)(
 #define sqlite3_value_pointer          sqlite3_api->value_pointer
 /* Version 3.22.0 and later */
 #define sqlite3_vtab_nochange          sqlite3_api->vtab_nochange
-#define sqlite3_value_nochange         sqlite3_api->value_nochange
-#define sqlite3_vtab_collation         sqlite3_api->vtab_collation
-/* Version 3.24.0 and later */
-#define sqlite3_keyword_count          sqlite3_api->keyword_count
-#define sqlite3_keyword_name           sqlite3_api->keyword_name
-#define sqlite3_keyword_check          sqlite3_api->keyword_check
-#define sqlite3_str_new                sqlite3_api->str_new
-#define sqlite3_str_finish             sqlite3_api->str_finish
-#define sqlite3_str_appendf            sqlite3_api->str_appendf
-#define sqlite3_str_vappendf           sqlite3_api->str_vappendf
-#define sqlite3_str_append             sqlite3_api->str_append
-#define sqlite3_str_appendall          sqlite3_api->str_appendall
-#define sqlite3_str_appendchar         sqlite3_api->str_appendchar
-#define sqlite3_str_reset              sqlite3_api->str_reset
-#define sqlite3_str_errcode            sqlite3_api->str_errcode
-#define sqlite3_str_length             sqlite3_api->str_length
-#define sqlite3_str_value              sqlite3_api->str_value
-/* Version 3.25.0 and later */
-#define sqlite3_create_window_function sqlite3_api->create_window_function
-/* Version 3.26.0 and later */
-#define sqlite3_normalized_sql         sqlite3_api->normalized_sql
-/* Version 3.28.0 and later */
+#define sqlite3_value_nochange         sqlite3_api->value_nochange 
+#define sqlite3_vtab_collation         sqlite3_api->vtab_collation 
+/* Version 3.24.0 and later */ 
+#define sqlite3_keyword_count          sqlite3_api->keyword_count 
+#define sqlite3_keyword_name           sqlite3_api->keyword_name 
+#define sqlite3_keyword_check          sqlite3_api->keyword_check 
+#define sqlite3_str_new                sqlite3_api->str_new 
+#define sqlite3_str_finish             sqlite3_api->str_finish 
+#define sqlite3_str_appendf            sqlite3_api->str_appendf 
+#define sqlite3_str_vappendf           sqlite3_api->str_vappendf 
+#define sqlite3_str_append             sqlite3_api->str_append 
+#define sqlite3_str_appendall          sqlite3_api->str_appendall 
+#define sqlite3_str_appendchar         sqlite3_api->str_appendchar 
+#define sqlite3_str_reset              sqlite3_api->str_reset 
+#define sqlite3_str_errcode            sqlite3_api->str_errcode 
+#define sqlite3_str_length             sqlite3_api->str_length 
+#define sqlite3_str_value              sqlite3_api->str_value 
+/* Version 3.25.0 and later */ 
+#define sqlite3_create_window_function sqlite3_api->create_window_function 
+/* Version 3.26.0 and later */ 
+#define sqlite3_normalized_sql         sqlite3_api->normalized_sql 
+/* Version 3.28.0 and later */ 
 #define sqlite3_stmt_isexplain         sqlite3_api->stmt_isexplain
 #define sqlite3_value_frombind         sqlite3_api->value_frombind
 /* Version 3.30.0 and later */
diff --git a/contrib/libs/sqlite3/test_multiplex.c b/contrib/libs/sqlite3/test_multiplex.c
index 1e185a95a2..863f249fb0 100644
--- a/contrib/libs/sqlite3/test_multiplex.c
+++ b/contrib/libs/sqlite3/test_multiplex.c
@@ -1220,7 +1220,7 @@ int sqlite3_multiplex_shutdown(int eForce){
 /***************************** Test Code ***********************************/
 #ifdef SQLITE_TEST
 #if defined(INCLUDE_SQLITE_TCL_H)
-#  error #include "sqlite_tcl.h"
+#  error #include "sqlite_tcl.h" 
 #else
 #  include "tcl.h"
 #  ifndef SQLITE_TCLAPI
diff --git a/contrib/libs/sqlite3/ya.make b/contrib/libs/sqlite3/ya.make
index e6b26dccc3..7318831f47 100644
--- a/contrib/libs/sqlite3/ya.make
+++ b/contrib/libs/sqlite3/ya.make
@@ -1,5 +1,5 @@
 # Generated by devtools/yamaker from nixpkgs 21.11.
-
+ 
 LIBRARY()
 
 OWNER(
@@ -17,7 +17,7 @@ LICENSE(
 )
 
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
-
+ 
 ADDINCL(
     contrib/libs/sqlite3
 )
@@ -26,31 +26,31 @@ NO_COMPILER_WARNINGS()
 
 NO_RUNTIME()
 
-CFLAGS(
-    -DBUILD_sqlite
-    -DHAVE_USLEEP
-    -DSQLITE_ENABLE_COLUMN_METADATA
-    -DSQLITE_ENABLE_DBSTAT_VTAB
-    -DSQLITE_ENABLE_FTS3
-    -DSQLITE_ENABLE_FTS3_PARENTHESIS
-    -DSQLITE_ENABLE_FTS3_TOKENIZER
-    -DSQLITE_ENABLE_FTS4
-    -DSQLITE_ENABLE_FTS5
-    -DSQLITE_ENABLE_JSON1
+CFLAGS( 
+    -DBUILD_sqlite 
+    -DHAVE_USLEEP 
+    -DSQLITE_ENABLE_COLUMN_METADATA 
+    -DSQLITE_ENABLE_DBSTAT_VTAB 
+    -DSQLITE_ENABLE_FTS3 
+    -DSQLITE_ENABLE_FTS3_PARENTHESIS 
+    -DSQLITE_ENABLE_FTS3_TOKENIZER 
+    -DSQLITE_ENABLE_FTS4 
+    -DSQLITE_ENABLE_FTS5 
+    -DSQLITE_ENABLE_JSON1 
     -DSQLITE_ENABLE_MATH_FUNCTIONS
-    -DSQLITE_ENABLE_RTREE
-    -DSQLITE_ENABLE_STMT_SCANSTATUS
-    -DSQLITE_ENABLE_UNLOCK_NOTIFY
-    -DSQLITE_ENABLE_UPDATE_DELETE_LIMIT
-    -DSQLITE_HAVE_ZLIB=1
-    -DSQLITE_MAX_EXPR_DEPTH=10000
-    -DSQLITE_MAX_VARIABLE_NUMBER=250000
-    -DSQLITE_SECURE_DELETE
-    -DSQLITE_SOUNDEX
-    -DSQLITE_TEMP_STORE=1
-    -DSQLITE_THREADSAFE=1
-)
-
+    -DSQLITE_ENABLE_RTREE 
+    -DSQLITE_ENABLE_STMT_SCANSTATUS 
+    -DSQLITE_ENABLE_UNLOCK_NOTIFY 
+    -DSQLITE_ENABLE_UPDATE_DELETE_LIMIT 
+    -DSQLITE_HAVE_ZLIB=1 
+    -DSQLITE_MAX_EXPR_DEPTH=10000 
+    -DSQLITE_MAX_VARIABLE_NUMBER=250000 
+    -DSQLITE_SECURE_DELETE 
+    -DSQLITE_SOUNDEX 
+    -DSQLITE_TEMP_STORE=1 
+    -DSQLITE_THREADSAFE=1 
+) 
+ 
 IF (OS_WINDOWS)
     CFLAGS(
         -DSQLITE_OS_WIN
@@ -63,7 +63,7 @@ ENDIF()
 
 SRCS(
     sqlite3.c
-    test_multiplex.c
+    test_multiplex.c 
 )
 
 END()