Regenerate Linux/amd64 using latest CCGO.

	modified:   generator.go
	modified:   internal/bin/bin_linux_amd64.go
	modified:   internal/mptest/mptest_linux_amd64.go
	modified:   internal/threadtest1/threadtest1_linux_amd64.go
	modified:   internal/threadtest2/threadtest2_linux_amd64.go
	modified:   internal/threadtest3/threadtest3_linux_amd64.go
	modified:   internal/threadtest4/threadtest4_linux_amd64.go

1 files changed, 1673 insertions, 1510 deletions

diff --git a/internal/threadtest3/threadtest3_linux_amd64.go b/internal/threadtest3/threadtest3_linux_amd64.go
index c1569f5..d4b6296 100644
--- a/internal/threadtest3/threadtest3_linux_amd64.go
+++ b/internal/threadtest3/threadtest3_linux_amd64.go
@@ -1,41 +1,43 @@
 // Code generated by ccgo. DO NOT EDIT.
 
-// threadtest3.c
-
-// 2010-07-22
-//
-// The author disclaims copyright to this source code.  In place of
-// a legal notice, here is a blessing:
-//
-// May you do good and not evil.
-// May you find forgiveness for yourself and forgive others.
-// May you share freely, never taking more than you give.
-//
-// *************************************************************************
-//
-// The code in this file runs a few multi-threaded test cases using the
-// SQLite library. It can be compiled to an executable on unix using the
-// following command:
-//
-// gcc -O2 threadtest3.c sqlite3.c -ldl -lpthread -lm
-//
-// Even though threadtest3.c is the only C source code file mentioned on
-// the compiler command-line, #include macros are used to pull in additional
-// C code files named "tt3_*.c".
-//
-// After compiling, run this program with an optional argument telling
-// which test to run.  All tests are run if no argument is given.  The
-// argument can be a glob pattern to match multiple tests.  Examples:
-//
-// ./a.out                 -- Run all tests
-// ./a.out walthread3      -- Run the "walthread3" test
-// ./a.out 'wal*'          -- Run all of the wal* tests
-// ./a.out --help          -- List all available tests
-//
-// The exit status is non-zero if any test fails.
-
-// The "Set Error Line" macro.
-
+// threadtest3
+//  /*
+//  ** 2010-07-22
+//  **
+//  ** The author disclaims copyright to this source code.  In place of
+//  ** a legal notice, here is a blessing:
+//  **
+//  **    May you do good and not evil.
+//  **    May you find forgiveness for yourself and forgive others.
+//  **    May you share freely, never taking more than you give.
+//  **
+//  *************************************************************************
+//  **
+//  ** The code in this file runs a few multi-threaded test cases using the
+//  ** SQLite library. It can be compiled to an executable on unix using the
+//  ** following command:
+//  **
+//  **   gcc -O2 threadtest3.c sqlite3.c -ldl -lpthread -lm
+//  **
+//  ** Even though threadtest3.c is the only C source code file mentioned on
+//  ** the compiler command-line, #include macros are used to pull in additional
+//  ** C code files named "tt3_*.c".
+//  **
+//  ** After compiling, run this program with an optional argument telling
+//  ** which test to run.  All tests are run if no argument is given.  The
+//  ** argument can be a glob pattern to match multiple tests.  Examples:
+//  **
+//  **        ./a.out                 -- Run all tests
+//  **        ./a.out walthread3      -- Run the "walthread3" test
+//  **        ./a.out 'wal*'          -- Run all of the wal* tests
+//  **        ./a.out --help          -- List all available tests
+//  **
+//  ** The exit status is non-zero if any test fails.
+//  */
+
+//  /*
+//  ** The "Set Error Line" macro.
+//  */
 package main
 
 import (
@@ -73,13 +75,13 @@ var X__stdfiles [3]unsafe.Pointer
 var Xstdout unsafe.Pointer
 
 func init() {
-	Xstdout = (unsafe.Pointer)(uintptr(unsafe.Pointer(&X__stdfiles)) + 8)
+	Xstdout = unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdfiles)) + 8)
 }
 
 var Xstderr unsafe.Pointer
 
 func init() {
-	Xstderr = (unsafe.Pointer)(uintptr(unsafe.Pointer(&X__stdfiles)) + 16)
+	Xstderr = unsafe.Pointer(uintptr(unsafe.Pointer(&X__stdfiles)) + 16)
 }
 
 func Xmain(tls *crt.TLS, _argc int32, _argv **int8) (r0 int32) {
@@ -88,48 +90,48 @@ func Xmain(tls *crt.TLS, _argc int32, _argv **int8) (r0 int32) {
 	var _aTest [14]TThreadTest
 	r0 = i32(0)
 	_aTest = [14]TThreadTest{}
-	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(0)))).X0))) = _walthread1
-	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(0)))).X1))) = str(0)
-	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(0)))).X2))) = i32(20000)
-	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(1)))).X0))) = _walthread2
-	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(1)))).X1))) = str(11)
-	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(1)))).X2))) = i32(20000)
-	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(2)))).X0))) = _walthread3
-	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(2)))).X1))) = str(22)
-	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(2)))).X2))) = i32(20000)
-	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(3)))).X0))) = _walthread4
-	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(3)))).X1))) = str(33)
-	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(3)))).X2))) = i32(20000)
-	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(4)))).X0))) = _walthread5
-	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(4)))).X1))) = str(44)
-	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(4)))).X2))) = i32(1000)
-	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(5)))).X0))) = _cgt_pager_1
-	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(5)))).X1))) = str(55)
-	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(5)))).X2))) = i32(0)
-	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(6)))).X0))) = _dynamic_triggers
-	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(6)))).X1))) = str(67)
-	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(6)))).X2))) = i32(20000)
-	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(7)))).X0))) = _checkpoint_starvation_1
-	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(7)))).X1))) = str(84)
-	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(7)))).X2))) = i32(10000)
-	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(8)))).X0))) = _checkpoint_starvation_2
-	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(8)))).X1))) = str(108)
-	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(8)))).X2))) = i32(10000)
-	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(9)))).X0))) = _create_drop_index_1
-	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(9)))).X1))) = str(132)
-	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(9)))).X2))) = i32(10000)
-	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(10)))).X0))) = _lookaside1
-	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(10)))).X1))) = str(152)
-	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(10)))).X2))) = i32(10000)
-	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(11)))).X0))) = _vacuum1
-	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(11)))).X1))) = str(163)
-	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(11)))).X2))) = i32(10000)
-	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(12)))).X0))) = _stress1
-	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(12)))).X1))) = str(171)
-	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(12)))).X2))) = i32(10000)
-	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(13)))).X0))) = _stress2
-	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(13)))).X1))) = str(179)
-	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(i32(13)))).X2))) = i32(60000)
+	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(0)))).X0))) = _walthread1
+	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(0)))).X1))) = str(0)
+	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(0)))).X2))) = i32(20000)
+	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(1)))).X0))) = _walthread2
+	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(1)))).X1))) = str(11)
+	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(1)))).X2))) = i32(20000)
+	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(2)))).X0))) = _walthread3
+	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(2)))).X1))) = str(22)
+	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(2)))).X2))) = i32(20000)
+	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(3)))).X0))) = _walthread4
+	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(3)))).X1))) = str(33)
+	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(3)))).X2))) = i32(20000)
+	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(4)))).X0))) = _walthread5
+	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(4)))).X1))) = str(44)
+	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(4)))).X2))) = i32(1000)
+	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(5)))).X0))) = _cgt_pager_1
+	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(5)))).X1))) = str(55)
+	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(5)))).X2))) = i32(0)
+	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(6)))).X0))) = _dynamic_triggers
+	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(6)))).X1))) = str(67)
+	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(6)))).X2))) = i32(20000)
+	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(7)))).X0))) = _checkpoint_starvation_1
+	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(7)))).X1))) = str(84)
+	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(7)))).X2))) = i32(10000)
+	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(8)))).X0))) = _checkpoint_starvation_2
+	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(8)))).X1))) = str(108)
+	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(8)))).X2))) = i32(10000)
+	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(9)))).X0))) = _create_drop_index_1
+	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(9)))).X1))) = str(132)
+	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(9)))).X2))) = i32(10000)
+	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(10)))).X0))) = _lookaside1
+	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(10)))).X1))) = str(152)
+	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(10)))).X2))) = i32(10000)
+	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(11)))).X0))) = _vacuum1
+	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(11)))).X1))) = str(163)
+	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(11)))).X2))) = i32(10000)
+	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(12)))).X0))) = _stress1
+	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(12)))).X1))) = str(171)
+	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(12)))).X2))) = i32(10000)
+	*(*func(*crt.TLS, int32))(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(13)))).X0))) = _stress2
+	*(**int8)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(13)))).X1))) = str(179)
+	*(*int32)(unsafe.Pointer(&((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(i32(13)))).X2))) = i32(60000)
 	_nTestfound = i32(0)
 	bin.Xsqlite3_config(tls, i32(2))
 	if _argc < i32(2) {
@@ -141,8 +143,8 @@ _1:
 	if _iArg >= _argc {
 		goto _4
 	}
-	_2_zArg = *(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_argv)) + 8*uintptr(_iArg)))
-	if int32(*(*int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_2_zArg)) + 1*uintptr(i32(0))))) != i32(45) {
+	_2_zArg = *(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_argv)) + 8*uintptr(_iArg)))
+	if int32(*(*int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_2_zArg)) + 1*uintptr(i32(0))))) != i32(45) {
 		goto _5
 	}
 	if bin.Xsqlite3_stricmp(tls, _2_zArg, str(187)) != i32(0) {
@@ -164,7 +166,7 @@ _9:
 	if uint64(_i) >= u64(14) {
 		goto _12
 	}
-	if bin.Xsqlite3_strglob(tls, _2_zArg, (*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest))+24*uintptr(_i))).X1) == i32(0) {
+	if bin.Xsqlite3_strglob(tls, _2_zArg, (*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest))+24*uintptr(_i))).X1) == i32(0) {
 		goto _12
 	}
 	_i += 1
@@ -182,7 +184,7 @@ _15:
 	if _iArg >= _argc {
 		goto _18
 	}
-	if int32(*(*int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(*(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_argv)) + 8*uintptr(_iArg))))) + 1*uintptr(i32(0))))) == i32(45) {
+	if int32(*(*int8)(unsafe.Pointer(uintptr(unsafe.Pointer(*(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_argv)) + 8*uintptr(_iArg))))) + 1*uintptr(i32(0))))) == i32(45) {
 		goto _16
 	}
 	_i = i32(0)
@@ -190,11 +192,11 @@ _20:
 	if uint64(_i) >= u64(14) {
 		goto _23
 	}
-	_9_z = (*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(_i))).X1
-	if bin.Xsqlite3_strglob(tls, *(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_argv)) + 8*uintptr(_iArg))), _9_z) == i32(0) {
-		crt.Xprintf(tls, str(240), unsafe.Pointer(_9_z), ((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest))+24*uintptr(_i))).X2)/i32(1000))
+	_9_z = (*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(_i))).X1
+	if bin.Xsqlite3_strglob(tls, *(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_argv)) + 8*uintptr(_iArg))), _9_z) == i32(0) {
+		crt.Xprintf(tls, str(240), unsafe.Pointer(_9_z), ((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest))+24*uintptr(_i))).X2)/i32(1000))
 		crt.Xfflush(tls, (*crt.XFILE)(Xstdout))
-		((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest)) + 24*uintptr(_i))).X0)(tls, (*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest))+24*uintptr(_i))).X2)
+		((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest)) + 24*uintptr(_i))).X0)(tls, (*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest))+24*uintptr(_i))).X2)
 		_nTestfound += 1
 	}
 	_i += 1
@@ -216,14 +218,14 @@ _18:
 	}()
 
 _usage:
-	crt.Xprintf(tls, str(297), unsafe.Pointer(*(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_argv)) + 8*uintptr(i32(0))))))
+	crt.Xprintf(tls, str(297), unsafe.Pointer(*(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_argv)) + 8*uintptr(i32(0))))))
 	crt.Xprintf(tls, str(349))
 	_i = i32(0)
 _28:
 	if uint64(_i) >= u64(14) {
 		goto _31
 	}
-	crt.Xprintf(tls, str(371), unsafe.Pointer((*TThreadTest)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTest))+24*uintptr(_i))).X1))
+	crt.Xprintf(tls, str(371), unsafe.Pointer((*TThreadTest)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTest))+24*uintptr(_i))).X1))
 	_i += 1
 	goto _28
 _31:
@@ -242,36 +244,36 @@ func _walthread1(tls *crt.TLS, _nMs int32) {
 	_db = XSqlite{}
 	_threads = bin.T_ht{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(987)
 		}()
 		return &_err
 	}(), &_db, str(378), i32(1))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(988)
 		}()
 		return &_err
 	}(), &_db, str(386))
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(995)
 		}()
 		return &_err
 	}(), &_db)
 	_setstoptime_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(997)
 		}()
@@ -283,9 +285,9 @@ _8:
 		goto _11
 	}
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(999)
 		}()
@@ -295,18 +297,18 @@ _8:
 	goto _8
 _11:
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1001)
 		}()
 		return &_err
 	}(), &_threads, _walthread1_ckpt_thread, nil)
 	_join_all_threads_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1002)
 		}()
@@ -320,27 +322,27 @@ _11:
 
 func _opendb_x(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _zFile *int8, _bDelete int32) {
 	var _1_rc, _1_flags int32
-	if (_pErr.X0) != i32(0) {
+	if _pErr.X0 != i32(0) {
 		goto _0
 	}
 	_1_flags = i32(70)
 	if _bDelete != 0 {
 		crt.Xunlink(tls, _zFile)
 	}
-	_1_rc = bin.Xsqlite3_open_v2(tls, _zFile, (**bin.Xsqlite3)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&(_pDb.X0))))), _1_flags, nil)
+	_1_rc = bin.Xsqlite3_open_v2(tls, _zFile, (**bin.Xsqlite3)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&_pDb.X0)))), _1_flags, nil)
 	if _1_rc != 0 {
 		_sqlite_error(tls, _pErr, _pDb, str(562))
 		bin.Xsqlite3_close(tls, (*bin.Xsqlite3)(_pDb.X0))
-		*(*unsafe.Pointer)(unsafe.Pointer(&(_pDb.X0))) = nil
+		*(*unsafe.Pointer)(unsafe.Pointer(&_pDb.X0)) = nil
 		goto _3
 	}
-	bin.Xsqlite3_create_function(tls, (*bin.Xsqlite3)(_pDb.X0), str(567), i32(-1), i32(1), nil, *(*func(*crt.TLS, *bin.Xsqlite3_context, int32, **bin.XMem))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, int32, *unsafe.Pointer)
-	}{nil})), *(*func(*crt.TLS, *bin.Xsqlite3_context, int32, **bin.XMem))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, int32, *unsafe.Pointer)
-	}{_md5step})), *(*func(*crt.TLS, *bin.Xsqlite3_context))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer)
-	}{_md5finalize})))
+	bin.Xsqlite3_create_function(tls, (*bin.Xsqlite3)(_pDb.X0), str(567), i32(-1), i32(1), nil, nil, func() func(*crt.TLS, *bin.Xsqlite3_context, int32, **bin.XMem) {
+		v := _md5step
+		return *(*func(*crt.TLS, *bin.Xsqlite3_context, int32, **bin.XMem))(unsafe.Pointer(&v))
+	}(), func() func(*crt.TLS, *bin.Xsqlite3_context) {
+		v := _md5finalize
+		return *(*func(*crt.TLS, *bin.Xsqlite3_context))(unsafe.Pointer(&v))
+	}())
 	bin.Xsqlite3_busy_handler(tls, (*bin.Xsqlite3)(_pDb.X0), _busyhandler, nil)
 	bin.Xsqlite3_exec(tls, (*bin.Xsqlite3)(_pDb.X0), str(574), nil, nil, nil)
 _3:
@@ -348,12 +350,15 @@ _0:
 }
 
 func _sqlite_error(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _zFunc *int8) {
-	*(*int32)(unsafe.Pointer(&(_pErr.X0))) = bin.Xsqlite3_errcode(tls, (*bin.Xsqlite3)(_pDb.X0))
-	*(**int8)(unsafe.Pointer(&(_pErr.X2))) = bin.Xsqlite3_mprintf(tls, str(597), unsafe.Pointer(_zFunc), unsafe.Pointer(bin.Xsqlite3_errmsg(tls, (*bin.Xsqlite3)(_pDb.X0))), bin.Xsqlite3_extended_errcode(tls, (*bin.Xsqlite3)(_pDb.X0)))
+	*(*int32)(unsafe.Pointer(&_pErr.X0)) = bin.Xsqlite3_errcode(tls, (*bin.Xsqlite3)(_pDb.X0))
+	*(**int8)(unsafe.Pointer(&_pErr.X2)) = bin.Xsqlite3_mprintf(tls, str(597), unsafe.Pointer(_zFunc), unsafe.Pointer(bin.Xsqlite3_errmsg(tls, (*bin.Xsqlite3)(_pDb.X0))), bin.Xsqlite3_extended_errcode(tls, (*bin.Xsqlite3)(_pDb.X0)))
 }
 
-// During testing, the special md5sum() aggregate function is available.
-// inside SQLite.  The following routines implement that function.
+// C comment
+//  /*
+//  ** During testing, the special md5sum() aggregate function is available.
+//  ** inside SQLite.  The following routines implement that function.
+//  */
 func _md5step(tls *crt.TLS, _context unsafe.Pointer, _argc int32, _argv *unsafe.Pointer) {
 	var _i int32
 	var _2_zData *int8
@@ -365,7 +370,7 @@ func _md5step(tls *crt.TLS, _context unsafe.Pointer, _argc int32, _argv *unsafe.
 	if _p == nil {
 		return
 	}
-	if (_p.X0) == 0 {
+	if _p.X0 == 0 {
 		_MD5Init(tls, _p)
 	}
 	_i = i32(0)
@@ -373,7 +378,7 @@ _3:
 	if _i >= _argc {
 		goto _6
 	}
-	_2_zData = (*int8)(unsafe.Pointer(bin.Xsqlite3_value_text(tls, (*bin.XMem)(*(*unsafe.Pointer)(unsafe.Pointer(uintptr((unsafe.Pointer)(_argv)) + 8*uintptr(_i)))))))
+	_2_zData = (*int8)(unsafe.Pointer(bin.Xsqlite3_value_text(tls, (*bin.XMem)(*(*unsafe.Pointer)(unsafe.Pointer(uintptr(unsafe.Pointer(_argv)) + 8*uintptr(_i)))))))
 	if _2_zData != nil {
 		_MD5Update(tls, _p, (*uint8)(unsafe.Pointer(_2_zData)), uint32(crt.Xstrlen(tls, _2_zData)))
 	}
@@ -382,29 +387,35 @@ _3:
 _6:
 }
 
-// * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
-// * initialization constants.
+// C comment
+//  /*
+//   * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
+//   * initialization constants.
+//   */
 func _MD5Init(tls *crt.TLS, _ctx *XMD5Context) {
-	*(*int32)(unsafe.Pointer(&(_ctx.X0))) = i32(1)
-	*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)((*[4]uint32)(unsafe.Pointer(&(_ctx.X1))))) + 4*uintptr(i32(0)))) = uint32(i32(1732584193))
-	*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)((*[4]uint32)(unsafe.Pointer(&(_ctx.X1))))) + 4*uintptr(i32(1)))) = u32(4023233417)
-	*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)((*[4]uint32)(unsafe.Pointer(&(_ctx.X1))))) + 4*uintptr(i32(2)))) = u32(2562383102)
-	*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)((*[4]uint32)(unsafe.Pointer(&(_ctx.X1))))) + 4*uintptr(i32(3)))) = uint32(i32(271733878))
-	*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)((*[2]uint32)(unsafe.Pointer(&(_ctx.X2))))) + 4*uintptr(i32(0)))) = uint32(i32(0))
-	*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)((*[2]uint32)(unsafe.Pointer(&(_ctx.X2))))) + 4*uintptr(i32(1)))) = uint32(i32(0))
-}
-
-// * Update context to reflect the concatenation of another buffer full
-// * of bytes.
+	*(*int32)(unsafe.Pointer(&_ctx.X0)) = i32(1)
+	*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer((*[4]uint32)(unsafe.Pointer(&_ctx.X1)))) + 4*uintptr(i32(0)))) = uint32(i32(1732584193))
+	*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer((*[4]uint32)(unsafe.Pointer(&_ctx.X1)))) + 4*uintptr(i32(1)))) = u32(4023233417)
+	*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer((*[4]uint32)(unsafe.Pointer(&_ctx.X1)))) + 4*uintptr(i32(2)))) = u32(2562383102)
+	*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer((*[4]uint32)(unsafe.Pointer(&_ctx.X1)))) + 4*uintptr(i32(3)))) = uint32(i32(271733878))
+	*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer((*[2]uint32)(unsafe.Pointer(&_ctx.X2)))) + 4*uintptr(i32(0)))) = uint32(i32(0))
+	*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer((*[2]uint32)(unsafe.Pointer(&_ctx.X2)))) + 4*uintptr(i32(1)))) = uint32(i32(0))
+}
+
+// C comment
+//  /*
+//   * Update context to reflect the concatenation of another buffer full
+//   * of bytes.
+//   */
 func _MD5Update(tls *crt.TLS, _ctx *XMD5Context, _buf *uint8, _len uint32) {
 	var _t uint32
 	var _1_p *uint8
-	_t = *(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)((*[2]uint32)(unsafe.Pointer(&(_ctx.X2))))) + 4*uintptr(i32(0))))
-	if store0((*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)((*[2]uint32)(unsafe.Pointer(&(_ctx.X2)))))+4*uintptr(i32(0)))), _t+(_len<<uint(i32(3)))) < _t {
-		*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)((*[2]uint32)(unsafe.Pointer(&(_ctx.X2))))) + 4*uintptr(i32(1)))) += 1
+	_t = *(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer((*[2]uint32)(unsafe.Pointer(&_ctx.X2)))) + 4*uintptr(i32(0))))
+	if store0((*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer((*[2]uint32)(unsafe.Pointer(&_ctx.X2))))+4*uintptr(i32(0)))), _t+(_len<<uint(i32(3)))) < _t {
+		*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer((*[2]uint32)(unsafe.Pointer(&_ctx.X2)))) + 4*uintptr(i32(1)))) += 1
 	}
 	{
-		p := (*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)((*[2]uint32)(unsafe.Pointer(&(_ctx.X2))))) + 4*uintptr(i32(1))))
+		p := (*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer((*[2]uint32)(unsafe.Pointer(&_ctx.X2)))) + 4*uintptr(i32(1))))
 		*p = (*p) + (_len >> uint(i32(29)))
 		sink0(*p)
 	}
@@ -412,18 +423,18 @@ func _MD5Update(tls *crt.TLS, _ctx *XMD5Context, _buf *uint8, _len uint32) {
 	if _t == 0 {
 		goto _1
 	}
-	_1_p = (*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer((*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&(_ctx.X3))))))))) + uintptr(_t)))
+	_1_p = (*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer((*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&_ctx.X3)))))))) + uintptr(_t)))
 	_t = uint32(i32(64)) - _t
 	if _len < _t {
-		crt.Xmemcpy(tls, (unsafe.Pointer)(_1_p), (unsafe.Pointer)(_buf), uint64(_len))
+		crt.Xmemcpy(tls, unsafe.Pointer(_1_p), unsafe.Pointer(_buf), uint64(_len))
 		return
 	}
-	crt.Xmemcpy(tls, (unsafe.Pointer)(_1_p), (unsafe.Pointer)(_buf), uint64(_t))
-	_byteReverse(tls, (*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&(_ctx.X3))))))), uint32(i32(16)))
-	_MD5Transform(tls, (*[4]uint32)(unsafe.Pointer((*uint32)(unsafe.Pointer((*[4]uint32)(unsafe.Pointer(&(_ctx.X1))))))), (*[16]uint32)(unsafe.Pointer((*uint32)(unsafe.Pointer((*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&(_ctx.X3))))))))))))
+	crt.Xmemcpy(tls, unsafe.Pointer(_1_p), unsafe.Pointer(_buf), uint64(_t))
+	_byteReverse(tls, (*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&_ctx.X3)))))), uint32(i32(16)))
+	_MD5Transform(tls, (*[4]uint32)(unsafe.Pointer((*uint32)(unsafe.Pointer((*[4]uint32)(unsafe.Pointer(&_ctx.X1)))))), (*[16]uint32)(unsafe.Pointer((*uint32)(unsafe.Pointer((*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&_ctx.X3)))))))))))
 	{
 		p := &_buf
-		*p = (*uint8)(unsafe.Pointer(uintptr((unsafe.Pointer)(*p)) + 1*uintptr(_t)))
+		*p = (*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(*p)) + 1*uintptr(_t)))
 		sink2(*p)
 	}
 	{
@@ -433,12 +444,12 @@ func _MD5Update(tls *crt.TLS, _ctx *XMD5Context, _buf *uint8, _len uint32) {
 	}
 _1:
 	if _len >= uint32(i32(64)) {
-		crt.Xmemcpy(tls, (unsafe.Pointer)((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&(_ctx.X3)))))), (unsafe.Pointer)(_buf), uint64(i32(64)))
-		_byteReverse(tls, (*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&(_ctx.X3))))))), uint32(i32(16)))
-		_MD5Transform(tls, (*[4]uint32)(unsafe.Pointer((*uint32)(unsafe.Pointer((*[4]uint32)(unsafe.Pointer(&(_ctx.X1))))))), (*[16]uint32)(unsafe.Pointer((*uint32)(unsafe.Pointer((*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&(_ctx.X3))))))))))))
+		crt.Xmemcpy(tls, unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&_ctx.X3))))), unsafe.Pointer(_buf), uint64(i32(64)))
+		_byteReverse(tls, (*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&_ctx.X3)))))), uint32(i32(16)))
+		_MD5Transform(tls, (*[4]uint32)(unsafe.Pointer((*uint32)(unsafe.Pointer((*[4]uint32)(unsafe.Pointer(&_ctx.X1)))))), (*[16]uint32)(unsafe.Pointer((*uint32)(unsafe.Pointer((*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&_ctx.X3)))))))))))
 		{
 			p := &_buf
-			*p = (*uint8)(unsafe.Pointer(uintptr((unsafe.Pointer)(*p)) + 1*uintptr(i32(64))))
+			*p = (*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(*p)) + 1*uintptr(i32(64))))
 			sink2(*p)
 		}
 		{
@@ -448,18 +459,21 @@ _1:
 		}
 		goto _1
 	}
-	crt.Xmemcpy(tls, (unsafe.Pointer)((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&(_ctx.X3)))))), (unsafe.Pointer)(_buf), uint64(_len))
+	crt.Xmemcpy(tls, unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&_ctx.X3))))), unsafe.Pointer(_buf), uint64(_len))
 }
 
-// * Note: this code is harmless on little-endian machines.
+// C comment
+//  /*
+//   * Note: this code is harmless on little-endian machines.
+//   */
 func _byteReverse(tls *crt.TLS, _buf *uint8, _longs uint32) {
 	var _t uint32
 _0:
-	_t = (((uint32(*(*uint8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_buf)) + 1*uintptr(i32(3))))) << uint(i32(8))) | uint32(*(*uint8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_buf)) + 1*uintptr(i32(2)))))) << uint(i32(16))) | ((uint32(*(*uint8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_buf)) + 1*uintptr(i32(1))))) << uint(i32(8))) | uint32(*(*uint8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_buf)) + 1*uintptr(i32(0))))))
+	_t = (((uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(_buf)) + 1*uintptr(i32(3))))) << uint(i32(8))) | uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(_buf)) + 1*uintptr(i32(2)))))) << uint(i32(16))) | ((uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(_buf)) + 1*uintptr(i32(1))))) << uint(i32(8))) | uint32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(_buf)) + 1*uintptr(i32(0))))))
 	*(*uint32)(unsafe.Pointer(_buf)) = _t
 	{
 		p := &_buf
-		*p = (*uint8)(unsafe.Pointer(uintptr((unsafe.Pointer)(*p)) + 1*uintptr(i32(4))))
+		*p = (*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(*p)) + 1*uintptr(i32(4))))
 		sink2(*p)
 	}
 	if preInc0(&_longs, uint32(4294967295)) != 0 {
@@ -467,21 +481,24 @@ _0:
 	}
 }
 
-// * The core of the MD5 algorithm, this alters an existing MD5 hash to
-// * reflect the addition of 16 longwords of new data.  MD5Update blocks
-// * the data and converts bytes into longwords for this routine.
+// C comment
+//  /*
+//   * The core of the MD5 algorithm, this alters an existing MD5 hash to
+//   * reflect the addition of 16 longwords of new data.  MD5Update blocks
+//   * the data and converts bytes into longwords for this routine.
+//   */
 func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 	var _a, _b, _c, _d uint32
-	_a = *(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_buf)) + 4*uintptr(i32(0))))
-	_b = *(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_buf)) + 4*uintptr(i32(1))))
-	_c = *(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_buf)) + 4*uintptr(i32(2))))
-	_d = *(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_buf)) + 4*uintptr(i32(3))))
+	_a = *(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_buf)) + 4*uintptr(i32(0))))
+	_b = *(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_buf)) + 4*uintptr(i32(1))))
+	_c = *(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_buf)) + 4*uintptr(i32(2))))
+	_d = *(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_buf)) + 4*uintptr(i32(3))))
 	{
 		p := func() *uint32 {
 			*func() *uint32 {
 				{
 					p := &_a
-					*p = (*p) + (((_d ^ (_b & (_c ^ _d))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(0)))))) + u32(3614090360))
+					*p = (*p) + (((_d ^ (_b & (_c ^ _d))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(0)))))) + u32(3614090360))
 					sink0(*p)
 				}
 				return &_a
@@ -496,7 +513,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_d
-					*p = (*p) + (((_c ^ (_a & (_b ^ _c))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(1)))))) + u32(3905402710))
+					*p = (*p) + (((_c ^ (_a & (_b ^ _c))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(1)))))) + u32(3905402710))
 					sink0(*p)
 				}
 				return &_d
@@ -511,7 +528,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_c
-					*p = (*p) + (((_b ^ (_d & (_a ^ _b))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(2)))))) + uint32(i32(606105819)))
+					*p = (*p) + (((_b ^ (_d & (_a ^ _b))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(2)))))) + uint32(i32(606105819)))
 					sink0(*p)
 				}
 				return &_c
@@ -526,7 +543,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_b
-					*p = (*p) + (((_a ^ (_c & (_d ^ _a))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(3)))))) + u32(3250441966))
+					*p = (*p) + (((_a ^ (_c & (_d ^ _a))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(3)))))) + u32(3250441966))
 					sink0(*p)
 				}
 				return &_b
@@ -541,7 +558,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_a
-					*p = (*p) + (((_d ^ (_b & (_c ^ _d))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(4)))))) + u32(4118548399))
+					*p = (*p) + (((_d ^ (_b & (_c ^ _d))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(4)))))) + u32(4118548399))
 					sink0(*p)
 				}
 				return &_a
@@ -556,7 +573,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_d
-					*p = (*p) + (((_c ^ (_a & (_b ^ _c))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(5)))))) + uint32(i32(1200080426)))
+					*p = (*p) + (((_c ^ (_a & (_b ^ _c))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(5)))))) + uint32(i32(1200080426)))
 					sink0(*p)
 				}
 				return &_d
@@ -571,7 +588,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_c
-					*p = (*p) + (((_b ^ (_d & (_a ^ _b))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(6)))))) + u32(2821735955))
+					*p = (*p) + (((_b ^ (_d & (_a ^ _b))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(6)))))) + u32(2821735955))
 					sink0(*p)
 				}
 				return &_c
@@ -586,7 +603,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_b
-					*p = (*p) + (((_a ^ (_c & (_d ^ _a))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(7)))))) + u32(4249261313))
+					*p = (*p) + (((_a ^ (_c & (_d ^ _a))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(7)))))) + u32(4249261313))
 					sink0(*p)
 				}
 				return &_b
@@ -601,7 +618,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_a
-					*p = (*p) + (((_d ^ (_b & (_c ^ _d))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(8)))))) + uint32(i32(1770035416)))
+					*p = (*p) + (((_d ^ (_b & (_c ^ _d))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(8)))))) + uint32(i32(1770035416)))
 					sink0(*p)
 				}
 				return &_a
@@ -616,7 +633,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_d
-					*p = (*p) + (((_c ^ (_a & (_b ^ _c))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(9)))))) + u32(2336552879))
+					*p = (*p) + (((_c ^ (_a & (_b ^ _c))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(9)))))) + u32(2336552879))
 					sink0(*p)
 				}
 				return &_d
@@ -631,7 +648,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_c
-					*p = (*p) + (((_b ^ (_d & (_a ^ _b))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(10)))))) + u32(4294925233))
+					*p = (*p) + (((_b ^ (_d & (_a ^ _b))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(10)))))) + u32(4294925233))
 					sink0(*p)
 				}
 				return &_c
@@ -646,7 +663,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_b
-					*p = (*p) + (((_a ^ (_c & (_d ^ _a))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(11)))))) + u32(2304563134))
+					*p = (*p) + (((_a ^ (_c & (_d ^ _a))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(11)))))) + u32(2304563134))
 					sink0(*p)
 				}
 				return &_b
@@ -661,7 +678,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_a
-					*p = (*p) + (((_d ^ (_b & (_c ^ _d))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(12)))))) + uint32(i32(1804603682)))
+					*p = (*p) + (((_d ^ (_b & (_c ^ _d))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(12)))))) + uint32(i32(1804603682)))
 					sink0(*p)
 				}
 				return &_a
@@ -676,7 +693,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_d
-					*p = (*p) + (((_c ^ (_a & (_b ^ _c))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(13)))))) + u32(4254626195))
+					*p = (*p) + (((_c ^ (_a & (_b ^ _c))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(13)))))) + u32(4254626195))
 					sink0(*p)
 				}
 				return &_d
@@ -691,7 +708,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_c
-					*p = (*p) + (((_b ^ (_d & (_a ^ _b))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(14)))))) + u32(2792965006))
+					*p = (*p) + (((_b ^ (_d & (_a ^ _b))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(14)))))) + u32(2792965006))
 					sink0(*p)
 				}
 				return &_c
@@ -706,7 +723,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_b
-					*p = (*p) + (((_a ^ (_c & (_d ^ _a))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(15)))))) + uint32(i32(1236535329)))
+					*p = (*p) + (((_a ^ (_c & (_d ^ _a))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(15)))))) + uint32(i32(1236535329)))
 					sink0(*p)
 				}
 				return &_b
@@ -721,7 +738,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_a
-					*p = (*p) + (((_c ^ (_d & (_b ^ _c))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(1)))))) + u32(4129170786))
+					*p = (*p) + (((_c ^ (_d & (_b ^ _c))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(1)))))) + u32(4129170786))
 					sink0(*p)
 				}
 				return &_a
@@ -736,7 +753,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_d
-					*p = (*p) + (((_b ^ (_c & (_a ^ _b))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(6)))))) + u32(3225465664))
+					*p = (*p) + (((_b ^ (_c & (_a ^ _b))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(6)))))) + u32(3225465664))
 					sink0(*p)
 				}
 				return &_d
@@ -751,7 +768,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_c
-					*p = (*p) + (((_a ^ (_b & (_d ^ _a))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(11)))))) + uint32(i32(643717713)))
+					*p = (*p) + (((_a ^ (_b & (_d ^ _a))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(11)))))) + uint32(i32(643717713)))
 					sink0(*p)
 				}
 				return &_c
@@ -766,7 +783,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_b
-					*p = (*p) + (((_d ^ (_a & (_c ^ _d))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(0)))))) + u32(3921069994))
+					*p = (*p) + (((_d ^ (_a & (_c ^ _d))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(0)))))) + u32(3921069994))
 					sink0(*p)
 				}
 				return &_b
@@ -781,7 +798,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_a
-					*p = (*p) + (((_c ^ (_d & (_b ^ _c))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(5)))))) + u32(3593408605))
+					*p = (*p) + (((_c ^ (_d & (_b ^ _c))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(5)))))) + u32(3593408605))
 					sink0(*p)
 				}
 				return &_a
@@ -796,7 +813,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_d
-					*p = (*p) + (((_b ^ (_c & (_a ^ _b))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(10)))))) + uint32(i32(38016083)))
+					*p = (*p) + (((_b ^ (_c & (_a ^ _b))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(10)))))) + uint32(i32(38016083)))
 					sink0(*p)
 				}
 				return &_d
@@ -811,7 +828,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_c
-					*p = (*p) + (((_a ^ (_b & (_d ^ _a))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(15)))))) + u32(3634488961))
+					*p = (*p) + (((_a ^ (_b & (_d ^ _a))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(15)))))) + u32(3634488961))
 					sink0(*p)
 				}
 				return &_c
@@ -826,7 +843,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_b
-					*p = (*p) + (((_d ^ (_a & (_c ^ _d))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(4)))))) + u32(3889429448))
+					*p = (*p) + (((_d ^ (_a & (_c ^ _d))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(4)))))) + u32(3889429448))
 					sink0(*p)
 				}
 				return &_b
@@ -841,7 +858,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_a
-					*p = (*p) + (((_c ^ (_d & (_b ^ _c))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(9)))))) + uint32(i32(568446438)))
+					*p = (*p) + (((_c ^ (_d & (_b ^ _c))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(9)))))) + uint32(i32(568446438)))
 					sink0(*p)
 				}
 				return &_a
@@ -856,7 +873,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_d
-					*p = (*p) + (((_b ^ (_c & (_a ^ _b))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(14)))))) + u32(3275163606))
+					*p = (*p) + (((_b ^ (_c & (_a ^ _b))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(14)))))) + u32(3275163606))
 					sink0(*p)
 				}
 				return &_d
@@ -871,7 +888,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_c
-					*p = (*p) + (((_a ^ (_b & (_d ^ _a))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(3)))))) + u32(4107603335))
+					*p = (*p) + (((_a ^ (_b & (_d ^ _a))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(3)))))) + u32(4107603335))
 					sink0(*p)
 				}
 				return &_c
@@ -886,7 +903,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_b
-					*p = (*p) + (((_d ^ (_a & (_c ^ _d))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(8)))))) + uint32(i32(1163531501)))
+					*p = (*p) + (((_d ^ (_a & (_c ^ _d))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(8)))))) + uint32(i32(1163531501)))
 					sink0(*p)
 				}
 				return &_b
@@ -901,7 +918,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_a
-					*p = (*p) + (((_c ^ (_d & (_b ^ _c))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(13)))))) + u32(2850285829))
+					*p = (*p) + (((_c ^ (_d & (_b ^ _c))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(13)))))) + u32(2850285829))
 					sink0(*p)
 				}
 				return &_a
@@ -916,7 +933,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_d
-					*p = (*p) + (((_b ^ (_c & (_a ^ _b))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(2)))))) + u32(4243563512))
+					*p = (*p) + (((_b ^ (_c & (_a ^ _b))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(2)))))) + u32(4243563512))
 					sink0(*p)
 				}
 				return &_d
@@ -931,7 +948,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_c
-					*p = (*p) + (((_a ^ (_b & (_d ^ _a))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(7)))))) + uint32(i32(1735328473)))
+					*p = (*p) + (((_a ^ (_b & (_d ^ _a))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(7)))))) + uint32(i32(1735328473)))
 					sink0(*p)
 				}
 				return &_c
@@ -946,7 +963,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_b
-					*p = (*p) + (((_d ^ (_a & (_c ^ _d))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(12)))))) + u32(2368359562))
+					*p = (*p) + (((_d ^ (_a & (_c ^ _d))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(12)))))) + u32(2368359562))
 					sink0(*p)
 				}
 				return &_b
@@ -961,7 +978,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_a
-					*p = (*p) + ((((_b ^ _c) ^ _d) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(5)))))) + u32(4294588738))
+					*p = (*p) + ((((_b ^ _c) ^ _d) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(5)))))) + u32(4294588738))
 					sink0(*p)
 				}
 				return &_a
@@ -976,7 +993,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_d
-					*p = (*p) + ((((_a ^ _b) ^ _c) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(8)))))) + u32(2272392833))
+					*p = (*p) + ((((_a ^ _b) ^ _c) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(8)))))) + u32(2272392833))
 					sink0(*p)
 				}
 				return &_d
@@ -991,7 +1008,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_c
-					*p = (*p) + ((((_d ^ _a) ^ _b) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(11)))))) + uint32(i32(1839030562)))
+					*p = (*p) + ((((_d ^ _a) ^ _b) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(11)))))) + uint32(i32(1839030562)))
 					sink0(*p)
 				}
 				return &_c
@@ -1006,7 +1023,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_b
-					*p = (*p) + ((((_c ^ _d) ^ _a) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(14)))))) + u32(4259657740))
+					*p = (*p) + ((((_c ^ _d) ^ _a) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(14)))))) + u32(4259657740))
 					sink0(*p)
 				}
 				return &_b
@@ -1021,7 +1038,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_a
-					*p = (*p) + ((((_b ^ _c) ^ _d) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(1)))))) + u32(2763975236))
+					*p = (*p) + ((((_b ^ _c) ^ _d) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(1)))))) + u32(2763975236))
 					sink0(*p)
 				}
 				return &_a
@@ -1036,7 +1053,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_d
-					*p = (*p) + ((((_a ^ _b) ^ _c) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(4)))))) + uint32(i32(1272893353)))
+					*p = (*p) + ((((_a ^ _b) ^ _c) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(4)))))) + uint32(i32(1272893353)))
 					sink0(*p)
 				}
 				return &_d
@@ -1051,7 +1068,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_c
-					*p = (*p) + ((((_d ^ _a) ^ _b) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(7)))))) + u32(4139469664))
+					*p = (*p) + ((((_d ^ _a) ^ _b) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(7)))))) + u32(4139469664))
 					sink0(*p)
 				}
 				return &_c
@@ -1066,7 +1083,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_b
-					*p = (*p) + ((((_c ^ _d) ^ _a) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(10)))))) + u32(3200236656))
+					*p = (*p) + ((((_c ^ _d) ^ _a) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(10)))))) + u32(3200236656))
 					sink0(*p)
 				}
 				return &_b
@@ -1081,7 +1098,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_a
-					*p = (*p) + ((((_b ^ _c) ^ _d) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(13)))))) + uint32(i32(681279174)))
+					*p = (*p) + ((((_b ^ _c) ^ _d) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(13)))))) + uint32(i32(681279174)))
 					sink0(*p)
 				}
 				return &_a
@@ -1096,7 +1113,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_d
-					*p = (*p) + ((((_a ^ _b) ^ _c) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(0)))))) + u32(3936430074))
+					*p = (*p) + ((((_a ^ _b) ^ _c) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(0)))))) + u32(3936430074))
 					sink0(*p)
 				}
 				return &_d
@@ -1111,7 +1128,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_c
-					*p = (*p) + ((((_d ^ _a) ^ _b) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(3)))))) + u32(3572445317))
+					*p = (*p) + ((((_d ^ _a) ^ _b) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(3)))))) + u32(3572445317))
 					sink0(*p)
 				}
 				return &_c
@@ -1126,7 +1143,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_b
-					*p = (*p) + ((((_c ^ _d) ^ _a) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(6)))))) + uint32(i32(76029189)))
+					*p = (*p) + ((((_c ^ _d) ^ _a) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(6)))))) + uint32(i32(76029189)))
 					sink0(*p)
 				}
 				return &_b
@@ -1141,7 +1158,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_a
-					*p = (*p) + ((((_b ^ _c) ^ _d) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(9)))))) + u32(3654602809))
+					*p = (*p) + ((((_b ^ _c) ^ _d) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(9)))))) + u32(3654602809))
 					sink0(*p)
 				}
 				return &_a
@@ -1156,7 +1173,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_d
-					*p = (*p) + ((((_a ^ _b) ^ _c) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(12)))))) + u32(3873151461))
+					*p = (*p) + ((((_a ^ _b) ^ _c) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(12)))))) + u32(3873151461))
 					sink0(*p)
 				}
 				return &_d
@@ -1171,7 +1188,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_c
-					*p = (*p) + ((((_d ^ _a) ^ _b) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(15)))))) + uint32(i32(530742520)))
+					*p = (*p) + ((((_d ^ _a) ^ _b) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(15)))))) + uint32(i32(530742520)))
 					sink0(*p)
 				}
 				return &_c
@@ -1186,7 +1203,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_b
-					*p = (*p) + ((((_c ^ _d) ^ _a) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(2)))))) + u32(3299628645))
+					*p = (*p) + ((((_c ^ _d) ^ _a) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(2)))))) + u32(3299628645))
 					sink0(*p)
 				}
 				return &_b
@@ -1201,7 +1218,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_a
-					*p = (*p) + (((_c ^ (_b | (^_d))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(0)))))) + u32(4096336452))
+					*p = (*p) + (((_c ^ (_b | (^_d))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(0)))))) + u32(4096336452))
 					sink0(*p)
 				}
 				return &_a
@@ -1216,7 +1233,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_d
-					*p = (*p) + (((_b ^ (_a | (^_c))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(7)))))) + uint32(i32(1126891415)))
+					*p = (*p) + (((_b ^ (_a | (^_c))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(7)))))) + uint32(i32(1126891415)))
 					sink0(*p)
 				}
 				return &_d
@@ -1231,7 +1248,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_c
-					*p = (*p) + (((_a ^ (_d | (^_b))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(14)))))) + u32(2878612391))
+					*p = (*p) + (((_a ^ (_d | (^_b))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(14)))))) + u32(2878612391))
 					sink0(*p)
 				}
 				return &_c
@@ -1246,7 +1263,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_b
-					*p = (*p) + (((_d ^ (_c | (^_a))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(5)))))) + u32(4237533241))
+					*p = (*p) + (((_d ^ (_c | (^_a))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(5)))))) + u32(4237533241))
 					sink0(*p)
 				}
 				return &_b
@@ -1261,7 +1278,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_a
-					*p = (*p) + (((_c ^ (_b | (^_d))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(12)))))) + uint32(i32(1700485571)))
+					*p = (*p) + (((_c ^ (_b | (^_d))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(12)))))) + uint32(i32(1700485571)))
 					sink0(*p)
 				}
 				return &_a
@@ -1276,7 +1293,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_d
-					*p = (*p) + (((_b ^ (_a | (^_c))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(3)))))) + u32(2399980690))
+					*p = (*p) + (((_b ^ (_a | (^_c))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(3)))))) + u32(2399980690))
 					sink0(*p)
 				}
 				return &_d
@@ -1291,7 +1308,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_c
-					*p = (*p) + (((_a ^ (_d | (^_b))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(10)))))) + u32(4293915773))
+					*p = (*p) + (((_a ^ (_d | (^_b))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(10)))))) + u32(4293915773))
 					sink0(*p)
 				}
 				return &_c
@@ -1306,7 +1323,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_b
-					*p = (*p) + (((_d ^ (_c | (^_a))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(1)))))) + u32(2240044497))
+					*p = (*p) + (((_d ^ (_c | (^_a))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(1)))))) + u32(2240044497))
 					sink0(*p)
 				}
 				return &_b
@@ -1321,7 +1338,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_a
-					*p = (*p) + (((_c ^ (_b | (^_d))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(8)))))) + uint32(i32(1873313359)))
+					*p = (*p) + (((_c ^ (_b | (^_d))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(8)))))) + uint32(i32(1873313359)))
 					sink0(*p)
 				}
 				return &_a
@@ -1336,7 +1353,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_d
-					*p = (*p) + (((_b ^ (_a | (^_c))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(15)))))) + u32(4264355552))
+					*p = (*p) + (((_b ^ (_a | (^_c))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(15)))))) + u32(4264355552))
 					sink0(*p)
 				}
 				return &_d
@@ -1351,7 +1368,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_c
-					*p = (*p) + (((_a ^ (_d | (^_b))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(6)))))) + u32(2734768916))
+					*p = (*p) + (((_a ^ (_d | (^_b))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(6)))))) + u32(2734768916))
 					sink0(*p)
 				}
 				return &_c
@@ -1366,7 +1383,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_b
-					*p = (*p) + (((_d ^ (_c | (^_a))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(13)))))) + uint32(i32(1309151649)))
+					*p = (*p) + (((_d ^ (_c | (^_a))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(13)))))) + uint32(i32(1309151649)))
 					sink0(*p)
 				}
 				return &_b
@@ -1381,7 +1398,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_a
-					*p = (*p) + (((_c ^ (_b | (^_d))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(4)))))) + u32(4149444226))
+					*p = (*p) + (((_c ^ (_b | (^_d))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(4)))))) + u32(4149444226))
 					sink0(*p)
 				}
 				return &_a
@@ -1396,7 +1413,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_d
-					*p = (*p) + (((_b ^ (_a | (^_c))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(11)))))) + u32(3174756917))
+					*p = (*p) + (((_b ^ (_a | (^_c))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(11)))))) + u32(3174756917))
 					sink0(*p)
 				}
 				return &_d
@@ -1411,7 +1428,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_c
-					*p = (*p) + (((_a ^ (_d | (^_b))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(2)))))) + uint32(i32(718787259)))
+					*p = (*p) + (((_a ^ (_d | (^_b))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(2)))))) + uint32(i32(718787259)))
 					sink0(*p)
 				}
 				return &_c
@@ -1426,7 +1443,7 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 			*func() *uint32 {
 				{
 					p := &_b
-					*p = (*p) + (((_d ^ (_c | (^_a))) + (*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_in)) + 4*uintptr(i32(9)))))) + u32(3951481745))
+					*p = (*p) + (((_d ^ (_c | (^_a))) + (*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_in)) + 4*uintptr(i32(9)))))) + u32(3951481745))
 					sink0(*p)
 				}
 				return &_b
@@ -1437,22 +1454,22 @@ func _MD5Transform(tls *crt.TLS, _buf *[4]uint32, _in *[16]uint32) {
 		sink0(*p)
 	}
 	{
-		p := (*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_buf)) + 4*uintptr(i32(0))))
+		p := (*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_buf)) + 4*uintptr(i32(0))))
 		*p = (*p) + _a
 		sink0(*p)
 	}
 	{
-		p := (*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_buf)) + 4*uintptr(i32(1))))
+		p := (*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_buf)) + 4*uintptr(i32(1))))
 		*p = (*p) + _b
 		sink0(*p)
 	}
 	{
-		p := (*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_buf)) + 4*uintptr(i32(2))))
+		p := (*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_buf)) + 4*uintptr(i32(2))))
 		*p = (*p) + _c
 		sink0(*p)
 	}
 	{
-		p := (*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)(_buf)) + 4*uintptr(i32(3))))
+		p := (*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer(_buf)) + 4*uintptr(i32(3))))
 		*p = (*p) + _d
 		sink0(*p)
 	}
@@ -1465,39 +1482,48 @@ func _md5finalize(tls *crt.TLS, _context unsafe.Pointer) {
 	_p = (*XMD5Context)(bin.Xsqlite3_aggregate_context(tls, (*bin.Xsqlite3_context)(_context), int32(u64(92))))
 	_MD5Final(tls, (*[16]uint8)(unsafe.Pointer((*uint8)(unsafe.Pointer(&_digest)))), _p)
 	_MD5DigestToBase16(tls, (*uint8)(unsafe.Pointer(&_digest)), (*int8)(unsafe.Pointer(&_zBuf)))
-	bin.Xsqlite3_result_text(tls, (*bin.Xsqlite3_context)(_context), (*int8)(unsafe.Pointer(&_zBuf)), i32(-1), *(*func(*crt.TLS, unsafe.Pointer))(unsafe.Pointer(&struct{ f uint64 }{u64(18446744073709551615)})))
+	bin.Xsqlite3_result_text(tls, (*bin.Xsqlite3_context)(_context), (*int8)(unsafe.Pointer(&_zBuf)), i32(-1), func() func(*crt.TLS, unsafe.Pointer) {
+		v := u64(18446744073709551615)
+		return *(*func(*crt.TLS, unsafe.Pointer))(unsafe.Pointer(&v))
+	}())
 	_ = _digest
 	_ = _zBuf
 }
 
-// * Final wrapup - pad to 64-byte boundary with the bit pattern
-// * 1 0* (64-bit count of bits processed, MSB-first)
+// C comment
+//  /*
+//   * Final wrapup - pad to 64-byte boundary with the bit pattern
+//   * 1 0* (64-bit count of bits processed, MSB-first)
+//   */
 func _MD5Final(tls *crt.TLS, _digest *[16]uint8, _ctx *XMD5Context) {
 	var _count uint32
 	var _p *uint8
-	_count = ((*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)((*[2]uint32)(unsafe.Pointer(&(_ctx.X2))))) + 4*uintptr(i32(0))))) >> uint(i32(3))) & uint32(i32(63))
-	_p = (*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer((*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&(_ctx.X3))))))))) + uintptr(_count)))
+	_count = ((*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer((*[2]uint32)(unsafe.Pointer(&_ctx.X2)))) + 4*uintptr(i32(0))))) >> uint(i32(3))) & uint32(i32(63))
+	_p = (*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer((*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&_ctx.X3)))))))) + uintptr(_count)))
 	*postInc2(&_p, 1) = uint8(i32(128))
 	_count = uint32(i32(63)) - _count
 	if _count < uint32(i32(8)) {
-		crt.Xmemset(tls, (unsafe.Pointer)(_p), i32(0), uint64(_count))
-		_byteReverse(tls, (*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&(_ctx.X3))))))), uint32(i32(16)))
-		_MD5Transform(tls, (*[4]uint32)(unsafe.Pointer((*uint32)(unsafe.Pointer((*[4]uint32)(unsafe.Pointer(&(_ctx.X1))))))), (*[16]uint32)(unsafe.Pointer((*uint32)(unsafe.Pointer((*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&(_ctx.X3))))))))))))
-		crt.Xmemset(tls, (unsafe.Pointer)((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&(_ctx.X3)))))), i32(0), uint64(i32(56)))
+		crt.Xmemset(tls, unsafe.Pointer(_p), i32(0), uint64(_count))
+		_byteReverse(tls, (*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&_ctx.X3)))))), uint32(i32(16)))
+		_MD5Transform(tls, (*[4]uint32)(unsafe.Pointer((*uint32)(unsafe.Pointer((*[4]uint32)(unsafe.Pointer(&_ctx.X1)))))), (*[16]uint32)(unsafe.Pointer((*uint32)(unsafe.Pointer((*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&_ctx.X3)))))))))))
+		crt.Xmemset(tls, unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&_ctx.X3))))), i32(0), uint64(i32(56)))
 		goto _1
 	}
-	crt.Xmemset(tls, (unsafe.Pointer)(_p), i32(0), uint64(_count-uint32(i32(8))))
+	crt.Xmemset(tls, unsafe.Pointer(_p), i32(0), uint64(_count-uint32(i32(8))))
 _1:
-	_byteReverse(tls, (*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&(_ctx.X3))))))), uint32(i32(14)))
-	*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)((*[16]uint32)(unsafe.Pointer((*t1)(unsafe.Pointer(&(_ctx.X3))))))) + 4*uintptr(i32(14)))) = *(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)((*[2]uint32)(unsafe.Pointer(&(_ctx.X2))))) + 4*uintptr(i32(0))))
-	*(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)((*[16]uint32)(unsafe.Pointer((*t1)(unsafe.Pointer(&(_ctx.X3))))))) + 4*uintptr(i32(15)))) = *(*uint32)(unsafe.Pointer(uintptr((unsafe.Pointer)((*[2]uint32)(unsafe.Pointer(&(_ctx.X2))))) + 4*uintptr(i32(1))))
-	_MD5Transform(tls, (*[4]uint32)(unsafe.Pointer((*uint32)(unsafe.Pointer((*[4]uint32)(unsafe.Pointer(&(_ctx.X1))))))), (*[16]uint32)(unsafe.Pointer((*uint32)(unsafe.Pointer((*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&(_ctx.X3))))))))))))
-	_byteReverse(tls, (*uint8)(unsafe.Pointer((*uint32)(unsafe.Pointer((*[4]uint32)(unsafe.Pointer(&(_ctx.X1))))))), uint32(i32(4)))
-	crt.Xmemcpy(tls, (unsafe.Pointer)(_digest), (unsafe.Pointer)((*[4]uint32)(unsafe.Pointer(&(_ctx.X1)))), uint64(i32(16)))
-	crt.Xmemset(tls, (unsafe.Pointer)(_ctx), i32(0), u64(92))
-}
-
-// Convert a 128-bit MD5 digest into a 32-digit base-16 number.
+	_byteReverse(tls, (*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&_ctx.X3)))))), uint32(i32(14)))
+	*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer((*[16]uint32)(unsafe.Pointer((*t1)(unsafe.Pointer(&_ctx.X3)))))) + 4*uintptr(i32(14)))) = *(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer((*[2]uint32)(unsafe.Pointer(&_ctx.X2)))) + 4*uintptr(i32(0))))
+	*(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer((*[16]uint32)(unsafe.Pointer((*t1)(unsafe.Pointer(&_ctx.X3)))))) + 4*uintptr(i32(15)))) = *(*uint32)(unsafe.Pointer(uintptr(unsafe.Pointer((*[2]uint32)(unsafe.Pointer(&_ctx.X2)))) + 4*uintptr(i32(1))))
+	_MD5Transform(tls, (*[4]uint32)(unsafe.Pointer((*uint32)(unsafe.Pointer((*[4]uint32)(unsafe.Pointer(&_ctx.X1)))))), (*[16]uint32)(unsafe.Pointer((*uint32)(unsafe.Pointer((*uint8)(unsafe.Pointer((*[64]uint8)(unsafe.Pointer((*t1)(unsafe.Pointer(&_ctx.X3)))))))))))
+	_byteReverse(tls, (*uint8)(unsafe.Pointer((*uint32)(unsafe.Pointer((*[4]uint32)(unsafe.Pointer(&_ctx.X1)))))), uint32(i32(4)))
+	crt.Xmemcpy(tls, unsafe.Pointer(_digest), unsafe.Pointer((*[4]uint32)(unsafe.Pointer(&_ctx.X1))), uint64(i32(16)))
+	crt.Xmemset(tls, unsafe.Pointer(_ctx), i32(0), u64(92))
+}
+
+// C comment
+//  /*
+//  ** Convert a 128-bit MD5 digest into a 32-digit base-16 number.
+//  */
 func _MD5DigestToBase16(tls *crt.TLS, _digest *uint8, _zBuf *int8) {
 	var _i, _j, _1_a int32
 	_j = store3(&_i, i32(0))
@@ -1505,13 +1531,13 @@ _0:
 	if _i >= i32(16) {
 		goto _3
 	}
-	_1_a = int32(*(*uint8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_digest)) + 1*uintptr(_i))))
-	*(*int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_zBuf)) + 1*uintptr(postInc3(&_j, int32(1))))) = *(*int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_MD5DigestToBase16Ø00zEncodeØ001)) + 1*uintptr((_1_a>>uint(i32(4)))&i32(15))))
-	*(*int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_zBuf)) + 1*uintptr(postInc3(&_j, int32(1))))) = *(*int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_MD5DigestToBase16Ø00zEncodeØ001)) + 1*uintptr(_1_a&i32(15))))
+	_1_a = int32(*(*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(_digest)) + 1*uintptr(_i))))
+	*(*int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_zBuf)) + 1*uintptr(postInc3(&_j, 1)))) = *(*int8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_MD5DigestToBase16Ø00zEncodeØ001)) + 1*uintptr((_1_a>>uint(i32(4)))&i32(15))))
+	*(*int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_zBuf)) + 1*uintptr(postInc3(&_j, 1)))) = *(*int8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_MD5DigestToBase16Ø00zEncodeØ001)) + 1*uintptr(_1_a&i32(15))))
 	_i += 1
 	goto _0
 _3:
-	*(*int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_zBuf)) + 1*uintptr(_j))) = int8(i32(0))
+	*(*int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_zBuf)) + 1*uintptr(_j))) = int8(i32(0))
 }
 
 var _MD5DigestToBase16Ø00zEncodeØ001 [17]int8
@@ -1526,8 +1552,8 @@ func _busyhandler(tls *crt.TLS, _pArg unsafe.Pointer, _n int32) (r0 int32) {
 }
 
 func _sql_script_x(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _zSql *int8) {
-	if (_pErr.X0) == i32(0) {
-		*(*int32)(unsafe.Pointer(&(_pErr.X0))) = bin.Xsqlite3_exec(tls, (*bin.Xsqlite3)(_pDb.X0), _zSql, nil, nil, (**int8)(unsafe.Pointer(&(_pErr.X2))))
+	if _pErr.X0 == i32(0) {
+		*(*int32)(unsafe.Pointer(&_pErr.X0)) = bin.Xsqlite3_exec(tls, (*bin.Xsqlite3)(_pDb.X0), _zSql, nil, nil, (**int8)(unsafe.Pointer(&_pErr.X2)))
 	}
 }
 
@@ -1541,30 +1567,30 @@ _0:
 	}
 	_pNext = (*bin.Xsqlite3_pcache_page)(_pIter.X1)
 	bin.Xsqlite3_finalize(tls, _pIter.X0)
-	bin.Xsqlite3_free(tls, (unsafe.Pointer)(_pIter))
+	bin.Xsqlite3_free(tls, unsafe.Pointer(_pIter))
 	_pIter = _pNext
 	goto _0
 _3:
 	_i = i32(0)
 _4:
-	if _i >= (_pDb.X2) {
+	if _i >= _pDb.X2 {
 		goto _7
 	}
-	bin.Xsqlite3_free(tls, (unsafe.Pointer)(*(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_pDb.X3)) + 8*uintptr(_i)))))
+	bin.Xsqlite3_free(tls, unsafe.Pointer(*(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_pDb.X3)) + 8*uintptr(_i)))))
 	_i += 1
 	goto _4
 _7:
-	bin.Xsqlite3_free(tls, (unsafe.Pointer)(_pDb.X3))
+	bin.Xsqlite3_free(tls, unsafe.Pointer(_pDb.X3))
 	_rc = bin.Xsqlite3_close(tls, (*bin.Xsqlite3)(_pDb.X0))
-	if _rc != 0 && ((_pErr.X0) == i32(0)) {
-		*(**int8)(unsafe.Pointer(&(_pErr.X2))) = bin.Xsqlite3_mprintf(tls, str(637), unsafe.Pointer(bin.Xsqlite3_errmsg(tls, (*bin.Xsqlite3)(_pDb.X0))))
+	if _rc != 0 && (_pErr.X0 == i32(0)) {
+		*(**int8)(unsafe.Pointer(&_pErr.X2)) = bin.Xsqlite3_mprintf(tls, str(637), unsafe.Pointer(bin.Xsqlite3_errmsg(tls, (*bin.Xsqlite3)(_pDb.X0))))
 	}
-	crt.Xmemset(tls, (unsafe.Pointer)(_pDb), i32(0), u64(32))
+	crt.Xmemset(tls, unsafe.Pointer(_pDb), i32(0), u64(32))
 }
 
 func _setstoptime_x(tls *crt.TLS, _pErr *XError, _nMs int32) {
 	var _1_t float64
-	if (_pErr.X0) == i32(0) {
+	if _pErr.X0 == i32(0) {
 		_1_t = _currentTime(tls)
 		_timelimit = _1_t + (float64(_nMs) / (8.64e+07))
 		bug20530(_timelimit)
@@ -1578,22 +1604,25 @@ func _currentTime(tls *crt.TLS) (r0 float64) {
 		_currentTimeØ00pTimelimitVfsØ001 = bin.Xsqlite3_vfs_find(tls, nil)
 		bug20530(_currentTimeØ00pTimelimitVfsØ001)
 	}
-	if ((_currentTimeØ00pTimelimitVfsØ001.X0) >= i32(2)) && (*(*unsafe.Pointer)(unsafe.Pointer(&struct {
+	if (_currentTimeØ00pTimelimitVfsØ001.X0 >= i32(2)) && (*(*unsafe.Pointer)(unsafe.Pointer(&struct {
 		f func(*crt.TLS, *bin.Xsqlite3_vfs, *int64) int32
-	}{(*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int64) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *int64) int32
-	}{(_currentTimeØ00pTimelimitVfsØ001.X18)})))})) != *(*unsafe.Pointer)(unsafe.Pointer(&struct {
+	}{func() func(*crt.TLS, *bin.Xsqlite3_vfs, *int64) int32 {
+		v := _currentTimeØ00pTimelimitVfsØ001.X18
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int64) int32)(unsafe.Pointer(&v))
+	}()})) != *(*unsafe.Pointer)(unsafe.Pointer(&struct {
 		f func(*crt.TLS, *bin.Xsqlite3_vfs, *int64) int32
 	}{nil}))) {
-		(*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int64) int32)(unsafe.Pointer(&struct {
-			f func(*crt.TLS, unsafe.Pointer, *int64) int32
-		}{(_currentTimeØ00pTimelimitVfsØ001.X18)})))(tls, _currentTimeØ00pTimelimitVfsØ001, &_1_tm)
+		func() func(*crt.TLS, *bin.Xsqlite3_vfs, *int64) int32 {
+			v := _currentTimeØ00pTimelimitVfsØ001.X18
+			return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int64) int32)(unsafe.Pointer(&v))
+		}()(tls, _currentTimeØ00pTimelimitVfsØ001, &_1_tm)
 		_t = float64(_1_tm) / (8.64e+07)
 		goto _3
 	}
-	(*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *float64) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *float64) int32
-	}{(_currentTimeØ00pTimelimitVfsØ001.X16)})))(tls, _currentTimeØ00pTimelimitVfsØ001, &_t)
+	func() func(*crt.TLS, *bin.Xsqlite3_vfs, *float64) int32 {
+		v := _currentTimeØ00pTimelimitVfsØ001.X16
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *float64) int32)(unsafe.Pointer(&v))
+	}()(tls, _currentTimeØ00pTimelimitVfsØ001, &_t)
 _3:
 	return _t
 }
@@ -1605,23 +1634,23 @@ var _timelimit float64
 func _launch_thread_x(tls *crt.TLS, _pErr *XError, _pThreads *bin.T_ht, _xProc func(*crt.TLS, int32, unsafe.Pointer) *int8, _pArg unsafe.Pointer) {
 	var _1_iTid, _1_rc int32
 	var _1_p *XThread
-	if (_pErr.X0) != i32(0) {
+	if _pErr.X0 != i32(0) {
 		goto _0
 	}
-	_1_iTid = preInc3((*int32)(unsafe.Pointer(&(_pThreads.X0))), 1)
+	_1_iTid = preInc3((*int32)(unsafe.Pointer(&_pThreads.X0)), 1)
 	_1_p = (*XThread)(bin.Xsqlite3_malloc(tls, int32(u64(40))))
-	crt.Xmemset(tls, (unsafe.Pointer)(_1_p), i32(0), u64(40))
-	*(*int32)(unsafe.Pointer(&(_1_p.X0))) = _1_iTid
-	*(*unsafe.Pointer)(unsafe.Pointer(&(_1_p.X1))) = _pArg
-	*(*func(*crt.TLS, int32, unsafe.Pointer) *int8)(unsafe.Pointer(&(_1_p.X3))) = _xProc
-	_1_rc = crt.Xpthread_create(tls, (*uint64)(unsafe.Pointer(&(_1_p.X2))), (*crt.Xpthread_attr_t)(unsafe.Pointer(nil)), _launch_thread_main, (unsafe.Pointer)(_1_p))
+	crt.Xmemset(tls, unsafe.Pointer(_1_p), i32(0), u64(40))
+	*(*int32)(unsafe.Pointer(&_1_p.X0)) = _1_iTid
+	*(*unsafe.Pointer)(unsafe.Pointer(&_1_p.X1)) = _pArg
+	*(*func(*crt.TLS, int32, unsafe.Pointer) *int8)(unsafe.Pointer(&_1_p.X3)) = _xProc
+	_1_rc = crt.Xpthread_create(tls, (*uint64)(unsafe.Pointer(&_1_p.X2)), (*crt.Xpthread_attr_t)(unsafe.Pointer(nil)), _launch_thread_main, unsafe.Pointer(_1_p))
 	if _1_rc != i32(0) {
 		_system_error(tls, _pErr, _1_rc)
-		bin.Xsqlite3_free(tls, (unsafe.Pointer)(_1_p))
+		bin.Xsqlite3_free(tls, unsafe.Pointer(_1_p))
 		goto _2
 	}
-	*(**XThread)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&(_1_p.X4))))) = (*XThread)(_pThreads.X1)
-	*(**XThread)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&(_pThreads.X1))))) = _1_p
+	*(**XThread)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&_1_p.X4)))) = (*XThread)(_pThreads.X1)
+	*(**XThread)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&_pThreads.X1)))) = _1_p
 _2:
 _0:
 }
@@ -1629,14 +1658,14 @@ _0:
 func _launch_thread_main(tls *crt.TLS, _pArg unsafe.Pointer) (r0 unsafe.Pointer) {
 	var _p *XThread
 	_p = (*XThread)(_pArg)
-	return (unsafe.Pointer)((_p.X3)(tls, _p.X0, _p.X1))
+	return unsafe.Pointer(_p.X3(tls, _p.X0, _p.X1))
 }
 
 func _system_error(tls *crt.TLS, _pErr *XError, _iSys int32) {
-	*(*int32)(unsafe.Pointer(&(_pErr.X0))) = _iSys
-	*(**int8)(unsafe.Pointer(&(_pErr.X2))) = (*int8)(bin.Xsqlite3_malloc(tls, i32(512)))
+	*(*int32)(unsafe.Pointer(&_pErr.X0)) = _iSys
+	*(**int8)(unsafe.Pointer(&_pErr.X2)) = (*int8)(bin.Xsqlite3_malloc(tls, i32(512)))
 	crt.Xstrerror_r(tls, _iSys, _pErr.X2, uint64(i32(512)))
-	*(*int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_pErr.X2)) + 1*uintptr(i32(511)))) = int8(i32(0))
+	*(*int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_pErr.X2)) + 1*uintptr(i32(511)))) = int8(i32(0))
 }
 
 func _walthread1_thread(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *int8) {
@@ -1649,9 +1678,9 @@ func _walthread1_thread(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *in
 	_db = XSqlite{}
 	_nIter = i32(0)
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(929)
 		}()
@@ -1659,9 +1688,9 @@ func _walthread1_thread(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *in
 	}(), &_db, str(378), i32(0))
 _2:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(930)
 		}()
@@ -1670,57 +1699,57 @@ _2:
 		goto _3
 	}
 	_1_azSql = [2]*int8{}
-	*(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_1_azSql)) + 8*uintptr(i32(0)))) = str(640)
-	*(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_1_azSql)) + 8*uintptr(i32(1)))) = str(708)
+	*(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_1_azSql)) + 8*uintptr(i32(0)))) = str(640)
+	*(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_1_azSql)) + 8*uintptr(i32(1)))) = str(708)
 	_execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(937)
 		}()
 		return &_err
 	}(), &_db, unsafe.Pointer(str(767)))
 	_integrity_check_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(938)
 		}()
 		return &_err
 	}(), &_db)
 	_1_z1 = _execsql_text_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(939)
 		}()
 		return &_err
-	}(), &_db, i32(1), unsafe.Pointer(*(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_1_azSql)) + 8*uintptr(i32(0))))))
+	}(), &_db, i32(1), unsafe.Pointer(*(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_1_azSql)) + 8*uintptr(i32(0))))))
 	_1_z2 = _execsql_text_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(940)
 		}()
 		return &_err
-	}(), &_db, i32(2), unsafe.Pointer(*(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_1_azSql)) + 8*uintptr(i32(1))))))
+	}(), &_db, i32(2), unsafe.Pointer(*(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_1_azSql)) + 8*uintptr(i32(1))))))
 	_1_z3 = _execsql_text_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(941)
 		}()
 		return &_err
-	}(), &_db, i32(3), unsafe.Pointer(*(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_1_azSql)) + 8*uintptr(i32(0))))))
+	}(), &_db, i32(3), unsafe.Pointer(*(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(&_1_azSql)) + 8*uintptr(i32(0))))))
 	_execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(942)
 		}()
@@ -1730,9 +1759,9 @@ _2:
 		_test_error_x(tls, &_err, bin.Xsqlite3_mprintf(tls, str(780), unsafe.Pointer(_1_z1), unsafe.Pointer(_1_z2), unsafe.Pointer(_1_z3)))
 	}
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(948)
 		}()
@@ -1742,9 +1771,9 @@ _2:
 	goto _2
 _3:
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(957)
 		}()
@@ -1763,7 +1792,7 @@ func _timetostop_x(tls *crt.TLS, _pErr *XError) (r0 int32) {
 	var _ret int32
 	var _1_t float64
 	_ret = i32(1)
-	if (_pErr.X0) == i32(0) {
+	if _pErr.X0 == i32(0) {
 		_1_t = _currentTime(tls)
 		_ret = bool2int(_1_t >= _timelimit)
 	}
@@ -1776,7 +1805,7 @@ func _execsql_i64_x(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, args ...interfac
 	var _1_pStmt unsafe.Pointer
 	var _1_ap []interface{}
 	_iRet = i64(0)
-	if (_pErr.X0) != i32(0) {
+	if _pErr.X0 != i32(0) {
 		goto _0
 	}
 	_1_ap = args
@@ -1821,7 +1850,7 @@ _1:
 	}
 	_1_zName = bin.Xsqlite3_bind_parameter_name(tls, _pStmt, _i)
 	_1_pArg = crt.VAPointer(&_ap)
-	switch int32(*(*int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_1_zName)) + 1*uintptr(i32(1))))) {
+	switch int32(*(*int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_1_zName)) + 1*uintptr(i32(1))))) {
 	case i32(105):
 		goto _6
 	default:
@@ -1832,8 +1861,8 @@ _6:
 	bin.Xsqlite3_bind_int64(tls, _pStmt, _i, *(*int64)(_1_pArg))
 	goto _8
 _7:
-	*(*int32)(unsafe.Pointer(&(_pErr.X0))) = i32(1)
-	*(**int8)(unsafe.Pointer(&(_pErr.X2))) = bin.Xsqlite3_mprintf(tls, str(954), unsafe.Pointer(_1_zName))
+	*(*int32)(unsafe.Pointer(&_pErr.X0)) = i32(1)
+	*(**int8)(unsafe.Pointer(&_pErr.X2)) = bin.Xsqlite3_mprintf(tls, str(954), unsafe.Pointer(_1_zName))
 	_pStmt = nil
 	goto _8
 _8:
@@ -1858,7 +1887,7 @@ _0:
 	goto _0
 _3:
 	_pRet = (*bin.Xsqlite3_pcache_page)(bin.Xsqlite3_malloc(tls, int32(u64(16))))
-	_rc = bin.Xsqlite3_prepare_v2(tls, (*bin.Xsqlite3)(_pDb.X0), _zSql, i32(-1), (*unsafe.Pointer)(unsafe.Pointer(&(_pRet.X0))), nil)
+	_rc = bin.Xsqlite3_prepare_v2(tls, (*bin.Xsqlite3)(_pDb.X0), _zSql, i32(-1), (*unsafe.Pointer)(unsafe.Pointer(&_pRet.X0)), nil)
 	if _rc != i32(0) {
 		_sqlite_error(tls, _pErr, _pDb, str(980))
 		return nil
@@ -1869,8 +1898,8 @@ _3:
 			crt.X__builtin_abort(tls)
 		}
 	}()
-	*(**bin.Xsqlite3_pcache_page)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&(_pRet.X1))))) = (*bin.Xsqlite3_pcache_page)(_pDb.X1)
-	*(**bin.Xsqlite3_pcache_page)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&(_pDb.X1))))) = _pRet
+	*(**bin.Xsqlite3_pcache_page)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&_pRet.X1)))) = (*bin.Xsqlite3_pcache_page)(_pDb.X1)
+	*(**bin.Xsqlite3_pcache_page)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&_pDb.X1)))) = _pRet
 	return _pRet
 }
 
@@ -1884,7 +1913,7 @@ func _integrity_check_x(tls *crt.TLS, _pErr *XError, _pDb *XSqlite) {
 	var _1_zErr, _3_z *int8
 	var _2_pStmt unsafe.Pointer
 	var _1_pStatement *bin.Xsqlite3_pcache_page
-	if (_pErr.X0) != i32(0) {
+	if _pErr.X0 != i32(0) {
 		goto _0
 	}
 	_1_zErr = nil
@@ -1912,8 +1941,8 @@ _4:
 _3:
 	bin.Xsqlite3_reset(tls, _2_pStmt)
 	if _1_zErr != nil {
-		*(**int8)(unsafe.Pointer(&(_pErr.X2))) = _1_zErr
-		*(*int32)(unsafe.Pointer(&(_pErr.X0))) = i32(1)
+		*(**int8)(unsafe.Pointer(&_pErr.X2)) = _1_zErr
+		*(*int32)(unsafe.Pointer(&_pErr.X0)) = i32(1)
 	}
 _1:
 _0:
@@ -1925,13 +1954,13 @@ func _execsql_text_x(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _iSlot int32, a
 	var _2_pStmt unsafe.Pointer
 	var _2_ap []interface{}
 	_zRet = nil
-	if _iSlot >= (_pDb.X2) {
+	if _iSlot >= _pDb.X2 {
 		_1_nByte = int32(u64(8) * uint64(_iSlot+i32(1)))
-		*(***int8)(unsafe.Pointer(&(_pDb.X3))) = (**int8)(bin.Xsqlite3_realloc(tls, (unsafe.Pointer)(_pDb.X3), _1_nByte))
-		crt.Xmemset(tls, (unsafe.Pointer)((**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_pDb.X3))+8*uintptr(_pDb.X2)))), i32(0), u64(8)*uint64((_iSlot+i32(1))-(_pDb.X2)))
-		*(*int32)(unsafe.Pointer(&(_pDb.X2))) = _iSlot + i32(1)
+		*(***int8)(unsafe.Pointer(&_pDb.X3)) = (**int8)(bin.Xsqlite3_realloc(tls, unsafe.Pointer(_pDb.X3), _1_nByte))
+		crt.Xmemset(tls, unsafe.Pointer((**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_pDb.X3))+8*uintptr(_pDb.X2)))), i32(0), u64(8)*uint64((_iSlot+i32(1))-_pDb.X2))
+		*(*int32)(unsafe.Pointer(&_pDb.X2)) = _iSlot + i32(1)
 	}
-	if (_pErr.X0) != i32(0) {
+	if _pErr.X0 != i32(0) {
 		goto _1
 	}
 	_2_ap = args
@@ -1946,8 +1975,8 @@ _3:
 	}
 	if _3_first != 0 && (bin.Xsqlite3_column_count(tls, _2_pStmt) > i32(0)) {
 		_zRet = bin.Xsqlite3_mprintf(tls, str(637), unsafe.Pointer(bin.Xsqlite3_column_text(tls, _2_pStmt, i32(0))))
-		bin.Xsqlite3_free(tls, (unsafe.Pointer)(*(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_pDb.X3)) + 8*uintptr(_iSlot)))))
-		*(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_pDb.X3)) + 8*uintptr(_iSlot))) = _zRet
+		bin.Xsqlite3_free(tls, unsafe.Pointer(*(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_pDb.X3)) + 8*uintptr(_iSlot)))))
+		*(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_pDb.X3)) + 8*uintptr(_iSlot))) = _zRet
 	}
 	_3_first = i32(0)
 	goto _3
@@ -1962,12 +1991,12 @@ _1:
 }
 
 func _test_error_x(tls *crt.TLS, _pErr *XError, _zErr *int8) {
-	if (_pErr.X0) == i32(0) {
-		*(*int32)(unsafe.Pointer(&(_pErr.X0))) = i32(1)
-		*(**int8)(unsafe.Pointer(&(_pErr.X2))) = _zErr
+	if _pErr.X0 == i32(0) {
+		*(*int32)(unsafe.Pointer(&_pErr.X0)) = i32(1)
+		*(**int8)(unsafe.Pointer(&_pErr.X2)) = _zErr
 		goto _1
 	}
-	bin.Xsqlite3_free(tls, (unsafe.Pointer)(_zErr))
+	bin.Xsqlite3_free(tls, unsafe.Pointer(_zErr))
 _1:
 }
 
@@ -1978,11 +2007,11 @@ func _print_and_free_err(tls *crt.TLS, _p *XError) {
 
 func _print_err(tls *crt.TLS, _p *XError) {
 	var _1_isWarn int32
-	if (_p.X0) == i32(0) {
+	if _p.X0 == i32(0) {
 		goto _0
 	}
 	_1_isWarn = i32(0)
-	if (_p.X0) == i32(17) {
+	if _p.X0 == i32(17) {
 		_1_isWarn = i32(1)
 	}
 	if bin.Xsqlite3_strglob(tls, str(1175), _p.X2) == i32(0) {
@@ -2004,9 +2033,9 @@ _0:
 var _nGlobalErr int32
 
 func _free_err(tls *crt.TLS, _p *XError) {
-	bin.Xsqlite3_free(tls, (unsafe.Pointer)(_p.X2))
-	*(**int8)(unsafe.Pointer(&(_p.X2))) = nil
-	*(*int32)(unsafe.Pointer(&(_p.X0))) = i32(0)
+	bin.Xsqlite3_free(tls, unsafe.Pointer(_p.X2))
+	*(**int8)(unsafe.Pointer(&_p.X2)) = nil
+	*(*int32)(unsafe.Pointer(&_p.X0)) = i32(0)
 }
 
 func _walthread1_ckpt_thread(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *int8) {
@@ -2017,9 +2046,9 @@ func _walthread1_ckpt_thread(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r
 	_db = XSqlite{}
 	_nCkpt = i32(0)
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(968)
 		}()
@@ -2027,9 +2056,9 @@ func _walthread1_ckpt_thread(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r
 	}(), &_db, str(378), i32(0))
 _2:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(969)
 		}()
@@ -2039,24 +2068,24 @@ _2:
 	}
 	crt.Xusleep(tls, uint32(i32(500000)))
 	_execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(971)
 		}()
 		return &_err
 	}(), &_db, unsafe.Pointer(str(1236)))
-	if (_err.X0) == i32(0) {
+	if _err.X0 == i32(0) {
 		_nCkpt += 1
 	}
 	_clear_error_x(tls, &_err, i32(5))
 	goto _2
 _3:
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(975)
 		}()
@@ -2071,10 +2100,10 @@ _3:
 }
 
 func _clear_error_x(tls *crt.TLS, _pErr *XError, _rc int32) {
-	if (_pErr.X0) == _rc {
-		*(*int32)(unsafe.Pointer(&(_pErr.X0))) = i32(0)
-		bin.Xsqlite3_free(tls, (unsafe.Pointer)(_pErr.X2))
-		*(**int8)(unsafe.Pointer(&(_pErr.X2))) = nil
+	if _pErr.X0 == _rc {
+		*(*int32)(unsafe.Pointer(&_pErr.X0)) = i32(0)
+		bin.Xsqlite3_free(tls, unsafe.Pointer(_pErr.X2))
+		*(**int8)(unsafe.Pointer(&_pErr.X2)) = nil
 	}
 }
 
@@ -2092,7 +2121,7 @@ _0:
 	if _1_rc == i32(0) {
 		goto _4
 	}
-	if (_pErr.X0) == i32(0) {
+	if _pErr.X0 == i32(0) {
 		_system_error(tls, _pErr, _1_rc)
 	}
 	goto _6
@@ -2105,11 +2134,11 @@ _4:
 	}()))
 	crt.Xfflush(tls, (*crt.XFILE)(Xstdout))
 _6:
-	bin.Xsqlite3_free(tls, (unsafe.Pointer)(_p))
+	bin.Xsqlite3_free(tls, unsafe.Pointer(_p))
 	_p = _pNext
 	goto _0
 _3:
-	*(**XThread)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&(_pThreads.X1))))) = nil
+	*(**XThread)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&_pThreads.X1)))) = nil
 }
 
 func _walthread2(tls *crt.TLS, _nMs int32) {
@@ -2120,81 +2149,81 @@ func _walthread2(tls *crt.TLS, _nMs int32) {
 	_db = XSqlite{}
 	_threads = bin.T_ht{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1050)
 		}()
 		return &_err
 	}(), &_db, str(378), i32(1))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1051)
 		}()
 		return &_err
 	}(), &_db, str(1297))
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1052)
 		}()
 		return &_err
 	}(), &_db)
 	_setstoptime_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1054)
 		}()
 		return &_err
 	}(), _nMs)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1055)
 		}()
 		return &_err
 	}(), &_threads, _walthread2_thread, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1056)
 		}()
 		return &_err
 	}(), &_threads, _walthread2_thread, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1057)
 		}()
 		return &_err
 	}(), &_threads, _walthread2_thread, crt.U2P(uintptr(u32(1))))
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1058)
 		}()
 		return &_err
 	}(), &_threads, _walthread2_thread, crt.U2P(uintptr(u32(1))))
 	_join_all_threads_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1059)
 		}()
@@ -2222,9 +2251,9 @@ func _walthread2_thread(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *in
 	}
 _0:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1016)
 		}()
@@ -2235,18 +2264,18 @@ _0:
 	_2_journal_exists = i32(0)
 	_2_wal_exists = i32(0)
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1020)
 		}()
 		return &_err
 	}(), &_db, str(378), i32(0))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1022)
 		}()
@@ -2254,36 +2283,36 @@ _0:
 	}(), &_db, _zJournal)
 	_clear_error_x(tls, &_err, i32(5))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1024)
 		}()
 		return &_err
 	}(), &_db, str(767))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1025)
 		}()
 		return &_err
 	}(), &_db, str(1401))
 	_2_journal_exists = bool2int(_filesize_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1027)
 		}()
 		return &_err
 	}(), str(1446)) >= int64(i32(0)))
 	_2_wal_exists = bool2int(_filesize_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1028)
 		}()
@@ -2292,29 +2321,29 @@ _0:
 	if (_2_journal_exists + _2_wal_exists) != i32(1) {
 		_test_error_x(tls, &_err, bin.Xsqlite3_mprintf(tls, str(1474), _2_journal_exists, _2_wal_exists))
 	}
-	*(*int32)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_anTrans)) + 4*uintptr(_2_journal_exists))) += 1
+	*(*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&_anTrans)) + 4*uintptr(_2_journal_exists))) += 1
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1036)
 		}()
 		return &_err
 	}(), &_db, str(773))
 	_integrity_check_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1037)
 		}()
 		return &_err
 	}(), &_db)
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1038)
 		}()
@@ -2323,7 +2352,7 @@ _0:
 	goto _0
 _2:
 	_print_and_free_err(tls, &_err)
-	return bin.Xsqlite3_mprintf(tls, str(1511), *(*int32)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_anTrans)) + 4*uintptr(i32(0)))), *(*int32)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_anTrans)) + 4*uintptr(i32(1)))))
+	return bin.Xsqlite3_mprintf(tls, str(1511), *(*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&_anTrans)) + 4*uintptr(i32(0)))), *(*int32)(unsafe.Pointer(uintptr(unsafe.Pointer(&_anTrans)) + 4*uintptr(i32(1)))))
 
 	_ = _err
 	_ = _db
@@ -2335,7 +2364,7 @@ func _filesize_x(tls *crt.TLS, _pErr *XError, _zFile *int8) (r0 int64) {
 	var _iRet int64
 	var _1_sStat crt.Xstruct_stat64
 	_iRet = i64(0)
-	if (_pErr.X0) != i32(0) {
+	if _pErr.X0 != i32(0) {
 		goto _0
 	}
 	if crt.Xstat64(tls, _zFile, &_1_sStat) != 0 {
@@ -2360,36 +2389,36 @@ func _walthread3(tls *crt.TLS, _nMs int32) {
 	_db = XSqlite{}
 	_threads = bin.T_ht{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1107)
 		}()
 		return &_err
 	}(), &_db, str(378), i32(1))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1108)
 		}()
 		return &_err
 	}(), &_db, str(1521))
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1115)
 		}()
 		return &_err
 	}(), &_db)
 	_setstoptime_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1117)
 		}()
@@ -2401,9 +2430,9 @@ _8:
 		goto _11
 	}
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1119)
 		}()
@@ -2413,9 +2442,9 @@ _8:
 	goto _8
 _11:
 	_join_all_threads_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1121)
 		}()
@@ -2436,18 +2465,18 @@ func _walthread3_thread(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *in
 	_db = XSqlite{}
 	_iArg = int32(int64(crt.P2U(_pArg)))
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1070)
 		}()
 		return &_err
 	}(), &_db, str(378), i32(0))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1071)
 		}()
@@ -2458,9 +2487,9 @@ _4:
 	_1_stop = i32(0)
 _6:
 	if i32(0) != store3(&_1_stop, _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1079)
 		}()
@@ -2469,9 +2498,9 @@ _6:
 		goto _7
 	}
 	_2_iMax = _execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1080)
 		}()
@@ -2486,36 +2515,36 @@ _7:
 		goto _5
 	}
 	_1_sum1 = _execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1085)
 		}()
 		return &_err
 	}(), &_db, unsafe.Pointer(str(1735)))
 	_1_sum2 = _execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1086)
 		}()
 		return &_err
 	}(), &_db, unsafe.Pointer(str(1759)))
 	_execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1087)
 		}()
 		return &_err
 	}(), &_db, unsafe.Pointer(str(1784)), unsafe.Pointer(&_iNextWrite), unsafe.Pointer(&_1_sum1), unsafe.Pointer(&_1_sum2))
 	_integrity_check_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1091)
 		}()
@@ -2529,9 +2558,9 @@ _7:
 	goto _4
 _5:
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1096)
 		}()
@@ -2555,63 +2584,63 @@ func _walthread4(tls *crt.TLS, _nMs int32) {
 	_db = XSqlite{}
 	_threads = bin.T_ht{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1165)
 		}()
 		return &_err
 	}(), &_db, str(378), i32(1))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1166)
 		}()
 		return &_err
 	}(), &_db, str(1835))
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1170)
 		}()
 		return &_err
 	}(), &_db)
 	_setstoptime_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1172)
 		}()
 		return &_err
 	}(), _nMs)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1173)
 		}()
 		return &_err
 	}(), &_threads, _walthread4_reader_thread, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1174)
 		}()
 		return &_err
 	}(), &_threads, _walthread4_writer_thread, nil)
 	_join_all_threads_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1175)
 		}()
@@ -2629,9 +2658,9 @@ func _walthread4_reader_thread(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer)
 	_err = XError{}
 	_db = XSqlite{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1130)
 		}()
@@ -2639,18 +2668,18 @@ func _walthread4_reader_thread(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer)
 	}(), &_db, str(378), i32(0))
 _2:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1131)
 		}()
 		return &_err
 	}()) == 0 {
 		_integrity_check_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(1132)
 			}()
@@ -2659,9 +2688,9 @@ _2:
 		goto _2
 	}
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1134)
 		}()
@@ -2683,18 +2712,18 @@ func _walthread4_writer_thread(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer)
 	_db = XSqlite{}
 	_iRow = i64(1)
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1145)
 		}()
 		return &_err
 	}(), &_db, str(378), i32(0))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1146)
 		}()
@@ -2702,9 +2731,9 @@ func _walthread4_writer_thread(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer)
 	}(), &_db, str(1911))
 _4:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1147)
 		}()
@@ -2713,9 +2742,9 @@ _4:
 		goto _5
 	}
 	_execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1148)
 		}()
@@ -2728,9 +2757,9 @@ _4:
 	goto _4
 _5:
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1154)
 		}()
@@ -2752,82 +2781,82 @@ func _walthread5(tls *crt.TLS, _nMs int32) {
 	_db = XSqlite{}
 	_threads = bin.T_ht{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1198)
 		}()
 		return &_err
 	}(), &_db, str(378), i32(1))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1199)
 		}()
 		return &_err
 	}(), &_db, str(1990))
 	_filecopy_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1224)
 		}()
 		return &_err
 	}(), str(378), str(3150))
 	_filecopy_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1225)
 		}()
 		return &_err
 	}(), str(1462), str(3161))
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1226)
 		}()
 		return &_err
 	}(), &_db)
 	_filecopy_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1228)
 		}()
 		return &_err
 	}(), str(3150), str(378))
 	_filecopy_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1229)
 		}()
 		return &_err
 	}(), str(3161), str(1462))
-	if (_err.X0) == i32(0) {
+	if _err.X0 == i32(0) {
 		crt.Xprintf(tls, str(3176), int32(_filesize_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(1232)
 			}()
 			return &_err
 		}(), str(1462))))
 		crt.Xprintf(tls, str(3200), int32(_filesize_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(1233)
 			}()
@@ -2835,82 +2864,82 @@ func _walthread5(tls *crt.TLS, _nMs int32) {
 		}(), str(378))))
 	}
 	_setstoptime_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1236)
 		}()
 		return &_err
 	}(), _nMs)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1237)
 		}()
 		return &_err
 	}(), &_threads, _walthread5_thread, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1238)
 		}()
 		return &_err
 	}(), &_threads, _walthread5_thread, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1239)
 		}()
 		return &_err
 	}(), &_threads, _walthread5_thread, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1240)
 		}()
 		return &_err
 	}(), &_threads, _walthread5_thread, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1241)
 		}()
 		return &_err
 	}(), &_threads, _walthread5_thread, nil)
 	_join_all_threads_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1242)
 		}()
 		return &_err
 	}(), &_threads)
-	if (_err.X0) == i32(0) {
+	if _err.X0 == i32(0) {
 		crt.Xprintf(tls, str(3176), int32(_filesize_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(1245)
 			}()
 			return &_err
 		}(), str(1462))))
 		crt.Xprintf(tls, str(3200), int32(_filesize_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(1246)
 			}()
@@ -2927,7 +2956,7 @@ func _filecopy_x(tls *crt.TLS, _pErr *XError, _zFrom *int8, _zTo *int8) {
 	var _3_fd1, _3_fd2, _6_nCopy int32
 	var _1_nByte, _3_iOff int64
 	var _3_aBuf [1024]int8
-	if (_pErr.X0) != i32(0) {
+	if _pErr.X0 != i32(0) {
 		goto _0
 	}
 	_1_nByte = _filesize_x(tls, _pErr, _zFrom)
@@ -2956,11 +2985,11 @@ _5:
 	if (int64(_6_nCopy) + _3_iOff) > _1_nByte {
 		_6_nCopy = int32(_1_nByte - _3_iOff)
 	}
-	if int64(_6_nCopy) != crt.Xread(tls, _3_fd1, (unsafe.Pointer)(&_3_aBuf), uint64(_6_nCopy)) {
+	if int64(_6_nCopy) != crt.Xread(tls, _3_fd1, unsafe.Pointer(&_3_aBuf), uint64(_6_nCopy)) {
 		_system_error(tls, _pErr, *crt.X__errno_location(tls))
 		goto _6
 	}
-	if int64(_6_nCopy) != crt.Xwrite(tls, _3_fd2, (unsafe.Pointer)(&_3_aBuf), uint64(_6_nCopy)) {
+	if int64(_6_nCopy) != crt.Xwrite(tls, _3_fd2, unsafe.Pointer(&_3_aBuf), uint64(_6_nCopy)) {
 		_system_error(tls, _pErr, *crt.X__errno_location(tls))
 		goto _6
 	}
@@ -2985,27 +3014,27 @@ func _walthread5_thread(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *in
 	_err = XError{}
 	_db = XSqlite{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1185)
 		}()
 		return &_err
 	}(), &_db, str(378), i32(0))
 	_nRow = _execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1186)
 		}()
 		return &_err
 	}(), &_db, unsafe.Pointer(str(3234)))
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1187)
 		}()
@@ -3029,18 +3058,18 @@ func _cgt_pager_1(tls *crt.TLS, _nMs int32) {
 	_err = XError{}
 	_db = XSqlite{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1289)
 		}()
 		return &_err
 	}(), &_db, str(378), i32(1))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1290)
 		}()
@@ -3053,9 +3082,9 @@ func _cgt_pager_1(tls *crt.TLS, _nMs int32) {
 	_xSub = _cgt_pager_1_read
 	_xSub(tls, &_err, &_db)
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1300)
 		}()
@@ -3071,9 +3100,9 @@ func _cgt_pager_1_populate(tls *crt.TLS, _pErr *XError, _pDb *XSqlite) {
 	var _zInsert *int8
 	_zInsert = str(3373)
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(1259)
 		}()
@@ -3086,9 +3115,9 @@ _2:
 	}
 	_1_iBlob = int64(i32(600)) + (_iRow % int64(i32(300)))
 	_execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(1262)
 		}()
@@ -3098,9 +3127,9 @@ _2:
 	goto _2
 _5:
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(1264)
 		}()
@@ -3114,9 +3143,9 @@ func _cgt_pager_1_update(tls *crt.TLS, _pErr *XError, _pDb *XSqlite) {
 	var _zUpdate *int8
 	_zUpdate = str(3420)
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(1269)
 		}()
@@ -3129,9 +3158,9 @@ _2:
 	}
 	_1_iBlob = int64(i32(600)) + ((_iRow + int64(i32(100))) % int64(i32(300)))
 	_execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(1272)
 		}()
@@ -3141,9 +3170,9 @@ _2:
 	goto _2
 _5:
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(1274)
 		}()
@@ -3155,9 +3184,9 @@ _5:
 func _cgt_pager_1_read(tls *crt.TLS, _pErr *XError, _pDb *XSqlite) {
 	var _iRow int64
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(1278)
 		}()
@@ -3169,9 +3198,9 @@ _2:
 		goto _5
 	}
 	_execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(1280)
 		}()
@@ -3181,9 +3210,9 @@ _2:
 	goto _2
 _5:
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(1282)
 		}()
@@ -3199,36 +3228,36 @@ func _dynamic_triggers(tls *crt.TLS, _nMs int32) {
 	_db = XSqlite{}
 	_threads = bin.T_ht{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1396)
 		}()
 		return &_err
 	}(), &_db, str(378), i32(1))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1397)
 		}()
 		return &_err
 	}(), &_db, str(3504))
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1410)
 		}()
 		return &_err
 	}(), &_db)
 	_setstoptime_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1412)
 		}()
@@ -3236,18 +3265,18 @@ func _dynamic_triggers(tls *crt.TLS, _nMs int32) {
 	}(), _nMs)
 	bin.Xsqlite3_enable_shared_cache(tls, i32(1))
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1415)
 		}()
 		return &_err
 	}(), &_threads, _dynamic_triggers_2, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1416)
 		}()
@@ -3256,27 +3285,27 @@ func _dynamic_triggers(tls *crt.TLS, _nMs int32) {
 	crt.Xsleep(tls, uint32(i32(2)))
 	bin.Xsqlite3_enable_shared_cache(tls, i32(0))
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1421)
 		}()
 		return &_err
 	}(), &_threads, _dynamic_triggers_2, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1422)
 		}()
 		return &_err
 	}(), &_threads, _dynamic_triggers_1, nil)
 	_join_all_threads_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1424)
 		}()
@@ -3299,9 +3328,9 @@ func _dynamic_triggers_2(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *i
 	_nInsert = i32(0)
 	_nDelete = i32(0)
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1371)
 		}()
@@ -3309,9 +3338,9 @@ func _dynamic_triggers_2(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *i
 	}(), &_db, str(378), i32(0))
 _2:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1372)
 		}()
@@ -3322,9 +3351,9 @@ _2:
 _6:
 	_iVal = (_iVal + int64(i32(1))) % int64(i32(100))
 	_execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1375)
 		}()
@@ -3337,9 +3366,9 @@ _6:
 _9:
 	_iVal = (_iVal + int64(i32(1))) % int64(i32(100))
 	_execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1381)
 		}()
@@ -3352,9 +3381,9 @@ _9:
 	goto _2
 _3:
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1385)
 		}()
@@ -3378,9 +3407,9 @@ func _dynamic_triggers_1(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *i
 	_nDrop = i32(0)
 	_nCreate = i32(0)
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1318)
 		}()
@@ -3388,9 +3417,9 @@ func _dynamic_triggers_1(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *i
 	}(), &_db, str(378), i32(0))
 _2:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1319)
 		}()
@@ -3405,15 +3434,15 @@ _6:
 	}
 	_2_zSql = bin.Xsqlite3_mprintf(tls, str(3839), _1_i, _1_i, _1_i+i32(1))
 	_execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1328)
 		}()
 		return &_err
 	}(), &_db, unsafe.Pointer(_2_zSql))
-	bin.Xsqlite3_free(tls, (unsafe.Pointer)(_2_zSql))
+	bin.Xsqlite3_free(tls, unsafe.Pointer(_2_zSql))
 	_nCreate += 1
 	_1_i += 1
 	goto _6
@@ -3425,15 +3454,15 @@ _12:
 	}
 	_3_zSql = bin.Xsqlite3_mprintf(tls, str(3929), _1_i, _1_i, _1_i+i32(1))
 	_execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1339)
 		}()
 		return &_err
 	}(), &_db, unsafe.Pointer(_3_zSql))
-	bin.Xsqlite3_free(tls, (unsafe.Pointer)(_3_zSql))
+	bin.Xsqlite3_free(tls, unsafe.Pointer(_3_zSql))
 	_nCreate += 1
 	_1_i += 1
 	goto _12
@@ -3445,15 +3474,15 @@ _18:
 	}
 	_4_zSql = bin.Xsqlite3_mprintf(tls, str(4015), _1_i)
 	_execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1346)
 		}()
 		return &_err
 	}(), &_db, unsafe.Pointer(_4_zSql))
-	bin.Xsqlite3_free(tls, (unsafe.Pointer)(_4_zSql))
+	bin.Xsqlite3_free(tls, unsafe.Pointer(_4_zSql))
 	_nDrop += 1
 	_1_i += 1
 	goto _18
@@ -3465,15 +3494,15 @@ _24:
 	}
 	_5_zSql = bin.Xsqlite3_mprintf(tls, str(4034), _1_i)
 	_execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1353)
 		}()
 		return &_err
 	}(), &_db, unsafe.Pointer(_5_zSql))
-	bin.Xsqlite3_free(tls, (unsafe.Pointer)(_5_zSql))
+	bin.Xsqlite3_free(tls, unsafe.Pointer(_5_zSql))
 	_nDrop += 1
 	_1_i += 1
 	goto _24
@@ -3481,9 +3510,9 @@ _27:
 	goto _2
 _3:
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(1358)
 		}()
@@ -3503,7 +3532,7 @@ func _checkpoint_starvation_1(tls *crt.TLS, _nMs int32) {
 	_err = XError{}
 	_ctx = bin.Xsqlite3_debug_mutex{}
 	_checkpoint_starvation_main(tls, _nMs, &_ctx)
-	if (_ctx.X1) < i32(500) {
+	if _ctx.X1 < i32(500) {
 		_test_error_x(tls, &_err, bin.Xsqlite3_mprintf(tls, str(4076), _ctx.X1))
 	}
 	_print_and_free_err(tls, &_err)
@@ -3521,27 +3550,27 @@ func _checkpoint_starvation_main(tls *crt.TLS, _nMs int32, _p *bin.Xsqlite3_debu
 	_threads = bin.T_ht{}
 	_nInsert = i32(0)
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(99)
 		}()
 		return &_err
 	}(), &_db, str(378), i32(1))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(100)
 		}()
 		return &_err
 	}(), &_db, str(4107))
 	_setstoptime_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(106)
 		}()
@@ -3553,9 +3582,9 @@ _6:
 		goto _9
 	}
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(109)
 		}()
@@ -3565,23 +3594,24 @@ _6:
 	_i += 1
 	goto _6
 _9:
-	bin.Xsqlite3_wal_hook(tls, (*bin.Xsqlite3)(_db.X0), *(*func(*crt.TLS, unsafe.Pointer, *bin.Xsqlite3, *int8, int32) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, *int8, int32) int32
-	}{_checkpoint_starvation_walhook})), (unsafe.Pointer)(_p))
+	bin.Xsqlite3_wal_hook(tls, (*bin.Xsqlite3)(_db.X0), func() func(*crt.TLS, unsafe.Pointer, *bin.Xsqlite3, *int8, int32) int32 {
+		v := _checkpoint_starvation_walhook
+		return *(*func(*crt.TLS, unsafe.Pointer, *bin.Xsqlite3, *int8, int32) int32)(unsafe.Pointer(&v))
+	}(), unsafe.Pointer(_p))
 _12:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(114)
 		}()
 		return &_err
 	}()) == 0 {
 		_sql_script_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(115)
 			}()
@@ -3591,7 +3621,7 @@ _12:
 		goto _12
 	}
 	crt.Xprintf(tls, str(4217), unsafe.Pointer(func() *int8 {
-		if (_p.X0) == i32(0) {
+		if _p.X0 == i32(0) {
 			return str(4241)
 		}
 		return str(4249)
@@ -3599,18 +3629,18 @@ _12:
 	crt.Xprintf(tls, str(4257), _p.X1)
 	crt.Xprintf(tls, str(4288), _nInsert)
 	_join_all_threads_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(125)
 		}()
 		return &_err
 	}(), &_threads)
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(126)
 		}()
@@ -3629,9 +3659,9 @@ func _checkpoint_starvation_reader(tls *crt.TLS, _iTid int32, _pArg unsafe.Point
 	_err = XError{}
 	_db = XSqlite{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(73)
 		}()
@@ -3639,9 +3669,9 @@ func _checkpoint_starvation_reader(tls *crt.TLS, _iTid int32, _pArg unsafe.Point
 	}(), &_db, str(378), i32(0))
 _2:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(74)
 		}()
@@ -3650,18 +3680,18 @@ _2:
 		goto _3
 	}
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(76)
 		}()
 		return &_err
 	}(), &_db, str(767))
 	_1_iCount1 = _execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(77)
 		}()
@@ -3669,18 +3699,18 @@ _2:
 	}(), &_db, unsafe.Pointer(str(4325)))
 	crt.Xusleep(tls, uint32(i32(100000)))
 	_1_iCount2 = _execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(79)
 		}()
 		return &_err
 	}(), &_db, unsafe.Pointer(str(4325)))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(80)
 		}()
@@ -3692,9 +3722,9 @@ _2:
 	goto _2
 _3:
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(86)
 		}()
@@ -3711,8 +3741,8 @@ _3:
 func _checkpoint_starvation_walhook(tls *crt.TLS, _pCtx unsafe.Pointer, _db unsafe.Pointer, _zDb *int8, _nFrame int32) (r0 int32) {
 	var _p *bin.Xsqlite3_debug_mutex
 	_p = (*bin.Xsqlite3_debug_mutex)(_pCtx)
-	if _nFrame > (_p.X1) {
-		*(*int32)(unsafe.Pointer(&(_p.X1))) = _nFrame
+	if _nFrame > _p.X1 {
+		*(*int32)(unsafe.Pointer(&_p.X1)) = _nFrame
 	}
 	if _nFrame >= i32(50) {
 		bin.Xsqlite3_wal_checkpoint_v2(tls, (*bin.Xsqlite3)(_db), _zDb, _p.X0, nil, nil)
@@ -3726,7 +3756,7 @@ func _checkpoint_starvation_2(tls *crt.TLS, _nMs int32) {
 	_err = XError{}
 	_ctx = bin.Xsqlite3_debug_mutex{X0: i32(2), X1: i32(0)}
 	_checkpoint_starvation_main(tls, _nMs, &_ctx)
-	if (_ctx.X1) > i32(60) {
+	if _ctx.X1 > i32(60) {
 		_test_error_x(tls, &_err, bin.Xsqlite3_mprintf(tls, str(4379), _ctx.X1))
 	}
 	_print_and_free_err(tls, &_err)
@@ -3742,36 +3772,36 @@ func _create_drop_index_1(tls *crt.TLS, _nMs int32) {
 	_db = XSqlite{}
 	_threads = bin.T_ht{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(54)
 		}()
 		return &_err
 	}(), &_db, str(378), i32(1))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(55)
 		}()
 		return &_err
 	}(), &_db, str(4410))
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(60)
 		}()
 		return &_err
 	}(), &_db)
 	_setstoptime_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(62)
 		}()
@@ -3779,54 +3809,54 @@ func _create_drop_index_1(tls *crt.TLS, _nMs int32) {
 	}(), _nMs)
 	bin.Xsqlite3_enable_shared_cache(tls, i32(1))
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(65)
 		}()
 		return &_err
 	}(), &_threads, _create_drop_index_thread, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(66)
 		}()
 		return &_err
 	}(), &_threads, _create_drop_index_thread, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(67)
 		}()
 		return &_err
 	}(), &_threads, _create_drop_index_thread, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(68)
 		}()
 		return &_err
 	}(), &_threads, _create_drop_index_thread, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(69)
 		}()
 		return &_err
 	}(), &_threads, _create_drop_index_thread, nil)
 	_join_all_threads_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(71)
 		}()
@@ -3846,27 +3876,27 @@ func _create_drop_index_thread(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer)
 	_db = XSqlite{}
 _0:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(21)
 		}()
 		return &_err
 	}()) == 0 {
 		_opendb_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(22)
 			}()
 			return &_err
 		}(), &_db, str(378), i32(0))
 		_sql_script_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(24)
 			}()
@@ -3874,9 +3904,9 @@ _0:
 		}(), &_db, str(4551))
 		_clear_error_x(tls, &_err, i32(6))
 		_closedb_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(42)
 			}()
@@ -3900,36 +3930,36 @@ func _lookaside1(tls *crt.TLS, _nMs int32) {
 	_db = XSqlite{}
 	_threads = bin.T_ht{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(71)
 		}()
 		return &_err
 	}(), &_db, str(378), i32(1))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(72)
 		}()
 		return &_err
 	}(), &_db, str(4924))
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(85)
 		}()
 		return &_err
 	}(), &_db)
 	_setstoptime_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(87)
 		}()
@@ -3937,63 +3967,63 @@ func _lookaside1(tls *crt.TLS, _nMs int32) {
 	}(), _nMs)
 	bin.Xsqlite3_enable_shared_cache(tls, i32(1))
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(90)
 		}()
 		return &_err
 	}(), &_threads, _lookaside1_thread_reader, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(91)
 		}()
 		return &_err
 	}(), &_threads, _lookaside1_thread_reader, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(92)
 		}()
 		return &_err
 	}(), &_threads, _lookaside1_thread_reader, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(93)
 		}()
 		return &_err
 	}(), &_threads, _lookaside1_thread_reader, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(94)
 		}()
 		return &_err
 	}(), &_threads, _lookaside1_thread_reader, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(95)
 		}()
 		return &_err
 	}(), &_threads, _lookaside1_thread_writer, nil)
 	_join_all_threads_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(96)
 		}()
@@ -4014,9 +4044,9 @@ func _lookaside1_thread_reader(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer)
 	_err = XError{}
 	_db = XSqlite{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(25)
 		}()
@@ -4024,9 +4054,9 @@ func _lookaside1_thread_reader(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer)
 	}(), &_db, str(378), i32(0))
 _2:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(27)
 		}()
@@ -4039,9 +4069,9 @@ _2:
 _6:
 	if bin.Xsqlite3_step(tls, _1_pStmt) == i32(100) {
 		_execsql_i64_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(33)
 			}()
@@ -4050,15 +4080,15 @@ _6:
 		goto _6
 	}
 	_1_rc = bin.Xsqlite3_finalize(tls, _1_pStmt)
-	if ((_err.X0) == i32(0)) && (_1_rc != i32(0)) {
+	if (_err.X0 == i32(0)) && (_1_rc != i32(0)) {
 		_sqlite_error(tls, &_err, &_db, str(5324))
 	}
 	goto _2
 _3:
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(41)
 		}()
@@ -4078,9 +4108,9 @@ func _lookaside1_thread_writer(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer)
 	_err = XError{}
 	_db = XSqlite{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(50)
 		}()
@@ -4088,18 +4118,18 @@ func _lookaside1_thread_writer(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer)
 	}(), &_db, str(378), i32(0))
 _2:
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(53)
 		}()
 		return &_err
 	}(), &_db, str(5333))
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(58)
 		}()
@@ -4108,9 +4138,9 @@ _2:
 		goto _2
 	}
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(60)
 		}()
@@ -4132,36 +4162,36 @@ func _vacuum1(tls *crt.TLS, _nMs int32) {
 	_db = XSqlite{}
 	_threads = bin.T_ht{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(72)
 		}()
 		return &_err
 	}(), &_db, str(378), i32(1))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(73)
 		}()
 		return &_err
 	}(), &_db, str(5379))
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(77)
 		}()
 		return &_err
 	}(), &_db)
 	_setstoptime_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(79)
 		}()
@@ -4169,45 +4199,45 @@ func _vacuum1(tls *crt.TLS, _nMs int32) {
 	}(), _nMs)
 	bin.Xsqlite3_enable_shared_cache(tls, i32(1))
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(82)
 		}()
 		return &_err
 	}(), &_threads, _vacuum1_thread_writer, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(83)
 		}()
 		return &_err
 	}(), &_threads, _vacuum1_thread_writer, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(84)
 		}()
 		return &_err
 	}(), &_threads, _vacuum1_thread_writer, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(85)
 		}()
 		return &_err
 	}(), &_threads, _vacuum1_thread_vacuumer, nil)
 	_join_all_threads_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(86)
 		}()
@@ -4227,9 +4257,9 @@ func _vacuum1_thread_writer(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0
 	_err = XError{}
 	_db = XSqlite{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(26)
 		}()
@@ -4238,9 +4268,9 @@ func _vacuum1_thread_writer(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0
 	_i = i64(0)
 _2:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(29)
 		}()
@@ -4248,18 +4278,18 @@ _2:
 	}()) == 0 {
 		_i += 1
 		_execsql_i64_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(33)
 			}()
 			return &_err
 		}(), &_db, unsafe.Pointer(str(5444)))
 		_execsql_i64_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(39)
 			}()
@@ -4267,9 +4297,9 @@ _2:
 		}(), &_db, unsafe.Pointer(str(5579)), unsafe.Pointer(&_i))
 		_clear_error_x(tls, &_err, i32(6))
 		_execsql_i64_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(43)
 			}()
@@ -4279,9 +4309,9 @@ _2:
 		goto _2
 	}
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(47)
 		}()
@@ -4302,9 +4332,9 @@ func _vacuum1_thread_vacuumer(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (
 	_err = XError{}
 	_db = XSqlite{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(55)
 		}()
@@ -4312,9 +4342,9 @@ func _vacuum1_thread_vacuumer(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (
 	}(), &_db, str(378), i32(0))
 _2:
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(58)
 		}()
@@ -4322,9 +4352,9 @@ _2:
 	}(), &_db, str(5639))
 	_clear_error_x(tls, &_err, i32(6))
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(60)
 		}()
@@ -4333,9 +4363,9 @@ _2:
 		goto _2
 	}
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(62)
 		}()
@@ -4355,9 +4385,9 @@ func _stress1(tls *crt.TLS, _nMs int32) {
 	_err = XError{}
 	_threads = bin.T_ht{}
 	_setstoptime_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(138)
 		}()
@@ -4365,99 +4395,99 @@ func _stress1(tls *crt.TLS, _nMs int32) {
 	}(), _nMs)
 	bin.Xsqlite3_enable_shared_cache(tls, i32(1))
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(141)
 		}()
 		return &_err
 	}(), &_threads, _stress_thread_1, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(142)
 		}()
 		return &_err
 	}(), &_threads, _stress_thread_1, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(144)
 		}()
 		return &_err
 	}(), &_threads, _stress_thread_2, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(145)
 		}()
 		return &_err
 	}(), &_threads, _stress_thread_2, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(147)
 		}()
 		return &_err
 	}(), &_threads, _stress_thread_3, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(148)
 		}()
 		return &_err
 	}(), &_threads, _stress_thread_3, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(150)
 		}()
 		return &_err
 	}(), &_threads, _stress_thread_4, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(151)
 		}()
 		return &_err
 	}(), &_threads, _stress_thread_4, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(153)
 		}()
 		return &_err
 	}(), &_threads, _stress_thread_5, nil)
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(154)
 		}()
 		return &_err
 	}(), &_threads, _stress_thread_5, crt.U2P(uintptr(u32(1))))
 	_join_all_threads_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(156)
 		}()
@@ -4469,16 +4499,19 @@ func _stress1(tls *crt.TLS, _nMs int32) {
 	_ = _threads
 }
 
-// Thread 1. CREATE and DROP a table.
+// C comment
+//  /*
+//  ** Thread 1. CREATE and DROP a table.
+//  */
 func _stress_thread_1(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *int8) {
 	var _err XError
 	var _db XSqlite
 	_err = XError{}
 	_db = XSqlite{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(24)
 		}()
@@ -4486,18 +4519,18 @@ func _stress_thread_1(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *int8
 	}(), &_db, str(378), i32(0))
 _2:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(25)
 		}()
 		return &_err
 	}()) == 0 {
 		_sql_script_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(26)
 			}()
@@ -4505,9 +4538,9 @@ _2:
 		}(), &_db, str(5646))
 		_clear_error_x(tls, &_err, i32(6))
 		_sql_script_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(28)
 			}()
@@ -4517,9 +4550,9 @@ _2:
 		goto _2
 	}
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(31)
 		}()
@@ -4533,7 +4566,10 @@ _2:
 	panic(0)
 }
 
-// Thread 2. Open and close database connections.
+// C comment
+//  /*
+//  ** Thread 2. Open and close database connections.
+//  */
 func _stress_thread_2(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *int8) {
 	var _err XError
 	var _db XSqlite
@@ -4541,27 +4577,27 @@ func _stress_thread_2(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *int8
 	_db = XSqlite{}
 _0:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(42)
 		}()
 		return &_err
 	}()) == 0 {
 		_opendb_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(43)
 			}()
 			return &_err
 		}(), &_db, str(378), i32(0))
 		_sql_script_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(44)
 			}()
@@ -4569,9 +4605,9 @@ _0:
 		}(), &_db, str(5718))
 		_clear_error_x(tls, &_err, i32(6))
 		_closedb_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(46)
 			}()
@@ -4587,7 +4623,10 @@ _0:
 	panic(0)
 }
 
-// Thread 3. Attempt many small SELECT statements.
+// C comment
+//  /*
+//  ** Thread 3. Attempt many small SELECT statements.
+//  */
 func _stress_thread_3(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *int8) {
 	var _i1, _i2 int32
 	var _err XError
@@ -4597,9 +4636,9 @@ func _stress_thread_3(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *int8
 	_i1 = i32(0)
 	_i2 = i32(0)
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(62)
 		}()
@@ -4607,9 +4646,9 @@ func _stress_thread_3(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *int8
 	}(), &_db, str(378), i32(0))
 _2:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(63)
 		}()
@@ -4618,16 +4657,16 @@ _2:
 		goto _3
 	}
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(64)
 		}()
 		return &_err
 	}(), &_db, str(5747))
 	_i1 += 1
-	if (_err.X0) != 0 {
+	if _err.X0 != 0 {
 		_i2 += 1
 	}
 	_clear_error_x(tls, &_err, i32(6))
@@ -4635,9 +4674,9 @@ _2:
 	goto _2
 _3:
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(70)
 		}()
@@ -4651,7 +4690,10 @@ _3:
 	panic(0)
 }
 
-// Thread 5. Attempt INSERT statements.
+// C comment
+//  /*
+//  ** Thread 5. Attempt INSERT statements.
+//  */
 func _stress_thread_4(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *int8) {
 	var _i1, _i2, _iArg int32
 	var _err XError
@@ -4662,9 +4704,9 @@ func _stress_thread_4(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *int8
 	_i2 = i32(0)
 	_iArg = int32(int64(crt.P2U(_pArg)))
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(85)
 		}()
@@ -4672,9 +4714,9 @@ func _stress_thread_4(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *int8
 	}(), &_db, str(378), i32(0))
 _2:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(86)
 		}()
@@ -4684,18 +4726,18 @@ _2:
 	}
 	if _iArg != 0 {
 		_closedb_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(88)
 			}()
 			return &_err
 		}(), &_db)
 		_opendb_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(89)
 			}()
@@ -4703,16 +4745,16 @@ _2:
 		}(), &_db, str(378), i32(0))
 	}
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(91)
 		}()
 		return &_err
 	}(), &_db, str(5799))
 	_i1 += 1
-	if (_err.X0) != 0 {
+	if _err.X0 != 0 {
 		_i2 += 1
 	}
 	_clear_error_x(tls, &_err, i32(6))
@@ -4720,9 +4762,9 @@ _2:
 	goto _2
 _3:
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(100)
 		}()
@@ -4736,7 +4778,10 @@ _3:
 	panic(0)
 }
 
-// Thread 6. Attempt DELETE operations.
+// C comment
+//  /*
+//  ** Thread 6. Attempt DELETE operations.
+//  */
 func _stress_thread_5(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *int8) {
 	var _iArg, _i1, _i2 int32
 	var _1_i int64
@@ -4748,9 +4793,9 @@ func _stress_thread_5(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *int8
 	_i1 = i32(0)
 	_i2 = i32(0)
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(116)
 		}()
@@ -4758,9 +4803,9 @@ func _stress_thread_5(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *int8
 	}(), &_db, str(378), i32(0))
 _2:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(117)
 		}()
@@ -4771,18 +4816,18 @@ _2:
 	_1_i = int64(_i1 % i32(4))
 	if _iArg != 0 {
 		_closedb_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(120)
 			}()
 			return &_err
 		}(), &_db)
 		_opendb_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(121)
 			}()
@@ -4790,25 +4835,25 @@ _2:
 		}(), &_db, str(378), i32(0))
 	}
 	_execsql_i64_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(123)
 		}()
 		return &_err
 	}(), &_db, unsafe.Pointer(str(5946)), unsafe.Pointer(&_1_i))
 	_i1 += 1
-	if (_err.X0) != 0 {
+	if _err.X0 != 0 {
 		_i2 += 1
 	}
 	_clear_error_x(tls, &_err, i32(6))
 	goto _2
 _3:
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(128)
 		}()
@@ -4831,80 +4876,93 @@ func _stress2(tls *crt.TLS, _nMs int32) {
 	var _db XSqlite
 	var _aTask [13]TStress2Task
 	_aTask = [13]TStress2Task{}
-	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTask)) + 8*uintptr(i32(0)))).X0))) = *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, *XError, *XSqlite, int32)
-	}{_stress2_workload1}))
-	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTask)) + 8*uintptr(i32(1)))).X0))) = *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, *XError, *XSqlite, int32)
-	}{_stress2_workload2}))
-	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTask)) + 8*uintptr(i32(2)))).X0))) = *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, *XError, *XSqlite, int32)
-	}{_stress2_workload3}))
-	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTask)) + 8*uintptr(i32(3)))).X0))) = *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, *XError, *XSqlite, int32)
-	}{_stress2_workload4}))
-	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTask)) + 8*uintptr(i32(4)))).X0))) = *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, *XError, *XSqlite, int32)
-	}{_stress2_workload5}))
-	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTask)) + 8*uintptr(i32(5)))).X0))) = *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, *XError, *XSqlite, int32)
-	}{_stress2_workload6}))
-	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTask)) + 8*uintptr(i32(6)))).X0))) = *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, *XError, *XSqlite, int32)
-	}{_stress2_workload7}))
-	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTask)) + 8*uintptr(i32(7)))).X0))) = *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, *XError, *XSqlite, int32)
-	}{_stress2_workload8}))
-	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTask)) + 8*uintptr(i32(8)))).X0))) = *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, *XError, *XSqlite, int32)
-	}{_stress2_workload9}))
-	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTask)) + 8*uintptr(i32(9)))).X0))) = *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, *XError, *XSqlite, int32)
-	}{_stress2_workload10}))
-	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTask)) + 8*uintptr(i32(10)))).X0))) = *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, *XError, *XSqlite, int32)
-	}{_stress2_workload11}))
-	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTask)) + 8*uintptr(i32(11)))).X0))) = *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, *XError, *XSqlite, int32)
-	}{_stress2_workload14}))
-	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTask)) + 8*uintptr(i32(12)))).X0))) = *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, *XError, *XSqlite, int32)
-	}{_stress2_workload17}))
+	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTask)) + 8*uintptr(i32(0)))).X0))) = func() func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32) {
+		v := _stress2_workload1
+		return *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&v))
+	}()
+	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTask)) + 8*uintptr(i32(1)))).X0))) = func() func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32) {
+		v := _stress2_workload2
+		return *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&v))
+	}()
+	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTask)) + 8*uintptr(i32(2)))).X0))) = func() func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32) {
+		v := _stress2_workload3
+		return *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&v))
+	}()
+	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTask)) + 8*uintptr(i32(3)))).X0))) = func() func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32) {
+		v := _stress2_workload4
+		return *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&v))
+	}()
+	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTask)) + 8*uintptr(i32(4)))).X0))) = func() func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32) {
+		v := _stress2_workload5
+		return *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&v))
+	}()
+	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTask)) + 8*uintptr(i32(5)))).X0))) = func() func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32) {
+		v := _stress2_workload6
+		return *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&v))
+	}()
+	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTask)) + 8*uintptr(i32(6)))).X0))) = func() func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32) {
+		v := _stress2_workload7
+		return *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&v))
+	}()
+	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTask)) + 8*uintptr(i32(7)))).X0))) = func() func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32) {
+		v := _stress2_workload8
+		return *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&v))
+	}()
+	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTask)) + 8*uintptr(i32(8)))).X0))) = func() func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32) {
+		v := _stress2_workload9
+		return *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&v))
+	}()
+	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTask)) + 8*uintptr(i32(9)))).X0))) = func() func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32) {
+		v := _stress2_workload10
+		return *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&v))
+	}()
+	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTask)) + 8*uintptr(i32(10)))).X0))) = func() func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32) {
+		v := _stress2_workload11
+		return *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&v))
+	}()
+	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTask)) + 8*uintptr(i32(11)))).X0))) = func() func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32) {
+		v := _stress2_workload14
+		return *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&v))
+	}()
+	*(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&((*TStress2Task)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTask)) + 8*uintptr(i32(12)))).X0))) = func() func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32) {
+		v := _stress2_workload17
+		return *(*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&v))
+	}()
 	_zDb = str(378)
 	_err = XError{}
 	_db = XSqlite{}
 	_threads = bin.T_ht{}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(345)
 		}()
 		return &_err
 	}(), &_db, _zDb, i32(1))
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(346)
 		}()
 		return &_err
 	}(), &_db, str(6014))
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(350)
 		}()
 		return &_err
 	}(), &_db)
 	_setstoptime_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(352)
 		}()
@@ -4916,34 +4974,35 @@ _8:
 	if uint64(_i) >= u64(13) {
 		goto _11
 	}
-	_stress2_launch_thread_loop(tls, &_err, &_threads, _zDb, *(*func(*crt.TLS, *XError, *XSqlite, int32))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32)
-	}{((*TStress2Task)(unsafe.Pointer(uintptr((unsafe.Pointer)(&_aTask)) + 8*uintptr(_i))).X0)})))
+	_stress2_launch_thread_loop(tls, &_err, &_threads, _zDb, func() func(*crt.TLS, *XError, *XSqlite, int32) {
+		v := (*TStress2Task)(unsafe.Pointer(uintptr(unsafe.Pointer(&_aTask)) + 8*uintptr(_i))).X0
+		return *(*func(*crt.TLS, *XError, *XSqlite, int32))(unsafe.Pointer(&v))
+	}())
 	_i += 1
 	goto _8
 _11:
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(358)
 		}()
 		return &_err
-	}(), &_threads, _stress2_workload19, (unsafe.Pointer)(_zDb))
+	}(), &_threads, _stress2_workload19, unsafe.Pointer(_zDb))
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(359)
 		}()
 		return &_err
-	}(), &_threads, _stress2_workload19, (unsafe.Pointer)(_zDb))
+	}(), &_threads, _stress2_workload19, unsafe.Pointer(_zDb))
 	_join_all_threads_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(361)
 		}()
@@ -4961,9 +5020,9 @@ func _stress2_workload1(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 	var _iTab int32
 	_iTab = (_i % i32(4)) + i32(1)
 	_sql_script_printf_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(193)
 		}()
@@ -4975,10 +5034,10 @@ func _sql_script_printf_x(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _zFormat *
 	var _1_zSql *int8
 	var _ap []interface{}
 	_ap = args
-	if (_pErr.X0) == i32(0) {
+	if _pErr.X0 == i32(0) {
 		_1_zSql = bin.Xsqlite3_vmprintf(tls, _zFormat, _ap)
-		*(*int32)(unsafe.Pointer(&(_pErr.X0))) = bin.Xsqlite3_exec(tls, (*bin.Xsqlite3)(_pDb.X0), _1_zSql, nil, nil, (**int8)(unsafe.Pointer(&(_pErr.X2))))
-		bin.Xsqlite3_free(tls, (unsafe.Pointer)(_1_zSql))
+		*(*int32)(unsafe.Pointer(&_pErr.X0)) = bin.Xsqlite3_exec(tls, (*bin.Xsqlite3)(_pDb.X0), _1_zSql, nil, nil, (**int8)(unsafe.Pointer(&_pErr.X2)))
+		bin.Xsqlite3_free(tls, unsafe.Pointer(_1_zSql))
 	}
 	_ap = nil
 }
@@ -4987,9 +5046,9 @@ func _stress2_workload2(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 	var _iTab int32
 	_iTab = (_i % i32(4)) + i32(1)
 	_sql_script_printf_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(200)
 		}()
@@ -4999,9 +5058,9 @@ func _stress2_workload2(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 
 func _stress2_workload3(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(204)
 		}()
@@ -5011,9 +5070,9 @@ func _stress2_workload3(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 
 func _stress2_workload4(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(208)
 		}()
@@ -5023,9 +5082,9 @@ func _stress2_workload4(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 
 func _stress2_workload5(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(212)
 		}()
@@ -5035,9 +5094,9 @@ func _stress2_workload5(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 
 func _stress2_workload6(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(218)
 		}()
@@ -5047,9 +5106,9 @@ func _stress2_workload6(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 
 func _stress2_workload7(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 	_sql_script_printf_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(224)
 		}()
@@ -5059,9 +5118,9 @@ func _stress2_workload7(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 
 func _stress2_workload8(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 	_sql_script_printf_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(231)
 		}()
@@ -5071,9 +5130,9 @@ func _stress2_workload8(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 
 func _stress2_workload9(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 	_sql_script_printf_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(239)
 		}()
@@ -5083,9 +5142,9 @@ func _stress2_workload9(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 
 func _stress2_workload10(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 	_sql_script_printf_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(244)
 		}()
@@ -5095,9 +5154,9 @@ func _stress2_workload10(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 
 func _stress2_workload11(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(250)
 		}()
@@ -5107,9 +5166,9 @@ func _stress2_workload11(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 
 func _stress2_workload14(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 	_sql_script_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(254)
 		}()
@@ -5119,9 +5178,9 @@ func _stress2_workload14(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 
 func _stress2_workload17(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 	_sql_script_printf_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(258)
 		}()
@@ -5137,17 +5196,17 @@ func _stress2_workload17(tls *crt.TLS, _pErr *XError, _pDb *XSqlite, _i int32) {
 func _stress2_launch_thread_loop(tls *crt.TLS, _pErr *XError, _pThreads *bin.T_ht, _zDb *int8, _x func(*crt.TLS, *XError, *XSqlite, int32)) {
 	var _pCtx *XStress2Ctx
 	_pCtx = (*XStress2Ctx)(bin.Xsqlite3_malloc(tls, int32(u64(16))))
-	*(**int8)(unsafe.Pointer(&(_pCtx.X0))) = _zDb
-	*(*func(*crt.TLS, *XError, *XSqlite, int32))(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&(_pCtx.X1))))) = _x
+	*(**int8)(unsafe.Pointer(&_pCtx.X0)) = _zDb
+	*(*func(*crt.TLS, *XError, *XSqlite, int32))(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32))(unsafe.Pointer(&_pCtx.X1)))) = _x
 	_launch_thread_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_pErr.X1))) = func() int32 {
-			if (_pErr.X0) != 0 {
-				return (_pErr.X1)
+		*(*int32)(unsafe.Pointer(&_pErr.X1)) = func() int32 {
+			if _pErr.X0 != 0 {
+				return _pErr.X1
 			}
 			return i32(316)
 		}()
 		return _pErr
-	}(), _pThreads, _stress2_thread_wrapper, (unsafe.Pointer)(_pCtx))
+	}(), _pThreads, _stress2_thread_wrapper, unsafe.Pointer(_pCtx))
 }
 
 func _stress2_thread_wrapper(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *int8) {
@@ -5162,9 +5221,9 @@ func _stress2_thread_wrapper(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r
 	_i2 = i32(0)
 _0:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(291)
 		}()
@@ -5173,9 +5232,9 @@ _0:
 		goto _1
 	}
 	_opendb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(293)
 		}()
@@ -5183,15 +5242,16 @@ _0:
 	}(), &_db, _pCtx.X0, i32(0))
 	_1_cnt = i32(0)
 _6:
-	if (_err.X0) != i32(0) || _1_cnt >= i32(5) {
+	if _err.X0 != i32(0) || _1_cnt >= i32(5) {
 		goto _10
 	}
-	(*(*func(*crt.TLS, *XError, *XSqlite, int32))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32)
-	}{(_pCtx.X1)})))(tls, &_err, &_db, _i1)
+	func() func(*crt.TLS, *XError, *XSqlite, int32) {
+		v := _pCtx.X1
+		return *(*func(*crt.TLS, *XError, *XSqlite, int32))(unsafe.Pointer(&v))
+	}()(tls, &_err, &_db, _i1)
 	{
 		p := &_i2
-		*p = (*p) + bool2int((_err.X0) == i32(0))
+		*p = (*p) + bool2int(_err.X0 == i32(0))
 		sink3(*p)
 	}
 	_clear_error_x(tls, &_err, i32(6))
@@ -5200,9 +5260,9 @@ _6:
 	goto _6
 _10:
 	_closedb_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(300)
 		}()
@@ -5227,27 +5287,27 @@ func _stress2_workload19(tls *crt.TLS, _iTid int32, _pArg unsafe.Pointer) (r0 *i
 	_zDb = (*int8)(_pArg)
 _0:
 	if _timetostop_x(tls, func() *XError {
-		*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-			if (_err.X0) != 0 {
-				return (_err.X1)
+		*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+			if _err.X0 != 0 {
+				return _err.X1
 			}
 			return i32(267)
 		}()
 		return &_err
 	}()) == 0 {
 		_opendb_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(268)
 			}()
 			return &_err
 		}(), &_db, _zDb, i32(0))
 		_sql_script_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(269)
 			}()
@@ -5255,9 +5315,9 @@ _0:
 		}(), &_db, str(5718))
 		_clear_error_x(tls, &_err, i32(6))
 		_closedb_x(tls, func() *XError {
-			*(*int32)(unsafe.Pointer(&(_err.X1))) = func() int32 {
-				if (_err.X0) != 0 {
-					return (_err.X1)
+			*(*int32)(unsafe.Pointer(&_err.X1)) = func() int32 {
+				if _err.X0 != 0 {
+					return _err.X1
 				}
 				return i32(271)
 			}()
@@ -5279,21 +5339,25 @@ func init() {
 	_mainØ00substArgvØ001 = [3]*int8{nil, str(6701), nil}
 }
 
-// ************************* Public Interfaces ****************************
-
-// CAPI: Initialize the multiplex VFS shim - sqlite3_multiplex_initialize()
-//
-// Use the VFS named zOrigVfsName as the VFS that does the actual work.
-// Use the default if zOrigVfsName==NULL.
-//
-// The multiplex VFS shim is named "multiplex".  It will become the default
-// VFS if makeDefault is non-zero.
-//
-// THIS ROUTINE IS NOT THREADSAFE.  Call this routine exactly once
-// during start-up.
+// C comment
+//  /************************** Public Interfaces *****************************/
+
+// C comment
+//  /*
+//  ** CAPI: Initialize the multiplex VFS shim - sqlite3_multiplex_initialize()
+//  **
+//  ** Use the VFS named zOrigVfsName as the VFS that does the actual work.
+//  ** Use the default if zOrigVfsName==NULL.
+//  **
+//  ** The multiplex VFS shim is named "multiplex".  It will become the default
+//  ** VFS if makeDefault is non-zero.
+//  **
+//  ** THIS ROUTINE IS NOT THREADSAFE.  Call this routine exactly once
+//  ** during start-up.
+//  */
 func Xsqlite3_multiplex_initialize(tls *crt.TLS, _zOrigVfsName *int8, _makeDefault int32) (r0 int32) {
 	var _pOrigVfs *bin.Xsqlite3_vfs
-	if (_gMultiplex.X4) != 0 {
+	if _gMultiplex.X4 != 0 {
 		return i32(21)
 	}
 	_pOrigVfs = bin.Xsqlite3_vfs_find(tls, _zOrigVfsName)
@@ -5301,56 +5365,54 @@ func Xsqlite3_multiplex_initialize(tls *crt.TLS, _zOrigVfsName *int8, _makeDefau
 		return i32(1)
 	}
 	func() {
-		if _pOrigVfs == (*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))) {
+		if _pOrigVfs == (*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)) {
 			crt.X__builtin_fprintf(tls, Xstderr, str(991), unsafe.Pointer(str(6703)), i32(1099), unsafe.Pointer((*int8)(unsafe.Pointer(&_sqlite3_multiplex_initializeØ00__func__Ø000))), unsafe.Pointer(str(6763)))
 			crt.X__builtin_abort(tls)
 		}
 	}()
-	*(*int32)(unsafe.Pointer(&(_gMultiplex.X4))) = i32(1)
-	*(**bin.Xsqlite3_vfs)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&(_gMultiplex.X0))))) = _pOrigVfs
-	*(*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))) = *_pOrigVfs
+	*(*int32)(unsafe.Pointer(&_gMultiplex.X4)) = i32(1)
+	*(**bin.Xsqlite3_vfs)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&_gMultiplex.X0)))) = _pOrigVfs
+	*(*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)) = *_pOrigVfs
 	{
-		p := (*int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))).X1)))
+		p := (*int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)).X1)))
 		*p = int32(uint64(*p) + u64(16))
 		sink3(*p)
 	}
-	*(**int8)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))).X4))) = str(6794)
-	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, *bin.Xsqlite3_file, int32, *int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *int8, unsafe.Pointer, int32, *int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))).X6))))) = _multiplexOpen
-	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *int8, int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))).X7))))) = _multiplexDelete
-	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *int8, int32, *int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))).X8))))) = _multiplexAccess
-	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int8) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *int8, int32, *int8) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))).X9))))) = _multiplexFullPathname
-	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8) unsafe.Pointer)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *int8) unsafe.Pointer)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))).X10))))) = _multiplexDlOpen
-	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, int32, *int8))(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32, *int8))(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))).X11))))) = _multiplexDlError
-	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, unsafe.Pointer, *int8) func(*crt.TLS))(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, *int8) func(*crt.TLS))(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))).X12))))) = _multiplexDlSym
-	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, unsafe.Pointer))(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer))(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))).X13))))) = _multiplexDlClose
-	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, int32, *int8) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32, *int8) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))).X14))))) = _multiplexRandomness
-	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))).X15))))) = _multiplexSleep
-	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *float64) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *float64) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))).X16))))) = _multiplexCurrentTime
-	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, int32, *int8) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32, *int8) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))).X17))))) = _multiplexGetLastError
-	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int64) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *int64) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))).X18))))) = _multiplexCurrentTimeInt64
-	*(*int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X2))).X0))) = i32(1)
-	*(*func(*crt.TLS, *bin.Xsqlite3_file) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X2))).X1))))) = _multiplexClose
-	*(*func(*crt.TLS, *bin.Xsqlite3_file, unsafe.Pointer, int32, int64) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32, int64) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X2))).X2))))) = _multiplexRead
-	*(*func(*crt.TLS, *bin.Xsqlite3_file, unsafe.Pointer, int32, int64) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32, int64) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X2))).X3))))) = _multiplexWrite
-	*(*func(*crt.TLS, *bin.Xsqlite3_file, int64) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int64) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X2))).X4))))) = _multiplexTruncate
-	*(*func(*crt.TLS, *bin.Xsqlite3_file, int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X2))).X5))))) = _multiplexSync
-	*(*func(*crt.TLS, *bin.Xsqlite3_file, *int64) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *int64) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X2))).X6))))) = _multiplexFileSize
-	*(*func(*crt.TLS, *bin.Xsqlite3_file, int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X2))).X7))))) = _multiplexLock
-	*(*func(*crt.TLS, *bin.Xsqlite3_file, int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X2))).X8))))) = _multiplexUnlock
-	*(*func(*crt.TLS, *bin.Xsqlite3_file, *int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X2))).X9))))) = _multiplexCheckReservedLock
-	*(*func(*crt.TLS, *bin.Xsqlite3_file, int32, unsafe.Pointer) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32, unsafe.Pointer) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X2))).X10))))) = _multiplexFileControl
-	*(*func(*crt.TLS, *bin.Xsqlite3_file) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X2))).X11))))) = _multiplexSectorSize
-	*(*func(*crt.TLS, *bin.Xsqlite3_file) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X2))).X12))))) = _multiplexDeviceCharacteristics
-	*(*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X3))) = _gMultiplex.X2
-	*(*int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X3))).X0))) = i32(2)
-	*(*func(*crt.TLS, *bin.Xsqlite3_file, int32, int32, int32, *unsafe.Pointer) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32, int32, int32, *unsafe.Pointer) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X3))).X13))))) = _multiplexShmMap
-	*(*func(*crt.TLS, *bin.Xsqlite3_file, int32, int32, int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32, int32, int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X3))).X14))))) = _multiplexShmLock
-	*(*func(*crt.TLS, *bin.Xsqlite3_file))(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer))(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X3))).X15))))) = _multiplexShmBarrier
-	*(*func(*crt.TLS, *bin.Xsqlite3_file, int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X3))).X16))))) = _multiplexShmUnmap
-	bin.Xsqlite3_vfs_register(tls, (*bin.Xsqlite3_vfs)(unsafe.Pointer(&(_gMultiplex.X1))), _makeDefault)
-	bin.Xsqlite3_auto_extension(tls, *(*func(*crt.TLS))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, **int8, *bin.Xsqlite3_api_routines) int32
-	}{_multiplexFuncInit})))
+	*(**int8)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)).X4))) = str(6794)
+	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, *bin.Xsqlite3_file, int32, *int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *int8, unsafe.Pointer, int32, *int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)).X6))))) = _multiplexOpen
+	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *int8, int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)).X7))))) = _multiplexDelete
+	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *int8, int32, *int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)).X8))))) = _multiplexAccess
+	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int8) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *int8, int32, *int8) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)).X9))))) = _multiplexFullPathname
+	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8) unsafe.Pointer)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *int8) unsafe.Pointer)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)).X10))))) = _multiplexDlOpen
+	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, int32, *int8))(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32, *int8))(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)).X11))))) = _multiplexDlError
+	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, unsafe.Pointer, *int8) func(*crt.TLS))(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, *int8) func(*crt.TLS))(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)).X12))))) = _multiplexDlSym
+	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, unsafe.Pointer))(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer))(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)).X13))))) = _multiplexDlClose
+	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, int32, *int8) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32, *int8) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)).X14))))) = _multiplexRandomness
+	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)).X15))))) = _multiplexSleep
+	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *float64) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *float64) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)).X16))))) = _multiplexCurrentTime
+	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, int32, *int8) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32, *int8) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)).X17))))) = _multiplexGetLastError
+	*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int64) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *int64) int32)(unsafe.Pointer(&((*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)).X18))))) = _multiplexCurrentTimeInt64
+	*(*int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X2)).X0))) = i32(1)
+	*(*func(*crt.TLS, *bin.Xsqlite3_file) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X2)).X1))))) = _multiplexClose
+	*(*func(*crt.TLS, *bin.Xsqlite3_file, unsafe.Pointer, int32, int64) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32, int64) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X2)).X2))))) = _multiplexRead
+	*(*func(*crt.TLS, *bin.Xsqlite3_file, unsafe.Pointer, int32, int64) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32, int64) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X2)).X3))))) = _multiplexWrite
+	*(*func(*crt.TLS, *bin.Xsqlite3_file, int64) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int64) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X2)).X4))))) = _multiplexTruncate
+	*(*func(*crt.TLS, *bin.Xsqlite3_file, int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X2)).X5))))) = _multiplexSync
+	*(*func(*crt.TLS, *bin.Xsqlite3_file, *int64) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *int64) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X2)).X6))))) = _multiplexFileSize
+	*(*func(*crt.TLS, *bin.Xsqlite3_file, int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X2)).X7))))) = _multiplexLock
+	*(*func(*crt.TLS, *bin.Xsqlite3_file, int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X2)).X8))))) = _multiplexUnlock
+	*(*func(*crt.TLS, *bin.Xsqlite3_file, *int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, *int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X2)).X9))))) = _multiplexCheckReservedLock
+	*(*func(*crt.TLS, *bin.Xsqlite3_file, int32, unsafe.Pointer) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32, unsafe.Pointer) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X2)).X10))))) = _multiplexFileControl
+	*(*func(*crt.TLS, *bin.Xsqlite3_file) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X2)).X11))))) = _multiplexSectorSize
+	*(*func(*crt.TLS, *bin.Xsqlite3_file) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X2)).X12))))) = _multiplexDeviceCharacteristics
+	*(*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X3)) = _gMultiplex.X2
+	*(*int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X3)).X0))) = i32(2)
+	*(*func(*crt.TLS, *bin.Xsqlite3_file, int32, int32, int32, *unsafe.Pointer) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32, int32, int32, *unsafe.Pointer) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X3)).X13))))) = _multiplexShmMap
+	*(*func(*crt.TLS, *bin.Xsqlite3_file, int32, int32, int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32, int32, int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X3)).X14))))) = _multiplexShmLock
+	*(*func(*crt.TLS, *bin.Xsqlite3_file))(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer))(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X3)).X15))))) = _multiplexShmBarrier
+	*(*func(*crt.TLS, *bin.Xsqlite3_file, int32) int32)(unsafe.Pointer((*func(*crt.TLS, unsafe.Pointer, int32) int32)(unsafe.Pointer(&((*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X3)).X16))))) = _multiplexShmUnmap
+	bin.Xsqlite3_vfs_register(tls, (*bin.Xsqlite3_vfs)(unsafe.Pointer(&_gMultiplex.X1)), _makeDefault)
+	bin.Xsqlite3_auto_extension(tls, func() func(*crt.TLS) { v := _multiplexFuncInit; return *(*func(*crt.TLS))(unsafe.Pointer(&v)) }())
 	return i32(0)
 }
 
@@ -5362,11 +5424,14 @@ func init() {
 	crt.Xstrncpy(nil, &_sqlite3_multiplex_initializeØ00__func__Ø000[0], str(6804), 29)
 }
 
-// This is the xOpen method used for the "multiplex" VFS.
-//
-// Most of the work is done by the underlying original VFS.  This method
-// simply links the new file into the appropriate multiplex group if it is a
-// file that needs to be tracked.
+// C comment
+//  /*
+//  ** This is the xOpen method used for the "multiplex" VFS.
+//  **
+//  ** Most of the work is done by the underlying original VFS.  This method
+//  ** simply links the new file into the appropriate multiplex group if it is a
+//  ** file that needs to be tracked.
+//  */
 func _multiplexOpen(tls *crt.TLS, _pVfs *bin.Xsqlite3_vfs, _zName *int8, _pConn *bin.Xsqlite3_file, _flags int32, _pOutFlags *int32) (r0 int32) {
 	var _rc, _nName, _sz, _9_bExists, _12_iChunk int32
 	var _8_sz64 int64
@@ -5383,7 +5448,7 @@ func _multiplexOpen(tls *crt.TLS, _pVfs *bin.Xsqlite3_vfs, _zName *int8, _pConn
 	_sz = i32(0)
 	_zToFree = nil
 
-	crt.Xmemset(tls, (unsafe.Pointer)(_pConn), i32(0), uint64(_pVfs.X1))
+	crt.Xmemset(tls, unsafe.Pointer(_pConn), i32(0), uint64(_pVfs.X1))
 	func() {
 		if _zName == nil && (_flags&i32(8)) == 0 {
 			crt.X__builtin_fprintf(tls, Xstderr, str(991), unsafe.Pointer(str(6703)), i32(484), unsafe.Pointer((*int8)(unsafe.Pointer(&_multiplexOpenØ00__func__Ø000))), unsafe.Pointer(str(6833)))
@@ -5415,32 +5480,32 @@ _3:
 		}
 		return nil
 	}()
-	crt.Xmemset(tls, (unsafe.Pointer)(_pGroup), i32(0), uint64(_sz))
-	*(**XmultiplexGroup)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&(_pMultiplexOpen.X1))))) = _pGroup
-	*(*uint8)(unsafe.Pointer(&(_pGroup.X6))) = u8(255)
-	*(*uint8)(unsafe.Pointer(&(_pGroup.X7))) = uint8(bin.Xsqlite3_uri_boolean(tls, _3_zUri, str(6878), bool2int((_flags&i32(256)) == i32(0))))
-	*(*uint32)(unsafe.Pointer(&(_pGroup.X5))) = uint32(int32(bin.Xsqlite3_uri_int64(tls, _3_zUri, str(6887), int64(i32(2147418112)))))
-	*(*uint32)(unsafe.Pointer(&(_pGroup.X5))) = ((_pGroup.X5) + uint32(i32(65535))) & uint32(i32(-65536))
+	crt.Xmemset(tls, unsafe.Pointer(_pGroup), i32(0), uint64(_sz))
+	*(**XmultiplexGroup)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&_pMultiplexOpen.X1)))) = _pGroup
+	*(*uint8)(unsafe.Pointer(&_pGroup.X6)) = u8(255)
+	*(*uint8)(unsafe.Pointer(&_pGroup.X7)) = uint8(bin.Xsqlite3_uri_boolean(tls, _3_zUri, str(6878), bool2int((_flags&i32(256)) == i32(0))))
+	*(*uint32)(unsafe.Pointer(&_pGroup.X5)) = uint32(int32(bin.Xsqlite3_uri_int64(tls, _3_zUri, str(6887), int64(i32(2147418112)))))
+	*(*uint32)(unsafe.Pointer(&_pGroup.X5)) = (_pGroup.X5 + uint32(i32(65535))) & uint32(i32(-65536))
 	if _zName != nil {
-		_4_p = (*int8)(unsafe.Pointer((*XmultiplexGroup)(unsafe.Pointer(uintptr((unsafe.Pointer)(_pGroup)) + 40*uintptr(i32(1))))))
-		*(**int8)(unsafe.Pointer(&(_pGroup.X2))) = _4_p
-		crt.Xmemcpy(tls, (unsafe.Pointer)(_pGroup.X2), (unsafe.Pointer)(_zName), uint64(_nName+i32(1)))
-		*(*int32)(unsafe.Pointer(&(_pGroup.X3))) = _nName
+		_4_p = (*int8)(unsafe.Pointer((*XmultiplexGroup)(unsafe.Pointer(uintptr(unsafe.Pointer(_pGroup)) + 40*uintptr(i32(1))))))
+		*(**int8)(unsafe.Pointer(&_pGroup.X2)) = _4_p
+		crt.Xmemcpy(tls, unsafe.Pointer(_pGroup.X2), unsafe.Pointer(_zName), uint64(_nName+i32(1)))
+		*(*int32)(unsafe.Pointer(&_pGroup.X3)) = _nName
 	}
-	if (_pGroup.X6) == 0 {
+	if _pGroup.X6 == 0 {
 		goto _11
 	}
 _12:
-	if (uint32(bin.Xsqlite3PendingByte()) % (_pGroup.X5)) >= ((_pGroup.X5) - uint32(i32(65536))) {
+	if (uint32(bin.Xsqlite3PendingByte()) % _pGroup.X5) >= (_pGroup.X5 - uint32(i32(65536))) {
 		{
-			p := (*uint32)(unsafe.Pointer(&(_pGroup.X5)))
+			p := (*uint32)(unsafe.Pointer(&_pGroup.X5))
 			*p = (*p) + uint32(i32(65536))
 			sink0(*p)
 		}
 		goto _12
 	}
 _11:
-	*(*int32)(unsafe.Pointer(&(_pGroup.X4))) = _flags
+	*(*int32)(unsafe.Pointer(&_pGroup.X4)) = _flags
 	_rc = _multiplexSubFilename(tls, _pGroup, i32(1))
 	if _rc != i32(0) {
 		goto _14
@@ -5453,14 +5518,15 @@ _14:
 	if _rc != i32(0) {
 		goto _17
 	}
-	_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_file, *int64) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *int64) int32
-	}{((*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X6)})))(tls, _pSubOpen, &_8_sz64)
+	_rc = func() func(*crt.TLS, *bin.Xsqlite3_file, *int64) int32 {
+		v := (*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X6
+		return *(*func(*crt.TLS, *bin.Xsqlite3_file, *int64) int32)(unsafe.Pointer(&v))
+	}()(tls, _pSubOpen, &_8_sz64)
 	if _rc != i32(0) || _zName == nil {
 		goto _19
 	}
 	if (_flags & i32(16384)) != 0 {
-		*(*uint8)(unsafe.Pointer(&(_pGroup.X6))) = uint8(i32(0))
+		*(*uint8)(unsafe.Pointer(&_pGroup.X6)) = uint8(i32(0))
 		goto _29
 	}
 	if _8_sz64 != int64(i32(0)) {
@@ -5471,15 +5537,17 @@ _14:
 	}
 	_12_iChunk = i32(1)
 _24:
-	_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *int8, int32, *int32) int32
-	}{(_pOrigVfs.X8)})))(tls, _pOrigVfs, (*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_12_iChunk))).X1, i32(0), &_9_bExists)
+	_rc = func() func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32 {
+		v := _pOrigVfs.X8
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32)(unsafe.Pointer(&v))
+	}()(tls, _pOrigVfs, (*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_12_iChunk))).X1, i32(0), &_9_bExists)
 	if _rc != i32(0) || _9_bExists == 0 {
 		goto _26
 	}
-	_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *int8, int32) int32
-	}{(_pOrigVfs.X7)})))(tls, _pOrigVfs, (*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_12_iChunk))).X1, i32(0))
+	_rc = func() func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32) int32 {
+		v := _pOrigVfs.X7
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32) int32)(unsafe.Pointer(&v))
+	}()(tls, _pOrigVfs, (*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_12_iChunk))).X1, i32(0))
 	if _rc == i32(0) {
 		_rc = _multiplexSubFilename(tls, _pGroup, preInc3(&_12_iChunk, 1))
 	}
@@ -5490,16 +5558,17 @@ _26:
 _23:
 	goto _29
 _22:
-	_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *int8, int32, *int32) int32
-	}{(_pOrigVfs.X8)})))(tls, _pOrigVfs, (*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(i32(1)))).X1, i32(0), &_9_bExists)
+	_rc = func() func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32 {
+		v := _pOrigVfs.X8
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32)(unsafe.Pointer(&v))
+	}()(tls, _pOrigVfs, (*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(i32(1)))).X1, i32(0), &_9_bExists)
 	_9_bExists = bool2int(_multiplexSubSize(tls, _pGroup, i32(1), &_rc) > int64(i32(0)))
 	if ((((_rc == i32(0)) && _9_bExists != 0) && (_8_sz64 == (_8_sz64 & int64(u32(4294901760))))) && (_8_sz64 > int64(i32(0)))) && (_8_sz64 != int64(_pGroup.X5)) {
-		*(*uint32)(unsafe.Pointer(&(_pGroup.X5))) = uint32(int32(_8_sz64))
+		*(*uint32)(unsafe.Pointer(&_pGroup.X5)) = uint32(int32(_8_sz64))
 		goto _38
 	}
 	if ((_rc == i32(0)) && (_9_bExists == 0)) && (_8_sz64 > int64(_pGroup.X5)) {
-		*(*uint8)(unsafe.Pointer(&(_pGroup.X6))) = uint8(i32(0))
+		*(*uint8)(unsafe.Pointer(&_pGroup.X6)) = uint8(i32(0))
 	}
 _38:
 _29:
@@ -5509,18 +5578,18 @@ _17:
 		goto _39
 	}
 	if ((*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X0) == i32(1) {
-		*(**bin.Xsqlite3_io_methods)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&((*bin.Xsqlite3_file)(unsafe.Pointer(&(_pMultiplexOpen.X0))).X0))))) = (*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X2)))
+		*(**bin.Xsqlite3_io_methods)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&((*bin.Xsqlite3_file)(unsafe.Pointer(&_pMultiplexOpen.X0)).X0))))) = (*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X2))
 		goto _41
 	}
-	*(**bin.Xsqlite3_io_methods)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&((*bin.Xsqlite3_file)(unsafe.Pointer(&(_pMultiplexOpen.X0))).X0))))) = (*bin.Xsqlite3_io_methods)(unsafe.Pointer(&(_gMultiplex.X3)))
+	*(**bin.Xsqlite3_io_methods)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&((*bin.Xsqlite3_file)(unsafe.Pointer(&_pMultiplexOpen.X0)).X0))))) = (*bin.Xsqlite3_io_methods)(unsafe.Pointer(&_gMultiplex.X3))
 _41:
 	goto _42
 _39:
 	_multiplexFreeComponents(tls, _pGroup)
-	bin.Xsqlite3_free(tls, (unsafe.Pointer)(_pGroup))
+	bin.Xsqlite3_free(tls, unsafe.Pointer(_pGroup))
 _42:
 _7:
-	bin.Xsqlite3_free(tls, (unsafe.Pointer)(_zToFree))
+	bin.Xsqlite3_free(tls, unsafe.Pointer(_zToFree))
 	return _rc
 }
 
@@ -5530,14 +5599,18 @@ func init() {
 	crt.Xstrncpy(nil, &_multiplexOpenØ00__func__Ø000[0], str(6897), 14)
 }
 
-// ************************ Utility Routines ********************************
+// C comment
+//  /************************* Utility Routines *********************************/
 
-// Compute a string length that is limited to what can be stored in
-// lower 30 bits of a 32-bit signed integer.
-//
-// The value returned will never be negative.  Nor will it ever be greater
-// than the actual length of the string.  For very long strings (greater
-// than 1GiB) the value returned might be less than the true string length.
+// C comment
+//  /*
+//  ** Compute a string length that is limited to what can be stored in
+//  ** lower 30 bits of a 32-bit signed integer.
+//  **
+//  ** The value returned will never be negative.  Nor will it ever be greater
+//  ** than the actual length of the string.  For very long strings (greater
+//  ** than 1GiB) the value returned might be less than the true string length.
+//  */
 func _multiplexStrlen30(tls *crt.TLS, _z *int8) (r0 int32) {
 	var _z2 *int8
 	_z2 = _z
@@ -5552,23 +5625,25 @@ _0:
 	return i32(1073741823) & int32(int64((uintptr(unsafe.Pointer(_z2))-uintptr(unsafe.Pointer(_z)))/1))
 }
 
-// Compute the filename for the iChunk-th chunk
+// C comment
+//  /* Compute the filename for the iChunk-th chunk
+//  */
 func _multiplexSubFilename(tls *crt.TLS, _pGroup *XmultiplexGroup, _iChunk int32) (r0 int32) {
 	var _3_n int32
 	var _3_z *int8
 	var _1_p *bin.XanalysisInfo
-	if _iChunk < (_pGroup.X1) {
+	if _iChunk < _pGroup.X1 {
 		goto _0
 	}
 	_1_p = (*bin.XanalysisInfo)(bin.Xsqlite3_realloc64(tls, _pGroup.X0, uint64(_iChunk+i32(1))*u64(16)))
 	if _1_p == nil {
 		return i32(7)
 	}
-	crt.Xmemset(tls, (unsafe.Pointer)((*bin.XanalysisInfo)(unsafe.Pointer(uintptr((unsafe.Pointer)(_1_p))+16*uintptr(_pGroup.X1)))), i32(0), u64(16)*uint64((_iChunk+i32(1))-(_pGroup.X1)))
-	*(**bin.XanalysisInfo)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&(_pGroup.X0))))) = _1_p
-	*(*int32)(unsafe.Pointer(&(_pGroup.X1))) = _iChunk + i32(1)
+	crt.Xmemset(tls, unsafe.Pointer((*bin.XanalysisInfo)(unsafe.Pointer(uintptr(unsafe.Pointer(_1_p))+16*uintptr(_pGroup.X1)))), i32(0), u64(16)*uint64((_iChunk+i32(1))-_pGroup.X1))
+	*(**bin.XanalysisInfo)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&_pGroup.X0)))) = _1_p
+	*(*int32)(unsafe.Pointer(&_pGroup.X1)) = _iChunk + i32(1)
 _0:
-	if (_pGroup.X2) == nil || ((*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_iChunk))).X1) != nil {
+	if _pGroup.X2 == nil || ((*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_iChunk))).X1) != nil {
 		goto _3
 	}
 	_3_n = _pGroup.X3
@@ -5581,35 +5656,38 @@ _3:
 	return i32(0)
 }
 
-// Generate the file-name for chunk iChunk of the group with base name
-// zBase. The file-name is written to buffer zOut before returning. Buffer
-// zOut must be allocated by the caller so that it is at least (nBase+5)
-// bytes in size, where nBase is the length of zBase, not including the
-// nul-terminator.
-//
-// If iChunk is 0 (or 400 - the number for the first journal file chunk),
-// the output is a copy of the input string. Otherwise, if
-// SQLITE_ENABLE_8_3_NAMES is not defined or the input buffer does not contain
-// a "." character, then the output is a copy of the input string with the
-// three-digit zero-padded decimal representation if iChunk appended to it.
-// For example:
-//
-// zBase="test.db", iChunk=4  ->  zOut="test.db004"
-//
-// Or, if SQLITE_ENABLE_8_3_NAMES is defined and the input buffer contains
-// a "." character, then everything after the "." is replaced by the
-// three-digit representation of iChunk.
-//
-// zBase="test.db", iChunk=4  ->  zOut="test.004"
-//
-// The output buffer string is terminated by 2 0x00 bytes. This makes it safe
-// to pass to sqlite3_uri_parameter() and similar.
+// C comment
+//  /*
+//  ** Generate the file-name for chunk iChunk of the group with base name
+//  ** zBase. The file-name is written to buffer zOut before returning. Buffer
+//  ** zOut must be allocated by the caller so that it is at least (nBase+5)
+//  ** bytes in size, where nBase is the length of zBase, not including the
+//  ** nul-terminator.
+//  **
+//  ** If iChunk is 0 (or 400 - the number for the first journal file chunk),
+//  ** the output is a copy of the input string. Otherwise, if
+//  ** SQLITE_ENABLE_8_3_NAMES is not defined or the input buffer does not contain
+//  ** a "." character, then the output is a copy of the input string with the
+//  ** three-digit zero-padded decimal representation if iChunk appended to it.
+//  ** For example:
+//  **
+//  **   zBase="test.db", iChunk=4  ->  zOut="test.db004"
+//  **
+//  ** Or, if SQLITE_ENABLE_8_3_NAMES is defined and the input buffer contains
+//  ** a "." character, then everything after the "." is replaced by the
+//  ** three-digit representation of iChunk.
+//  **
+//  **   zBase="test.db", iChunk=4  ->  zOut="test.004"
+//  **
+//  ** The output buffer string is terminated by 2 0x00 bytes. This makes it safe
+//  ** to pass to sqlite3_uri_parameter() and similar.
+//  */
 func _multiplexFilename(tls *crt.TLS, _zBase *int8, _nBase int32, _flags int32, _iChunk int32, _zOut *int8) {
 	var _n int32
 	_n = _nBase
-	crt.Xmemcpy(tls, (unsafe.Pointer)(_zOut), (unsafe.Pointer)(_zBase), uint64(_n+i32(1)))
+	crt.Xmemcpy(tls, unsafe.Pointer(_zOut), unsafe.Pointer(_zBase), uint64(_n+i32(1)))
 	if (_iChunk != i32(0)) && (_iChunk <= i32(299)) {
-		bin.Xsqlite3_snprintf(tls, i32(4), (*int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_zOut))+1*uintptr(_n))), str(6911), _iChunk)
+		bin.Xsqlite3_snprintf(tls, i32(4), (*int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_zOut))+1*uintptr(_n))), str(6911), _iChunk)
 		{
 			p := &_n
 			*p = (*p) + i32(3)
@@ -5617,12 +5695,12 @@ func _multiplexFilename(tls *crt.TLS, _zBase *int8, _nBase int32, _flags int32,
 		}
 	}
 	func() {
-		if int32(*(*int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_zOut)) + 1*uintptr(_n)))) != i32(0) {
+		if int32(*(*int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_zOut)) + 1*uintptr(_n)))) != i32(0) {
 			crt.X__builtin_fprintf(tls, Xstderr, str(991), unsafe.Pointer(str(6703)), i32(250), unsafe.Pointer((*int8)(unsafe.Pointer(&_multiplexFilenameØ00__func__Ø000))), unsafe.Pointer(str(6916)))
 			crt.X__builtin_abort(tls)
 		}
 	}()
-	*(*int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_zOut)) + 1*uintptr(_n+i32(1)))) = int8(i32(0))
+	*(*int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_zOut)) + 1*uintptr(_n+i32(1)))) = int8(i32(0))
 }
 
 var _multiplexFilenameØ00__func__Ø000 [18]int8
@@ -5631,12 +5709,14 @@ func init() {
 	crt.Xstrncpy(nil, &_multiplexFilenameØ00__func__Ø000[0], str(6930), 18)
 }
 
-// Translate an sqlite3_file* that is really a multiplexGroup* into
-// the sqlite3_file* for the underlying original VFS.
-//
-// For chunk 0, the pGroup->flags determines whether or not a new file
-// is created if it does not already exist.  For chunks 1 and higher, the
-// file is created only if createFlag is 1.
+// C comment
+//  /* Translate an sqlite3_file* that is really a multiplexGroup* into
+//  ** the sqlite3_file* for the underlying original VFS.
+//  **
+//  ** For chunk 0, the pGroup->flags determines whether or not a new file
+//  ** is created if it does not already exist.  For chunks 1 and higher, the
+//  ** file is created only if createFlag is 1.
+//  */
 func _multiplexSubOpen(tls *crt.TLS, _pGroup *XmultiplexGroup, _iChunk int32, _rc *int32, _pOutFlags *int32, _createFlag int32) (r0 *bin.Xsqlite3_file) {
 	var _1_flags, _1_bExists int32
 	var _pSubOpen *bin.Xsqlite3_file
@@ -5662,9 +5742,10 @@ func _multiplexSubOpen(tls *crt.TLS, _pGroup *XmultiplexGroup, _iChunk int32, _r
 	if ((*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0) + 16*uintptr(_iChunk))).X1) == nil {
 		return nil
 	}
-	*_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *int8, int32, *int32) int32
-	}{(_pOrigVfs.X8)})))(tls, _pOrigVfs, (*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_iChunk))).X1, i32(0), &_1_bExists)
+	*_rc = func() func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32 {
+		v := _pOrigVfs.X8
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32)(unsafe.Pointer(&v))
+	}()(tls, _pOrigVfs, (*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_iChunk))).X1, i32(0), &_1_bExists)
 	if (*_rc) == 0 && _1_bExists != 0 {
 		goto _9
 	}
@@ -5686,12 +5767,13 @@ _7:
 		return nil
 	}
 	*(**bin.Xsqlite3_file)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&((*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0) + 16*uintptr(_iChunk))).X0))))) = _pSubOpen
-	*_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, *bin.Xsqlite3_file, int32, *int32) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *int8, unsafe.Pointer, int32, *int32) int32
-	}{(_pOrigVfs.X6)})))(tls, _pOrigVfs, (*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_iChunk))).X1, _pSubOpen, _1_flags, _pOutFlags)
+	*_rc = func() func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, *bin.Xsqlite3_file, int32, *int32) int32 {
+		v := _pOrigVfs.X6
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, *bin.Xsqlite3_file, int32, *int32) int32)(unsafe.Pointer(&v))
+	}()(tls, _pOrigVfs, (*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_iChunk))).X1, _pSubOpen, _1_flags, _pOutFlags)
 	if (*_rc) != i32(0) {
 		bin.Xsqlite3_log(tls, *_rc, str(6982), unsafe.Pointer((*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_iChunk))).X1))
-		bin.Xsqlite3_free(tls, (unsafe.Pointer)(_pSubOpen))
+		bin.Xsqlite3_free(tls, unsafe.Pointer(_pSubOpen))
 		*(**bin.Xsqlite3_file)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&((*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0) + 16*uintptr(_iChunk))).X0))))) = nil
 		return nil
 	}
@@ -5699,9 +5781,12 @@ _1:
 	return _pSubOpen
 }
 
-// Return the size, in bytes, of chunk number iChunk.  If that chunk
-// does not exist, then return 0.  This function does not distingish between
-// non-existant files and zero-length files.
+// C comment
+//  /*
+//  ** Return the size, in bytes, of chunk number iChunk.  If that chunk
+//  ** does not exist, then return 0.  This function does not distingish between
+//  ** non-existant files and zero-length files.
+//  */
 func _multiplexSubSize(tls *crt.TLS, _pGroup *XmultiplexGroup, _iChunk int32, _rc *int32) (r0 int64) {
 	var _sz int64
 	var _pSub *bin.Xsqlite3_file
@@ -5713,18 +5798,22 @@ func _multiplexSubSize(tls *crt.TLS, _pGroup *XmultiplexGroup, _iChunk int32, _r
 	if _pSub == nil {
 		return int64(i32(0))
 	}
-	*_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_file, *int64) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *int64) int32
-	}{((*bin.Xsqlite3_io_methods)(_pSub.X0).X6)})))(tls, _pSub, &_sz)
+	*_rc = func() func(*crt.TLS, *bin.Xsqlite3_file, *int64) int32 {
+		v := (*bin.Xsqlite3_io_methods)(_pSub.X0).X6
+		return *(*func(*crt.TLS, *bin.Xsqlite3_file, *int64) int32)(unsafe.Pointer(&v))
+	}()(tls, _pSub, &_sz)
 	return _sz
 }
 
-// Deallocate memory held by a multiplexGroup
+// C comment
+//  /*
+//  ** Deallocate memory held by a multiplexGroup
+//  */
 func _multiplexFreeComponents(tls *crt.TLS, _pGroup *XmultiplexGroup) {
 	var _i int32
 	_i = i32(0)
 _0:
-	if _i >= (_pGroup.X1) {
+	if _i >= _pGroup.X1 {
 		goto _3
 	}
 	_multiplexSubClose(tls, _pGroup, _i, nil)
@@ -5732,41 +5821,50 @@ _0:
 	goto _0
 _3:
 	bin.Xsqlite3_free(tls, _pGroup.X0)
-	*(**bin.XanalysisInfo)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&(_pGroup.X0))))) = nil
-	*(*int32)(unsafe.Pointer(&(_pGroup.X1))) = i32(0)
+	*(**bin.XanalysisInfo)(unsafe.Pointer((*unsafe.Pointer)(unsafe.Pointer(&_pGroup.X0)))) = nil
+	*(*int32)(unsafe.Pointer(&_pGroup.X1)) = i32(0)
 }
 
-// Close a single sub-file in the connection group.
+// C comment
+//  /*
+//  ** Close a single sub-file in the connection group.
+//  */
 func _multiplexSubClose(tls *crt.TLS, _pGroup *XmultiplexGroup, _iChunk int32, _pOrigVfs *bin.Xsqlite3_vfs) {
 	var _pSubOpen *bin.Xsqlite3_file
 	_pSubOpen = (*bin.Xsqlite3_file)((*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0) + 16*uintptr(_iChunk))).X0)
 	if _pSubOpen == nil {
 		goto _0
 	}
-	(*(*func(*crt.TLS, *bin.Xsqlite3_file) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer) int32
-	}{((*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X1)})))(tls, _pSubOpen)
+	func() func(*crt.TLS, *bin.Xsqlite3_file) int32 {
+		v := (*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X1
+		return *(*func(*crt.TLS, *bin.Xsqlite3_file) int32)(unsafe.Pointer(&v))
+	}()(tls, _pSubOpen)
 	if (_pOrigVfs != nil) && (((*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0) + 16*uintptr(_iChunk))).X1) != nil) {
-		(*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32) int32)(unsafe.Pointer(&struct {
-			f func(*crt.TLS, unsafe.Pointer, *int8, int32) int32
-		}{(_pOrigVfs.X7)})))(tls, _pOrigVfs, (*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_iChunk))).X1, i32(0))
+		func() func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32) int32 {
+			v := _pOrigVfs.X7
+			return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32) int32)(unsafe.Pointer(&v))
+		}()(tls, _pOrigVfs, (*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_iChunk))).X1, i32(0))
 	}
 	bin.Xsqlite3_free(tls, (*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_iChunk))).X0)
 _0:
-	bin.Xsqlite3_free(tls, (unsafe.Pointer)((*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_iChunk))).X1))
-	crt.Xmemset(tls, (unsafe.Pointer)((*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_iChunk)))), i32(0), u64(16))
+	bin.Xsqlite3_free(tls, unsafe.Pointer((*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_iChunk))).X1))
+	crt.Xmemset(tls, unsafe.Pointer((*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0)+16*uintptr(_iChunk)))), i32(0), u64(16))
 }
 
-// This is the xDelete method used for the "multiplex" VFS.
-// It attempts to delete the filename specified.
+// C comment
+//  /*
+//  ** This is the xDelete method used for the "multiplex" VFS.
+//  ** It attempts to delete the filename specified.
+//  */
 func _multiplexDelete(tls *crt.TLS, _pVfs *bin.Xsqlite3_vfs, _zName *int8, _syncDir int32) (r0 int32) {
 	var _rc, _1_nName, _3_iChunk, _3_bExists int32
 	var _1_z *int8
 	var _pOrigVfs *bin.Xsqlite3_vfs
 	_pOrigVfs = (*bin.Xsqlite3_vfs)(_gMultiplex.X0)
-	_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *int8, int32) int32
-	}{(_pOrigVfs.X7)})))(tls, _pOrigVfs, _zName, _syncDir)
+	_rc = func() func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32) int32 {
+		v := _pOrigVfs.X7
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32) int32)(unsafe.Pointer(&v))
+	}()(tls, _pOrigVfs, _zName, _syncDir)
 	if _rc != i32(0) {
 		goto _0
 	}
@@ -5779,18 +5877,20 @@ func _multiplexDelete(tls *crt.TLS, _pVfs *bin.Xsqlite3_vfs, _zName *int8, _sync
 	_3_iChunk = i32(0)
 _3:
 	_multiplexFilename(tls, _zName, _1_nName, i32(2048), preInc3(&_3_iChunk, 1), _1_z)
-	_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *int8, int32, *int32) int32
-	}{(_pOrigVfs.X8)})))(tls, _pOrigVfs, _1_z, i32(0), &_3_bExists)
+	_rc = func() func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32 {
+		v := _pOrigVfs.X8
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32)(unsafe.Pointer(&v))
+	}()(tls, _pOrigVfs, _1_z, i32(0), &_3_bExists)
 	if (_rc == i32(0)) && _3_bExists != 0 {
 		goto _3
 	}
 _5:
 	if (_rc == i32(0)) && (_3_iChunk > i32(1)) {
 		_multiplexFilename(tls, _zName, _1_nName, i32(2048), preInc3(&_3_iChunk, -1), _1_z)
-		_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32) int32)(unsafe.Pointer(&struct {
-			f func(*crt.TLS, unsafe.Pointer, *int8, int32) int32
-		}{(_pOrigVfs.X7)})))(tls, _pOrigVfs, _1_z, _syncDir)
+		_rc = func() func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32) int32 {
+			v := _pOrigVfs.X7
+			return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32) int32)(unsafe.Pointer(&v))
+		}()(tls, _pOrigVfs, _1_z, _syncDir)
 		goto _5
 	}
 	if _rc != i32(0) {
@@ -5799,102 +5899,115 @@ _5:
 	_3_iChunk = i32(0)
 _9:
 	_multiplexFilename(tls, _zName, _1_nName, i32(524288), preInc3(&_3_iChunk, 1), _1_z)
-	_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *int8, int32, *int32) int32
-	}{(_pOrigVfs.X8)})))(tls, _pOrigVfs, _1_z, i32(0), &_3_bExists)
+	_rc = func() func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32 {
+		v := _pOrigVfs.X8
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32)(unsafe.Pointer(&v))
+	}()(tls, _pOrigVfs, _1_z, i32(0), &_3_bExists)
 	if (_rc == i32(0)) && _3_bExists != 0 {
 		goto _9
 	}
 _11:
 	if (_rc == i32(0)) && (_3_iChunk > i32(1)) {
 		_multiplexFilename(tls, _zName, _1_nName, i32(524288), preInc3(&_3_iChunk, -1), _1_z)
-		_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32) int32)(unsafe.Pointer(&struct {
-			f func(*crt.TLS, unsafe.Pointer, *int8, int32) int32
-		}{(_pOrigVfs.X7)})))(tls, _pOrigVfs, _1_z, _syncDir)
+		_rc = func() func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32) int32 {
+			v := _pOrigVfs.X7
+			return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32) int32)(unsafe.Pointer(&v))
+		}()(tls, _pOrigVfs, _1_z, _syncDir)
 		goto _11
 	}
 _8:
 _2:
-	bin.Xsqlite3_free(tls, (unsafe.Pointer)(_1_z))
+	bin.Xsqlite3_free(tls, unsafe.Pointer(_1_z))
 _0:
 	return _rc
 }
 
 func _multiplexAccess(tls *crt.TLS, _a *bin.Xsqlite3_vfs, _b *int8, _c int32, _d *int32) (r0 int32) {
-	return (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *int8, int32, *int32) int32
-	}{((*bin.Xsqlite3_vfs)(_gMultiplex.X0).X8)})))(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b, _c, _d)
+	return func() func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32 {
+		v := (*bin.Xsqlite3_vfs)(_gMultiplex.X0).X8
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int32) int32)(unsafe.Pointer(&v))
+	}()(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b, _c, _d)
 }
 
 func _multiplexFullPathname(tls *crt.TLS, _a *bin.Xsqlite3_vfs, _b *int8, _c int32, _d *int8) (r0 int32) {
-	return (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int8) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *int8, int32, *int8) int32
-	}{((*bin.Xsqlite3_vfs)(_gMultiplex.X0).X9)})))(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b, _c, _d)
+	return func() func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int8) int32 {
+		v := (*bin.Xsqlite3_vfs)(_gMultiplex.X0).X9
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8, int32, *int8) int32)(unsafe.Pointer(&v))
+	}()(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b, _c, _d)
 }
 
 func _multiplexDlOpen(tls *crt.TLS, _a *bin.Xsqlite3_vfs, _b *int8) (r0 unsafe.Pointer) {
-	return (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8) unsafe.Pointer)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *int8) unsafe.Pointer
-	}{((*bin.Xsqlite3_vfs)(_gMultiplex.X0).X10)})))(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b)
+	return func() func(*crt.TLS, *bin.Xsqlite3_vfs, *int8) unsafe.Pointer {
+		v := (*bin.Xsqlite3_vfs)(_gMultiplex.X0).X10
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int8) unsafe.Pointer)(unsafe.Pointer(&v))
+	}()(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b)
 }
 
 func _multiplexDlError(tls *crt.TLS, _a *bin.Xsqlite3_vfs, _b int32, _c *int8) {
-	(*(*func(*crt.TLS, *bin.Xsqlite3_vfs, int32, *int8))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, int32, *int8)
-	}{((*bin.Xsqlite3_vfs)(_gMultiplex.X0).X11)})))(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b, _c)
+	func() func(*crt.TLS, *bin.Xsqlite3_vfs, int32, *int8) {
+		v := (*bin.Xsqlite3_vfs)(_gMultiplex.X0).X11
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, int32, *int8))(unsafe.Pointer(&v))
+	}()(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b, _c)
 }
 
 func _multiplexDlSym(tls *crt.TLS, _a *bin.Xsqlite3_vfs, _b unsafe.Pointer, _c *int8) (r0 func(*crt.TLS)) {
-	return (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, unsafe.Pointer, *int8) func(*crt.TLS))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, *int8) func(*crt.TLS)
-	}{((*bin.Xsqlite3_vfs)(_gMultiplex.X0).X12)})))(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b, _c)
+	return func() func(*crt.TLS, *bin.Xsqlite3_vfs, unsafe.Pointer, *int8) func(*crt.TLS) {
+		v := (*bin.Xsqlite3_vfs)(_gMultiplex.X0).X12
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, unsafe.Pointer, *int8) func(*crt.TLS))(unsafe.Pointer(&v))
+	}()(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b, _c)
 }
 
 func _multiplexDlClose(tls *crt.TLS, _a *bin.Xsqlite3_vfs, _b unsafe.Pointer) {
-	(*(*func(*crt.TLS, *bin.Xsqlite3_vfs, unsafe.Pointer))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, unsafe.Pointer)
-	}{((*bin.Xsqlite3_vfs)(_gMultiplex.X0).X13)})))(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b)
+	func() func(*crt.TLS, *bin.Xsqlite3_vfs, unsafe.Pointer) {
+		v := (*bin.Xsqlite3_vfs)(_gMultiplex.X0).X13
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, unsafe.Pointer))(unsafe.Pointer(&v))
+	}()(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b)
 }
 
 func _multiplexRandomness(tls *crt.TLS, _a *bin.Xsqlite3_vfs, _b int32, _c *int8) (r0 int32) {
-	return (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, int32, *int8) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, int32, *int8) int32
-	}{((*bin.Xsqlite3_vfs)(_gMultiplex.X0).X14)})))(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b, _c)
+	return func() func(*crt.TLS, *bin.Xsqlite3_vfs, int32, *int8) int32 {
+		v := (*bin.Xsqlite3_vfs)(_gMultiplex.X0).X14
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, int32, *int8) int32)(unsafe.Pointer(&v))
+	}()(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b, _c)
 }
 
 func _multiplexSleep(tls *crt.TLS, _a *bin.Xsqlite3_vfs, _b int32) (r0 int32) {
-	return (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, int32) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, int32) int32
-	}{((*bin.Xsqlite3_vfs)(_gMultiplex.X0).X15)})))(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b)
+	return func() func(*crt.TLS, *bin.Xsqlite3_vfs, int32) int32 {
+		v := (*bin.Xsqlite3_vfs)(_gMultiplex.X0).X15
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, int32) int32)(unsafe.Pointer(&v))
+	}()(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b)
 }
 
 func _multiplexCurrentTime(tls *crt.TLS, _a *bin.Xsqlite3_vfs, _b *float64) (r0 int32) {
-	return (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *float64) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *float64) int32
-	}{((*bin.Xsqlite3_vfs)(_gMultiplex.X0).X16)})))(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b)
+	return func() func(*crt.TLS, *bin.Xsqlite3_vfs, *float64) int32 {
+		v := (*bin.Xsqlite3_vfs)(_gMultiplex.X0).X16
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *float64) int32)(unsafe.Pointer(&v))
+	}()(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b)
 }
 
 func _multiplexGetLastError(tls *crt.TLS, _a *bin.Xsqlite3_vfs, _b int32, _c *int8) (r0 int32) {
-	if (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, int32, *int8) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, int32, *int8) int32
-	}{((*bin.Xsqlite3_vfs)(_gMultiplex.X0).X17)}))) != nil {
-		return (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, int32, *int8) int32)(unsafe.Pointer(&struct {
-			f func(*crt.TLS, unsafe.Pointer, int32, *int8) int32
-		}{((*bin.Xsqlite3_vfs)(_gMultiplex.X0).X17)})))(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b, _c)
+	if ((*bin.Xsqlite3_vfs)(_gMultiplex.X0).X17) != nil {
+		return func() func(*crt.TLS, *bin.Xsqlite3_vfs, int32, *int8) int32 {
+			v := (*bin.Xsqlite3_vfs)(_gMultiplex.X0).X17
+			return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, int32, *int8) int32)(unsafe.Pointer(&v))
+		}()(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b, _c)
 	}
 	return i32(0)
 }
 
 func _multiplexCurrentTimeInt64(tls *crt.TLS, _a *bin.Xsqlite3_vfs, _b *int64) (r0 int32) {
-	return (*(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int64) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *int64) int32
-	}{((*bin.Xsqlite3_vfs)(_gMultiplex.X0).X18)})))(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b)
-}
-
-// xClose requests get passed through to the original VFS.
-// We loop over all open chunk handles and close them.
-// The group structure for this file is unlinked from
-// our list of groups and freed.
+	return func() func(*crt.TLS, *bin.Xsqlite3_vfs, *int64) int32 {
+		v := (*bin.Xsqlite3_vfs)(_gMultiplex.X0).X18
+		return *(*func(*crt.TLS, *bin.Xsqlite3_vfs, *int64) int32)(unsafe.Pointer(&v))
+	}()(tls, (*bin.Xsqlite3_vfs)(_gMultiplex.X0), _b)
+}
+
+// C comment
+//  /* xClose requests get passed through to the original VFS.
+//  ** We loop over all open chunk handles and close them.
+//  ** The group structure for this file is unlinked from
+//  ** our list of groups and freed.
+//  */
 func _multiplexClose(tls *crt.TLS, _pConn *bin.Xsqlite3_file) (r0 int32) {
 	var _rc int32
 	var _pGroup *XmultiplexGroup
@@ -5903,13 +6016,15 @@ func _multiplexClose(tls *crt.TLS, _pConn *bin.Xsqlite3_file) (r0 int32) {
 	_pGroup = (*XmultiplexGroup)(_p.X1)
 	_rc = i32(0)
 	_multiplexFreeComponents(tls, _pGroup)
-	bin.Xsqlite3_free(tls, (unsafe.Pointer)(_pGroup))
+	bin.Xsqlite3_free(tls, unsafe.Pointer(_pGroup))
 	return _rc
 }
 
-// Pass xRead requests thru to the original VFS after
-// determining the correct chunk to operate on.
-// Break up reads across chunk boundaries.
+// C comment
+//  /* Pass xRead requests thru to the original VFS after
+//  ** determining the correct chunk to operate on.
+//  ** Break up reads across chunk boundaries.
+//  */
 func _multiplexRead(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _pBuf unsafe.Pointer, _iAmt int32, _iOfst int64) (r0 int32) {
 	var _rc, _5_i, _6_extra int32
 	var _1_pSubOpen, _5_pSubOpen *bin.Xsqlite3_file
@@ -5918,7 +6033,7 @@ func _multiplexRead(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _pBuf unsafe.Pointe
 	_p = (*XmultiplexConn)(unsafe.Pointer(_pConn))
 	_pGroup = (*XmultiplexGroup)(_p.X1)
 	_rc = i32(0)
-	if (_pGroup.X6) != 0 {
+	if _pGroup.X6 != 0 {
 		goto _0
 	}
 	_1_pSubOpen = _multiplexSubOpen(tls, _pGroup, i32(0), &_rc, (*int32)(unsafe.Pointer(nil)), i32(0))
@@ -5926,9 +6041,10 @@ func _multiplexRead(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _pBuf unsafe.Pointe
 		_rc = i32(266)
 		goto _2
 	}
-	_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_file, unsafe.Pointer, int32, int64) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32, int64) int32
-	}{((*bin.Xsqlite3_io_methods)(_1_pSubOpen.X0).X2)})))(tls, _1_pSubOpen, _pBuf, _iAmt, _iOfst)
+	_rc = func() func(*crt.TLS, *bin.Xsqlite3_file, unsafe.Pointer, int32, int64) int32 {
+		v := (*bin.Xsqlite3_io_methods)(_1_pSubOpen.X0).X2
+		return *(*func(*crt.TLS, *bin.Xsqlite3_file, unsafe.Pointer, int32, int64) int32)(unsafe.Pointer(&v))
+	}()(tls, _1_pSubOpen, _pBuf, _iAmt, _iOfst)
 _2:
 	goto _3
 _0:
@@ -5941,7 +6057,7 @@ _4:
 	if _5_pSubOpen == nil {
 		goto _6
 	}
-	_6_extra = int32(uint32(int32(_iOfst%int64(_pGroup.X5))+_iAmt) - (_pGroup.X5))
+	_6_extra = int32(uint32(int32(_iOfst%int64(_pGroup.X5))+_iAmt) - _pGroup.X5)
 	if _6_extra < i32(0) {
 		_6_extra = i32(0)
 	}
@@ -5950,13 +6066,14 @@ _4:
 		*p = (*p) - _6_extra
 		sink3(*p)
 	}
-	_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_file, unsafe.Pointer, int32, int64) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32, int64) int32
-	}{((*bin.Xsqlite3_io_methods)(_5_pSubOpen.X0).X2)})))(tls, _5_pSubOpen, _pBuf, _iAmt, _iOfst%int64(_pGroup.X5))
+	_rc = func() func(*crt.TLS, *bin.Xsqlite3_file, unsafe.Pointer, int32, int64) int32 {
+		v := (*bin.Xsqlite3_io_methods)(_5_pSubOpen.X0).X2
+		return *(*func(*crt.TLS, *bin.Xsqlite3_file, unsafe.Pointer, int32, int64) int32)(unsafe.Pointer(&v))
+	}()(tls, _5_pSubOpen, _pBuf, _iAmt, _iOfst%int64(_pGroup.X5))
 	if _rc != i32(0) {
 		goto _5
 	}
-	_pBuf = (unsafe.Pointer)((*int8)(unsafe.Pointer(uintptr(unsafe.Pointer((*int8)(_pBuf))) + uintptr(_iAmt))))
+	_pBuf = unsafe.Pointer((*int8)(unsafe.Pointer(uintptr(unsafe.Pointer((*int8)(_pBuf))) + uintptr(_iAmt))))
 	{
 		p := &_iOfst
 		*p = (*p) + int64(_iAmt)
@@ -5974,9 +6091,11 @@ _3:
 	return _rc
 }
 
-// Pass xWrite requests thru to the original VFS after
-// determining the correct chunk to operate on.
-// Break up writes across chunk boundaries.
+// C comment
+//  /* Pass xWrite requests thru to the original VFS after
+//  ** determining the correct chunk to operate on.
+//  ** Break up writes across chunk boundaries.
+//  */
 func _multiplexWrite(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _pBuf unsafe.Pointer, _iAmt int32, _iOfst int64) (r0 int32) {
 	var _rc, _5_i, _6_extra int32
 	var _1_pSubOpen, _5_pSubOpen *bin.Xsqlite3_file
@@ -5985,7 +6104,7 @@ func _multiplexWrite(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _pBuf unsafe.Point
 	_p = (*XmultiplexConn)(unsafe.Pointer(_pConn))
 	_pGroup = (*XmultiplexGroup)(_p.X1)
 	_rc = i32(0)
-	if (_pGroup.X6) != 0 {
+	if _pGroup.X6 != 0 {
 		goto _0
 	}
 	_1_pSubOpen = _multiplexSubOpen(tls, _pGroup, i32(0), &_rc, (*int32)(unsafe.Pointer(nil)), i32(0))
@@ -5993,9 +6112,10 @@ func _multiplexWrite(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _pBuf unsafe.Point
 		_rc = i32(778)
 		goto _2
 	}
-	_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_file, unsafe.Pointer, int32, int64) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32, int64) int32
-	}{((*bin.Xsqlite3_io_methods)(_1_pSubOpen.X0).X3)})))(tls, _1_pSubOpen, _pBuf, _iAmt, _iOfst)
+	_rc = func() func(*crt.TLS, *bin.Xsqlite3_file, unsafe.Pointer, int32, int64) int32 {
+		v := (*bin.Xsqlite3_io_methods)(_1_pSubOpen.X0).X3
+		return *(*func(*crt.TLS, *bin.Xsqlite3_file, unsafe.Pointer, int32, int64) int32)(unsafe.Pointer(&v))
+	}()(tls, _1_pSubOpen, _pBuf, _iAmt, _iOfst)
 _2:
 	goto _3
 _0:
@@ -6008,7 +6128,7 @@ _4:
 	if _5_pSubOpen == nil {
 		goto _7
 	}
-	_6_extra = int32(uint32(int32(_iOfst%int64(_pGroup.X5))+_iAmt) - (_pGroup.X5))
+	_6_extra = int32(uint32(int32(_iOfst%int64(_pGroup.X5))+_iAmt) - _pGroup.X5)
 	if _6_extra < i32(0) {
 		_6_extra = i32(0)
 	}
@@ -6017,10 +6137,11 @@ _4:
 		*p = (*p) - _6_extra
 		sink3(*p)
 	}
-	_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_file, unsafe.Pointer, int32, int64) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, unsafe.Pointer, int32, int64) int32
-	}{((*bin.Xsqlite3_io_methods)(_5_pSubOpen.X0).X3)})))(tls, _5_pSubOpen, _pBuf, _iAmt, _iOfst%int64(_pGroup.X5))
-	_pBuf = (unsafe.Pointer)((*int8)(unsafe.Pointer(uintptr(unsafe.Pointer((*int8)(_pBuf))) + uintptr(_iAmt))))
+	_rc = func() func(*crt.TLS, *bin.Xsqlite3_file, unsafe.Pointer, int32, int64) int32 {
+		v := (*bin.Xsqlite3_io_methods)(_5_pSubOpen.X0).X3
+		return *(*func(*crt.TLS, *bin.Xsqlite3_file, unsafe.Pointer, int32, int64) int32)(unsafe.Pointer(&v))
+	}()(tls, _5_pSubOpen, _pBuf, _iAmt, _iOfst%int64(_pGroup.X5))
+	_pBuf = unsafe.Pointer((*int8)(unsafe.Pointer(uintptr(unsafe.Pointer((*int8)(_pBuf))) + uintptr(_iAmt))))
 	{
 		p := &_iOfst
 		*p = (*p) + int64(_iAmt)
@@ -6034,9 +6155,11 @@ _3:
 	return _rc
 }
 
-// Pass xTruncate requests thru to the original VFS after
-// determining the correct chunk to operate on.  Delete any
-// chunks above the truncate mark.
+// C comment
+//  /* Pass xTruncate requests thru to the original VFS after
+//  ** determining the correct chunk to operate on.  Delete any
+//  ** chunks above the truncate mark.
+//  */
 func _multiplexTruncate(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _size int64) (r0 int32) {
 	var _rc, _4_i, _4_iBaseGroup int32
 	var _1_pSubOpen, _4_pSubOpen *bin.Xsqlite3_file
@@ -6046,7 +6169,7 @@ func _multiplexTruncate(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _size int64) (r
 	_p = (*XmultiplexConn)(unsafe.Pointer(_pConn))
 	_pGroup = (*XmultiplexGroup)(_p.X1)
 	_rc = i32(0)
-	if (_pGroup.X6) != 0 {
+	if _pGroup.X6 != 0 {
 		goto _0
 	}
 	_1_pSubOpen = _multiplexSubOpen(tls, _pGroup, i32(0), &_rc, (*int32)(unsafe.Pointer(nil)), i32(0))
@@ -6054,28 +6177,30 @@ func _multiplexTruncate(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _size int64) (r
 		_rc = i32(1546)
 		goto _2
 	}
-	_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_file, int64) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, int64) int32
-	}{((*bin.Xsqlite3_io_methods)(_1_pSubOpen.X0).X4)})))(tls, _1_pSubOpen, _size)
+	_rc = func() func(*crt.TLS, *bin.Xsqlite3_file, int64) int32 {
+		v := (*bin.Xsqlite3_io_methods)(_1_pSubOpen.X0).X4
+		return *(*func(*crt.TLS, *bin.Xsqlite3_file, int64) int32)(unsafe.Pointer(&v))
+	}()(tls, _1_pSubOpen, _size)
 _2:
 	goto _3
 _0:
 	_4_iBaseGroup = int32(_size / int64(_pGroup.X5))
 	_4_pOrigVfs = (*bin.Xsqlite3_vfs)(_gMultiplex.X0)
-	_4_i = (_pGroup.X1) - i32(1)
+	_4_i = _pGroup.X1 - i32(1)
 _4:
 	if _4_i <= _4_iBaseGroup || _rc != i32(0) {
 		goto _8
 	}
-	if (_pGroup.X7) != 0 {
+	if _pGroup.X7 != 0 {
 		_multiplexSubClose(tls, _pGroup, _4_i, _4_pOrigVfs)
 		goto _10
 	}
 	_4_pSubOpen = _multiplexSubOpen(tls, _pGroup, _4_i, &_rc, nil, i32(0))
 	if _4_pSubOpen != nil {
-		_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_file, int64) int32)(unsafe.Pointer(&struct {
-			f func(*crt.TLS, unsafe.Pointer, int64) int32
-		}{((*bin.Xsqlite3_io_methods)(_4_pSubOpen.X0).X4)})))(tls, _4_pSubOpen, int64(i32(0)))
+		_rc = func() func(*crt.TLS, *bin.Xsqlite3_file, int64) int32 {
+			v := (*bin.Xsqlite3_io_methods)(_4_pSubOpen.X0).X4
+			return *(*func(*crt.TLS, *bin.Xsqlite3_file, int64) int32)(unsafe.Pointer(&v))
+		}()(tls, _4_pSubOpen, int64(i32(0)))
 	}
 _10:
 	_4_i -= 1
@@ -6086,9 +6211,10 @@ _8:
 	}
 	_4_pSubOpen = _multiplexSubOpen(tls, _pGroup, _4_iBaseGroup, &_rc, nil, i32(0))
 	if _4_pSubOpen != nil {
-		_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_file, int64) int32)(unsafe.Pointer(&struct {
-			f func(*crt.TLS, unsafe.Pointer, int64) int32
-		}{((*bin.Xsqlite3_io_methods)(_4_pSubOpen.X0).X4)})))(tls, _4_pSubOpen, _size%int64(_pGroup.X5))
+		_rc = func() func(*crt.TLS, *bin.Xsqlite3_file, int64) int32 {
+			v := (*bin.Xsqlite3_io_methods)(_4_pSubOpen.X0).X4
+			return *(*func(*crt.TLS, *bin.Xsqlite3_file, int64) int32)(unsafe.Pointer(&v))
+		}()(tls, _4_pSubOpen, _size%int64(_pGroup.X5))
 	}
 _12:
 	if _rc != 0 {
@@ -6098,7 +6224,9 @@ _3:
 	return _rc
 }
 
-// Pass xSync requests through to the original VFS without change
+// C comment
+//  /* Pass xSync requests through to the original VFS without change
+//  */
 func _multiplexSync(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _flags int32) (r0 int32) {
 	var _rc, _i, _2_rc2 int32
 	var _1_pSubOpen *bin.Xsqlite3_file
@@ -6109,16 +6237,17 @@ func _multiplexSync(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _flags int32) (r0 i
 	_rc = i32(0)
 	_i = i32(0)
 _0:
-	if _i >= (_pGroup.X1) {
+	if _i >= _pGroup.X1 {
 		goto _3
 	}
 	_1_pSubOpen = (*bin.Xsqlite3_file)((*bin.XanalysisInfo)(unsafe.Pointer(uintptr(_pGroup.X0) + 16*uintptr(_i))).X0)
 	if _1_pSubOpen == nil {
 		goto _4
 	}
-	_2_rc2 = (*(*func(*crt.TLS, *bin.Xsqlite3_file, int32) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, int32) int32
-	}{((*bin.Xsqlite3_io_methods)(_1_pSubOpen.X0).X5)})))(tls, _1_pSubOpen, _flags)
+	_2_rc2 = func() func(*crt.TLS, *bin.Xsqlite3_file, int32) int32 {
+		v := (*bin.Xsqlite3_io_methods)(_1_pSubOpen.X0).X5
+		return *(*func(*crt.TLS, *bin.Xsqlite3_file, int32) int32)(unsafe.Pointer(&v))
+	}()(tls, _1_pSubOpen, _flags)
 	if _2_rc2 != i32(0) {
 		_rc = _2_rc2
 	}
@@ -6129,8 +6258,10 @@ _3:
 	return _rc
 }
 
-// Pass xFileSize requests through to the original VFS.
-// Aggregate the size of all the chunks before returning.
+// C comment
+//  /* Pass xFileSize requests through to the original VFS.
+//  ** Aggregate the size of all the chunks before returning.
+//  */
 func _multiplexFileSize(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _pSize *int64) (r0 int32) {
 	var _rc, _i int32
 	var _5_sz int64
@@ -6140,7 +6271,7 @@ func _multiplexFileSize(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _pSize *int64)
 	_p = (*XmultiplexConn)(unsafe.Pointer(_pConn))
 	_pGroup = (*XmultiplexGroup)(_p.X1)
 	_rc = i32(0)
-	if (_pGroup.X6) != 0 {
+	if _pGroup.X6 != 0 {
 		goto _0
 	}
 	_1_pSubOpen = _multiplexSubOpen(tls, _pGroup, i32(0), &_rc, (*int32)(unsafe.Pointer(nil)), i32(0))
@@ -6148,9 +6279,10 @@ func _multiplexFileSize(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _pSize *int64)
 		_rc = i32(1802)
 		goto _2
 	}
-	_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_file, *int64) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, *int64) int32
-	}{((*bin.Xsqlite3_io_methods)(_1_pSubOpen.X0).X6)})))(tls, _1_pSubOpen, _pSize)
+	_rc = func() func(*crt.TLS, *bin.Xsqlite3_file, *int64) int32 {
+		v := (*bin.Xsqlite3_io_methods)(_1_pSubOpen.X0).X6
+		return *(*func(*crt.TLS, *bin.Xsqlite3_file, *int64) int32)(unsafe.Pointer(&v))
+	}()(tls, _1_pSubOpen, _pSize)
 _2:
 	goto _3
 _0:
@@ -6172,7 +6304,9 @@ _3:
 	return _rc
 }
 
-// Pass xLock requests through to the original VFS unchanged.
+// C comment
+//  /* Pass xLock requests through to the original VFS unchanged.
+//  */
 func _multiplexLock(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _lock int32) (r0 int32) {
 	var _rc int32
 	var _pSubOpen *bin.Xsqlite3_file
@@ -6180,9 +6314,10 @@ func _multiplexLock(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _lock int32) (r0 in
 	_p = (*XmultiplexConn)(unsafe.Pointer(_pConn))
 	_pSubOpen = _multiplexSubOpen(tls, (*XmultiplexGroup)(_p.X1), i32(0), &_rc, (*int32)(unsafe.Pointer(nil)), i32(0))
 	if _pSubOpen != nil {
-		return (*(*func(*crt.TLS, *bin.Xsqlite3_file, int32) int32)(unsafe.Pointer(&struct {
-			f func(*crt.TLS, unsafe.Pointer, int32) int32
-		}{((*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X7)})))(tls, _pSubOpen, _lock)
+		return func() func(*crt.TLS, *bin.Xsqlite3_file, int32) int32 {
+			v := (*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X7
+			return *(*func(*crt.TLS, *bin.Xsqlite3_file, int32) int32)(unsafe.Pointer(&v))
+		}()(tls, _pSubOpen, _lock)
 	}
 	return i32(5)
 
@@ -6190,7 +6325,9 @@ func _multiplexLock(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _lock int32) (r0 in
 	panic(0)
 }
 
-// Pass xUnlock requests through to the original VFS unchanged.
+// C comment
+//  /* Pass xUnlock requests through to the original VFS unchanged.
+//  */
 func _multiplexUnlock(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _lock int32) (r0 int32) {
 	var _rc int32
 	var _pSubOpen *bin.Xsqlite3_file
@@ -6198,9 +6335,10 @@ func _multiplexUnlock(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _lock int32) (r0
 	_p = (*XmultiplexConn)(unsafe.Pointer(_pConn))
 	_pSubOpen = _multiplexSubOpen(tls, (*XmultiplexGroup)(_p.X1), i32(0), &_rc, (*int32)(unsafe.Pointer(nil)), i32(0))
 	if _pSubOpen != nil {
-		return (*(*func(*crt.TLS, *bin.Xsqlite3_file, int32) int32)(unsafe.Pointer(&struct {
-			f func(*crt.TLS, unsafe.Pointer, int32) int32
-		}{((*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X8)})))(tls, _pSubOpen, _lock)
+		return func() func(*crt.TLS, *bin.Xsqlite3_file, int32) int32 {
+			v := (*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X8
+			return *(*func(*crt.TLS, *bin.Xsqlite3_file, int32) int32)(unsafe.Pointer(&v))
+		}()(tls, _pSubOpen, _lock)
 	}
 	return i32(2058)
 
@@ -6208,7 +6346,9 @@ func _multiplexUnlock(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _lock int32) (r0
 	panic(0)
 }
 
-// Pass xCheckReservedLock requests through to the original VFS unchanged.
+// C comment
+//  /* Pass xCheckReservedLock requests through to the original VFS unchanged.
+//  */
 func _multiplexCheckReservedLock(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _pResOut *int32) (r0 int32) {
 	var _rc int32
 	var _pSubOpen *bin.Xsqlite3_file
@@ -6216,9 +6356,10 @@ func _multiplexCheckReservedLock(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _pResO
 	_p = (*XmultiplexConn)(unsafe.Pointer(_pConn))
 	_pSubOpen = _multiplexSubOpen(tls, (*XmultiplexGroup)(_p.X1), i32(0), &_rc, (*int32)(unsafe.Pointer(nil)), i32(0))
 	if _pSubOpen != nil {
-		return (*(*func(*crt.TLS, *bin.Xsqlite3_file, *int32) int32)(unsafe.Pointer(&struct {
-			f func(*crt.TLS, unsafe.Pointer, *int32) int32
-		}{((*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X9)})))(tls, _pSubOpen, _pResOut)
+		return func() func(*crt.TLS, *bin.Xsqlite3_file, *int32) int32 {
+			v := (*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X9
+			return *(*func(*crt.TLS, *bin.Xsqlite3_file, *int32) int32)(unsafe.Pointer(&v))
+		}()(tls, _pSubOpen, _pResOut)
 	}
 	return i32(3594)
 
@@ -6226,8 +6367,10 @@ func _multiplexCheckReservedLock(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _pResO
 	panic(0)
 }
 
-// Pass xFileControl requests through to the original VFS unchanged,
-// except for any MULTIPLEX_CTRL_* requests here.
+// C comment
+//  /* Pass xFileControl requests through to the original VFS unchanged,
+//  ** except for any MULTIPLEX_CTRL_* requests here.
+//  */
 func _multiplexFileControl(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _op int32, _pArg unsafe.Pointer) (r0 int32) {
 	var _rc, _2_bEnabled int32
 	var _3_szChunk uint32
@@ -6238,7 +6381,7 @@ func _multiplexFileControl(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _op int32, _
 	_p = (*XmultiplexConn)(unsafe.Pointer(_pConn))
 	_pGroup = (*XmultiplexGroup)(_p.X1)
 	_rc = i32(1)
-	if (_gMultiplex.X4) == 0 {
+	if _gMultiplex.X4 == 0 {
 		return i32(21)
 	}
 	switch _op {
@@ -6261,7 +6404,7 @@ func _multiplexFileControl(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _op int32, _
 _2:
 	if _pArg != nil {
 		_2_bEnabled = *(*int32)(_pArg)
-		*(*uint8)(unsafe.Pointer(&(_pGroup.X6))) = uint8(_2_bEnabled)
+		*(*uint8)(unsafe.Pointer(&_pGroup.X6)) = uint8(_2_bEnabled)
 		_rc = i32(0)
 	}
 	goto _10
@@ -6280,7 +6423,7 @@ _3:
 		*p = (*p) & uint32(i32(-65536))
 		sink0(*p)
 	}
-	*(*uint32)(unsafe.Pointer(&(_pGroup.X5))) = _3_szChunk
+	*(*uint32)(unsafe.Pointer(&_pGroup.X5)) = _3_szChunk
 	_rc = i32(0)
 _13:
 _11:
@@ -6293,23 +6436,23 @@ _5:
 	goto _10
 _7:
 	_6_aFcntl = (**int8)(_pArg)
-	if (*(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_6_aFcntl)) + 8*uintptr(i32(1))))) == nil || bin.Xsqlite3_stricmp(tls, *(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_6_aFcntl)) + 8*uintptr(i32(1)))), str(7014)) != i32(0) {
+	if (*(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_6_aFcntl)) + 8*uintptr(i32(1))))) == nil || bin.Xsqlite3_stricmp(tls, *(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_6_aFcntl)) + 8*uintptr(i32(1)))), str(7014)) != i32(0) {
 		goto _15
 	}
-	if (*(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_6_aFcntl)) + 8*uintptr(i32(2))))) == nil || (*(*int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(*(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_6_aFcntl)) + 8*uintptr(i32(2)))))) + 1*uintptr(i32(0))))) == 0 {
+	if (*(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_6_aFcntl)) + 8*uintptr(i32(2))))) == nil || (*(*int8)(unsafe.Pointer(uintptr(unsafe.Pointer(*(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_6_aFcntl)) + 8*uintptr(i32(2)))))) + 1*uintptr(i32(0))))) == 0 {
 		goto _17
 	}
-	if (bin.Xsqlite3_stricmp(tls, *(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_6_aFcntl)) + 8*uintptr(i32(2)))), str(7033)) == i32(0)) || (bin.Xsqlite3_stricmp(tls, *(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_6_aFcntl)) + 8*uintptr(i32(2)))), str(7036)) == i32(0)) {
-		*(*uint8)(unsafe.Pointer(&(_pGroup.X7))) = uint8(i32(1))
+	if (bin.Xsqlite3_stricmp(tls, *(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_6_aFcntl)) + 8*uintptr(i32(2)))), str(7033)) == i32(0)) || (bin.Xsqlite3_stricmp(tls, *(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_6_aFcntl)) + 8*uintptr(i32(2)))), str(7036)) == i32(0)) {
+		*(*uint8)(unsafe.Pointer(&_pGroup.X7)) = uint8(i32(1))
 		goto _22
 	}
-	if (bin.Xsqlite3_stricmp(tls, *(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_6_aFcntl)) + 8*uintptr(i32(2)))), str(7038)) == i32(0)) || (bin.Xsqlite3_stricmp(tls, *(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_6_aFcntl)) + 8*uintptr(i32(2)))), str(7042)) == i32(0)) {
-		*(*uint8)(unsafe.Pointer(&(_pGroup.X7))) = uint8(i32(0))
+	if (bin.Xsqlite3_stricmp(tls, *(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_6_aFcntl)) + 8*uintptr(i32(2)))), str(7038)) == i32(0)) || (bin.Xsqlite3_stricmp(tls, *(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_6_aFcntl)) + 8*uintptr(i32(2)))), str(7042)) == i32(0)) {
+		*(*uint8)(unsafe.Pointer(&_pGroup.X7)) = uint8(i32(0))
 	}
 _22:
 _17:
-	*(**int8)(unsafe.Pointer(uintptr((unsafe.Pointer)(_6_aFcntl)) + 8*uintptr(i32(0)))) = bin.Xsqlite3_mprintf(tls, func() *int8 {
-		if (_pGroup.X7) != 0 {
+	*(**int8)(unsafe.Pointer(uintptr(unsafe.Pointer(_6_aFcntl)) + 8*uintptr(i32(0)))) = bin.Xsqlite3_mprintf(tls, func() *int8 {
+		if _pGroup.X7 != 0 {
 			return str(7033)
 		}
 		return str(7038)
@@ -6322,9 +6465,10 @@ _8:
 	if _pSubOpen == nil {
 		goto _25
 	}
-	_rc = (*(*func(*crt.TLS, *bin.Xsqlite3_file, int32, unsafe.Pointer) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, int32, unsafe.Pointer) int32
-	}{((*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X10)})))(tls, _pSubOpen, _op, _pArg)
+	_rc = func() func(*crt.TLS, *bin.Xsqlite3_file, int32, unsafe.Pointer) int32 {
+		v := (*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X10
+		return *(*func(*crt.TLS, *bin.Xsqlite3_file, int32, unsafe.Pointer) int32)(unsafe.Pointer(&v))
+	}()(tls, _pSubOpen, _op, _pArg)
 	if (_op == i32(12)) && (_rc == i32(0)) {
 		*(**int8)(_pArg) = bin.Xsqlite3_mprintf(tls, str(7044), unsafe.Pointer(*(**int8)(_pArg)))
 	}
@@ -6334,19 +6478,20 @@ _10:
 	return _rc
 }
 
-// Pass xSectorSize requests through to the original VFS unchanged.
+// C comment
+//  /* Pass xSectorSize requests through to the original VFS unchanged.
+//  */
 func _multiplexSectorSize(tls *crt.TLS, _pConn *bin.Xsqlite3_file) (r0 int32) {
 	var _rc int32
 	var _pSubOpen *bin.Xsqlite3_file
 	var _p *XmultiplexConn
 	_p = (*XmultiplexConn)(unsafe.Pointer(_pConn))
 	_pSubOpen = _multiplexSubOpen(tls, (*XmultiplexGroup)(_p.X1), i32(0), &_rc, (*int32)(unsafe.Pointer(nil)), i32(0))
-	if (_pSubOpen != nil) && ((*(*func(*crt.TLS, *bin.Xsqlite3_file) int32)(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer) int32
-	}{((*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X11)}))) != nil) {
-		return (*(*func(*crt.TLS, *bin.Xsqlite3_file) int32)(unsafe.Pointer(&struct {
-			f func(*crt.TLS, unsafe.Pointer) int32
-		}{((*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X11)})))(tls, _pSubOpen)
+	if (_pSubOpen != nil) && (((*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X11) != nil) {
+		return func() func(*crt.TLS, *bin.Xsqlite3_file) int32 {
+			v := (*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X11
+			return *(*func(*crt.TLS, *bin.Xsqlite3_file) int32)(unsafe.Pointer(&v))
+		}()(tls, _pSubOpen)
 	}
 	return i32(4096)
 
@@ -6354,7 +6499,9 @@ func _multiplexSectorSize(tls *crt.TLS, _pConn *bin.Xsqlite3_file) (r0 int32) {
 	panic(0)
 }
 
-// Pass xDeviceCharacteristics requests through to the original VFS unchanged.
+// C comment
+//  /* Pass xDeviceCharacteristics requests through to the original VFS unchanged.
+//  */
 func _multiplexDeviceCharacteristics(tls *crt.TLS, _pConn *bin.Xsqlite3_file) (r0 int32) {
 	var _rc int32
 	var _pSubOpen *bin.Xsqlite3_file
@@ -6362,9 +6509,10 @@ func _multiplexDeviceCharacteristics(tls *crt.TLS, _pConn *bin.Xsqlite3_file) (r
 	_p = (*XmultiplexConn)(unsafe.Pointer(_pConn))
 	_pSubOpen = _multiplexSubOpen(tls, (*XmultiplexGroup)(_p.X1), i32(0), &_rc, (*int32)(unsafe.Pointer(nil)), i32(0))
 	if _pSubOpen != nil {
-		return (*(*func(*crt.TLS, *bin.Xsqlite3_file) int32)(unsafe.Pointer(&struct {
-			f func(*crt.TLS, unsafe.Pointer) int32
-		}{((*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X12)})))(tls, _pSubOpen)
+		return func() func(*crt.TLS, *bin.Xsqlite3_file) int32 {
+			v := (*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X12
+			return *(*func(*crt.TLS, *bin.Xsqlite3_file) int32)(unsafe.Pointer(&v))
+		}()(tls, _pSubOpen)
 	}
 	return i32(0)
 
@@ -6372,7 +6520,9 @@ func _multiplexDeviceCharacteristics(tls *crt.TLS, _pConn *bin.Xsqlite3_file) (r
 	panic(0)
 }
 
-// Pass xShmMap requests through to the original VFS unchanged.
+// C comment
+//  /* Pass xShmMap requests through to the original VFS unchanged.
+//  */
 func _multiplexShmMap(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _iRegion int32, _szRegion int32, _bExtend int32, _pp *unsafe.Pointer) (r0 int32) {
 	var _rc int32
 	var _pSubOpen *bin.Xsqlite3_file
@@ -6380,9 +6530,10 @@ func _multiplexShmMap(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _iRegion int32, _
 	_p = (*XmultiplexConn)(unsafe.Pointer(_pConn))
 	_pSubOpen = _multiplexSubOpen(tls, (*XmultiplexGroup)(_p.X1), i32(0), &_rc, (*int32)(unsafe.Pointer(nil)), i32(0))
 	if _pSubOpen != nil {
-		return (*(*func(*crt.TLS, *bin.Xsqlite3_file, int32, int32, int32, *unsafe.Pointer) int32)(unsafe.Pointer(&struct {
-			f func(*crt.TLS, unsafe.Pointer, int32, int32, int32, *unsafe.Pointer) int32
-		}{((*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X13)})))(tls, _pSubOpen, _iRegion, _szRegion, _bExtend, _pp)
+		return func() func(*crt.TLS, *bin.Xsqlite3_file, int32, int32, int32, *unsafe.Pointer) int32 {
+			v := (*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X13
+			return *(*func(*crt.TLS, *bin.Xsqlite3_file, int32, int32, int32, *unsafe.Pointer) int32)(unsafe.Pointer(&v))
+		}()(tls, _pSubOpen, _iRegion, _szRegion, _bExtend, _pp)
 	}
 	return i32(10)
 
@@ -6390,7 +6541,9 @@ func _multiplexShmMap(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _iRegion int32, _
 	panic(0)
 }
 
-// Pass xShmLock requests through to the original VFS unchanged.
+// C comment
+//  /* Pass xShmLock requests through to the original VFS unchanged.
+//  */
 func _multiplexShmLock(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _ofst int32, _n int32, _flags int32) (r0 int32) {
 	var _rc int32
 	var _pSubOpen *bin.Xsqlite3_file
@@ -6398,9 +6551,10 @@ func _multiplexShmLock(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _ofst int32, _n
 	_p = (*XmultiplexConn)(unsafe.Pointer(_pConn))
 	_pSubOpen = _multiplexSubOpen(tls, (*XmultiplexGroup)(_p.X1), i32(0), &_rc, (*int32)(unsafe.Pointer(nil)), i32(0))
 	if _pSubOpen != nil {
-		return (*(*func(*crt.TLS, *bin.Xsqlite3_file, int32, int32, int32) int32)(unsafe.Pointer(&struct {
-			f func(*crt.TLS, unsafe.Pointer, int32, int32, int32) int32
-		}{((*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X14)})))(tls, _pSubOpen, _ofst, _n, _flags)
+		return func() func(*crt.TLS, *bin.Xsqlite3_file, int32, int32, int32) int32 {
+			v := (*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X14
+			return *(*func(*crt.TLS, *bin.Xsqlite3_file, int32, int32, int32) int32)(unsafe.Pointer(&v))
+		}()(tls, _pSubOpen, _ofst, _n, _flags)
 	}
 	return i32(5)
 
@@ -6408,7 +6562,9 @@ func _multiplexShmLock(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _ofst int32, _n
 	panic(0)
 }
 
-// Pass xShmBarrier requests through to the original VFS unchanged.
+// C comment
+//  /* Pass xShmBarrier requests through to the original VFS unchanged.
+//  */
 func _multiplexShmBarrier(tls *crt.TLS, _pConn *bin.Xsqlite3_file) {
 	var _rc int32
 	var _pSubOpen *bin.Xsqlite3_file
@@ -6416,14 +6572,17 @@ func _multiplexShmBarrier(tls *crt.TLS, _pConn *bin.Xsqlite3_file) {
 	_p = (*XmultiplexConn)(unsafe.Pointer(_pConn))
 	_pSubOpen = _multiplexSubOpen(tls, (*XmultiplexGroup)(_p.X1), i32(0), &_rc, (*int32)(unsafe.Pointer(nil)), i32(0))
 	if _pSubOpen != nil {
-		(*(*func(*crt.TLS, *bin.Xsqlite3_file))(unsafe.Pointer(&struct {
-			f func(*crt.TLS, unsafe.Pointer)
-		}{((*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X15)})))(tls, _pSubOpen)
+		func() func(*crt.TLS, *bin.Xsqlite3_file) {
+			v := (*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X15
+			return *(*func(*crt.TLS, *bin.Xsqlite3_file))(unsafe.Pointer(&v))
+		}()(tls, _pSubOpen)
 	}
 	_ = _rc
 }
 
-// Pass xShmUnmap requests through to the original VFS unchanged.
+// C comment
+//  /* Pass xShmUnmap requests through to the original VFS unchanged.
+//  */
 func _multiplexShmUnmap(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _deleteFlag int32) (r0 int32) {
 	var _rc int32
 	var _pSubOpen *bin.Xsqlite3_file
@@ -6431,9 +6590,10 @@ func _multiplexShmUnmap(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _deleteFlag int
 	_p = (*XmultiplexConn)(unsafe.Pointer(_pConn))
 	_pSubOpen = _multiplexSubOpen(tls, (*XmultiplexGroup)(_p.X1), i32(0), &_rc, (*int32)(unsafe.Pointer(nil)), i32(0))
 	if _pSubOpen != nil {
-		return (*(*func(*crt.TLS, *bin.Xsqlite3_file, int32) int32)(unsafe.Pointer(&struct {
-			f func(*crt.TLS, unsafe.Pointer, int32) int32
-		}{((*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X16)})))(tls, _pSubOpen, _deleteFlag)
+		return func() func(*crt.TLS, *bin.Xsqlite3_file, int32) int32 {
+			v := (*bin.Xsqlite3_io_methods)(_pSubOpen.X0).X16
+			return *(*func(*crt.TLS, *bin.Xsqlite3_file, int32) int32)(unsafe.Pointer(&v))
+		}()(tls, _pSubOpen, _deleteFlag)
 	}
 	return i32(0)
 
@@ -6441,21 +6601,24 @@ func _multiplexShmUnmap(tls *crt.TLS, _pConn *bin.Xsqlite3_file, _deleteFlag int
 	panic(0)
 }
 
-// This is the entry point to register the auto-extension for the
-// multiplex_control() function.
+// C comment
+//  /*
+//  ** This is the entry point to register the auto-extension for the
+//  ** multiplex_control() function.
+//  */
 func _multiplexFuncInit(tls *crt.TLS, _db unsafe.Pointer, _pzErrMsg **int8, _pApi *bin.Xsqlite3_api_routines) (r0 int32) {
 	var _rc int32
-	_rc = bin.Xsqlite3_create_function(tls, (*bin.Xsqlite3)(_db), str(7057), i32(2), i32(5), nil, *(*func(*crt.TLS, *bin.Xsqlite3_context, int32, **bin.XMem))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, int32, *unsafe.Pointer)
-	}{_multiplexControlFunc})), *(*func(*crt.TLS, *bin.Xsqlite3_context, int32, **bin.XMem))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer, int32, *unsafe.Pointer)
-	}{nil})), *(*func(*crt.TLS, *bin.Xsqlite3_context))(unsafe.Pointer(&struct {
-		f func(*crt.TLS, unsafe.Pointer)
-	}{nil})))
+	_rc = bin.Xsqlite3_create_function(tls, (*bin.Xsqlite3)(_db), str(7057), i32(2), i32(5), nil, func() func(*crt.TLS, *bin.Xsqlite3_context, int32, **bin.XMem) {
+		v := _multiplexControlFunc
+		return *(*func(*crt.TLS, *bin.Xsqlite3_context, int32, **bin.XMem))(unsafe.Pointer(&v))
+	}(), nil, nil)
 	return _rc
 }
 
-// This is the implementation of the multiplex_control() SQL function.
+// C comment
+//  /*
+//  ** This is the implementation of the multiplex_control() SQL function.
+//  */
 func _multiplexControlFunc(tls *crt.TLS, _context unsafe.Pointer, _argc int32, _argv *unsafe.Pointer) {
 	var _rc, _op, _iVal int32
 	var _db unsafe.Pointer
@@ -6466,8 +6629,8 @@ func _multiplexControlFunc(tls *crt.TLS, _context unsafe.Pointer, _argc int32, _
 		_rc = i32(1)
 		goto _2
 	}
-	_op = bin.Xsqlite3_value_int(tls, (*bin.XMem)(*(*unsafe.Pointer)(unsafe.Pointer(uintptr((unsafe.Pointer)(_argv)) + 8*uintptr(i32(0))))))
-	_iVal = bin.Xsqlite3_value_int(tls, (*bin.XMem)(*(*unsafe.Pointer)(unsafe.Pointer(uintptr((unsafe.Pointer)(_argv)) + 8*uintptr(i32(1))))))
+	_op = bin.Xsqlite3_value_int(tls, (*bin.XMem)(*(*unsafe.Pointer)(unsafe.Pointer(uintptr(unsafe.Pointer(_argv)) + 8*uintptr(i32(0))))))
+	_iVal = bin.Xsqlite3_value_int(tls, (*bin.XMem)(*(*unsafe.Pointer)(unsafe.Pointer(uintptr(unsafe.Pointer(_argv)) + 8*uintptr(i32(1))))))
 	switch _op {
 	case i32(1):
 		goto _4
@@ -6494,7 +6657,7 @@ _7:
 _8:
 _2:
 	if _rc == i32(0) {
-		_rc = bin.Xsqlite3_file_control(tls, (*bin.Xsqlite3)(_db), nil, _op, (unsafe.Pointer)(&_iVal))
+		_rc = bin.Xsqlite3_file_control(tls, (*bin.Xsqlite3)(_db), nil, _op, unsafe.Pointer(&_iVal))
 	}
 	bin.Xsqlite3_result_error_code(tls, (*bin.Xsqlite3_context)(_context), _rc)
 	_ = _iVal