// Code generated by modernc.org/undup from the per-target sqlite_*.go files; DO NOT EDIT.

//go:build (freebsd && 386) || (freebsd && arm)

package sqlite3

import (
	"unsafe"

	"modernc.org/libc"
)

const RSIZE_MAX = 2147483647

type Tcap_ioctl_t = uint32

type Tcritical_t = int32

type Tfd_set = struct {
	F__fds_bits [32]t__fd_mask
}

type Tsyscallarg_t = int32

type Tu_register_t = uint32

type Tvm_offset_t = uint32

type Tvm_size_t = uint32

// C documentation
//
//	/*
//	** Create an sqlite3_backup process to copy the contents of zSrcDb from
//	** connection handle pSrcDb to zDestDb in pDestDb. If successful, return
//	** a pointer to the new sqlite3_backup object.
//	**
//	** If an error occurs, NULL is returned and an error code and error message
//	** stored in database handle pDestDb.
//	*/
func Xsqlite3_backup_init(tls *libc.TLS, pDestDb uintptr, zDestDb uintptr, pSrcDb uintptr, zSrcDb uintptr) (r uintptr) {
	var nDest int32
	var p, pDest uintptr
	_, _, _ = nDest, p, pDest /* Value to return */
	/* Lock the source database handle. The destination database
	 ** handle is not locked in this routine, but it is locked in
	 ** sqlite3_backup_step(). The user is required to ensure that no
	 ** other thread accesses the destination handle for the duration
	 ** of the backup operation.  Any attempt to use the destination
	 ** database connection while a backup is in progress may cause
	 ** a malfunction or a deadlock.
	 */
	Xsqlite3_mutex_enter(tls, (*Tsqlite3)(unsafe.Pointer(pSrcDb)).Fmutex)
	Xsqlite3_mutex_enter(tls, (*Tsqlite3)(unsafe.Pointer(pDestDb)).Fmutex)
	if pSrcDb == pDestDb {
		_sqlite3ErrorWithMsg(tls, pDestDb, int32(SQLITE_ERROR), __ccgo_ts+5178, 0)
		p = uintptr(0)
	} else {
		nDest = _sqlite3Strlen30(tls, zDestDb)
		/* Allocate space for a new sqlite3_backup object...
		 ** EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
		 ** call to sqlite3_backup_init() and is destroyed by a call to
		 ** sqlite3_backup_finish(). */
		p = _sqlite3MallocZero(tls, uint64(uint32(52)+libc.Uint32FromInt32(nDest)+uint32(1)))
		if !(p != 0) {
			_sqlite3Error(tls, pDestDb, int32(SQLITE_NOMEM))
		} else {
			(*Tsqlite3_backup)(unsafe.Pointer(p)).FzDestDb = p + 1*52
			libc.Xmemcpy(tls, (*Tsqlite3_backup)(unsafe.Pointer(p)).FzDestDb, zDestDb, libc.Uint32FromInt32(nDest))
		}
	}
	/* If the allocation succeeded, populate the new object. */
	if p != 0 {
		/* Do not store the pointer to the destination b-tree at this point.
		 ** This is because there is nothing preventing it from being detached
		 ** or otherwise freed before the first call to sqlite3_backup_step()
		 ** on this object. The source b-tree does not have this problem, as
		 ** incrementing Btree.nBackup (see below) effectively locks the object. */
		pDest = _findBtree(tls, pDestDb, pDestDb, zDestDb)
		(*Tsqlite3_backup)(unsafe.Pointer(p)).FpSrc = _findBtree(tls, pDestDb, pSrcDb, zSrcDb)
		(*Tsqlite3_backup)(unsafe.Pointer(p)).FpDestDb = pDestDb
		(*Tsqlite3_backup)(unsafe.Pointer(p)).FpSrcDb = pSrcDb
		(*Tsqlite3_backup)(unsafe.Pointer(p)).FiNext = uint32(1)
		(*Tsqlite3_backup)(unsafe.Pointer(p)).FisAttached = 0
		if uintptr(0) == (*Tsqlite3_backup)(unsafe.Pointer(p)).FpSrc || uintptr(0) == pDest || _checkReadTransaction(tls, pDestDb, pDest) != SQLITE_OK {
			/* One (or both) of the named databases did not exist or an OOM
			 ** error was hit. Or there is a transaction open on the destination
			 ** database. The error has already been written into the pDestDb
			 ** handle. All that is left to do here is free the sqlite3_backup
			 ** structure.  */
			Xsqlite3_free(tls, p)
			p = uintptr(0)
		}
	}
	if p != 0 {
		(*TBtree)(unsafe.Pointer((*Tsqlite3_backup)(unsafe.Pointer(p)).FpSrc)).FnBackup = (*TBtree)(unsafe.Pointer((*Tsqlite3_backup)(unsafe.Pointer(p)).FpSrc)).FnBackup + 1
	}
	Xsqlite3_mutex_leave(tls, (*Tsqlite3)(unsafe.Pointer(pDestDb)).Fmutex)
	Xsqlite3_mutex_leave(tls, (*Tsqlite3)(unsafe.Pointer(pSrcDb)).Fmutex)
	return p
}

// C documentation
//
//	/*
//	** Open a blob handle.
//	*/
func Xsqlite3_blob_open(tls *libc.TLS, db uintptr, zDb uintptr, zTable uintptr, zColumn uintptr, iRow Tsqlite_int64, wrFlag int32, ppBlob uintptr) (r int32) {
	bp := tls.Alloc(304)
	defer tls.Free(304)
	var aOp, pBlob, pFKey, pIdx, pTab, v, zFault, v8 uintptr
	var iCol, iDb, j, j1, nAttempt, rc, v1 int32
	var v2 bool
	var _ /* sParse at bp+4 */ TParse
	var _ /* zErr at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = aOp, iCol, iDb, j, j1, nAttempt, pBlob, pFKey, pIdx, pTab, rc, v, zFault, v1, v2, v8
	nAttempt = 0 /* Index of zColumn in row-record */
	rc = SQLITE_OK
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	pBlob = uintptr(0)
	**(**uintptr)(__ccgo_up(ppBlob)) = uintptr(0)
	wrFlag = libc.BoolInt32(!!(wrFlag != 0)) /* wrFlag = (wrFlag ? 1 : 0); */
	Xsqlite3_mutex_enter(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex)
	pBlob = _sqlite3DbMallocZero(tls, db, uint64(32))
	for int32(1) != 0 {
		_sqlite3ParseObjectInit(tls, bp+4, db)
		if !(pBlob != 0) {
			goto blob_open_out
		}
		_sqlite3DbFree(tls, db, **(**uintptr)(__ccgo_up(bp)))
		**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
		_sqlite3BtreeEnterAll(tls, db)
		pTab = _sqlite3LocateTable(tls, bp+4, uint32(0), zTable, zDb)
		if pTab != 0 && libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) {
			pTab = uintptr(0)
			_sqlite3ErrorMsg(tls, bp+4, __ccgo_ts+6551, libc.VaList(bp+296, zTable))
		}
		if pTab != 0 && !((*TTable)(unsafe.Pointer(pTab)).FtabFlags&libc.Uint32FromInt32(TF_WithoutRowid) == libc.Uint32FromInt32(0)) {
			pTab = uintptr(0)
			_sqlite3ErrorMsg(tls, bp+4, __ccgo_ts+6581, libc.VaList(bp+296, zTable))
		}
		if pTab != 0 && (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_HasGenerated) != uint32(0) {
			pTab = uintptr(0)
			_sqlite3ErrorMsg(tls, bp+4, __ccgo_ts+6617, libc.VaList(bp+296, zTable))
		}
		if pTab != 0 && libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VIEW) {
			pTab = uintptr(0)
			_sqlite3ErrorMsg(tls, bp+4, __ccgo_ts+6662, libc.VaList(bp+296, zTable))
		}
		if v2 = pTab == uintptr(0); !v2 {
			v1 = _sqlite3SchemaToIndex(tls, db, (*TTable)(unsafe.Pointer(pTab)).FpSchema)
			iDb = v1
		}
		if v2 || v1 == int32(1) && _sqlite3OpenTempDatabase(tls, bp+4) != 0 {
			if (**(**TParse)(__ccgo_up(bp + 4))).FzErrMsg != 0 {
				_sqlite3DbFree(tls, db, **(**uintptr)(__ccgo_up(bp)))
				**(**uintptr)(__ccgo_up(bp)) = (**(**TParse)(__ccgo_up(bp + 4))).FzErrMsg
				(**(**TParse)(__ccgo_up(bp + 4))).FzErrMsg = uintptr(0)
			}
			rc = int32(SQLITE_ERROR)
			_sqlite3BtreeLeaveAll(tls, db)
			goto blob_open_out
		}
		(*TIncrblob)(unsafe.Pointer(pBlob)).FpTab = pTab
		(*TIncrblob)(unsafe.Pointer(pBlob)).FzDb = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FzDbSName
		/* Now search pTab for the exact column. */
		iCol = _sqlite3ColumnIndex(tls, pTab, zColumn)
		if iCol < 0 {
			_sqlite3DbFree(tls, db, **(**uintptr)(__ccgo_up(bp)))
			**(**uintptr)(__ccgo_up(bp)) = _sqlite3MPrintf(tls, db, __ccgo_ts+6683, libc.VaList(bp+296, zColumn))
			rc = int32(SQLITE_ERROR)
			_sqlite3BtreeLeaveAll(tls, db)
			goto blob_open_out
		}
		/* If the value is being opened for writing, check that the
		 ** column is not indexed, and that it is not part of a foreign key.
		 */
		if wrFlag != 0 {
			zFault = uintptr(0)
			if (*Tsqlite3)(unsafe.Pointer(db)).Fflags&uint64(SQLITE_ForeignKeys) != 0 {
				pFKey = (*(*struct {
					FaddColOffset int32
					FpFKey        uintptr
					FpDfltList    uintptr
				})(unsafe.Pointer(pTab + 44))).FpFKey
				for {
					if !(pFKey != 0) {
						break
					}
					j = 0
					for {
						if !(j < (*TFKey)(unsafe.Pointer(pFKey)).FnCol) {
							break
						}
						if (*(*TsColMap)(unsafe.Pointer(pFKey + 36 + uintptr(j)*8))).FiFrom == iCol {
							zFault = __ccgo_ts + 6704
						}
						goto _4
					_4:
						;
						j = j + 1
					}
					goto _3
				_3:
					;
					pFKey = (*TFKey)(unsafe.Pointer(pFKey)).FpNextFrom
				}
			}
			pIdx = (*TTable)(unsafe.Pointer(pTab)).FpIndex
			for {
				if !(pIdx != 0) {
					break
				}
				j1 = 0
				for {
					if !(j1 < libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pIdx)).FnKeyCol)) {
						break
					}
					/* FIXME: Be smarter about indexes that use expressions */
					if int32(**(**Ti16)(__ccgo_up((*TIndex)(unsafe.Pointer(pIdx)).FaiColumn + uintptr(j1)*2))) == iCol || int32(**(**Ti16)(__ccgo_up((*TIndex)(unsafe.Pointer(pIdx)).FaiColumn + uintptr(j1)*2))) == -int32(2) {
						zFault = __ccgo_ts + 6716
					}
					goto _6
				_6:
					;
					j1 = j1 + 1
				}
				goto _5
			_5:
				;
				pIdx = (*TIndex)(unsafe.Pointer(pIdx)).FpNext
			}
			if zFault != 0 {
				_sqlite3DbFree(tls, db, **(**uintptr)(__ccgo_up(bp)))
				**(**uintptr)(__ccgo_up(bp)) = _sqlite3MPrintf(tls, db, __ccgo_ts+6724, libc.VaList(bp+296, zFault))
				rc = int32(SQLITE_ERROR)
				_sqlite3BtreeLeaveAll(tls, db)
				goto blob_open_out
			}
		}
		(*TIncrblob)(unsafe.Pointer(pBlob)).FpStmt = _sqlite3VdbeCreate(tls, bp+4)
		if (*TIncrblob)(unsafe.Pointer(pBlob)).FpStmt != 0 {
			v = (*TIncrblob)(unsafe.Pointer(pBlob)).FpStmt
			_sqlite3VdbeAddOp4Int(tls, v, int32(OP_Transaction), iDb, wrFlag, (*TSchema)(unsafe.Pointer((*TTable)(unsafe.Pointer(pTab)).FpSchema)).Fschema_cookie, (*TSchema)(unsafe.Pointer((*TTable)(unsafe.Pointer(pTab)).FpSchema)).FiGeneration)
			_sqlite3VdbeChangeP5(tls, v, uint16(1))
			aOp = _sqlite3VdbeAddOpList(tls, v, libc.Int32FromUint32(libc.Uint32FromInt64(24)/libc.Uint32FromInt64(4)), uintptr(unsafe.Pointer(&_openBlob)), _iLn)
			/* Make sure a mutex is held on the table to be accessed */
			_sqlite3VdbeUsesBtree(tls, v, iDb)
			if libc.Int32FromUint8((*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed) == 0 {
				/* Configure the OP_TableLock instruction */
				(**(**TVdbeOp)(__ccgo_up(aOp))).Fp1 = iDb
				(**(**TVdbeOp)(__ccgo_up(aOp))).Fp2 = libc.Int32FromUint32((*TTable)(unsafe.Pointer(pTab)).Ftnum)
				(**(**TVdbeOp)(__ccgo_up(aOp))).Fp3 = wrFlag
				_sqlite3VdbeChangeP4(tls, v, int32(2), (*TTable)(unsafe.Pointer(pTab)).FzName, P4_TRANSIENT)
			}
			if libc.Int32FromUint8((*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed) == 0 {
				/* Remove either the OP_OpenWrite or OpenRead. Set the P2
				 ** parameter of the other to pTab->tnum.  */
				if wrFlag != 0 {
					(**(**TVdbeOp)(__ccgo_up(aOp + 1*20))).Fopcode = uint8(OP_OpenWrite)
				}
				(**(**TVdbeOp)(__ccgo_up(aOp + 1*20))).Fp2 = libc.Int32FromUint32((*TTable)(unsafe.Pointer(pTab)).Ftnum)
				(**(**TVdbeOp)(__ccgo_up(aOp + 1*20))).Fp3 = iDb
				/* Configure the number of columns. Configure the cursor to
				 ** think that the table has one more column than it really
				 ** does. An OP_Column to retrieve this imaginary column will
				 ** always return an SQL NULL. This is useful because it means
				 ** we can invoke OP_Column to fill in the vdbe cursors type
				 ** and offset cache without causing any IO.
				 */
				(**(**TVdbeOp)(__ccgo_up(aOp + 1*20))).Fp4type = int8(-libc.Int32FromInt32(3))
				*(*int32)(unsafe.Pointer(aOp + 1*20 + 16)) = int32((*TTable)(unsafe.Pointer(pTab)).FnCol) + int32(1)
				(**(**TVdbeOp)(__ccgo_up(aOp + 3*20))).Fp2 = int32((*TTable)(unsafe.Pointer(pTab)).FnCol)
				(**(**TParse)(__ccgo_up(bp + 4))).FnVar = 0
				(**(**TParse)(__ccgo_up(bp + 4))).FnMem = int32(1)
				(**(**TParse)(__ccgo_up(bp + 4))).FnTab = int32(1)
				_sqlite3VdbeMakeReady(tls, v, bp+4)
			}
		}
		(*TIncrblob)(unsafe.Pointer(pBlob)).FiCol = libc.Uint16FromInt32(iCol)
		(*TIncrblob)(unsafe.Pointer(pBlob)).Fdb = db
		_sqlite3BtreeLeaveAll(tls, db)
		if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
			goto blob_open_out
		}
		rc = _blobSeekToRow(tls, pBlob, iRow, bp)
		nAttempt = nAttempt + 1
		v1 = nAttempt
		if v1 >= int32(SQLITE_MAX_SCHEMA_RETRY) || rc != int32(SQLITE_SCHEMA) {
			break
		}
		_sqlite3ParseObjectReset(tls, bp+4)
	}
	goto blob_open_out
blob_open_out:
	;
	if rc == SQLITE_OK && libc.Int32FromUint8((*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed) == 0 {
		**(**uintptr)(__ccgo_up(ppBlob)) = pBlob
	} else {
		if pBlob != 0 && (*TIncrblob)(unsafe.Pointer(pBlob)).FpStmt != 0 {
			_sqlite3VdbeFinalize(tls, (*TIncrblob)(unsafe.Pointer(pBlob)).FpStmt)
		}
		_sqlite3DbFree(tls, db, pBlob)
	}
	if **(**uintptr)(__ccgo_up(bp)) != 0 {
		v8 = __ccgo_ts + 3942
	} else {
		v8 = libc.UintptrFromInt32(0)
	}
	_sqlite3ErrorWithMsg(tls, db, rc, v8, libc.VaList(bp+296, **(**uintptr)(__ccgo_up(bp))))
	_sqlite3DbFree(tls, db, **(**uintptr)(__ccgo_up(bp)))
	_sqlite3ParseObjectReset(tls, bp+4)
	rc = _sqlite3ApiExit(tls, db, rc)
	Xsqlite3_mutex_leave(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex)
	return rc
}

// C documentation
//
//	/*
//	** This function is used to set the schema of a virtual table.  It is only
//	** valid to call this function from within the xCreate() or xConnect() of a
//	** virtual table module.
//	*/
func Xsqlite3_declare_vtab(tls *libc.TLS, db uintptr, zCreateTable uintptr) (r int32) {
	bp := tls.Alloc(304)
	defer tls.Free(304)
	var i, initBusy, rc int32
	var pCtx, pIdx, pNew, pTab, z, v3 uintptr
	var v2 Ti16
	var _ /* sParse at bp+0 */ TParse
	var _ /* tokenType at bp+284 */ int32
	_, _, _, _, _, _, _, _, _, _ = i, initBusy, pCtx, pIdx, pNew, pTab, rc, z, v2, v3
	rc = SQLITE_OK
	/* Verify that the first two keywords in the CREATE TABLE statement
	 ** really are "CREATE" and "TABLE".  If this is not the case, then
	 ** sqlite3_declare_vtab() is being misused.
	 */
	z = zCreateTable
	i = 0
	for {
		if !(_aKeyword1[i] != 0) {
			break
		}
		**(**int32)(__ccgo_up(bp + 284)) = 0
		for cond := true; cond; cond = **(**int32)(__ccgo_up(bp + 284)) == int32(TK_SPACE) || **(**int32)(__ccgo_up(bp + 284)) == int32(TK_COMMENT) {
			z = z + uintptr(_sqlite3GetToken(tls, z, bp+284))
		}
		if **(**int32)(__ccgo_up(bp + 284)) != libc.Int32FromUint8(_aKeyword1[i]) {
			_sqlite3ErrorWithMsg(tls, db, int32(SQLITE_ERROR), __ccgo_ts+23607, 0)
			return int32(SQLITE_ERROR)
		}
		goto _1
	_1:
		;
		i = i + 1
	}
	Xsqlite3_mutex_enter(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex)
	pCtx = (*Tsqlite3)(unsafe.Pointer(db)).FpVtabCtx
	if !(pCtx != 0) || (*TVtabCtx)(unsafe.Pointer(pCtx)).FbDeclared != 0 {
		_sqlite3Error(tls, db, _sqlite3MisuseError(tls, int32(162730)))
		Xsqlite3_mutex_leave(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex)
		return _sqlite3MisuseError(tls, int32(162732))
	}
	pTab = (*TVtabCtx)(unsafe.Pointer(pCtx)).FpTab
	_sqlite3ParseObjectInit(tls, bp, db)
	(**(**TParse)(__ccgo_up(bp))).FeParseMode = uint8(PARSE_MODE_DECLARE_VTAB)
	libc.SetBitFieldPtr16Uint32(bp+28, libc.Uint32FromInt32(1), 0, 0x1)
	/* We should never be able to reach this point while loading the
	 ** schema.  Nevertheless, defend against that (turn off db->init.busy)
	 ** in case a bug arises. */
	initBusy = libc.Int32FromUint8((*Tsqlite3)(unsafe.Pointer(db)).Finit1.Fbusy)
	(*Tsqlite3)(unsafe.Pointer(db)).Finit1.Fbusy = uint8(0)
	(**(**TParse)(__ccgo_up(bp))).FnQueryLoop = int16(1)
	if SQLITE_OK == _sqlite3RunParser(tls, bp, zCreateTable) {
		if !((*TTable)(unsafe.Pointer(pTab)).FaCol != 0) {
			pNew = (**(**TParse)(__ccgo_up(bp))).FpNewTable
			(*TTable)(unsafe.Pointer(pTab)).FaCol = (*TTable)(unsafe.Pointer(pNew)).FaCol
			_sqlite3ExprListDelete(tls, db, (*(*struct {
				FaddColOffset int32
				FpFKey        uintptr
				FpDfltList    uintptr
			})(unsafe.Pointer(pNew + 44))).FpDfltList)
			v2 = (*TTable)(unsafe.Pointer(pNew)).FnCol
			(*TTable)(unsafe.Pointer(pTab)).FnCol = v2
			(*TTable)(unsafe.Pointer(pTab)).FnNVCol = v2
			**(**Tu32)(__ccgo_up(pTab + 28)) |= (*TTable)(unsafe.Pointer(pNew)).FtabFlags & libc.Uint32FromInt32(libc.Int32FromInt32(TF_WithoutRowid)|libc.Int32FromInt32(TF_NoVisibleRowid))
			(*TTable)(unsafe.Pointer(pNew)).FnCol = 0
			(*TTable)(unsafe.Pointer(pNew)).FaCol = uintptr(0)
			if !((*TTable)(unsafe.Pointer(pNew)).FtabFlags&libc.Uint32FromInt32(TF_WithoutRowid) == libc.Uint32FromInt32(0)) && (*Tsqlite3_module)(unsafe.Pointer((*TModule)(unsafe.Pointer((*TVTable)(unsafe.Pointer((*TVtabCtx)(unsafe.Pointer(pCtx)).FpVTable)).FpMod)).FpModule)).FxUpdate != uintptr(0) && libc.Int32FromUint16((*TIndex)(unsafe.Pointer(_sqlite3PrimaryKeyIndex(tls, pNew))).FnKeyCol) != int32(1) {
				/* WITHOUT ROWID virtual tables must either be read-only (xUpdate==0)
				 ** or else must have a single-column PRIMARY KEY */
				rc = int32(SQLITE_ERROR)
			}
			pIdx = (*TTable)(unsafe.Pointer(pNew)).FpIndex
			if pIdx != 0 {
				(*TTable)(unsafe.Pointer(pTab)).FpIndex = pIdx
				(*TTable)(unsafe.Pointer(pNew)).FpIndex = uintptr(0)
				(*TIndex)(unsafe.Pointer(pIdx)).FpTable = pTab
			}
		}
		(*TVtabCtx)(unsafe.Pointer(pCtx)).FbDeclared = int32(1)
	} else {
		if (**(**TParse)(__ccgo_up(bp))).FzErrMsg != 0 {
			v3 = __ccgo_ts + 3942
		} else {
			v3 = uintptr(0)
		}
		_sqlite3ErrorWithMsg(tls, db, int32(SQLITE_ERROR), v3, libc.VaList(bp+296, (**(**TParse)(__ccgo_up(bp))).FzErrMsg))
		_sqlite3DbFree(tls, db, (**(**TParse)(__ccgo_up(bp))).FzErrMsg)
		rc = int32(SQLITE_ERROR)
	}
	(**(**TParse)(__ccgo_up(bp))).FeParseMode = uint8(PARSE_MODE_NORMAL)
	if (**(**TParse)(__ccgo_up(bp))).FpVdbe != 0 {
		_sqlite3VdbeFinalize(tls, (**(**TParse)(__ccgo_up(bp))).FpVdbe)
	}
	_sqlite3DeleteTable(tls, db, (**(**TParse)(__ccgo_up(bp))).FpNewTable)
	_sqlite3ParseObjectReset(tls, bp)
	(*Tsqlite3)(unsafe.Pointer(db)).Finit1.Fbusy = libc.Uint8FromInt32(initBusy)
	rc = _sqlite3ApiExit(tls, db, rc)
	Xsqlite3_mutex_leave(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex)
	return rc
}

// C documentation
//
//	/*
//	** Query the database.  But instead of invoking a callback for each row,
//	** malloc() for space to hold the result and return the entire results
//	** at the conclusion of the call.
//	**
//	** The result that is written to ***pazResult is held in memory obtained
//	** from malloc().  But the caller cannot free this memory directly.
//	** Instead, the entire table should be passed to sqlite3_free_table() when
//	** the calling procedure is finished using it.
//	*/
func Xsqlite3_get_table(tls *libc.TLS, db uintptr, zSql uintptr, pazResult uintptr, pnRow uintptr, pnColumn uintptr, pzErrMsg uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var azNew uintptr
	var rc int32
	var _ /* res at bp+0 */ TTabResult
	_, _ = azNew, rc
	**(**uintptr)(__ccgo_up(pazResult)) = uintptr(0)
	if pnColumn != 0 {
		**(**int32)(__ccgo_up(pnColumn)) = 0
	}
	if pnRow != 0 {
		**(**int32)(__ccgo_up(pnRow)) = 0
	}
	if pzErrMsg != 0 {
		**(**uintptr)(__ccgo_up(pzErrMsg)) = uintptr(0)
	}
	(**(**TTabResult)(__ccgo_up(bp))).FzErrMsg = uintptr(0)
	(**(**TTabResult)(__ccgo_up(bp))).FnRow = uint32(0)
	(**(**TTabResult)(__ccgo_up(bp))).FnColumn = uint32(0)
	(**(**TTabResult)(__ccgo_up(bp))).FnData = uint32(1)
	(**(**TTabResult)(__ccgo_up(bp))).FnAlloc = uint32(20)
	(**(**TTabResult)(__ccgo_up(bp))).Frc = SQLITE_OK
	(**(**TTabResult)(__ccgo_up(bp))).FazResult = Xsqlite3_malloc64(tls, uint64(uint32(4)*(**(**TTabResult)(__ccgo_up(bp))).FnAlloc))
	if (**(**TTabResult)(__ccgo_up(bp))).FazResult == uintptr(0) {
		(*Tsqlite3)(unsafe.Pointer(db)).FerrCode = int32(SQLITE_NOMEM)
		return int32(SQLITE_NOMEM)
	}
	**(**uintptr)(__ccgo_up((**(**TTabResult)(__ccgo_up(bp))).FazResult)) = uintptr(0)
	rc = Xsqlite3_exec(tls, db, zSql, __ccgo_fp(_sqlite3_get_table_cb), bp, pzErrMsg)
	**(**uintptr)(__ccgo_up((**(**TTabResult)(__ccgo_up(bp))).FazResult)) = uintptr(libc.Int32FromUint32((**(**TTabResult)(__ccgo_up(bp))).FnData))
	if rc&int32(0xff) == int32(SQLITE_ABORT) {
		Xsqlite3_free_table(tls, (**(**TTabResult)(__ccgo_up(bp))).FazResult+1*4)
		if (**(**TTabResult)(__ccgo_up(bp))).FzErrMsg != 0 {
			if pzErrMsg != 0 {
				Xsqlite3_free(tls, **(**uintptr)(__ccgo_up(pzErrMsg)))
				**(**uintptr)(__ccgo_up(pzErrMsg)) = Xsqlite3_mprintf(tls, __ccgo_ts+3942, libc.VaList(bp+40, (**(**TTabResult)(__ccgo_up(bp))).FzErrMsg))
			}
			Xsqlite3_free(tls, (**(**TTabResult)(__ccgo_up(bp))).FzErrMsg)
		}
		(*Tsqlite3)(unsafe.Pointer(db)).FerrCode = (**(**TTabResult)(__ccgo_up(bp))).Frc /* Assume 32-bit assignment is atomic */
		return (**(**TTabResult)(__ccgo_up(bp))).Frc
	}
	Xsqlite3_free(tls, (**(**TTabResult)(__ccgo_up(bp))).FzErrMsg)
	if rc != SQLITE_OK {
		Xsqlite3_free_table(tls, (**(**TTabResult)(__ccgo_up(bp))).FazResult+1*4)
		return rc
	}
	if (**(**TTabResult)(__ccgo_up(bp))).FnAlloc > (**(**TTabResult)(__ccgo_up(bp))).FnData {
		azNew = _sqlite3Realloc(tls, (**(**TTabResult)(__ccgo_up(bp))).FazResult, uint64(uint32(4)*(**(**TTabResult)(__ccgo_up(bp))).FnData))
		if azNew == uintptr(0) {
			Xsqlite3_free_table(tls, (**(**TTabResult)(__ccgo_up(bp))).FazResult+1*4)
			(*Tsqlite3)(unsafe.Pointer(db)).FerrCode = int32(SQLITE_NOMEM)
			return int32(SQLITE_NOMEM)
		}
		(**(**TTabResult)(__ccgo_up(bp))).FazResult = azNew
	}
	**(**uintptr)(__ccgo_up(pazResult)) = (**(**TTabResult)(__ccgo_up(bp))).FazResult + 1*4
	if pnColumn != 0 {
		**(**int32)(__ccgo_up(pnColumn)) = libc.Int32FromUint32((**(**TTabResult)(__ccgo_up(bp))).FnColumn)
	}
	if pnRow != 0 {
		**(**int32)(__ccgo_up(pnRow)) = libc.Int32FromUint32((**(**TTabResult)(__ccgo_up(bp))).FnRow)
	}
	return rc
}

// C documentation
//
//	/*
//	** Return the serialization of a database
//	*/
func Xsqlite3_serialize(tls *libc.TLS, db uintptr, zSchema uintptr, piSize uintptr, mFlags uint32) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var iDb, nPage, pgno, rc, szPage, v1 int32
	var p, pBt, pOut, pPager, pStore, pTo, zSql uintptr
	var sz Tsqlite3_int64
	var _ /* pPage at bp+4 */ uintptr
	var _ /* pStmt at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = iDb, nPage, p, pBt, pOut, pPager, pStore, pTo, pgno, rc, sz, szPage, zSql, v1
	szPage = 0
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	pOut = uintptr(0)
	Xsqlite3_mutex_enter(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex)
	if zSchema == uintptr(0) {
		zSchema = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb))).FzDbSName
	}
	p = _memdbFromDbSchema(tls, db, zSchema)
	iDb = _sqlite3FindDbName(tls, db, zSchema)
	if piSize != 0 {
		**(**Tsqlite3_int64)(__ccgo_up(piSize)) = int64(-int32(1))
	}
	if iDb < 0 {
		goto serialize_out
	}
	if p != 0 {
		pStore = (*TMemFile)(unsafe.Pointer(p)).FpStore
		if piSize != 0 {
			**(**Tsqlite3_int64)(__ccgo_up(piSize)) = (*TMemStore)(unsafe.Pointer(pStore)).Fsz
		}
		if mFlags&uint32(SQLITE_SERIALIZE_NOCOPY) != 0 {
			pOut = (*TMemStore)(unsafe.Pointer(pStore)).FaData
		} else {
			pOut = Xsqlite3_malloc64(tls, libc.Uint64FromInt64((*TMemStore)(unsafe.Pointer(pStore)).Fsz))
			if pOut != 0 {
				libc.Xmemcpy(tls, pOut, (*TMemStore)(unsafe.Pointer(pStore)).FaData, libc.Uint32FromInt64((*TMemStore)(unsafe.Pointer(pStore)).Fsz))
			}
		}
		goto serialize_out
	}
	pBt = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FpBt
	if pBt == uintptr(0) {
		goto serialize_out
	}
	szPage = _sqlite3BtreeGetPageSize(tls, pBt)
	zSql = Xsqlite3_mprintf(tls, __ccgo_ts+4135, libc.VaList(bp+16, zSchema))
	if zSql != 0 {
		v1 = Xsqlite3_prepare_v2(tls, db, zSql, -int32(1), bp, uintptr(0))
	} else {
		v1 = int32(SQLITE_NOMEM)
	}
	rc = v1
	Xsqlite3_free(tls, zSql)
	if rc != 0 {
		goto serialize_out
	}
	rc = Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp)))
	if rc == int32(SQLITE_ROW) {
		sz = Xsqlite3_column_int64(tls, **(**uintptr)(__ccgo_up(bp)), 0) * int64(szPage)
		if sz == 0 {
			Xsqlite3_reset(tls, **(**uintptr)(__ccgo_up(bp)))
			Xsqlite3_exec(tls, db, __ccgo_ts+4158, uintptr(0), uintptr(0), uintptr(0))
			rc = Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp)))
			if rc == int32(SQLITE_ROW) {
				sz = Xsqlite3_column_int64(tls, **(**uintptr)(__ccgo_up(bp)), 0) * int64(szPage)
			}
		}
		if piSize != 0 {
			**(**Tsqlite3_int64)(__ccgo_up(piSize)) = sz
		}
		if mFlags&uint32(SQLITE_SERIALIZE_NOCOPY) != 0 {
			pOut = uintptr(0)
		} else {
			pOut = Xsqlite3_malloc64(tls, libc.Uint64FromInt64(sz))
			if pOut != 0 {
				nPage = Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), 0)
				pPager = _sqlite3BtreePager(tls, pBt)
				pgno = int32(1)
				for {
					if !(pgno <= nPage) {
						break
					}
					**(**uintptr)(__ccgo_up(bp + 4)) = uintptr(0)
					pTo = pOut + uintptr(int64(szPage)*int64(pgno-libc.Int32FromInt32(1)))
					rc = _sqlite3PagerGet(tls, pPager, libc.Uint32FromInt32(pgno), bp+4, 0)
					if rc == SQLITE_OK {
						libc.Xmemcpy(tls, pTo, _sqlite3PagerGetData(tls, **(**uintptr)(__ccgo_up(bp + 4))), libc.Uint32FromInt32(szPage))
					} else {
						libc.Xmemset(tls, pTo, 0, libc.Uint32FromInt32(szPage))
					}
					_sqlite3PagerUnref(tls, **(**uintptr)(__ccgo_up(bp + 4)))
					goto _2
				_2:
					;
					pgno = pgno + 1
				}
			}
		}
	}
	Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp)))
	goto serialize_out
serialize_out:
	;
	Xsqlite3_mutex_leave(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex)
	return pOut
}

// C documentation
//
//	/*
//	** Return meta information about a specific column of a database table.
//	** See comment in sqlite3.h (sqlite.h.in) for details.
//	*/
func Xsqlite3_table_column_metadata(tls *libc.TLS, db uintptr, zDbName uintptr, zTableName uintptr, zColumnName uintptr, pzDataType uintptr, pzCollSeq uintptr, pNotNull uintptr, pPrimaryKey uintptr, pAutoinc uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var autoinc, iCol, notnull, primarykey, rc int32
	var pCol, pTab, zCollSeq, zDataType, v1 uintptr
	var _ /* zErrMsg at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _ = autoinc, iCol, notnull, pCol, pTab, primarykey, rc, zCollSeq, zDataType, v1
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	pTab = uintptr(0)
	pCol = uintptr(0)
	iCol = 0
	zDataType = uintptr(0)
	zCollSeq = uintptr(0)
	notnull = 0
	primarykey = 0
	autoinc = 0
	/* Ensure the database schema has been loaded */
	Xsqlite3_mutex_enter(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex)
	_sqlite3BtreeEnterAll(tls, db)
	rc = _sqlite3Init(tls, db, bp)
	if SQLITE_OK != rc {
		goto error_out
	}
	/* Locate the table in question */
	pTab = _sqlite3FindTable(tls, db, zTableName, zDbName)
	if !(pTab != 0) || libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VIEW) {
		pTab = uintptr(0)
		goto error_out
	}
	/* Find the column for which info is requested */
	if zColumnName == uintptr(0) {
		/* Query for existence of table only */
	} else {
		iCol = _sqlite3ColumnIndex(tls, pTab, zColumnName)
		if iCol >= 0 {
			pCol = (*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(iCol)*12
		} else {
			if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_WithoutRowid) == uint32(0) && _sqlite3IsRowid(tls, zColumnName) != 0 {
				iCol = int32((*TTable)(unsafe.Pointer(pTab)).FiPKey)
				if iCol >= 0 {
					v1 = (*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(iCol)*12
				} else {
					v1 = uintptr(0)
				}
				pCol = v1
			} else {
				pTab = uintptr(0)
				goto error_out
			}
		}
	}
	/* The following block stores the meta information that will be returned
	 ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
	 ** and autoinc. At this point there are two possibilities:
	 **
	 **     1. The specified column name was rowid", "oid" or "_rowid_"
	 **        and there is no explicitly declared IPK column.
	 **
	 **     2. The table is not a view and the column name identified an
	 **        explicitly declared column. Copy meta information from *pCol.
	 */
	if pCol != 0 {
		zDataType = _sqlite3ColumnType(tls, pCol, uintptr(0))
		zCollSeq = _sqlite3ColumnColl(tls, pCol)
		notnull = libc.BoolInt32(int32(uint32(*(*uint8)(unsafe.Pointer(pCol + 4))&0xf>>0)) != 0)
		primarykey = libc.BoolInt32(libc.Int32FromUint16((*TColumn)(unsafe.Pointer(pCol)).FcolFlags)&int32(COLFLAG_PRIMKEY) != 0)
		autoinc = libc.BoolInt32(int32((*TTable)(unsafe.Pointer(pTab)).FiPKey) == iCol && (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_Autoincrement) != uint32(0))
	} else {
		zDataType = __ccgo_ts + 1176
		primarykey = int32(1)
	}
	if !(zCollSeq != 0) {
		zCollSeq = uintptr(unsafe.Pointer(&_sqlite3StrBINARY))
	}
	goto error_out
error_out:
	;
	_sqlite3BtreeLeaveAll(tls, db)
	/* Whether the function call succeeded or failed, set the output parameters
	 ** to whatever their local counterparts contain. If an error did occur,
	 ** this has the effect of zeroing all output parameters.
	 */
	if pzDataType != 0 {
		**(**uintptr)(__ccgo_up(pzDataType)) = zDataType
	}
	if pzCollSeq != 0 {
		**(**uintptr)(__ccgo_up(pzCollSeq)) = zCollSeq
	}
	if pNotNull != 0 {
		**(**int32)(__ccgo_up(pNotNull)) = notnull
	}
	if pPrimaryKey != 0 {
		**(**int32)(__ccgo_up(pPrimaryKey)) = primarykey
	}
	if pAutoinc != 0 {
		**(**int32)(__ccgo_up(pAutoinc)) = autoinc
	}
	if SQLITE_OK == rc && !(pTab != 0) {
		_sqlite3DbFree(tls, db, **(**uintptr)(__ccgo_up(bp)))
		**(**uintptr)(__ccgo_up(bp)) = _sqlite3MPrintf(tls, db, __ccgo_ts+26338, libc.VaList(bp+16, zTableName, zColumnName))
		rc = int32(SQLITE_ERROR)
	}
	if **(**uintptr)(__ccgo_up(bp)) != 0 {
		v1 = __ccgo_ts + 3942
	} else {
		v1 = uintptr(0)
	}
	_sqlite3ErrorWithMsg(tls, db, rc, v1, libc.VaList(bp+16, **(**uintptr)(__ccgo_up(bp))))
	_sqlite3DbFree(tls, db, **(**uintptr)(__ccgo_up(bp)))
	rc = _sqlite3ApiExit(tls, db, rc)
	Xsqlite3_mutex_leave(tls, (*Tsqlite3)(unsafe.Pointer(db)).Fmutex)
	return rc
}

// C documentation
//
//	/*
//	** Begin adding a change to a changegroup object.
//	*/
func Xsqlite3changegroup_change_begin(tls *libc.TLS, pGrp uintptr, eOp int32, zTab uintptr, bIndirect int32, pzErr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var aBuf uintptr
	var nReq, rc, v1 int32
	var _ /* pTab at bp+0 */ uintptr
	_, _, _, _ = aBuf, nReq, rc, v1
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	rc = SQLITE_OK
	if (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FpTab != 0 {
		rc = int32(SQLITE_MISUSE)
	} else {
		if eOp != int32(SQLITE_INSERT) && eOp != int32(SQLITE_UPDATE) && eOp != int32(SQLITE_DELETE) {
			rc = int32(SQLITE_ERROR)
		} else {
			rc = _sessionChangesetFindTable(tls, pGrp, zTab, uintptr(0), bp)
		}
	}
	if rc == SQLITE_OK {
		if **(**uintptr)(__ccgo_up(bp)) == uintptr(0) {
			if pzErr != 0 {
				**(**uintptr)(__ccgo_up(pzErr)) = Xsqlite3_mprintf(tls, __ccgo_ts+21341, libc.VaList(bp+16, zTab))
			}
			rc = int32(SQLITE_ERROR)
		} else {
			if eOp == int32(SQLITE_UPDATE) {
				v1 = int32(2)
			} else {
				v1 = int32(1)
			}
			nReq = (*TSessionTable)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp)))).FnCol * v1
			(*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FpTab = **(**uintptr)(__ccgo_up(bp))
			(*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FeOp = eOp
			(*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FbIndirect = bIndirect
			if (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FnBufAlloc < nReq {
				aBuf = Xsqlite3_realloc(tls, (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FaBuf, libc.Int32FromUint32(libc.Uint32FromInt32(nReq)*uint32(12)))
				if aBuf == uintptr(0) {
					rc = int32(SQLITE_NOMEM)
				} else {
					libc.Xmemset(tls, aBuf+uintptr((*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FnBufAlloc)*12, 0, uint32(12)*libc.Uint32FromInt32(nReq-(*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FnBufAlloc))
					(*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FaBuf = aBuf
					(*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FnBufAlloc = nReq
				}
			}
		}
	}
	return rc
}

// C documentation
//
//	/*
//	** Finish any change currently being constructed by the changegroup object.
//	*/
func Xsqlite3changegroup_change_finish(tls *libc.TLS, pGrp uintptr, bDiscard int32, pzErr uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var aBuf, p, v2, v3 uintptr
	var eUndef Tu8
	var ii, isPK, nBuf, nZero, v7 int32
	var _ /* rc at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _ = aBuf, eUndef, ii, isPK, nBuf, nZero, p, v2, v3, v7
	**(**int32)(__ccgo_up(bp)) = SQLITE_OK
	if (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FpTab != 0 {
		aBuf = (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FaBuf
		if bDiscard == 0 {
			nBuf = (*TSessionTable)(unsafe.Pointer((*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FpTab)).FnCol
			eUndef = uint8(SQLITE_NULL)
			if (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FeOp == int32(SQLITE_UPDATE) {
				ii = 0
				for {
					if !(ii < nBuf) {
						break
					}
					if **(**Tu8)(__ccgo_up((*TSessionTable)(unsafe.Pointer((*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FpTab)).FabPK + uintptr(ii))) != 0 {
						if (**(**TSessionBuffer)(__ccgo_up(aBuf + uintptr(ii)*12))).FnBuf <= int32(1) {
							if (**(**TSessionBuffer)(__ccgo_up(aBuf + uintptr(ii)*12))).FnBuf == int32(1) {
								v2 = __ccgo_ts + 1688
							} else {
								v2 = __ccgo_ts + 36828
							}
							**(**uintptr)(__ccgo_up(pzErr)) = Xsqlite3_mprintf(tls, __ccgo_ts+36838, libc.VaList(bp+16, v2))
							**(**int32)(__ccgo_up(bp)) = int32(SQLITE_ERROR)
							break
						} else {
							if (**(**TSessionBuffer)(__ccgo_up(aBuf + uintptr(ii+nBuf)*12))).FnBuf > 0 {
								**(**uintptr)(__ccgo_up(pzErr)) = Xsqlite3_mprintf(tls, __ccgo_ts+36885, 0)
								**(**int32)(__ccgo_up(bp)) = int32(SQLITE_ERROR)
								break
							}
						}
					} else {
						if (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).FbPatch == 0 && libc.BoolInt32((**(**TSessionBuffer)(__ccgo_up(aBuf + uintptr(ii)*12))).FnBuf > 0) != libc.BoolInt32((**(**TSessionBuffer)(__ccgo_up(aBuf + uintptr(ii+nBuf)*12))).FnBuf > 0) {
							if (**(**TSessionBuffer)(__ccgo_up(aBuf + uintptr(ii)*12))).FnBuf != 0 {
								v2 = __ccgo_ts + 1702
							} else {
								v2 = __ccgo_ts + 36937
							}
							if (**(**TSessionBuffer)(__ccgo_up(aBuf + uintptr(ii+nBuf)*12))).FnBuf != 0 {
								v3 = __ccgo_ts + 1702
							} else {
								v3 = __ccgo_ts + 36937
							}
							**(**uintptr)(__ccgo_up(pzErr)) = Xsqlite3_mprintf(tls, __ccgo_ts+36940, libc.VaList(bp+16, ii, v2, v3))
							**(**int32)(__ccgo_up(bp)) = int32(SQLITE_ERROR)
							break
						}
					}
					goto _1
				_1:
					;
					ii = ii + 1
				}
				eUndef = uint8(0x00)
				if (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).FbPatch == 0 {
					nBuf = nBuf * int32(2)
				}
			} else {
				ii = 0
				for {
					if !(ii < nBuf) {
						break
					}
					isPK = libc.Int32FromUint8(**(**Tu8)(__ccgo_up((*TSessionTable)(unsafe.Pointer((*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FpTab)).FabPK + uintptr(ii))))
					if ((*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FeOp == int32(SQLITE_INSERT) || (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).FbPatch == 0 || isPK != 0) && (**(**TSessionBuffer)(__ccgo_up(aBuf + uintptr(ii)*12))).FnBuf == 0 {
						**(**uintptr)(__ccgo_up(pzErr)) = Xsqlite3_mprintf(tls, __ccgo_ts+37016, libc.VaList(bp+16, ii))
						**(**int32)(__ccgo_up(bp)) = int32(SQLITE_ERROR)
						break
					}
					if (**(**TSessionBuffer)(__ccgo_up(aBuf + uintptr(ii)*12))).FnBuf == int32(1) && isPK != 0 {
						**(**uintptr)(__ccgo_up(pzErr)) = Xsqlite3_mprintf(tls, __ccgo_ts+37055, 0)
						**(**int32)(__ccgo_up(bp)) = int32(SQLITE_ERROR)
						break
					}
					goto _5
				_5:
					;
					ii = ii + 1
				}
			}
			(*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.Frecord.FnBuf = 0
			ii = 0
			for {
				if !(ii < nBuf) {
					break
				}
				p = (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FaBuf + uintptr(ii)*12
				if (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).FbPatch != 0 {
					if libc.Int32FromUint8(**(**Tu8)(__ccgo_up((*TSessionTable)(unsafe.Pointer((*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FpTab)).FabPK + uintptr(ii)))) == 0 {
						if (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FeOp == int32(SQLITE_UPDATE) {
							p = p + uintptr((*TSessionTable)(unsafe.Pointer((*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FpTab)).FnCol)*12
						} else {
							if (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FeOp == int32(SQLITE_DELETE) {
								goto _6
							}
						}
					}
				}
				if (*TSessionBuffer)(unsafe.Pointer(p)).FnBuf != 0 {
					v7 = (*TSessionBuffer)(unsafe.Pointer(p)).FnBuf
				} else {
					v7 = int32(1)
				}
				if 0 == _sessionBufferGrow(tls, pGrp+32+20, int64(v7), bp) {
					if (*TSessionBuffer)(unsafe.Pointer(p)).FnBuf != 0 {
						libc.Xmemcpy(tls, (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.Frecord.FaBuf+uintptr((*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.Frecord.FnBuf), (*TSessionBuffer)(unsafe.Pointer(p)).FaBuf, libc.Uint32FromInt32((*TSessionBuffer)(unsafe.Pointer(p)).FnBuf))
						(*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.Frecord.FnBuf += (*TSessionBuffer)(unsafe.Pointer(p)).FnBuf
					} else {
						v2 = pGrp + 32 + 20 + 4
						v7 = *(*int32)(unsafe.Pointer(v2))
						*(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1
						**(**Tu8)(__ccgo_up((*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.Frecord.FaBuf + uintptr(v7))) = eUndef
					}
				}
				goto _6
			_6:
				;
				ii = ii + 1
			}
			if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
				**(**int32)(__ccgo_up(bp)) = _sessionOneChangeToHash(tls, pGrp, (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FpTab, (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FeOp, (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FbIndirect, (*TSessionTable)(unsafe.Pointer((*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FpTab)).FnCol, (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.Frecord.FaBuf, (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.Frecord.FnBuf, 0)
			}
		}
		/* Reset all aBuf[] entries to "undefined". */
		nZero = (*TSessionTable)(unsafe.Pointer((*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FpTab)).FnCol
		if (*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FeOp == int32(SQLITE_UPDATE) {
			nZero = nZero + nZero
		}
		ii = 0
		for {
			if !(ii < nZero) {
				break
			}
			(**(**TSessionBuffer)(__ccgo_up((*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FaBuf + uintptr(ii)*12))).FnBuf = 0
			goto _10
		_10:
			;
			ii = ii + 1
		}
		(*Tsqlite3_changegroup)(unsafe.Pointer(pGrp)).Fcd.FpTab = uintptr(0)
	}
	return **(**int32)(__ccgo_up(bp))
}

/************** End of sqlite3session.c **************************************/
/************** Begin file fts5.c ********************************************/

/*
** This, the "fts5.c" source file, is a composite file that is itself
** assembled from the following files:
**
**    fts5.h
**    fts5Int.h
**    fts5parse.h          <--- Generated from fts5parse.y by Lemon
**    fts5parse.c          <--- Generated from fts5parse.y by Lemon
**    fts5_aux.c
**    fts5_buffer.c
**    fts5_config.c
**    fts5_expr.c
**    fts5_hash.c
**    fts5_index.c
**    fts5_main.c
**    fts5_storage.c
**    fts5_tokenize.c
**    fts5_unicode2.c
**    fts5_varint.c
**    fts5_vocab.c
 */

/*
** 2014 May 31
**
** 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.
**
******************************************************************************
**
** Interfaces to extend FTS5. Using the interfaces defined in this file,
** FTS5 may be extended with:
**
**     * custom tokenizers, and
**     * custom auxiliary functions.
 */

/*
** 2014 May 31
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:
**
**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
******************************************************************************
**
 */

/* #include "fts5.h" */
/* #include "sqlite3ext.h" */

/* #include <string.h> */
/* #include <assert.h> */
/* #include <stddef.h> */

/*
** Constants for the largest and smallest possible 32-bit signed integers.
 */

/* Truncate very long tokens to this many bytes. Hard limit is
** (65536-1-1-4-9)==65521 bytes. The limiting factor is the 16-bit offset
** field that occurs at the start of each leaf page (see fts5_index.c). */

/*
** Maximum number of prefix indexes on single FTS5 table. This must be
** less than 32. If it is set to anything large than that, an #error
** directive in fts5_index.c will cause the build to fail.
 */

/*
** Maximum segments permitted in a single index
 */

/* Name of rank and rowid columns */

/*
** The assert_nc() macro is similar to the assert() macro, except that it
** is used for assert() conditions that are true only if it can be
** guranteed that the database is not corrupt.
 */

/*
** A version of memcmp() that does not cause asan errors if one of the pointer
** parameters is NULL and the number of bytes to compare is zero.
 */

/* Mark a function parameter as unused, to suppress nuisance compiler
** warnings. */

// C documentation
//
//	/*
//	** Open a handle to begin or resume an RBU VACUUM operation.
//	*/
func Xsqlite3rbu_vacuum(tls *libc.TLS, zTarget uintptr, zState uintptr) (r uintptr) {
	var n Tsize_t
	_ = n
	if zTarget == uintptr(0) {
		return _rbuMisuseError(tls)
	}
	if zState != 0 {
		n = libc.Xstrlen(tls, zState)
		if n >= uint32(7) && 0 == libc.Xmemcmp(tls, __ccgo_ts+34674, zState+uintptr(n-uint32(7)), uint32(7)) {
			return _rbuMisuseError(tls)
		}
	}
	/* TODO: Check that both arguments are non-NULL */
	return _openRbuHandle(tls, uintptr(0), zTarget, zState)
}

func Xsqlite3session_diff(tls *libc.TLS, pSession uintptr, zFrom uintptr, zTbl uintptr, pzErrMsg uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var bHasPk, bMismatch, i, rc int32
	var db, zDb, zDbExists, zExpr, v1 uintptr
	var _ /* abPK at bp+24 */ uintptr
	var _ /* azCol at bp+28 */ uintptr
	var _ /* bRowid at bp+20 */ int32
	var _ /* d at bp+0 */ TSessionDiffCtx
	var _ /* nCol at bp+16 */ int32
	var _ /* pDbExists at bp+32 */ uintptr
	var _ /* pTo at bp+12 */ uintptr
	_, _, _, _, _, _, _, _, _ = bHasPk, bMismatch, db, i, rc, zDb, zDbExists, zExpr, v1
	zDb = (*Tsqlite3_session)(unsafe.Pointer(pSession)).FzDb
	rc = (*Tsqlite3_session)(unsafe.Pointer(pSession)).Frc
	libc.Xmemset(tls, bp, 0, uint32(12))
	_sessionDiffHooks(tls, pSession, bp)
	Xsqlite3_mutex_enter(tls, Xsqlite3_db_mutex(tls, (*Tsqlite3_session)(unsafe.Pointer(pSession)).Fdb))
	if pzErrMsg != 0 {
		**(**uintptr)(__ccgo_up(pzErrMsg)) = uintptr(0)
	}
	if rc == SQLITE_OK {
		zExpr = uintptr(0)
		db = (*Tsqlite3_session)(unsafe.Pointer(pSession)).Fdb /* Table zTbl */
		/* Locate and if necessary initialize the target table object */
		(*Tsqlite3_session)(unsafe.Pointer(pSession)).FbAutoAttach = (*Tsqlite3_session)(unsafe.Pointer(pSession)).FbAutoAttach + 1
		rc = _sessionFindTable(tls, pSession, zTbl, bp+12)
		(*Tsqlite3_session)(unsafe.Pointer(pSession)).FbAutoAttach = (*Tsqlite3_session)(unsafe.Pointer(pSession)).FbAutoAttach - 1
		if **(**uintptr)(__ccgo_up(bp + 12)) == uintptr(0) {
			goto diff_out
		}
		if _sessionInitTable(tls, pSession, **(**uintptr)(__ccgo_up(bp + 12)), (*Tsqlite3_session)(unsafe.Pointer(pSession)).Fdb, (*Tsqlite3_session)(unsafe.Pointer(pSession)).FzDb) != 0 {
			rc = (*Tsqlite3_session)(unsafe.Pointer(pSession)).Frc
			goto diff_out
		}
		/* Check the table schemas match */
		if rc == SQLITE_OK {
			bHasPk = 0
			bMismatch = 0
			**(**int32)(__ccgo_up(bp + 16)) = 0 /* Columns in zFrom.zTbl */
			**(**int32)(__ccgo_up(bp + 20)) = 0
			**(**uintptr)(__ccgo_up(bp + 24)) = uintptr(0)
			**(**uintptr)(__ccgo_up(bp + 28)) = uintptr(0)
			zDbExists = uintptr(0)
			/* Check that database zFrom is attached.  */
			zDbExists = Xsqlite3_mprintf(tls, __ccgo_ts+35605, libc.VaList(bp+48, zFrom))
			if zDbExists == uintptr(0) {
				rc = int32(SQLITE_NOMEM)
			} else {
				**(**uintptr)(__ccgo_up(bp + 32)) = uintptr(0)
				rc = Xsqlite3_prepare_v2(tls, db, zDbExists, -int32(1), bp+32, uintptr(0))
				if rc == int32(SQLITE_ERROR) {
					rc = SQLITE_OK
					**(**int32)(__ccgo_up(bp + 16)) = -int32(1)
				}
				Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp + 32)))
				Xsqlite3_free(tls, zDbExists)
			}
			if rc == SQLITE_OK && **(**int32)(__ccgo_up(bp + 16)) == 0 {
				if (*Tsqlite3_session)(unsafe.Pointer(pSession)).FbImplicitPK != 0 {
					v1 = bp + 20
				} else {
					v1 = uintptr(0)
				}
				rc = _sessionTableInfo(tls, uintptr(0), db, zFrom, zTbl, bp+16, uintptr(0), uintptr(0), bp+28, uintptr(0), uintptr(0), bp+24, v1)
			}
			if rc == SQLITE_OK {
				if (*TSessionTable)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 12)))).FnCol != **(**int32)(__ccgo_up(bp + 16)) {
					if **(**int32)(__ccgo_up(bp + 16)) <= 0 {
						rc = int32(SQLITE_SCHEMA)
						if pzErrMsg != 0 {
							**(**uintptr)(__ccgo_up(pzErrMsg)) = Xsqlite3_mprintf(tls, __ccgo_ts+35636, libc.VaList(bp+48, zFrom, zTbl))
						}
					} else {
						bMismatch = int32(1)
					}
				} else {
					i = 0
					for {
						if !(i < **(**int32)(__ccgo_up(bp + 16))) {
							break
						}
						if libc.Int32FromUint8(**(**Tu8)(__ccgo_up((*TSessionTable)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 12)))).FabPK + uintptr(i)))) != libc.Int32FromUint8(**(**Tu8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 24)) + uintptr(i)))) {
							bMismatch = int32(1)
						}
						if Xsqlite3_stricmp(tls, **(**uintptr)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 28)) + uintptr(i)*4)), **(**uintptr)(__ccgo_up((*TSessionTable)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 12)))).FazCol + uintptr(i)*4))) != 0 {
							bMismatch = int32(1)
						}
						if **(**Tu8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 24)) + uintptr(i))) != 0 {
							bHasPk = int32(1)
						}
						goto _2
					_2:
						;
						i = i + 1
					}
				}
			}
			Xsqlite3_free(tls, **(**uintptr)(__ccgo_up(bp + 28)))
			if bMismatch != 0 {
				if pzErrMsg != 0 {
					**(**uintptr)(__ccgo_up(pzErrMsg)) = Xsqlite3_mprintf(tls, __ccgo_ts+35657, 0)
				}
				rc = int32(SQLITE_SCHEMA)
			}
			if bHasPk == 0 {
				/* Ignore tables with no primary keys */
				goto diff_out
			}
		}
		if rc == SQLITE_OK {
			zExpr = _sessionExprComparePK(tls, (*TSessionTable)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 12)))).FnCol, zDb, zFrom, (*TSessionTable)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 12)))).FzName, (*TSessionTable)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 12)))).FazCol, (*TSessionTable)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 12)))).FabPK)
		}
		/* Find new rows */
		if rc == SQLITE_OK {
			rc = _sessionDiffFindNew(tls, int32(SQLITE_INSERT), pSession, **(**uintptr)(__ccgo_up(bp + 12)), zDb, zFrom, zExpr)
		}
		/* Find old rows */
		if rc == SQLITE_OK {
			rc = _sessionDiffFindNew(tls, int32(SQLITE_DELETE), pSession, **(**uintptr)(__ccgo_up(bp + 12)), zFrom, zDb, zExpr)
		}
		/* Find modified rows */
		if rc == SQLITE_OK {
			rc = _sessionDiffFindModified(tls, pSession, **(**uintptr)(__ccgo_up(bp + 12)), zFrom, zExpr)
		}
		Xsqlite3_free(tls, zExpr)
	}
	goto diff_out
diff_out:
	;
	_sessionPreupdateHooks(tls, pSession)
	Xsqlite3_mutex_leave(tls, Xsqlite3_db_mutex(tls, (*Tsqlite3_session)(unsafe.Pointer(pSession)).Fdb))
	return rc
}

const __INTPTR_FMTd__ = "d"

const __INTPTR_FMTi__ = "i"

const __LONG_BIT = 32

const __LONG_MIN = -2147483648

const __POINTER_WIDTH__ = 32

const __PTRDIFF_FMTd__ = "d"

const __PTRDIFF_FMTi__ = "i"

const __SIZE_FMTX__ = "X"

const __SIZE_FMTo__ = "o"

const __SIZE_FMTu__ = "u"

const __SIZE_FMTx__ = "x"

const __SIZE_T_MAX = 4294967295

const __SSIZE_MAX = 2147483647

const __UINTPTR_FMTX__ = "X"

const __UINTPTR_FMTo__ = "o"

const __UINTPTR_FMTu__ = "u"

const __UINTPTR_FMTx__ = "x"

const __UINTPTR_WIDTH__ = 32

const __ULONG_MAX = 4294967295

const __WORDSIZE = 32

var _aBase = [27]Tu64{
	0:  libc.Uint64FromUint64(0x8000000000000000),
	1:  libc.Uint64FromUint64(0xa000000000000000),
	2:  libc.Uint64FromUint64(0xc800000000000000),
	3:  libc.Uint64FromUint64(0xfa00000000000000),
	4:  libc.Uint64FromUint64(0x9c40000000000000),
	5:  libc.Uint64FromUint64(0xc350000000000000),
	6:  libc.Uint64FromUint64(0xf424000000000000),
	7:  libc.Uint64FromUint64(0x9896800000000000),
	8:  libc.Uint64FromUint64(0xbebc200000000000),
	9:  libc.Uint64FromUint64(0xee6b280000000000),
	10: libc.Uint64FromUint64(0x9502f90000000000),
	11: libc.Uint64FromUint64(0xba43b74000000000),
	12: libc.Uint64FromUint64(0xe8d4a51000000000),
	13: libc.Uint64FromUint64(0x9184e72a00000000),
	14: libc.Uint64FromUint64(0xb5e620f480000000),
	15: libc.Uint64FromUint64(0xe35fa931a0000000),
	16: libc.Uint64FromUint64(0x8e1bc9bf04000000),
	17: libc.Uint64FromUint64(0xb1a2bc2ec5000000),
	18: libc.Uint64FromUint64(0xde0b6b3a76400000),
	19: libc.Uint64FromUint64(0x8ac7230489e80000),
	20: libc.Uint64FromUint64(0xad78ebc5ac620000),
	21: libc.Uint64FromUint64(0xd8d726b7177a8000),
	22: libc.Uint64FromUint64(0x878678326eac9000),
	23: libc.Uint64FromUint64(0xa968163f0a57b400),
	24: libc.Uint64FromUint64(0xd3c21bcecceda100),
	25: libc.Uint64FromUint64(0x84595161401484a0),
	26: libc.Uint64FromUint64(0xa56fa5b99019a5c8),
}

/*
 ** The following array holds FuncDef structures for all of the functions
 ** defined in this file.
 **
 ** The array cannot be constant since changes are made to the
 ** FuncDef.pHash elements at start-time.  The elements of this array
 ** are read-only after initialization is complete.
 **
 ** For peak efficiency, put the most frequently used function last.
 */
var _aBuiltinFunc = [106]TFuncDef{
	0: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_FUNC_INTERNAL) | libc.Int32FromInt32(SQLITE_FUNC_TEST) | libc.Int32FromInt32(SQLITE_FUNC_INLINE) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(0)),
		FpUserData: uintptr(libc.Int32FromInt32(INLINEFUNC_implies_nonnull_row)),
		FzName:     __ccgo_ts + 16612,
	},
	1: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_FUNC_INTERNAL) | libc.Int32FromInt32(SQLITE_FUNC_TEST) | libc.Int32FromInt32(SQLITE_FUNC_INLINE) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(0)),
		FpUserData: uintptr(libc.Int32FromInt32(INLINEFUNC_expr_compare)),
		FzName:     __ccgo_ts + 16632,
	},
	2: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_FUNC_INTERNAL) | libc.Int32FromInt32(SQLITE_FUNC_TEST) | libc.Int32FromInt32(SQLITE_FUNC_INLINE) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(0)),
		FpUserData: uintptr(libc.Int32FromInt32(INLINEFUNC_expr_implies_expr)),
		FzName:     __ccgo_ts + 16645,
	},
	3: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_FUNC_INTERNAL) | libc.Int32FromInt32(SQLITE_FUNC_TEST) | libc.Int32FromInt32(SQLITE_FUNC_INLINE) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(0)),
		FpUserData: uintptr(libc.Int32FromInt32(INLINEFUNC_affinity)),
		FzName:     __ccgo_ts + 16663,
	},
	4: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16672,
	},
	5: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_DIRECTONLY) | libc.Int32FromInt32(SQLITE_FUNC_UNSAFE)),
		FzName:     __ccgo_ts + 16680,
	},
	6: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_DIRECTONLY) | libc.Int32FromInt32(SQLITE_FUNC_UNSAFE)),
		FzName:     __ccgo_ts + 16680,
	},
	7: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_SLOCHNG) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 16695,
	},
	8: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_SLOCHNG) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 16721,
	},
	9: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_FUNC_INLINE) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_FUNC_UNLIKELY)),
		FpUserData: uintptr(libc.Int32FromInt32(INLINEFUNC_unlikely)),
		FzName:     __ccgo_ts + 16746,
	},
	10: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_FUNC_INLINE) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_FUNC_UNLIKELY)),
		FpUserData: uintptr(libc.Int32FromInt32(INLINEFUNC_unlikely)),
		FzName:     __ccgo_ts + 16755,
	},
	11: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_FUNC_INLINE) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_FUNC_UNLIKELY)),
		FpUserData: uintptr(libc.Int32FromInt32(INLINEFUNC_unlikely)),
		FzName:     __ccgo_ts + 16766,
	},
	12: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_FUNC_INLINE) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(0)),
		FpUserData: uintptr(libc.Int32FromInt32(INLINEFUNC_sqlite_offset)),
		FzName:     __ccgo_ts + 16773,
	},
	13: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FpUserData: uintptr(libc.Int32FromInt32(1)),
		FzName:     __ccgo_ts + 16787,
	},
	14: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FpUserData: uintptr(libc.Int32FromInt32(1)),
		FzName:     __ccgo_ts + 16787,
	},
	15: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FpUserData: uintptr(libc.Int32FromInt32(2)),
		FzName:     __ccgo_ts + 16793,
	},
	16: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FpUserData: uintptr(libc.Int32FromInt32(2)),
		FzName:     __ccgo_ts + 16793,
	},
	17: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FpUserData: uintptr(libc.Int32FromInt32(3)),
		FzName:     __ccgo_ts + 16799,
	},
	18: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FpUserData: uintptr(libc.Int32FromInt32(3)),
		FzName:     __ccgo_ts + 16799,
	},
	19: {
		FnArg:      int16(-int32(3)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16804,
	},
	20: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(SQLITE_FUNC_MINMAX) | libc.Int32FromInt32(SQLITE_FUNC_ANYORDER)),
		FzName:     __ccgo_ts + 16804,
	},
	21: {
		FnArg:      int16(-int32(3)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FpUserData: uintptr(libc.Int32FromInt32(1)),
		FzName:     __ccgo_ts + 16808,
	},
	22: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(SQLITE_FUNC_MINMAX) | libc.Int32FromInt32(SQLITE_FUNC_ANYORDER)),
		FpUserData: uintptr(libc.Int32FromInt32(1)),
		FzName:     __ccgo_ts + 16808,
	},
	23: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(SQLITE_FUNC_TYPEOF)),
		FzName:     __ccgo_ts + 16812,
	},
	24: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(SQLITE_FUNC_TYPEOF) | libc.Int32FromInt32(SQLITE_SUBTYPE)),
		FzName:     __ccgo_ts + 16819,
	},
	25: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(SQLITE_FUNC_LENGTH)),
		FzName:     __ccgo_ts + 16827,
	},
	26: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(SQLITE_FUNC_BYTELEN)),
		FzName:     __ccgo_ts + 16834,
	},
	27: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16847,
	},
	28: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16853,
	},
	29: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16860,
	},
	30: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16867,
	},
	31: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16875,
	},
	32: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16880,
	},
	33: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16884,
	},
	34: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16884,
	},
	35: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16890,
	},
	36: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16896,
	},
	37: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16902,
	},
	38: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16906,
	},
	39: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16906,
	},
	40: {
		FnArg:      int16(-int32(3)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16912,
	},
	41: {
		FnArg:      int16(-int32(4)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16919,
	},
	42: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_FUNC_INLINE) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(0)),
		FzName:     __ccgo_ts + 16929,
	},
	43: {
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16936,
	},
	44: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16943,
	},
	45: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16954,
	},
	46: {
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_SLOCHNG) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 16961,
	},
	47: {
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_SLOCHNG) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 16976,
	},
	48: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 16993,
	},
	49: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 17004,
	},
	50: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 17011,
	},
	51: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FpUserData: uintptr(libc.Int32FromInt32(1)),
		FzName:     __ccgo_ts + 17017,
	},
	52: {
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 17030,
	},
	53: {
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 17048,
	},
	54: {
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 17056,
	},
	55: {
		FnArg:      int16(3),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 17070,
	},
	56: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 17078,
	},
	57: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 17087,
	},
	58: {
		FnArg:      int16(3),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 17087,
	},
	59: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 17094,
	},
	60: {
		FnArg:      int16(3),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 17094,
	},
	61: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(0)),
		FzName:     __ccgo_ts + 17104,
	},
	62: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(0)),
		FzName:     __ccgo_ts + 17108,
	},
	63: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(0)),
		FzName:     __ccgo_ts + 17114,
	},
	64: {
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(SQLITE_FUNC_COUNT) | libc.Int32FromInt32(SQLITE_FUNC_ANYORDER)),
		FzName:     __ccgo_ts + 17118,
	},
	65: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(SQLITE_FUNC_ANYORDER)),
		FzName:     __ccgo_ts + 17118,
	},
	66: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(0)),
		FzName:     __ccgo_ts + 17124,
	},
	67: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(0)),
		FzName:     __ccgo_ts + 17124,
	},
	68: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(0)),
		FzName:     __ccgo_ts + 17137,
	},
	69: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_FUNC_LIKE) | libc.Int32FromInt32(SQLITE_FUNC_CASE)),
		FpUserData: uintptr(unsafe.Pointer(&_globInfo)),
		FzName:     __ccgo_ts + 17148,
	},
	70: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_FUNC_LIKE)),
		FpUserData: uintptr(unsafe.Pointer(&_likeInfoNorm)),
		FzName:     __ccgo_ts + 16607,
	},
	71: {
		FnArg:      int16(3),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_FUNC_LIKE)),
		FpUserData: uintptr(unsafe.Pointer(&_likeInfoNorm)),
		FzName:     __ccgo_ts + 16607,
	},
	72: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17153,
	},
	73: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 1275,
	},
	74: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 1283,
	},
	75: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17158,
	},
	76: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 17164,
	},
	77: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FpUserData: uintptr(libc.Int32FromInt32(1)),
		FzName:     __ccgo_ts + 17167,
	},
	78: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FpUserData: uintptr(libc.Int32FromInt32(1)),
		FzName:     __ccgo_ts + 17171,
	},
	79: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FpUserData: uintptr(libc.Int32FromInt32(2)),
		FzName:     __ccgo_ts + 17177,
	},
	80: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 17167,
	},
	81: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17182,
	},
	82: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17186,
	},
	83: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17190,
	},
	84: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17196,
	},
	85: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17200,
	},
	86: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17205,
	},
	87: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17210,
	},
	88: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17215,
	},
	89: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17221,
	},
	90: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17225,
	},
	91: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17229,
	},
	92: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17233,
	},
	93: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17238,
	},
	94: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17243,
	},
	95: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17248,
	},
	96: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17254,
	},
	97: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17260,
	},
	98: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17266,
	},
	99: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17271,
	},
	100: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17279,
	},
	101: {
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8)),
		FzName:     __ccgo_ts + 17287,
	},
	102: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)),
		FzName:     __ccgo_ts + 17290,
	},
	103: {
		FnArg:      int16(-int32(4)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_FUNC_INLINE) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(0)),
		FzName:     __ccgo_ts + 6963,
	},
	104: {
		FnArg:      int16(-int32(4)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_FUNC_INLINE) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(0)),
		FpUserData: uintptr(libc.Int32FromInt32(INLINEFUNC_iif)),
		FzName:     __ccgo_ts + 17295,
	},
	105: {
		FnArg:      int16(-int32(4)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_FUNC_INLINE) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(0)),
		FpUserData: uintptr(libc.Int32FromInt32(INLINEFUNC_iif)),
		FzName:     __ccgo_ts + 17299,
	},
}

var _aJsonFunc = [36]TFuncDef{
	0: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 13696,
	},
	1: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FpUserData: uintptr(libc.Int32FromInt32(0) | libc.Int32FromInt32(1)*libc.Int32FromInt32(JSON_BLOB)),
		FzName:     __ccgo_ts + 26966,
	},
	2: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 26972,
	},
	3: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FpUserData: uintptr(libc.Int32FromInt32(0) | libc.Int32FromInt32(1)*libc.Int32FromInt32(JSON_BLOB)),
		FzName:     __ccgo_ts + 26983,
	},
	4: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FpUserData: uintptr(libc.Int32FromInt32(JSON_AINS) | libc.Int32FromInt32(0)*libc.Int32FromInt32(JSON_BLOB)),
		FzName:     __ccgo_ts + 26995,
	},
	5: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FpUserData: uintptr(libc.Int32FromInt32(JSON_AINS) | libc.Int32FromInt32(1)*libc.Int32FromInt32(JSON_BLOB)),
		FzName:     __ccgo_ts + 27013,
	},
	6: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 27032,
	},
	7: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 27032,
	},
	8: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 27050,
	},
	9: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 27070,
	},
	10: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FpUserData: uintptr(libc.Int32FromInt32(0) | libc.Int32FromInt32(1)*libc.Int32FromInt32(JSON_BLOB)),
		FzName:     __ccgo_ts + 27083,
	},
	11: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FpUserData: uintptr(libc.Int32FromInt32(JSON_JSON) | libc.Int32FromInt32(0)*libc.Int32FromInt32(JSON_BLOB)),
		FzName:     __ccgo_ts + 27097,
	},
	12: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FpUserData: uintptr(libc.Int32FromInt32(JSON_SQL) | libc.Int32FromInt32(0)*libc.Int32FromInt32(JSON_BLOB)),
		FzName:     __ccgo_ts + 27100,
	},
	13: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 27104,
	},
	14: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FpUserData: uintptr(libc.Int32FromInt32(0) | libc.Int32FromInt32(1)*libc.Int32FromInt32(JSON_BLOB)),
		FzName:     __ccgo_ts + 27116,
	},
	15: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 27129,
	},
	16: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FpUserData: uintptr(libc.Int32FromInt32(0) | libc.Int32FromInt32(1)*libc.Int32FromInt32(JSON_BLOB)),
		FzName:     __ccgo_ts + 27141,
	},
	17: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 27154,
	},
	18: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FpUserData: uintptr(libc.Int32FromInt32(0) | libc.Int32FromInt32(1)*libc.Int32FromInt32(JSON_BLOB)),
		FzName:     __ccgo_ts + 27165,
	},
	19: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 27177,
	},
	20: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 27177,
	},
	21: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 27189,
	},
	22: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 27200,
	},
	23: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FpUserData: uintptr(libc.Int32FromInt32(0) | libc.Int32FromInt32(1)*libc.Int32FromInt32(JSON_BLOB)),
		FzName:     __ccgo_ts + 27212,
	},
	24: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 27225,
	},
	25: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FpUserData: uintptr(libc.Int32FromInt32(0) | libc.Int32FromInt32(1)*libc.Int32FromInt32(JSON_BLOB)),
		FzName:     __ccgo_ts + 27238,
	},
	26: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FpUserData: uintptr(libc.Int32FromInt32(JSON_ISSET) | libc.Int32FromInt32(0)*libc.Int32FromInt32(JSON_BLOB)),
		FzName:     __ccgo_ts + 27252,
	},
	27: {
		FnArg:      int16(-int32(1)),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FpUserData: uintptr(libc.Int32FromInt32(JSON_ISSET) | libc.Int32FromInt32(1)*libc.Int32FromInt32(JSON_BLOB)),
		FzName:     __ccgo_ts + 27261,
	},
	28: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 27271,
	},
	29: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 27271,
	},
	30: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 27281,
	},
	31: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_FUNC_CONSTANT) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(1)*libc.Int32FromInt32(SQLITE_FUNC_RUNONLY) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE)),
		FzName:     __ccgo_ts + 27281,
	},
	32: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_DETERMINISTIC)),
		FzName:     __ccgo_ts + 27292,
	},
	33: {
		FnArg:      int16(1),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_DETERMINISTIC)),
		FpUserData: uintptr(libc.Int32FromInt32(JSON_BLOB)),
		FzName:     __ccgo_ts + 27309,
	},
	34: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_DETERMINISTIC)),
		FzName:     __ccgo_ts + 27327,
	},
	35: {
		FnArg:      int16(2),
		FfuncFlags: libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_BUILTIN) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(0)*libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL) | libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE) | libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_DETERMINISTIC)),
		FpUserData: uintptr(libc.Int32FromInt32(JSON_BLOB)),
		FzName:     __ccgo_ts + 27345,
	},
}

var _aScale = [26]Tu64{
	0:  libc.Uint64FromUint64(0x8049a4ac0c5811ae),
	1:  libc.Uint64FromUint64(0xcf42894a5dce35ea),
	2:  libc.Uint64FromUint64(0xa76c582338ed2621),
	3:  libc.Uint64FromUint64(0x873e4f75e2224e68),
	4:  libc.Uint64FromUint64(0xda7f5bf590966848),
	5:  libc.Uint64FromUint64(0xb080392cc4349dec),
	6:  libc.Uint64FromUint64(0x8e938662882af53e),
	7:  libc.Uint64FromUint64(0xe65829b3046b0afa),
	8:  libc.Uint64FromUint64(0xba121a4650e4ddeb),
	9:  libc.Uint64FromUint64(0x964e858c91ba2655),
	10: libc.Uint64FromUint64(0xf2d56790ab41c2a2),
	11: libc.Uint64FromUint64(0xc428d05aa4751e4c),
	12: libc.Uint64FromUint64(0x9e74d1b791e07e48),
	13: libc.Uint64FromUint64(0xcccccccccccccccc),
	14: libc.Uint64FromUint64(0xcecb8f27f4200f3a),
	15: libc.Uint64FromUint64(0xa70c3c40a64e6c51),
	16: libc.Uint64FromUint64(0x86f0ac99b4e8dafd),
	17: libc.Uint64FromUint64(0xda01ee641a708de9),
	18: libc.Uint64FromUint64(0xb01ae745b101e9e4),
	19: libc.Uint64FromUint64(0x8e41ade9fbebc27d),
	20: libc.Uint64FromUint64(0xe5d3ef282a242e81),
	21: libc.Uint64FromUint64(0xb9a74a0637ce2ee1),
	22: libc.Uint64FromUint64(0x95f83d0a1fb69cd9),
	23: libc.Uint64FromUint64(0xf24a01a73cf2dccf),
	24: libc.Uint64FromUint64(0xc3b8358109e84f07),
	25: libc.Uint64FromUint64(0x9e19db92b4e31ba9),
}

// C documentation
//
//	/*
//	** Internal SQL function:
//	**
//	**     sqlite_add_constraint(SQL, CONSTRAINT-TEXT, ICOL)
//	**
//	** SQL is a CREATE TABLE statement.  Return a modified version of
//	** SQL that adds CONSTRAINT-TEXT at the end of the ICOL-th column
//	** definition.  (The left-most column defintion is 0.)
//	*/
func _addConstraintFunc(tls *libc.TLS, ctx uintptr, NotUsed int32, argv uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var db, zCons, zNew, zSql uintptr
	var iCol, ii, nTok int32
	var _ /* iOff at bp+0 */ int32
	var _ /* t at bp+4 */ int32
	_, _, _, _, _, _, _ = db, iCol, ii, nTok, zCons, zNew, zSql
	zSql = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv)))
	zCons = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv + 1*4)))
	iCol = Xsqlite3_value_int(tls, **(**uintptr)(__ccgo_up(argv + 2*4)))
	**(**int32)(__ccgo_up(bp)) = 0
	zNew = uintptr(0)
	**(**int32)(__ccgo_up(bp + 4)) = 0
	_ = NotUsed
	if _skipCreateTable(tls, ctx, zSql, bp) != 0 {
		return
	}
	ii = 0
	for {
		if !(ii <= iCol || iCol < 0 && **(**int32)(__ccgo_up(bp + 4)) != int32(TK_RP)) {
			break
		}
		**(**int32)(__ccgo_up(bp)) = **(**int32)(__ccgo_up(bp)) + _getConstraintToken(tls, zSql+uintptr(**(**int32)(__ccgo_up(bp))), bp+4)
		for int32(1) != 0 {
			nTok = _getConstraintToken(tls, zSql+uintptr(**(**int32)(__ccgo_up(bp))), bp+4)
			if **(**int32)(__ccgo_up(bp + 4)) == int32(TK_COMMA) || **(**int32)(__ccgo_up(bp + 4)) == int32(TK_RP) {
				break
			}
			if **(**int32)(__ccgo_up(bp + 4)) == int32(TK_ILLEGAL) {
				Xsqlite3_result_error_code(tls, ctx, _sqlite3CorruptError(tls, int32(123226)))
				return
			}
			**(**int32)(__ccgo_up(bp)) = **(**int32)(__ccgo_up(bp)) + nTok
		}
		goto _1
	_1:
		;
		ii = ii + 1
	}
	**(**int32)(__ccgo_up(bp)) = **(**int32)(__ccgo_up(bp)) + _getWhitespace(tls, zSql+uintptr(**(**int32)(__ccgo_up(bp))))
	db = Xsqlite3_context_db_handle(tls, ctx)
	if iCol < 0 {
		zNew = _sqlite3MPrintf(tls, db, __ccgo_ts+11887, libc.VaList(bp+16, **(**int32)(__ccgo_up(bp)), zSql, zCons, zSql+uintptr(**(**int32)(__ccgo_up(bp)))))
	} else {
		zNew = _sqlite3MPrintf(tls, db, __ccgo_ts+11898, libc.VaList(bp+16, **(**int32)(__ccgo_up(bp)), zSql, zCons, zSql+uintptr(**(**int32)(__ccgo_up(bp)))))
	}
	Xsqlite3_result_text(tls, ctx, zNew, -int32(1), __ccgo_fp(_sqlite3RowSetClear))
}

// C documentation
//
//	/*
//	** Find a column named pCol in table pTab. If successful, set output
//	** parameter *piCol to the index of the column in the table and return
//	** SQLITE_OK. Otherwise, set *piCol to -1 and return an SQLite error
//	** code.
//	*/
func _alterFindCol(tls *libc.TLS, pParse uintptr, pTab uintptr, pCol uintptr, piCol uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var db, zCol, zDb, zName uintptr
	var iCol, rc int32
	_, _, _, _, _, _ = db, iCol, rc, zCol, zDb, zName
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	zName = _sqlite3NameFromToken(tls, db, pCol)
	rc = int32(SQLITE_NOMEM)
	iCol = -int32(1)
	if zName != 0 {
		iCol = _sqlite3ColumnIndex(tls, pTab, zName)
		if iCol < 0 {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+11908, libc.VaList(bp+8, zName))
			rc = int32(SQLITE_ERROR)
		} else {
			rc = SQLITE_OK
		}
	}
	if rc == SQLITE_OK {
		zDb = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(_sqlite3SchemaToIndex(tls, db, (*TTable)(unsafe.Pointer(pTab)).FpSchema))*16))).FzDbSName
		zCol = (**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(iCol)*12))).FzCnName
		if _sqlite3AuthCheck(tls, pParse, int32(SQLITE_ALTER_TABLE), zDb, (*TTable)(unsafe.Pointer(pTab)).FzName, zCol) != 0 {
			pTab = uintptr(0)
		}
	}
	_sqlite3DbFree(tls, db, zName)
	**(**int32)(__ccgo_up(piCol)) = iCol
	return rc
}

// C documentation
//
//	/*
//	** Generate code to do an analysis of all indices associated with
//	** a single table.
//	*/
func _analyzeOneTable(tls *libc.TLS, pParse uintptr, pTab uintptr, pOnlyIdx uintptr, iStatCur int32, iMem int32, iTab int32) {
	var aGotoChng, db, pColl, pIdx, pPk, pStat1, pX, v, zIdxName uintptr
	var addrGotoEnd, addrIsNull, addrNext, addrNextRow, doOnce, endDistinctTest, i, iDb, iIdxCur, iTabCur, j, j1, j2, j3, jZeroRows, k, mxCol, nCol, nColTest, nColX, regChng, regCol, regDLt, regEq, regIdxname, regKey, regLt, regNewRowid, regPrev, regRowid, regSample, regSampleRowid, regStat, regStat1, regTabname, regTemp, regTemp2, v1, v2, v3, v4, v5, v6, v7, v8, v9 int32
	var needTableCnt, seekOp Tu8
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = aGotoChng, addrGotoEnd, addrIsNull, addrNext, addrNextRow, db, doOnce, endDistinctTest, i, iDb, iIdxCur, iTabCur, j, j1, j2, j3, jZeroRows, k, mxCol, nCol, nColTest, nColX, needTableCnt, pColl, pIdx, pPk, pStat1, pX, regChng, regCol, regDLt, regEq, regIdxname, regKey, regLt, regNewRowid, regPrev, regRowid, regSample, regSampleRowid, regStat, regStat1, regTabname, regTemp, regTemp2, seekOp, v, zIdxName, v1, v2, v3, v4, v5, v6, v7, v8, v9
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb /* Loop counter */
	jZeroRows = -int32(1)                      /* Index of database containing pTab */
	needTableCnt = uint8(1)
	v1 = iMem
	iMem = iMem + 1 /* True to count the table */
	regNewRowid = v1
	v2 = iMem
	iMem = iMem + 1 /* Rowid for the inserted record */
	regStat = v2
	v3 = iMem
	iMem = iMem + 1 /* Register to hold StatAccum object */
	regChng = v3
	v4 = iMem
	iMem = iMem + 1 /* Index of changed index field */
	regRowid = v4
	v5 = iMem
	iMem = iMem + 1 /* Rowid argument passed to stat_push() */
	regTemp = v5
	v6 = iMem
	iMem = iMem + 1 /* Temporary use register */
	regTemp2 = v6
	v7 = iMem
	iMem = iMem + 1 /* Second temporary use register */
	regTabname = v7
	v8 = iMem
	iMem = iMem + 1 /* Register containing table name */
	regIdxname = v8
	v9 = iMem
	iMem = iMem + 1   /* Register containing index name */
	regStat1 = v9     /* Value for the stat column of sqlite_stat1 */
	regPrev = iMem    /* MUST BE LAST (see below) */
	doOnce = int32(1) /* Flag for a one-time computation */
	pStat1 = uintptr(0)
	_sqlite3TouchRegister(tls, pParse, iMem)
	v = _sqlite3GetVdbe(tls, pParse)
	if v == uintptr(0) || pTab == uintptr(0) {
		return
	}
	if !(libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == libc.Int32FromInt32(TABTYP_NORM)) {
		/* Do not gather statistics on views or virtual tables */
		return
	}
	if Xsqlite3_strlike(tls, __ccgo_ts+13032, (*TTable)(unsafe.Pointer(pTab)).FzName, uint32('\\')) == 0 {
		/* Do not gather statistics on system tables */
		return
	}
	iDb = _sqlite3SchemaToIndex(tls, db, (*TTable)(unsafe.Pointer(pTab)).FpSchema)
	if _sqlite3AuthCheck(tls, pParse, int32(SQLITE_ANALYZE), (*TTable)(unsafe.Pointer(pTab)).FzName, uintptr(0), (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FzDbSName) != 0 {
		return
	}
	if (*Tsqlite3)(unsafe.Pointer(db)).FxPreUpdateCallback != 0 {
		pStat1 = _sqlite3DbMallocZero(tls, db, uint64(libc.Uint32FromInt64(80)+libc.Uint32FromInt32(13)))
		if pStat1 == uintptr(0) {
			return
		}
		(*TTable)(unsafe.Pointer(pStat1)).FzName = pStat1 + 1*80
		libc.Xmemcpy(tls, (*TTable)(unsafe.Pointer(pStat1)).FzName, __ccgo_ts+12835, uint32(13))
		(*TTable)(unsafe.Pointer(pStat1)).FnCol = int16(3)
		(*TTable)(unsafe.Pointer(pStat1)).FiPKey = int16(-int32(1))
		_sqlite3VdbeAddOp4(tls, (*TParse)(unsafe.Pointer(pParse)).FpVdbe, int32(OP_Noop), 0, 0, 0, pStat1, -int32(7))
	}
	/* Establish a read-lock on the table at the shared-cache level.
	 ** Open a read-only cursor on the table. Also allocate a cursor number
	 ** to use for scanning indexes (iIdxCur). No index cursor is opened at
	 ** this time though.  */
	_sqlite3TableLock(tls, pParse, iDb, (*TTable)(unsafe.Pointer(pTab)).Ftnum, uint8(0), (*TTable)(unsafe.Pointer(pTab)).FzName)
	v1 = iTab
	iTab = iTab + 1
	iTabCur = v1
	v1 = iTab
	iTab = iTab + 1
	iIdxCur = v1
	if (*TParse)(unsafe.Pointer(pParse)).FnTab > iTab {
		v1 = (*TParse)(unsafe.Pointer(pParse)).FnTab
	} else {
		v1 = iTab
	}
	(*TParse)(unsafe.Pointer(pParse)).FnTab = v1
	_sqlite3OpenTable(tls, pParse, iTabCur, iDb, pTab, int32(OP_OpenRead))
	_sqlite3VdbeLoadString(tls, v, regTabname, (*TTable)(unsafe.Pointer(pTab)).FzName)
	pIdx = (*TTable)(unsafe.Pointer(pTab)).FpIndex
	for {
		if !(pIdx != 0) {
			break
		} /* Number of columns to test for changes */
		if pOnlyIdx != 0 && pOnlyIdx != pIdx {
			goto _13
		}
		if (*TIndex)(unsafe.Pointer(pIdx)).FpPartIdxWhere == uintptr(0) {
			needTableCnt = uint8(0)
		}
		if !((*TTable)(unsafe.Pointer(pTab)).FtabFlags&libc.Uint32FromInt32(TF_WithoutRowid) == libc.Uint32FromInt32(0)) && int32(uint32(*(*uint16)(unsafe.Pointer(pIdx + 56))&0x3>>0)) == int32(SQLITE_IDXTYPE_PRIMARYKEY) {
			nCol = libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pIdx)).FnKeyCol)
			zIdxName = (*TTable)(unsafe.Pointer(pTab)).FzName
			nColTest = nCol - int32(1)
		} else {
			nCol = libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pIdx)).FnColumn)
			zIdxName = (*TIndex)(unsafe.Pointer(pIdx)).FzName
			if int32(uint32(*(*uint16)(unsafe.Pointer(pIdx + 56))&0x8>>3)) != 0 {
				v1 = libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pIdx)).FnKeyCol) - int32(1)
			} else {
				v1 = nCol - int32(1)
			}
			nColTest = v1
		}
		/* Populate the register containing the index name. */
		_sqlite3VdbeLoadString(tls, v, regIdxname, zIdxName)
		/*
		 ** Pseudo-code for loop that calls stat_push():
		 **
		 **   regChng = 0
		 **   Rewind csr
		 **   if eof(csr){
		 **      stat_init() with count = 0;
		 **      goto end_of_scan;
		 **   }
		 **   count()
		 **   stat_init()
		 **   goto chng_addr_0;
		 **
		 **  next_row:
		 **   regChng = 0
		 **   if( idx(0) != regPrev(0) ) goto chng_addr_0
		 **   regChng = 1
		 **   if( idx(1) != regPrev(1) ) goto chng_addr_1
		 **   ...
		 **   regChng = N
		 **   goto chng_addr_N
		 **
		 **  chng_addr_0:
		 **   regPrev(0) = idx(0)
		 **  chng_addr_1:
		 **   regPrev(1) = idx(1)
		 **  ...
		 **
		 **  endDistinctTest:
		 **   regRowid = idx(rowid)
		 **   stat_push(P, regChng, regRowid)
		 **   Next csr
		 **   if !eof(csr) goto next_row;
		 **
		 **  end_of_scan:
		 */
		/* Make sure there are enough memory cells allocated to accommodate
		 ** the regPrev array and a trailing rowid (the rowid slot is required
		 ** when building a record to insert into the sample column of
		 ** the sqlite_stat4 table.  */
		_sqlite3TouchRegister(tls, pParse, regPrev+nColTest)
		/* Open a read-only cursor on the index being analyzed. */
		_sqlite3VdbeAddOp3(tls, v, int32(OP_OpenRead), iIdxCur, libc.Int32FromUint32((*TIndex)(unsafe.Pointer(pIdx)).Ftnum), iDb)
		_sqlite3VdbeSetP4KeyInfo(tls, pParse, pIdx)
		/* Implementation of the following:
		 **
		 **   regChng = 0
		 **   Rewind csr
		 **   if eof(csr){
		 **      stat_init() with count = 0;
		 **      goto end_of_scan;
		 **   }
		 **   count()
		 **   stat_init()
		 **   goto chng_addr_0;
		 */
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), (*Tsqlite3)(unsafe.Pointer(db)).FnAnalysisLimit, regTemp2)
		/* Arguments to stat_init():
		 **    (1) the number of columns in the index including the rowid
		 **        (or for a WITHOUT ROWID table, the number of PK columns),
		 **    (2) the number of columns in the key without the rowid/pk
		 **    (3) estimated number of rows in the index. */
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), nCol, regStat+int32(1))
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pIdx)).FnKeyCol), regRowid)
		_sqlite3VdbeAddOp3(tls, v, int32(OP_Count), iIdxCur, regTemp, libc.BoolInt32((*Tsqlite3)(unsafe.Pointer(db)).FdbOptFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_Stat4)) != uint32(0)))
		_sqlite3VdbeAddFunctionCall(tls, pParse, 0, regStat+int32(1), regStat, int32(4), uintptr(unsafe.Pointer(&_statInitFuncdef)), 0)
		addrGotoEnd = _sqlite3VdbeAddOp1(tls, v, int32(OP_Rewind), iIdxCur)
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), 0, regChng)
		addrNextRow = _sqlite3VdbeCurrentAddr(tls, v)
		if nColTest > 0 {
			endDistinctTest = _sqlite3VdbeMakeLabel(tls, pParse) /* Array of jump instruction addresses */
			aGotoChng = _sqlite3DbMallocRawNN(tls, db, uint64(uint32(4)*libc.Uint32FromInt32(nColTest)))
			if aGotoChng == uintptr(0) {
				goto _13
			}
			/*
			 **  next_row:
			 **   regChng = 0
			 **   if( idx(0) != regPrev(0) ) goto chng_addr_0
			 **   regChng = 1
			 **   if( idx(1) != regPrev(1) ) goto chng_addr_1
			 **   ...
			 **   regChng = N
			 **   goto endDistinctTest
			 */
			_sqlite3VdbeAddOp0(tls, v, int32(OP_Goto))
			addrNextRow = _sqlite3VdbeCurrentAddr(tls, v)
			if nColTest == int32(1) && libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pIdx)).FnKeyCol) == int32(1) && libc.Int32FromUint8((*TIndex)(unsafe.Pointer(pIdx)).FonError) != OE_None {
				/* For a single-column UNIQUE index, once we have found a non-NULL
				 ** row, we know that all the rest will be distinct, so skip
				 ** subsequent distinctness tests. */
				_sqlite3VdbeAddOp2(tls, v, int32(OP_NotNull), regPrev, endDistinctTest)
			}
			i = 0
			for {
				if !(i < nColTest) {
					break
				}
				pColl = _sqlite3LocateCollSeq(tls, pParse, **(**uintptr)(__ccgo_up((*TIndex)(unsafe.Pointer(pIdx)).FazColl + uintptr(i)*4)))
				_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), i, regChng)
				_sqlite3VdbeAddOp3(tls, v, int32(OP_Column), iIdxCur, i, regTemp)
				**(**int32)(__ccgo_up(aGotoChng + uintptr(i)*4)) = _sqlite3VdbeAddOp4(tls, v, int32(OP_Ne), regTemp, 0, regPrev+i, pColl, -int32(2))
				_sqlite3VdbeChangeP5(tls, v, uint16(SQLITE_NULLEQ))
				goto _15
			_15:
				;
				i = i + 1
			}
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), nColTest, regChng)
			_sqlite3VdbeGoto(tls, v, endDistinctTest)
			/*
			 **  chng_addr_0:
			 **   regPrev(0) = idx(0)
			 **  chng_addr_1:
			 **   regPrev(1) = idx(1)
			 **  ...
			 */
			_sqlite3VdbeJumpHere(tls, v, addrNextRow-int32(1))
			i = 0
			for {
				if !(i < nColTest) {
					break
				}
				_sqlite3VdbeJumpHere(tls, v, **(**int32)(__ccgo_up(aGotoChng + uintptr(i)*4)))
				_sqlite3VdbeAddOp3(tls, v, int32(OP_Column), iIdxCur, i, regPrev+i)
				goto _16
			_16:
				;
				i = i + 1
			}
			_sqlite3VdbeResolveLabel(tls, v, endDistinctTest)
			_sqlite3DbFree(tls, db, aGotoChng)
		}
		/*
		 **  chng_addr_N:
		 **   regRowid = idx(rowid)            // STAT4 only
		 **   stat_push(P, regChng, regRowid)  // 3rd parameter STAT4 only
		 **   Next csr
		 **   if !eof(csr) goto next_row;
		 */
		if (*Tsqlite3)(unsafe.Pointer(db)).FdbOptFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_Stat4)) == uint32(0) {
			if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_WithoutRowid) == uint32(0) {
				_sqlite3VdbeAddOp2(tls, v, int32(OP_IdxRowid), iIdxCur, regRowid)
			} else {
				pPk = _sqlite3PrimaryKeyIndex(tls, (*TIndex)(unsafe.Pointer(pIdx)).FpTable)
				regKey = _sqlite3GetTempRange(tls, pParse, libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pPk)).FnKeyCol))
				j = 0
				for {
					if !(j < libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pPk)).FnKeyCol)) {
						break
					}
					k = _sqlite3TableColumnToIndex(tls, pIdx, int32(**(**Ti16)(__ccgo_up((*TIndex)(unsafe.Pointer(pPk)).FaiColumn + uintptr(j)*2))))
					_sqlite3VdbeAddOp3(tls, v, int32(OP_Column), iIdxCur, k, regKey+j)
					goto _17
				_17:
					;
					j = j + 1
				}
				_sqlite3VdbeAddOp3(tls, v, int32(OP_MakeRecord), regKey, libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pPk)).FnKeyCol), regRowid)
				_sqlite3ReleaseTempRange(tls, pParse, regKey, libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pPk)).FnKeyCol))
			}
		}
		_sqlite3VdbeAddFunctionCall(tls, pParse, int32(1), regStat, regTemp, libc.Int32FromInt32(2)+libc.Int32FromInt32(IsStat4), uintptr(unsafe.Pointer(&_statPushFuncdef)), 0)
		if (*Tsqlite3)(unsafe.Pointer(db)).FnAnalysisLimit != 0 {
			j1 = _sqlite3VdbeAddOp1(tls, v, int32(OP_IsNull), regTemp)
			j2 = _sqlite3VdbeAddOp1(tls, v, int32(OP_If), regTemp)
			j3 = _sqlite3VdbeAddOp4Int(tls, v, int32(OP_SeekGT), iIdxCur, 0, regPrev, int32(1))
			_sqlite3VdbeJumpHere(tls, v, j1)
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Next), iIdxCur, addrNextRow)
			_sqlite3VdbeJumpHere(tls, v, j2)
			_sqlite3VdbeJumpHere(tls, v, j3)
		} else {
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Next), iIdxCur, addrNextRow)
		}
		/* Add the entry to the stat1 table. */
		if (*TIndex)(unsafe.Pointer(pIdx)).FpPartIdxWhere != 0 {
			/* Partial indexes might get a zero-entry in sqlite_stat1.  But
			 ** an empty table is omitted from sqlite_stat1. */
			_sqlite3VdbeJumpHere(tls, v, addrGotoEnd)
			addrGotoEnd = 0
		}
		_callStatGet(tls, pParse, regStat, STAT_GET_STAT1, regStat1)
		_sqlite3VdbeAddOp4(tls, v, int32(OP_MakeRecord), regTabname, int32(3), regTemp, __ccgo_ts+13042, 0)
		_sqlite3VdbeAddOp2(tls, v, int32(OP_NewRowid), iStatCur, regNewRowid)
		_sqlite3VdbeAddOp3(tls, v, int32(OP_Insert), iStatCur, regTemp, regNewRowid)
		_sqlite3VdbeChangeP4(tls, v, -int32(1), pStat1, -int32(5))
		_sqlite3VdbeChangeP5(tls, v, uint16(OPFLAG_APPEND))
		/* Add the entries to the stat4 table. */
		if (*Tsqlite3)(unsafe.Pointer(db)).FdbOptFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_Stat4)) == uint32(0) && (*Tsqlite3)(unsafe.Pointer(db)).FnAnalysisLimit == 0 {
			regEq = regStat1
			regLt = regStat1 + int32(1)
			regDLt = regStat1 + int32(2)
			regSample = regStat1 + int32(3)
			regCol = regStat1 + int32(4)
			regSampleRowid = regCol + nCol
			if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_WithoutRowid) == uint32(0) {
				v1 = int32(OP_NotExists)
			} else {
				v1 = int32(OP_NotFound)
			}
			seekOp = libc.Uint8FromInt32(v1)
			/* No STAT4 data is generated if the number of rows is zero */
			if addrGotoEnd == 0 {
				_sqlite3VdbeAddOp2(tls, v, int32(OP_Cast), regStat1, int32(SQLITE_AFF_INTEGER))
				addrGotoEnd = _sqlite3VdbeAddOp1(tls, v, int32(OP_IfNot), regStat1)
			}
			if doOnce != 0 {
				mxCol = nCol
				/* Compute the maximum number of columns in any index */
				pX = (*TTable)(unsafe.Pointer(pTab)).FpIndex
				for {
					if !(pX != 0) {
						break
					} /* Number of columns in pX */
					if !((*TTable)(unsafe.Pointer(pTab)).FtabFlags&libc.Uint32FromInt32(TF_WithoutRowid) == libc.Uint32FromInt32(0)) && int32(uint32(*(*uint16)(unsafe.Pointer(pX + 56))&0x3>>0)) == int32(SQLITE_IDXTYPE_PRIMARYKEY) {
						nColX = libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pX)).FnKeyCol)
					} else {
						nColX = libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pX)).FnColumn)
					}
					if nColX > mxCol {
						mxCol = nColX
					}
					goto _19
				_19:
					;
					pX = (*TIndex)(unsafe.Pointer(pX)).FpNext
				}
				/* Allocate space to compute results for the largest index */
				_sqlite3TouchRegister(tls, pParse, regCol+mxCol)
				doOnce = 0
				_sqlite3ClearTempRegCache(tls, pParse) /* tag-20230325-1 */
			}
			addrNext = _sqlite3VdbeCurrentAddr(tls, v)
			_callStatGet(tls, pParse, regStat, int32(STAT_GET_ROWID), regSampleRowid)
			addrIsNull = _sqlite3VdbeAddOp1(tls, v, int32(OP_IsNull), regSampleRowid)
			_callStatGet(tls, pParse, regStat, int32(STAT_GET_NEQ), regEq)
			_callStatGet(tls, pParse, regStat, int32(STAT_GET_NLT), regLt)
			_callStatGet(tls, pParse, regStat, int32(STAT_GET_NDLT), regDLt)
			_sqlite3VdbeAddOp4Int(tls, v, libc.Int32FromUint8(seekOp), iTabCur, addrNext, regSampleRowid, 0)
			i = 0
			for {
				if !(i < nCol) {
					break
				}
				_sqlite3ExprCodeLoadIndexColumn(tls, pParse, pIdx, iTabCur, i, regCol+i)
				goto _20
			_20:
				;
				i = i + 1
			}
			_sqlite3VdbeAddOp3(tls, v, int32(OP_MakeRecord), regCol, nCol, regSample)
			_sqlite3VdbeAddOp3(tls, v, int32(OP_MakeRecord), regTabname, int32(6), regTemp)
			_sqlite3VdbeAddOp2(tls, v, int32(OP_NewRowid), iStatCur+int32(1), regNewRowid)
			_sqlite3VdbeAddOp3(tls, v, int32(OP_Insert), iStatCur+int32(1), regTemp, regNewRowid)
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Goto), int32(1), addrNext) /* P1==1 for end-of-loop */
			_sqlite3VdbeJumpHere(tls, v, addrIsNull)
		}
		/* End of analysis */
		if addrGotoEnd != 0 {
			_sqlite3VdbeJumpHere(tls, v, addrGotoEnd)
		}
		goto _13
	_13:
		;
		pIdx = (*TIndex)(unsafe.Pointer(pIdx)).FpNext
	}
	/* Create a single sqlite_stat1 entry containing NULL as the index
	 ** name and the row count as the content.
	 */
	if pOnlyIdx == uintptr(0) && needTableCnt != 0 {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Count), iTabCur, regStat1)
		jZeroRows = _sqlite3VdbeAddOp1(tls, v, int32(OP_IfNot), regStat1)
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Null), 0, regIdxname)
		_sqlite3VdbeAddOp4(tls, v, int32(OP_MakeRecord), regTabname, int32(3), regTemp, __ccgo_ts+13042, 0)
		_sqlite3VdbeAddOp2(tls, v, int32(OP_NewRowid), iStatCur, regNewRowid)
		_sqlite3VdbeAddOp3(tls, v, int32(OP_Insert), iStatCur, regTemp, regNewRowid)
		_sqlite3VdbeChangeP5(tls, v, uint16(OPFLAG_APPEND))
		_sqlite3VdbeChangeP4(tls, v, -int32(1), pStat1, -int32(5))
		_sqlite3VdbeJumpHere(tls, v, jZeroRows)
	}
}

// C documentation
//
//	/*
//	** Generate code that will do an analysis of a single table in
//	** a database.  If pOnlyIdx is not NULL then it is a single index
//	** in pTab that should be analyzed.
//	*/
func _analyzeTable(tls *libc.TLS, pParse uintptr, pTab uintptr, pOnlyIdx uintptr) {
	var iDb, iStatCur int32
	_, _ = iDb, iStatCur
	iDb = _sqlite3SchemaToIndex(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, (*TTable)(unsafe.Pointer(pTab)).FpSchema)
	_sqlite3BeginWriteOperation(tls, pParse, 0, iDb)
	iStatCur = (*TParse)(unsafe.Pointer(pParse)).FnTab
	**(**int32)(__ccgo_up(pParse + 44)) += int32(3)
	if pOnlyIdx != 0 {
		_openStatTable(tls, pParse, iDb, iStatCur, (*TIndex)(unsafe.Pointer(pOnlyIdx)).FzName, __ccgo_ts+13046)
	} else {
		_openStatTable(tls, pParse, iDb, iStatCur, (*TTable)(unsafe.Pointer(pTab)).FzName, __ccgo_ts+13050)
	}
	_analyzeOneTable(tls, pParse, pTab, pOnlyIdx, iStatCur, (*TParse)(unsafe.Pointer(pParse)).FnMem+int32(1), (*TParse)(unsafe.Pointer(pParse)).FnTab)
	_loadAnalysis(tls, pParse, iDb)
}

// C documentation
//
//	/*
//	** This function is used by both blob_open() and blob_reopen(). It seeks
//	** the b-tree cursor associated with blob handle p to point to row iRow.
//	** If successful, SQLITE_OK is returned and subsequent calls to
//	** sqlite3_blob_read() or sqlite3_blob_write() access the specified row.
//	**
//	** If an error occurs, or if the specified row does not exist or does not
//	** contain a value of type TEXT or BLOB in the column nominated when the
//	** blob handle was opened, then an error code is returned and *pzErr may
//	** be set to point to a buffer containing an error message. It is the
//	** responsibility of the caller to free the error message buffer using
//	** sqlite3DbFree().
//	**
//	** If an error does occur, then the b-tree cursor is closed. All subsequent
//	** calls to sqlite3_blob_read(), blob_write() or blob_reopen() will
//	** immediately return SQLITE_ABORT.
//	*/
func _blobSeekToRow(tls *libc.TLS, p uintptr, iRow Tsqlite3_int64, pzErr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var pC, v, zErr, v2, v3 uintptr
	var rc int32
	var type1 Tu32
	var v1 uint32
	_, _, _, _, _, _, _, _ = pC, rc, type1, v, zErr, v1, v2, v3 /* Error code */
	zErr = uintptr(0)                                           /* Error message */
	v = (*TIncrblob)(unsafe.Pointer(p)).FpStmt
	/* Set the value of register r[1] in the SQL statement to integer iRow.
	 ** This is done directly as a performance optimization
	 */
	_sqlite3VdbeMemSetInt64(tls, (*TVdbe)(unsafe.Pointer(v)).FaMem+1*40, iRow)
	/* If the statement has been run before (and is paused at the OP_ResultRow)
	 ** then back it up to the point where it does the OP_NotExists.  This could
	 ** have been down with an extra OP_Goto, but simply setting the program
	 ** counter is faster. */
	if (*TVdbe)(unsafe.Pointer(v)).Fpc > int32(4) {
		(*TVdbe)(unsafe.Pointer(v)).Fpc = int32(4)
		rc = _sqlite3VdbeExec(tls, v)
	} else {
		rc = Xsqlite3_step(tls, (*TIncrblob)(unsafe.Pointer(p)).FpStmt)
	}
	if rc == int32(SQLITE_ROW) {
		pC = **(**uintptr)(__ccgo_up((*TVdbe)(unsafe.Pointer(v)).FapCsr))
		if libc.Int32FromUint16((*TVdbeCursor)(unsafe.Pointer(pC)).FnHdrParsed) > libc.Int32FromUint16((*TIncrblob)(unsafe.Pointer(p)).FiCol) {
			v1 = *(*Tu32)(unsafe.Pointer(pC + 84 + uintptr((*TIncrblob)(unsafe.Pointer(p)).FiCol)*4))
		} else {
			v1 = uint32(0)
		}
		type1 = v1
		if type1 < uint32(12) {
			if type1 == uint32(0) {
				v2 = __ccgo_ts + 1688
			} else {
				if type1 == uint32(7) {
					v3 = __ccgo_ts + 6489
				} else {
					v3 = __ccgo_ts + 6494
				}
				v2 = v3
			}
			zErr = _sqlite3MPrintf(tls, (*TIncrblob)(unsafe.Pointer(p)).Fdb, __ccgo_ts+6502, libc.VaList(bp+8, v2))
			rc = int32(SQLITE_ERROR)
			Xsqlite3_finalize(tls, (*TIncrblob)(unsafe.Pointer(p)).FpStmt)
			(*TIncrblob)(unsafe.Pointer(p)).FpStmt = uintptr(0)
		} else {
			(*TIncrblob)(unsafe.Pointer(p)).FiOffset = libc.Int32FromUint32(*(*Tu32)(unsafe.Pointer(pC + 84 + uintptr(libc.Int32FromUint16((*TIncrblob)(unsafe.Pointer(p)).FiCol)+int32((*TVdbeCursor)(unsafe.Pointer(pC)).FnField))*4)))
			(*TIncrblob)(unsafe.Pointer(p)).FnByte = libc.Int32FromUint32(_sqlite3VdbeSerialTypeLen(tls, type1))
			(*TIncrblob)(unsafe.Pointer(p)).FpCsr = *(*uintptr)(unsafe.Pointer(pC + 36))
			_sqlite3BtreeIncrblobCursor(tls, (*TIncrblob)(unsafe.Pointer(p)).FpCsr)
		}
	}
	if rc == int32(SQLITE_ROW) {
		rc = SQLITE_OK
	} else {
		if (*TIncrblob)(unsafe.Pointer(p)).FpStmt != 0 {
			rc = Xsqlite3_finalize(tls, (*TIncrblob)(unsafe.Pointer(p)).FpStmt)
			(*TIncrblob)(unsafe.Pointer(p)).FpStmt = uintptr(0)
			if rc == SQLITE_OK {
				zErr = _sqlite3MPrintf(tls, (*TIncrblob)(unsafe.Pointer(p)).Fdb, __ccgo_ts+6531, libc.VaList(bp+8, iRow))
				rc = int32(SQLITE_ERROR)
			} else {
				zErr = _sqlite3MPrintf(tls, (*TIncrblob)(unsafe.Pointer(p)).Fdb, __ccgo_ts+3942, libc.VaList(bp+8, Xsqlite3_errmsg(tls, (*TIncrblob)(unsafe.Pointer(p)).Fdb)))
			}
		}
	}
	**(**uintptr)(__ccgo_up(pzErr)) = zErr
	return rc
}

// C documentation
//
//	/*
//	** Check to see if the FROM clause term pFrom has table-valued function
//	** arguments.  If it does, leave an error message in pParse and return
//	** non-zero, since pFrom is not allowed to be a table-valued function.
//	*/
func _cannotBeFunction(tls *libc.TLS, pParse uintptr, pFrom uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	if int32(*(*uint32)(unsafe.Pointer(pFrom + 12 + 4))&0x8>>3) != 0 {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+21034, libc.VaList(bp+8, (*TSrcItem)(unsafe.Pointer(pFrom)).FzName))
		return int32(1)
	}
	return 0
}

// C documentation
//
//	/*
//	** Append a message to the error message string.
//	*/
func _checkAppendMsg(tls *libc.TLS, pCheck uintptr, zFormat uintptr, va uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var ap Tva_list
	_ = ap
	_checkProgress(tls, pCheck)
	if !((*TIntegrityCk)(unsafe.Pointer(pCheck)).FmxErr != 0) {
		return
	}
	(*TIntegrityCk)(unsafe.Pointer(pCheck)).FmxErr = (*TIntegrityCk)(unsafe.Pointer(pCheck)).FmxErr - 1
	(*TIntegrityCk)(unsafe.Pointer(pCheck)).FnErr = (*TIntegrityCk)(unsafe.Pointer(pCheck)).FnErr + 1
	ap = va
	if (*TIntegrityCk)(unsafe.Pointer(pCheck)).FerrMsg.FnChar != 0 {
		Xsqlite3_str_append(tls, pCheck+48, __ccgo_ts+4354, int32(1))
	}
	if (*TIntegrityCk)(unsafe.Pointer(pCheck)).FzPfx != 0 {
		Xsqlite3_str_appendf(tls, pCheck+48, (*TIntegrityCk)(unsafe.Pointer(pCheck)).FzPfx, libc.VaList(bp+8, (*TIntegrityCk)(unsafe.Pointer(pCheck)).Fv0, (*TIntegrityCk)(unsafe.Pointer(pCheck)).Fv1, (*TIntegrityCk)(unsafe.Pointer(pCheck)).Fv2))
	}
	Xsqlite3_str_vappendf(tls, pCheck+48, zFormat, ap)
	_ = ap
	if libc.Int32FromUint8((*TIntegrityCk)(unsafe.Pointer(pCheck)).FerrMsg.FaccError) == int32(SQLITE_NOMEM) {
		_checkOom(tls, pCheck)
	}
}

// C documentation
//
//	/*
//	** Do various sanity checks on a single page of a tree.  Return
//	** the tree depth.  Root pages return 0.  Parents of root pages
//	** return 1, and so forth.
//	**
//	** These checks are done:
//	**
//	**      1.  Make sure that cells and freeblocks do not overlap
//	**          but combine to completely cover the page.
//	**      2.  Make sure integer cell keys are in order.
//	**      3.  Check the integrity of overflow pages.
//	**      4.  Recursively call checkTreePage on all children.
//	**      5.  Verify that the depth of all children is the same.
//	*/
func _checkTreePage(tls *libc.TLS, pCheck uintptr, iPage TPgno, piMinKey uintptr, _maxKey Ti64) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	*(*Ti64)(unsafe.Pointer(bp)) = _maxKey
	var cellStart, d2, depth, doCoverageCheck, hdr, i, j, keyCanBeEqual, nCell, nFrag, pgno, rc, saved_v1, saved_v2, size1, v1 int32
	var contentOffset, nPage, pc, prev, size, usableSize Tu32
	var data, heap, pBt, pCell, pCellIdx, saved_zPfx uintptr
	var pgnoOvfl TPgno
	var savedIsInit Tu8
	var _ /* info at bp+16 */ TCellInfo
	var _ /* pPage at bp+8 */ uintptr
	var _ /* x at bp+12 */ Tu32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cellStart, contentOffset, d2, data, depth, doCoverageCheck, hdr, heap, i, j, keyCanBeEqual, nCell, nFrag, nPage, pBt, pCell, pCellIdx, pc, pgno, pgnoOvfl, prev, rc, savedIsInit, saved_v1, saved_v2, saved_zPfx, size, size1, usableSize, v1
	**(**uintptr)(__ccgo_up(bp + 8)) = uintptr(0) /* Result code from subroutine call */
	depth = -int32(1)                             /* Number of cells */
	doCoverageCheck = int32(1)                    /* True if cell coverage checking should be done */
	keyCanBeEqual = int32(1)                      /* Offset to the start of the cell content area */
	heap = uintptr(0)
	prev = uint32(0) /* Next and previous entry on the min-heap */
	saved_zPfx = (*TIntegrityCk)(unsafe.Pointer(pCheck)).FzPfx
	saved_v1 = libc.Int32FromUint32((*TIntegrityCk)(unsafe.Pointer(pCheck)).Fv1)
	saved_v2 = (*TIntegrityCk)(unsafe.Pointer(pCheck)).Fv2
	savedIsInit = uint8(0)
	/* Check that the page exists
	 */
	_checkProgress(tls, pCheck)
	if (*TIntegrityCk)(unsafe.Pointer(pCheck)).FmxErr == 0 {
		goto end_of_check
	}
	pBt = (*TIntegrityCk)(unsafe.Pointer(pCheck)).FpBt
	usableSize = (*TBtShared)(unsafe.Pointer(pBt)).FusableSize
	if iPage == uint32(0) {
		return 0
	}
	if _checkRef(tls, pCheck, iPage) != 0 {
		return 0
	}
	(*TIntegrityCk)(unsafe.Pointer(pCheck)).FzPfx = __ccgo_ts + 4600
	(*TIntegrityCk)(unsafe.Pointer(pCheck)).Fv1 = iPage
	v1 = _btreeGetPage(tls, pBt, iPage, bp+8, 0)
	rc = v1
	if v1 != 0 {
		_checkAppendMsg(tls, pCheck, __ccgo_ts+4618, libc.VaList(bp+48, rc))
		if rc == libc.Int32FromInt32(SQLITE_IOERR)|libc.Int32FromInt32(12)<<libc.Int32FromInt32(8) {
			(*TIntegrityCk)(unsafe.Pointer(pCheck)).Frc = int32(SQLITE_NOMEM)
		}
		goto end_of_check
	}
	/* Clear MemPage.isInit to make sure the corruption detection code in
	 ** btreeInitPage() is executed.  */
	savedIsInit = (*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).FisInit
	(*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).FisInit = uint8(0)
	v1 = _btreeInitPage(tls, **(**uintptr)(__ccgo_up(bp + 8)))
	rc = v1
	if v1 != 0 {
		/* The only possible error from InitPage */
		_checkAppendMsg(tls, pCheck, __ccgo_ts+4656, libc.VaList(bp+48, rc))
		goto end_of_check
	}
	v1 = _btreeComputeFreeSpace(tls, **(**uintptr)(__ccgo_up(bp + 8)))
	rc = v1
	if v1 != 0 {
		_checkAppendMsg(tls, pCheck, __ccgo_ts+4694, libc.VaList(bp+48, rc))
		goto end_of_check
	}
	data = (*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).FaData
	hdr = libc.Int32FromUint8((*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).FhdrOffset)
	/* Set up for cell analysis */
	(*TIntegrityCk)(unsafe.Pointer(pCheck)).FzPfx = __ccgo_ts + 4716
	contentOffset = libc.Uint32FromInt32((libc.Int32FromUint8(**(**Tu8)(__ccgo_up(data + uintptr(hdr+int32(5)))))<<libc.Int32FromInt32(8)|libc.Int32FromUint8(**(**Tu8)(__ccgo_up(data + uintptr(hdr+int32(5)) + 1)))-libc.Int32FromInt32(1))&libc.Int32FromInt32(0xffff) + libc.Int32FromInt32(1))
	/* Enforced by btreeInitPage() */
	/* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the
	 ** number of cells on the page. */
	nCell = libc.Int32FromUint8(**(**Tu8)(__ccgo_up(data + uintptr(hdr+int32(3)))))<<int32(8) | libc.Int32FromUint8(**(**Tu8)(__ccgo_up(data + uintptr(hdr+int32(3)) + 1)))
	if (*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).Fleaf != 0 || libc.Int32FromUint8((*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).FintKey) == 0 {
		**(**Ti64)(__ccgo_up(pCheck + 80)) += int64(nCell)
	}
	/* EVIDENCE-OF: R-23882-45353 The cell pointer array of a b-tree page
	 ** immediately follows the b-tree page header. */
	cellStart = hdr + int32(12) - int32(4)*libc.Int32FromUint8((*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).Fleaf)
	pCellIdx = data + uintptr(cellStart+int32(2)*(nCell-int32(1)))
	if !((*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).Fleaf != 0) {
		/* Analyze the right-child page of internal pages */
		pgno = libc.Int32FromUint32(_sqlite3Get4byte(tls, data+uintptr(hdr+int32(8))))
		if (*TBtShared)(unsafe.Pointer(pBt)).FautoVacuum != 0 {
			(*TIntegrityCk)(unsafe.Pointer(pCheck)).FzPfx = __ccgo_ts + 4742
			_checkPtrmap(tls, pCheck, libc.Uint32FromInt32(pgno), uint8(PTRMAP_BTREE), iPage)
		}
		depth = _checkTreePage(tls, pCheck, libc.Uint32FromInt32(pgno), bp, **(**Ti64)(__ccgo_up(bp)))
		keyCanBeEqual = 0
	} else {
		/* For leaf pages, the coverage check will occur in the same loop
		 ** as the other cell checks, so initialize the heap.  */
		heap = (*TIntegrityCk)(unsafe.Pointer(pCheck)).Fheap
		**(**Tu32)(__ccgo_up(heap)) = uint32(0)
	}
	/* EVIDENCE-OF: R-02776-14802 The cell pointer array consists of K 2-byte
	 ** integer offsets to the cell contents. */
	i = nCell - int32(1)
	for {
		if !(i >= 0 && (*TIntegrityCk)(unsafe.Pointer(pCheck)).FmxErr != 0) {
			break
		}
		/* Check cell size */
		(*TIntegrityCk)(unsafe.Pointer(pCheck)).Fv2 = i
		pc = libc.Uint32FromInt32(libc.Int32FromUint8(**(**Tu8)(__ccgo_up(pCellIdx)))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(**(**Tu8)(__ccgo_up(pCellIdx + 1))))
		pCellIdx = pCellIdx - uintptr(2)
		if pc < contentOffset || pc > usableSize-uint32(4) {
			_checkAppendMsg(tls, pCheck, __ccgo_ts+4772, libc.VaList(bp+48, pc, contentOffset, usableSize-uint32(4)))
			doCoverageCheck = 0
			goto _4
		}
		pCell = data + uintptr(pc)
		(*(*func(*libc.TLS, uintptr, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).FxParseCell})))(tls, **(**uintptr)(__ccgo_up(bp + 8)), pCell, bp+16)
		if pc+uint32((**(**TCellInfo)(__ccgo_up(bp + 16))).FnSize) > usableSize {
			_checkAppendMsg(tls, pCheck, __ccgo_ts+4802, 0)
			doCoverageCheck = 0
			goto _4
		}
		/* Check for integer primary key out of range */
		if (*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).FintKey != 0 {
			if keyCanBeEqual != 0 {
				v1 = libc.BoolInt32((**(**TCellInfo)(__ccgo_up(bp + 16))).FnKey > **(**Ti64)(__ccgo_up(bp)))
			} else {
				v1 = libc.BoolInt32((**(**TCellInfo)(__ccgo_up(bp + 16))).FnKey >= **(**Ti64)(__ccgo_up(bp)))
			}
			if v1 != 0 {
				_checkAppendMsg(tls, pCheck, __ccgo_ts+4826, libc.VaList(bp+48, (**(**TCellInfo)(__ccgo_up(bp + 16))).FnKey))
			}
			**(**Ti64)(__ccgo_up(bp)) = (**(**TCellInfo)(__ccgo_up(bp + 16))).FnKey
			keyCanBeEqual = 0 /* Only the first key on the page may ==maxKey */
		}
		/* Check the content overflow list */
		if (**(**TCellInfo)(__ccgo_up(bp + 16))).FnPayload > uint32((**(**TCellInfo)(__ccgo_up(bp + 16))).FnLocal) { /* First page of the overflow chain */
			nPage = ((**(**TCellInfo)(__ccgo_up(bp + 16))).FnPayload - uint32((**(**TCellInfo)(__ccgo_up(bp + 16))).FnLocal) + usableSize - uint32(5)) / (usableSize - uint32(4))
			pgnoOvfl = _sqlite3Get4byte(tls, pCell+uintptr(libc.Int32FromUint16((**(**TCellInfo)(__ccgo_up(bp + 16))).FnSize)-int32(4)))
			if (*TBtShared)(unsafe.Pointer(pBt)).FautoVacuum != 0 {
				_checkPtrmap(tls, pCheck, pgnoOvfl, uint8(PTRMAP_OVERFLOW1), iPage)
			}
			_checkList(tls, pCheck, 0, pgnoOvfl, nPage)
		}
		if !((*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).Fleaf != 0) {
			/* Check sanity of left child page for internal pages */
			pgno = libc.Int32FromUint32(_sqlite3Get4byte(tls, pCell))
			if (*TBtShared)(unsafe.Pointer(pBt)).FautoVacuum != 0 {
				_checkPtrmap(tls, pCheck, libc.Uint32FromInt32(pgno), uint8(PTRMAP_BTREE), iPage)
			}
			d2 = _checkTreePage(tls, pCheck, libc.Uint32FromInt32(pgno), bp, **(**Ti64)(__ccgo_up(bp)))
			keyCanBeEqual = 0
			if d2 != depth {
				_checkAppendMsg(tls, pCheck, __ccgo_ts+4850, 0)
				depth = d2
			}
		} else {
			/* Populate the coverage-checking heap for leaf pages */
			_btreeHeapInsert(tls, heap, pc<<libc.Int32FromInt32(16)|(pc+uint32((**(**TCellInfo)(__ccgo_up(bp + 16))).FnSize)-uint32(1)))
		}
		goto _4
	_4:
		;
		i = i - 1
	}
	**(**Ti64)(__ccgo_up(piMinKey)) = **(**Ti64)(__ccgo_up(bp))
	/* Check for complete coverage of the page
	 */
	(*TIntegrityCk)(unsafe.Pointer(pCheck)).FzPfx = uintptr(0)
	if doCoverageCheck != 0 && (*TIntegrityCk)(unsafe.Pointer(pCheck)).FmxErr > 0 {
		/* For leaf pages, the min-heap has already been initialized and the
		 ** cells have already been inserted.  But for internal pages, that has
		 ** not yet been done, so do it now */
		if !((*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).Fleaf != 0) {
			heap = (*TIntegrityCk)(unsafe.Pointer(pCheck)).Fheap
			**(**Tu32)(__ccgo_up(heap)) = uint32(0)
			i = nCell - int32(1)
			for {
				if !(i >= 0) {
					break
				}
				pc = libc.Uint32FromInt32(libc.Int32FromUint8(**(**Tu8)(__ccgo_up(data + uintptr(cellStart+i*int32(2)))))<<libc.Int32FromInt32(8) | libc.Int32FromUint8(**(**Tu8)(__ccgo_up(data + uintptr(cellStart+i*int32(2)) + 1))))
				size = uint32((*(*func(*libc.TLS, uintptr, uintptr) Tu16)(unsafe.Pointer(&struct{ uintptr }{(*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).FxCellSize})))(tls, **(**uintptr)(__ccgo_up(bp + 8)), data+uintptr(pc)))
				_btreeHeapInsert(tls, heap, pc<<libc.Int32FromInt32(16)|(pc+size-uint32(1)))
				goto _6
			_6:
				;
				i = i - 1
			}
		}
		/* Add the freeblocks to the min-heap
		 **
		 ** EVIDENCE-OF: R-20690-50594 The second field of the b-tree page header
		 ** is the offset of the first freeblock, or zero if there are no
		 ** freeblocks on the page.
		 */
		i = libc.Int32FromUint8(**(**Tu8)(__ccgo_up(data + uintptr(hdr+int32(1)))))<<int32(8) | libc.Int32FromUint8(**(**Tu8)(__ccgo_up(data + uintptr(hdr+int32(1)) + 1)))
		for i > 0 {
			/* Enforced by btreeComputeFreeSpace() */
			size1 = libc.Int32FromUint8(**(**Tu8)(__ccgo_up(data + uintptr(i+int32(2)))))<<int32(8) | libc.Int32FromUint8(**(**Tu8)(__ccgo_up(data + uintptr(i+int32(2)) + 1)))
			/* due to btreeComputeFreeSpace() */
			_btreeHeapInsert(tls, heap, libc.Uint32FromInt32(i)<<libc.Int32FromInt32(16)|libc.Uint32FromInt32(i+size1-libc.Int32FromInt32(1)))
			/* EVIDENCE-OF: R-58208-19414 The first 2 bytes of a freeblock are a
			 ** big-endian integer which is the offset in the b-tree page of the next
			 ** freeblock in the chain, or zero if the freeblock is the last on the
			 ** chain. */
			j = libc.Int32FromUint8(**(**Tu8)(__ccgo_up(data + uintptr(i))))<<int32(8) | libc.Int32FromUint8(**(**Tu8)(__ccgo_up(data + uintptr(i) + 1)))
			/* EVIDENCE-OF: R-06866-39125 Freeblocks are always connected in order of
			 ** increasing offset. */
			/* Enforced by btreeComputeFreeSpace() */
			/* Enforced by btreeComputeFreeSpace() */
			i = j
		}
		/* Analyze the min-heap looking for overlap between cells and/or
		 ** freeblocks, and counting the number of untracked bytes in nFrag.
		 **
		 ** Each min-heap entry is of the form:    (start_address<<16)|end_address.
		 ** There is an implied first entry the covers the page header, the cell
		 ** pointer index, and the gap between the cell pointer index and the start
		 ** of cell content.
		 **
		 ** The loop below pulls entries from the min-heap in order and compares
		 ** the start_address against the previous end_address.  If there is an
		 ** overlap, that means bytes are used multiple times.  If there is a gap,
		 ** that gap is added to the fragmentation count.
		 */
		nFrag = 0
		prev = contentOffset - uint32(1) /* Implied first min-heap entry */
		for _btreeHeapPull(tls, heap, bp+12) != 0 {
			if prev&uint32(0xffff) >= **(**Tu32)(__ccgo_up(bp + 12))>>libc.Int32FromInt32(16) {
				_checkAppendMsg(tls, pCheck, __ccgo_ts+4875, libc.VaList(bp+48, **(**Tu32)(__ccgo_up(bp + 12))>>int32(16), iPage))
				break
			} else {
				nFrag = libc.Int32FromUint32(uint32(nFrag) + (**(**Tu32)(__ccgo_up(bp + 12))>>libc.Int32FromInt32(16) - prev&libc.Uint32FromInt32(0xffff) - libc.Uint32FromInt32(1)))
				prev = **(**Tu32)(__ccgo_up(bp + 12))
			}
		}
		nFrag = libc.Int32FromUint32(uint32(nFrag) + (usableSize - prev&libc.Uint32FromInt32(0xffff) - libc.Uint32FromInt32(1)))
		/* EVIDENCE-OF: R-43263-13491 The total number of bytes in all fragments
		 ** is stored in the fifth field of the b-tree page header.
		 ** EVIDENCE-OF: R-07161-27322 The one-byte integer at offset 7 gives the
		 ** number of fragmented free bytes within the cell content area.
		 */
		if **(**Tu32)(__ccgo_up(heap)) == uint32(0) && nFrag != libc.Int32FromUint8(**(**Tu8)(__ccgo_up(data + uintptr(hdr+int32(7))))) {
			_checkAppendMsg(tls, pCheck, __ccgo_ts+4912, libc.VaList(bp+48, nFrag, libc.Int32FromUint8(**(**Tu8)(__ccgo_up(data + uintptr(hdr+int32(7))))), iPage))
		}
	}
	goto end_of_check
end_of_check:
	;
	if !(doCoverageCheck != 0) {
		(*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 8)))).FisInit = savedIsInit
	}
	_releasePage(tls, **(**uintptr)(__ccgo_up(bp + 8)))
	(*TIntegrityCk)(unsafe.Pointer(pCheck)).FzPfx = saved_zPfx
	(*TIntegrityCk)(unsafe.Pointer(pCheck)).Fv1 = libc.Uint32FromInt32(saved_v1)
	(*TIntegrityCk)(unsafe.Pointer(pCheck)).Fv2 = saved_v2
	return depth + int32(1)
}

// C documentation
//
//	/*
//	** Generate an instruction that will put the integer describe by
//	** text z[0..n-1] into register iMem.
//	**
//	** Expr.u.zToken is always UTF8 and zero-terminated.
//	*/
func _codeInteger(tls *libc.TLS, pParse uintptr, pExpr uintptr, negFlag int32, iMem int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var c, i int32
	var v, z, v1 uintptr
	var v2 int64
	var _ /* value at bp+0 */ Ti64
	_, _, _, _, _, _ = c, i, v, z, v1, v2
	v = (*TParse)(unsafe.Pointer(pParse)).FpVdbe
	if (*TExpr)(unsafe.Pointer(pExpr)).Fflags&uint32(EP_IntValue) != 0 {
		i = *(*int32)(unsafe.Pointer(pExpr + 8))
		if negFlag != 0 {
			i = -i
		}
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), i, iMem)
	} else {
		z = *(*uintptr)(unsafe.Pointer(pExpr + 8))
		c = _sqlite3DecOrHexToI64(tls, z, bp)
		if c == int32(3) && !(negFlag != 0) || c == int32(2) || negFlag != 0 && **(**Ti64)(__ccgo_up(bp)) == int64(-libc.Int32FromInt32(1))-(libc.Int64FromUint32(0xffffffff)|libc.Int64FromInt32(0x7fffffff)<<libc.Int32FromInt32(32)) {
			if Xsqlite3_strnicmp(tls, z, __ccgo_ts+8424, int32(2)) == 0 {
				if negFlag != 0 {
					v1 = __ccgo_ts + 5227
				} else {
					v1 = __ccgo_ts + 1702
				}
				_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+8427, libc.VaList(bp+16, v1, pExpr))
			} else {
				_codeReal(tls, v, z, negFlag, iMem)
			}
		} else {
			if negFlag != 0 {
				if c == int32(3) {
					v2 = int64(-libc.Int32FromInt32(1)) - (libc.Int64FromUint32(0xffffffff) | libc.Int64FromInt32(0x7fffffff)<<libc.Int32FromInt32(32))
				} else {
					v2 = -**(**Ti64)(__ccgo_up(bp))
				}
				**(**Ti64)(__ccgo_up(bp)) = v2
			}
			_sqlite3VdbeAddOp4Dup8(tls, v, int32(OP_Int64), 0, iMem, 0, bp, -int32(14))
		}
	}
}

// C documentation
//
//	/*
//	** Generate VDBE code for the statements inside the body of a single
//	** trigger.
//	*/
func _codeTriggerProgram(tls *libc.TLS, pParse uintptr, pStepList uintptr, orconf int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var db, pSelect, pStep, v uintptr
	var v2 int32
	var _ /* sDest at bp+0 */ TSelectDest
	_, _, _, _, _ = db, pSelect, pStep, v, v2
	v = (*TParse)(unsafe.Pointer(pParse)).FpVdbe
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	pStep = pStepList
	for {
		if !(pStep != 0) {
			break
		}
		/* Figure out the ON CONFLICT policy that will be used for this step
		 ** of the trigger program. If the statement that caused this trigger
		 ** to fire had an explicit ON CONFLICT, then use it. Otherwise, use
		 ** the ON CONFLICT policy that was specified as part of the trigger
		 ** step statement. Example:
		 **
		 **   CREATE TRIGGER AFTER INSERT ON t1 BEGIN;
		 **     INSERT OR REPLACE INTO t2 VALUES(new.a, new.b);
		 **   END;
		 **
		 **   INSERT INTO t1 ... ;            -- insert into t2 uses REPLACE policy
		 **   INSERT OR IGNORE INTO t1 ... ;  -- insert into t2 uses IGNORE policy
		 */
		if orconf == int32(OE_Default) {
			v2 = libc.Int32FromUint8((*TTriggerStep)(unsafe.Pointer(pStep)).Forconf)
		} else {
			v2 = libc.Int32FromUint8(libc.Uint8FromInt32(orconf))
		}
		(*TParse)(unsafe.Pointer(pParse)).FeOrconf = libc.Uint8FromInt32(v2)
		if (*TTriggerStep)(unsafe.Pointer(pStep)).FzSpan != 0 {
			_sqlite3VdbeAddOp4(tls, v, int32(OP_Trace), int32(0x7fffffff), int32(1), 0, _sqlite3MPrintf(tls, db, __ccgo_ts+6483, libc.VaList(bp+40, (*TTriggerStep)(unsafe.Pointer(pStep)).FzSpan)), -int32(7))
		}
		switch libc.Int32FromUint8((*TTriggerStep)(unsafe.Pointer(pStep)).Fop) {
		case int32(TK_UPDATE):
			_sqlite3Update(tls, pParse, _sqlite3SrcListDup(tls, db, (*TTriggerStep)(unsafe.Pointer(pStep)).FpSrc, 0), _sqlite3ExprListDup(tls, db, (*TTriggerStep)(unsafe.Pointer(pStep)).FpExprList, 0), _sqlite3ExprDup(tls, db, (*TTriggerStep)(unsafe.Pointer(pStep)).FpWhere, 0), libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).FeOrconf), uintptr(0), uintptr(0), uintptr(0))
			_sqlite3VdbeAddOp0(tls, v, int32(OP_ResetCount))
		case int32(TK_INSERT):
			_sqlite3Insert(tls, pParse, _sqlite3SrcListDup(tls, db, (*TTriggerStep)(unsafe.Pointer(pStep)).FpSrc, 0), _sqlite3SelectDup(tls, db, (*TTriggerStep)(unsafe.Pointer(pStep)).FpSelect, 0), _sqlite3IdListDup(tls, db, (*TTriggerStep)(unsafe.Pointer(pStep)).FpIdList), libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).FeOrconf), _sqlite3UpsertDup(tls, db, (*TTriggerStep)(unsafe.Pointer(pStep)).FpUpsert))
			_sqlite3VdbeAddOp0(tls, v, int32(OP_ResetCount))
		case int32(TK_DELETE):
			_sqlite3DeleteFrom(tls, pParse, _sqlite3SrcListDup(tls, db, (*TTriggerStep)(unsafe.Pointer(pStep)).FpSrc, 0), _sqlite3ExprDup(tls, db, (*TTriggerStep)(unsafe.Pointer(pStep)).FpWhere, 0), uintptr(0), uintptr(0))
			_sqlite3VdbeAddOp0(tls, v, int32(OP_ResetCount))
		default:
			pSelect = _sqlite3SelectDup(tls, db, (*TTriggerStep)(unsafe.Pointer(pStep)).FpSelect, 0)
			_sqlite3SelectDestInit(tls, bp, int32(SRT_Discard), 0)
			_sqlite3Select(tls, pParse, pSelect, bp)
			_sqlite3SelectDelete(tls, db, pSelect)
			break
		}
		goto _1
	_1:
		;
		pStep = (*TTriggerStep)(unsafe.Pointer(pStep)).FpNext
	}
	return 0
}

// C documentation
//
//	/*
//	** Expression pExpr is a comparison between two vector values. Compute
//	** the result of the comparison (1, 0, or NULL) and write that
//	** result into register dest.
//	**
//	** The caller must satisfy the following preconditions:
//	**
//	**    if pExpr->op==TK_IS:      op==TK_EQ and p5==SQLITE_NULLEQ
//	**    if pExpr->op==TK_ISNOT:   op==TK_NE and p5==SQLITE_NULLEQ
//	**    otherwise:                op==pExpr->op and p5==0
//	*/
func _codeVectorCompare(tls *libc.TLS, pParse uintptr, pExpr uintptr, dest int32, op Tu8, p5 Tu8) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var addrCmp, addrDone, i, isCommuted, nLeft, r1, r2, regLeft, regRight int32
	var opx Tu8
	var pLeft, pRight, v uintptr
	var _ /* pL at bp+8 */ uintptr
	var _ /* pR at bp+12 */ uintptr
	var _ /* regFree1 at bp+0 */ int32
	var _ /* regFree2 at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _ = addrCmp, addrDone, i, isCommuted, nLeft, opx, pLeft, pRight, r1, r2, regLeft, regRight, v
	v = (*TParse)(unsafe.Pointer(pParse)).FpVdbe
	pLeft = (*TExpr)(unsafe.Pointer(pExpr)).FpLeft
	pRight = (*TExpr)(unsafe.Pointer(pExpr)).FpRight
	nLeft = _sqlite3ExprVectorSize(tls, pLeft)
	regLeft = 0
	regRight = 0
	opx = op
	addrCmp = 0
	addrDone = _sqlite3VdbeMakeLabel(tls, pParse)
	isCommuted = libc.BoolInt32((*TExpr)(unsafe.Pointer(pExpr)).Fflags&libc.Uint32FromInt32(libc.Int32FromInt32(EP_Commuted)) != uint32(0))
	if (*TParse)(unsafe.Pointer(pParse)).FnErr != 0 {
		return
	}
	if nLeft != _sqlite3ExprVectorSize(tls, pRight) {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+6910, 0)
		return
	}
	if libc.Int32FromUint8(op) == int32(TK_LE) {
		opx = uint8(TK_LT)
	}
	if libc.Int32FromUint8(op) == int32(TK_GE) {
		opx = uint8(TK_GT)
	}
	if libc.Int32FromUint8(op) == int32(TK_NE) {
		opx = uint8(TK_EQ)
	}
	regLeft = _exprCodeSubselect(tls, pParse, pLeft)
	regRight = _exprCodeSubselect(tls, pParse, pRight)
	_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), int32(1), dest)
	i = 0
	for {
		if !(int32(1) != 0) {
			break
		}
		**(**int32)(__ccgo_up(bp)) = 0
		**(**int32)(__ccgo_up(bp + 4)) = 0
		**(**uintptr)(__ccgo_up(bp + 8)) = uintptr(0)
		**(**uintptr)(__ccgo_up(bp + 12)) = uintptr(0)
		if addrCmp != 0 {
			_sqlite3VdbeJumpHere(tls, v, addrCmp)
		}
		r1 = _exprVectorRegister(tls, pParse, pLeft, i, regLeft, bp+8, bp)
		r2 = _exprVectorRegister(tls, pParse, pRight, i, regRight, bp+12, bp+4)
		addrCmp = _sqlite3VdbeCurrentAddr(tls, v)
		_codeCompare(tls, pParse, **(**uintptr)(__ccgo_up(bp + 8)), **(**uintptr)(__ccgo_up(bp + 12)), libc.Int32FromUint8(opx), r1, r2, addrDone, libc.Int32FromUint8(p5), isCommuted)
		_sqlite3ReleaseTempReg(tls, pParse, **(**int32)(__ccgo_up(bp)))
		_sqlite3ReleaseTempReg(tls, pParse, **(**int32)(__ccgo_up(bp + 4)))
		if (libc.Int32FromUint8(opx) == int32(TK_LT) || libc.Int32FromUint8(opx) == int32(TK_GT)) && i < nLeft-int32(1) {
			addrCmp = _sqlite3VdbeAddOp0(tls, v, int32(OP_ElseEq))
		}
		if libc.Int32FromUint8(p5) == int32(SQLITE_NULLEQ) {
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), 0, dest)
		} else {
			_sqlite3VdbeAddOp3(tls, v, int32(OP_ZeroOrNull), r1, dest, r2)
		}
		if i == nLeft-int32(1) {
			break
		}
		if libc.Int32FromUint8(opx) == int32(TK_EQ) {
			_sqlite3VdbeAddOp2(tls, v, int32(OP_NotNull), dest, addrDone)
		} else {
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Goto), 0, addrDone)
			if i == nLeft-int32(2) {
				opx = op
			}
		}
		goto _1
	_1:
		;
		i = i + 1
	}
	_sqlite3VdbeJumpHere(tls, v, addrCmp)
	_sqlite3VdbeResolveLabel(tls, v, addrDone)
	if libc.Int32FromUint8(op) == int32(TK_NE) {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Not), dest, dest)
	}
}

// C documentation
//
//	/*
//	** Return a pointer to a string containing the 'declaration type' of the
//	** expression pExpr. The string may be treated as static by the caller.
//	**
//	** The declaration type is the exact datatype definition extracted from the
//	** original CREATE TABLE statement if the expression is a column. The
//	** declaration type for a ROWID field is INTEGER. Exactly when an expression
//	** is considered a column can be complex in the presence of subqueries. The
//	** result-set expression in all of the following SELECT statements is
//	** considered a column by this function.
//	**
//	**   SELECT col FROM tbl;
//	**   SELECT (SELECT col FROM tbl;
//	**   SELECT (SELECT col FROM tbl);
//	**   SELECT abc FROM (SELECT col AS abc FROM tbl);
//	**
//	** The declaration type for any expression other than a column is NULL.
//	**
//	** This routine has either 3 or 6 parameters depending on whether or not
//	** the SQLITE_ENABLE_COLUMN_METADATA compile-time option is used.
//	*/
func _columnTypeImpl(tls *libc.TLS, pNC uintptr, pExpr uintptr, pzOrigDb uintptr, pzOrigTab uintptr, pzOrigCol uintptr) (r uintptr) {
	bp := tls.Alloc(96)
	defer tls.Free(96)
	var iCol, iDb, j int32
	var p, p1, pS, pS1, pTab, pTabList, zType uintptr
	var _ /* sNC at bp+12 */ TNameContext
	var _ /* sNC at bp+48 */ TNameContext
	var _ /* zOrigCol at bp+8 */ uintptr
	var _ /* zOrigDb at bp+0 */ uintptr
	var _ /* zOrigTab at bp+4 */ uintptr
	_, _, _, _, _, _, _, _, _, _ = iCol, iDb, j, p, p1, pS, pS1, pTab, pTabList, zType
	zType = uintptr(0)
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	**(**uintptr)(__ccgo_up(bp + 4)) = uintptr(0)
	**(**uintptr)(__ccgo_up(bp + 8)) = uintptr(0)
	switch libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pExpr)).Fop) {
	case int32(TK_COLUMN):
		/* The expression is a column. Locate the table the column is being
		 ** extracted from in NameContext.pSrcList. This table may be real
		 ** database table or a subquery.
		 */
		pTab = uintptr(0)                                      /* Table structure column is extracted from */
		pS = uintptr(0)                                        /* Select the column is extracted from */
		iCol = int32((*TExpr)(unsafe.Pointer(pExpr)).FiColumn) /* Index of column in pTab */
		for pNC != 0 && !(pTab != 0) {
			pTabList = (*TNameContext)(unsafe.Pointer(pNC)).FpSrcList
			j = 0
			for {
				if !(j < (*TSrcList)(unsafe.Pointer(pTabList)).FnSrc && (*(*TSrcItem)(unsafe.Pointer(pTabList + 8 + uintptr(j)*48))).FiCursor != (*TExpr)(unsafe.Pointer(pExpr)).FiTable) {
					break
				}
				goto _1
			_1:
				;
				j = j + 1
			}
			if j < (*TSrcList)(unsafe.Pointer(pTabList)).FnSrc {
				pTab = (*(*TSrcItem)(unsafe.Pointer(pTabList + 8 + uintptr(j)*48))).FpSTab
				if int32(*(*uint32)(unsafe.Pointer(pTabList + 8 + uintptr(j)*48 + 12 + 4))&0x4>>2) != 0 {
					pS = (*TSubquery)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pTabList + 8 + uintptr(j)*48 + 44)))).FpSelect
				} else {
					pS = uintptr(0)
				}
			} else {
				pNC = (*TNameContext)(unsafe.Pointer(pNC)).FpNext
			}
		}
		if pTab == uintptr(0) {
			/* At one time, code such as "SELECT new.x" within a trigger would
			 ** cause this condition to run.  Since then, we have restructured how
			 ** trigger code is generated and so this condition is no longer
			 ** possible. However, it can still be true for statements like
			 ** the following:
			 **
			 **   CREATE TABLE t1(col INTEGER);
			 **   SELECT (SELECT t1.col) FROM FROM t1;
			 **
			 ** when columnType() is called on the expression "t1.col" in the
			 ** sub-select. In this case, set the column type to NULL, even
			 ** though it should really be "INTEGER".
			 **
			 ** This is not a problem, as the column type of "t1.col" is never
			 ** used. When columnType() is called on the expression
			 ** "(SELECT t1.col)", the correct type is returned (see the TK_SELECT
			 ** branch below.  */
			break
		}
		if pS != 0 {
			/* The "table" is actually a sub-select or a view in the FROM clause
			 ** of the SELECT statement. Return the declaration type and origin
			 ** data for the result-set column of the sub-select.
			 */
			if iCol < (*TExprList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(pS)).FpEList)).FnExpr && libc.Bool(libc.Bool(!(libc.Int32FromInt32(ViewCanHaveRowid) != 0)) || iCol >= 0) {
				p = (*(*TExprList_item)(unsafe.Pointer((*TSelect)(unsafe.Pointer(pS)).FpEList + 8 + uintptr(iCol)*20))).FpExpr
				(**(**TNameContext)(__ccgo_up(bp + 12))).FpSrcList = (*TSelect)(unsafe.Pointer(pS)).FpSrc
				(**(**TNameContext)(__ccgo_up(bp + 12))).FpNext = pNC
				(**(**TNameContext)(__ccgo_up(bp + 12))).FpParse = (*TNameContext)(unsafe.Pointer(pNC)).FpParse
				zType = _columnTypeImpl(tls, bp+12, p, bp, bp+4, bp+8)
			}
		} else {
			/* A real table or a CTE table */
			if iCol < 0 {
				iCol = int32((*TTable)(unsafe.Pointer(pTab)).FiPKey)
			}
			if iCol < 0 {
				zType = __ccgo_ts + 1176
				**(**uintptr)(__ccgo_up(bp + 8)) = __ccgo_ts + 17965
			} else {
				**(**uintptr)(__ccgo_up(bp + 8)) = (**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(iCol)*12))).FzCnName
				zType = _sqlite3ColumnType(tls, (*TTable)(unsafe.Pointer(pTab)).FaCol+uintptr(iCol)*12, uintptr(0))
			}
			**(**uintptr)(__ccgo_up(bp + 4)) = (*TTable)(unsafe.Pointer(pTab)).FzName
			if (*TNameContext)(unsafe.Pointer(pNC)).FpParse != 0 && (*TTable)(unsafe.Pointer(pTab)).FpSchema != 0 {
				iDb = _sqlite3SchemaToIndex(tls, (*TParse)(unsafe.Pointer((*TNameContext)(unsafe.Pointer(pNC)).FpParse)).Fdb, (*TTable)(unsafe.Pointer(pTab)).FpSchema)
				**(**uintptr)(__ccgo_up(bp)) = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer((*TParse)(unsafe.Pointer((*TNameContext)(unsafe.Pointer(pNC)).FpParse)).Fdb)).FaDb + uintptr(iDb)*16))).FzDbSName
			}
		}
	case int32(TK_SELECT):
		pS1 = *(*uintptr)(unsafe.Pointer(pExpr + 20))
		p1 = (*(*TExprList_item)(unsafe.Pointer((*TSelect)(unsafe.Pointer(pS1)).FpEList + 8))).FpExpr
		(**(**TNameContext)(__ccgo_up(bp + 48))).FpSrcList = (*TSelect)(unsafe.Pointer(pS1)).FpSrc
		(**(**TNameContext)(__ccgo_up(bp + 48))).FpNext = pNC
		(**(**TNameContext)(__ccgo_up(bp + 48))).FpParse = (*TNameContext)(unsafe.Pointer(pNC)).FpParse
		zType = _columnTypeImpl(tls, bp+48, p1, bp, bp+4, bp+8)
		break
	}
	if pzOrigDb != 0 {
		**(**uintptr)(__ccgo_up(pzOrigDb)) = **(**uintptr)(__ccgo_up(bp))
		**(**uintptr)(__ccgo_up(pzOrigTab)) = **(**uintptr)(__ccgo_up(bp + 4))
		**(**uintptr)(__ccgo_up(pzOrigCol)) = **(**uintptr)(__ccgo_up(bp + 8))
	}
	return zType
}

// C documentation
//
//	/*
//	** Attempt to transform a query of the form
//	**
//	**    SELECT count(*) FROM (SELECT x FROM t1 UNION ALL SELECT y FROM t2)
//	**
//	** Into this:
//	**
//	**    SELECT (SELECT count(*) FROM t1)+(SELECT count(*) FROM t2)
//	**
//	** The transformation only works if all of the following are true:
//	**
//	**   *  The subquery is a UNION ALL of two or more terms
//	**   *  The subquery does not have a LIMIT clause
//	**   *  There is no WHERE or GROUP BY or HAVING clauses on the subqueries
//	**   *  The outer query is a simple count(*) with no WHERE clause or other
//	**      extraneous syntax.
//	**   *  None of the subqueries are DISTINCT (forumpost/a860f5fb2e 2025-03-10)
//	**
//	** Return TRUE if the optimization is undertaken.
//	*/
func _countOfViewOptimization(tls *libc.TLS, pParse uintptr, p uintptr) (r int32) {
	var db, pCount, pExpr, pFrom, pPrior, pSub, pTerm, v1 uintptr
	_, _, _, _, _, _, _, _ = db, pCount, pExpr, pFrom, pPrior, pSub, pTerm, v1
	if (*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_Aggregate) == uint32(0) {
		return 0
	} /* This is an aggregate */
	if (*TExprList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpEList)).FnExpr != int32(1) {
		return 0
	} /* Single result column */
	if (*TSelect)(unsafe.Pointer(p)).FpWhere != 0 {
		return 0
	}
	if (*TSelect)(unsafe.Pointer(p)).FpHaving != 0 {
		return 0
	}
	if (*TSelect)(unsafe.Pointer(p)).FpGroupBy != 0 {
		return 0
	}
	if (*TSelect)(unsafe.Pointer(p)).FpOrderBy != 0 {
		return 0
	}
	pExpr = (*(*TExprList_item)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpEList + 8))).FpExpr
	if libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pExpr)).Fop) != int32(TK_AGG_FUNCTION) {
		return 0
	} /* Result is an aggregate */
	if Xsqlite3_stricmp(tls, *(*uintptr)(unsafe.Pointer(pExpr + 8)), __ccgo_ts+17118) != 0 {
		return 0
	} /* Is count() */
	if *(*uintptr)(unsafe.Pointer(pExpr + 20)) != uintptr(0) {
		return 0
	} /* Must be count(*) */
	if (*TSrcList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpSrc)).FnSrc != int32(1) {
		return 0
	} /* One table in FROM  */
	if (*TExpr)(unsafe.Pointer(pExpr)).Fflags&libc.Uint32FromInt32(libc.Int32FromInt32(EP_WinFunc)) != uint32(0) {
		return 0
	} /* Not a window function */
	pFrom = (*TSelect)(unsafe.Pointer(p)).FpSrc + 8
	if int32(*(*uint32)(unsafe.Pointer(pFrom + 12 + 4))&0x4>>2) == 0 {
		return 0
	} /* FROM is a subquery */
	pSub = (*TSubquery)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pFrom + 44)))).FpSelect
	if (*TSelect)(unsafe.Pointer(pSub)).FpPrior == uintptr(0) {
		return 0
	} /* Must be a compound */
	if (*TSelect)(unsafe.Pointer(pSub)).FselFlags&uint32(SF_CopyCte) != 0 {
		return 0
	} /* Not a CTE */
	for cond := true; cond; cond = pSub != 0 {
		if libc.Int32FromUint8((*TSelect)(unsafe.Pointer(pSub)).Fop) != int32(TK_ALL) && (*TSelect)(unsafe.Pointer(pSub)).FpPrior != 0 {
			return 0
		} /* Must be UNION ALL */
		if (*TSelect)(unsafe.Pointer(pSub)).FpWhere != 0 {
			return 0
		} /* No WHERE clause */
		if (*TSelect)(unsafe.Pointer(pSub)).FpLimit != 0 {
			return 0
		} /* No LIMIT clause */
		if (*TSelect)(unsafe.Pointer(pSub)).FselFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SF_Aggregate)|libc.Int32FromInt32(SF_Distinct)) != 0 {
			return 0 /* Not an aggregate nor DISTINCT */
		}
		/* Due to the previous */
		pSub = (*TSelect)(unsafe.Pointer(pSub)).FpPrior /* Repeat over compound */
	}
	/* If we reach this point then it is OK to perform the transformation */
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	pCount = pExpr
	pExpr = uintptr(0)
	pSub = _sqlite3SubqueryDetach(tls, db, pFrom)
	_sqlite3SrcListDelete(tls, db, (*TSelect)(unsafe.Pointer(p)).FpSrc)
	(*TSelect)(unsafe.Pointer(p)).FpSrc = _sqlite3DbMallocZero(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, uint64(uint32(libc.UintptrFromInt32(0)+8)+libc.Uint32FromInt64(48)))
	for pSub != 0 {
		pPrior = (*TSelect)(unsafe.Pointer(pSub)).FpPrior
		(*TSelect)(unsafe.Pointer(pSub)).FpPrior = uintptr(0)
		(*TSelect)(unsafe.Pointer(pSub)).FpNext = uintptr(0)
		**(**Tu32)(__ccgo_up(pSub + 4)) |= uint32(SF_Aggregate)
		**(**Tu32)(__ccgo_up(pSub + 4)) &= ^libc.Uint32FromInt32(SF_Compound)
		(*TSelect)(unsafe.Pointer(pSub)).FnSelectRow = 0
		_sqlite3ParserAddCleanup(tls, pParse, __ccgo_fp(_sqlite3ExprListDeleteGeneric), (*TSelect)(unsafe.Pointer(pSub)).FpEList)
		if pPrior != 0 {
			v1 = _sqlite3ExprDup(tls, db, pCount, 0)
		} else {
			v1 = pCount
		}
		pTerm = v1
		(*TSelect)(unsafe.Pointer(pSub)).FpEList = _sqlite3ExprListAppend(tls, pParse, uintptr(0), pTerm)
		pTerm = _sqlite3PExpr(tls, pParse, int32(TK_SELECT), uintptr(0), uintptr(0))
		_sqlite3PExprAddSelect(tls, pParse, pTerm, pSub)
		if pExpr == uintptr(0) {
			pExpr = pTerm
		} else {
			pExpr = _sqlite3PExpr(tls, pParse, int32(TK_PLUS), pTerm, pExpr)
		}
		pSub = pPrior
	}
	(*(*TExprList_item)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpEList + 8))).FpExpr = pExpr
	**(**Tu32)(__ccgo_up(p + 4)) &= ^libc.Uint32FromInt32(SF_Aggregate)
	return int32(1)
}

// C documentation
//
//	/*
//	** Connect to or create a dbpagevfs virtual table.
//	*/
func _dbpageConnect(tls *libc.TLS, db uintptr, pAux uintptr, argc int32, argv uintptr, ppVtab uintptr, pzErr uintptr) (r int32) {
	var pTab uintptr
	var rc int32
	_, _ = pTab, rc
	pTab = uintptr(0)
	rc = SQLITE_OK
	_ = pAux
	_ = argc
	_ = argv
	_ = pzErr
	Xsqlite3_vtab_config(tls, db, int32(SQLITE_VTAB_DIRECTONLY), 0)
	Xsqlite3_vtab_config(tls, db, int32(SQLITE_VTAB_USES_ALL_SCHEMAS), 0)
	rc = Xsqlite3_declare_vtab(tls, db, __ccgo_ts+35000)
	if rc == SQLITE_OK {
		pTab = Xsqlite3_malloc64(tls, uint64(24))
		if pTab == uintptr(0) {
			rc = int32(SQLITE_NOMEM)
		}
	}
	if rc == SQLITE_OK {
		libc.Xmemset(tls, pTab, 0, uint32(24))
		(*TDbpageTable)(unsafe.Pointer(pTab)).Fdb = db
	}
	**(**uintptr)(__ccgo_up(ppVtab)) = pTab
	return rc
}

func _dbpageUpdate(tls *libc.TLS, pVtab uintptr, argc int32, argv uintptr, pRowid uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var aPage, pBt, pData, pPager, pTab, zErr, zSchema uintptr
	var iDb, isInsert, rc, szPage, v1 int32
	var pgno TPgno
	var _ /* pDbPage at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _ = aPage, iDb, isInsert, pBt, pData, pPager, pTab, pgno, rc, szPage, zErr, zSchema, v1
	pTab = pVtab
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	rc = SQLITE_OK
	zErr = uintptr(0)
	_ = pRowid
	if (*Tsqlite3)(unsafe.Pointer((*TDbpageTable)(unsafe.Pointer(pTab)).Fdb)).Fflags&uint64(SQLITE_Defensive) != 0 {
		zErr = __ccgo_ts + 35067
		goto update_fail
	}
	if argc == int32(1) {
		zErr = __ccgo_ts + 35077
		goto update_fail
	}
	if Xsqlite3_value_type(tls, **(**uintptr)(__ccgo_up(argv))) == int32(SQLITE_NULL) {
		pgno = libc.Uint32FromInt64(Xsqlite3_value_int64(tls, **(**uintptr)(__ccgo_up(argv + 2*4))))
		isInsert = int32(1)
	} else {
		pgno = libc.Uint32FromInt64(Xsqlite3_value_int64(tls, **(**uintptr)(__ccgo_up(argv))))
		if libc.Uint32FromInt32(Xsqlite3_value_int(tls, **(**uintptr)(__ccgo_up(argv + 1*4)))) != pgno {
			zErr = __ccgo_ts + 35091
			goto update_fail
		}
		isInsert = 0
	}
	if Xsqlite3_value_type(tls, **(**uintptr)(__ccgo_up(argv + 4*4))) == int32(SQLITE_NULL) {
		iDb = 0
	} else {
		zSchema = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv + 4*4)))
		iDb = _sqlite3FindDbName(tls, (*TDbpageTable)(unsafe.Pointer(pTab)).Fdb, zSchema)
		if iDb < 0 {
			zErr = __ccgo_ts + 35105
			goto update_fail
		}
	}
	pBt = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer((*TDbpageTable)(unsafe.Pointer(pTab)).Fdb)).FaDb + uintptr(iDb)*16))).FpBt
	if pgno < uint32(1) || pBt == uintptr(0) {
		zErr = __ccgo_ts + 35120
		goto update_fail
	}
	szPage = _sqlite3BtreeGetPageSize(tls, pBt)
	if Xsqlite3_value_type(tls, **(**uintptr)(__ccgo_up(argv + 3*4))) != int32(SQLITE_BLOB) || Xsqlite3_value_bytes(tls, **(**uintptr)(__ccgo_up(argv + 3*4))) != szPage {
		if Xsqlite3_value_type(tls, **(**uintptr)(__ccgo_up(argv + 3*4))) == int32(SQLITE_NULL) && isInsert != 0 && pgno > uint32(1) {
			/* "INSERT INTO dbpage($PGNO,NULL)" causes page number $PGNO and
			 ** all subsequent pages to be deleted. */
			(*TDbpageTable)(unsafe.Pointer(pTab)).FiDbTrunc = iDb
			(*TDbpageTable)(unsafe.Pointer(pTab)).FpgnoTrunc = pgno - uint32(1)
			pgno = uint32(1)
		} else {
			zErr = __ccgo_ts + 35136
			goto update_fail
		}
	}
	if _dbpageBeginTrans(tls, pTab) != SQLITE_OK {
		zErr = __ccgo_ts + 35151
		goto update_fail
	}
	pPager = _sqlite3BtreePager(tls, pBt)
	rc = _sqlite3PagerGet(tls, pPager, pgno, bp, 0)
	if rc == SQLITE_OK {
		pData = Xsqlite3_value_blob(tls, **(**uintptr)(__ccgo_up(argv + 3*4)))
		v1 = _sqlite3PagerWrite(tls, **(**uintptr)(__ccgo_up(bp)))
		rc = v1
		if v1 == SQLITE_OK && pData != 0 {
			aPage = _sqlite3PagerGetData(tls, **(**uintptr)(__ccgo_up(bp)))
			libc.Xmemcpy(tls, aPage, pData, libc.Uint32FromInt32(szPage))
			(*TDbpageTable)(unsafe.Pointer(pTab)).FpgnoTrunc = uint32(0)
		}
	}
	if rc != SQLITE_OK {
		(*TDbpageTable)(unsafe.Pointer(pTab)).FpgnoTrunc = uint32(0)
	}
	_sqlite3PagerUnref(tls, **(**uintptr)(__ccgo_up(bp)))
	return rc
	goto update_fail
update_fail:
	;
	(*TDbpageTable)(unsafe.Pointer(pTab)).FpgnoTrunc = uint32(0)
	Xsqlite3_free(tls, (*Tsqlite3_vtab)(unsafe.Pointer(pVtab)).FzErrMsg)
	(*Tsqlite3_vtab)(unsafe.Pointer(pVtab)).FzErrMsg = Xsqlite3_mprintf(tls, __ccgo_ts+3942, libc.VaList(bp+16, zErr))
	return int32(SQLITE_ERROR)
}

// C documentation
//
//	/*
//	** Write code to erase the table with root-page iTable from database iDb.
//	** Also write code to modify the sqlite_schema table and internal schema
//	** if a root-page of another table is moved by the btree-layer whilst
//	** erasing iTable (this can happen with an auto-vacuum database).
//	*/
func _destroyRootPage(tls *libc.TLS, pParse uintptr, iTable int32, iDb int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var r1 int32
	var v uintptr
	_, _ = r1, v
	v = _sqlite3GetVdbe(tls, pParse)
	r1 = _sqlite3GetTempReg(tls, pParse)
	if iTable < int32(2) {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+14871, 0)
	}
	_sqlite3VdbeAddOp3(tls, v, int32(OP_Destroy), iTable, r1, iDb)
	_sqlite3MayAbort(tls, pParse)
	/* OP_Destroy stores an in integer r1. If this integer
	 ** is non-zero, then it is the root page number of a table moved to
	 ** location iTable. The following code modifies the sqlite_schema table to
	 ** reflect this.
	 **
	 ** The "#NNN" in the SQL is a special constant that means whatever value
	 ** is in register NNN.  See grammar rules associated with the TK_REGISTER
	 ** token for additional information.
	 */
	_sqlite3NestedParse(tls, pParse, __ccgo_ts+14886, libc.VaList(bp+8, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer((*TParse)(unsafe.Pointer(pParse)).Fdb)).FaDb + uintptr(iDb)*16))).FzDbSName, iTable, r1, r1))
	_sqlite3ReleaseTempReg(tls, pParse, r1)
}

// C documentation
//
//	/*
//	** The implementation of internal UDF sqlite_drop_column().
//	**
//	** Arguments:
//	**
//	**  argv[0]: An integer - the index of the schema containing the table
//	**  argv[1]: CREATE TABLE statement to modify.
//	**  argv[2]: An integer - the index of the column to remove.
//	**
//	** The value returned is a string containing the CREATE TABLE statement
//	** with column argv[2] removed.
//	*/
func _dropColumnFunc(tls *libc.TLS, context uintptr, NotUsed int32, argv uintptr) {
	bp := tls.Alloc(320)
	defer tls.Free(320)
	var db, pCol, pEnd, pTab, zDb, zEnd, zNew, zSql uintptr
	var iCol, iSchema, rc int32
	var xAuth Tsqlite3_xauth
	var _ /* eTok at bp+284 */ int32
	var _ /* sParse at bp+0 */ TParse
	_, _, _, _, _, _, _, _, _, _, _, _ = db, iCol, iSchema, pCol, pEnd, pTab, rc, xAuth, zDb, zEnd, zNew, zSql
	db = Xsqlite3_context_db_handle(tls, context)
	iSchema = Xsqlite3_value_int(tls, **(**uintptr)(__ccgo_up(argv)))
	zSql = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv + 1*4)))
	iCol = Xsqlite3_value_int(tls, **(**uintptr)(__ccgo_up(argv + 2*4)))
	zDb = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iSchema)*16))).FzDbSName
	zNew = uintptr(0)
	xAuth = (*Tsqlite3)(unsafe.Pointer(db)).FxAuth
	(*Tsqlite3)(unsafe.Pointer(db)).FxAuth = uintptr(0)
	_ = NotUsed
	rc = _renameParseSql(tls, bp, zDb, db, zSql, libc.BoolInt32(iSchema == int32(1)))
	if rc != SQLITE_OK {
		goto drop_column_done
	}
	pTab = (**(**TParse)(__ccgo_up(bp))).FpNewTable
	if pTab == uintptr(0) || int32((*TTable)(unsafe.Pointer(pTab)).FnCol) == int32(1) || iCol >= int32((*TTable)(unsafe.Pointer(pTab)).FnCol) {
		/* This can happen if the sqlite_schema table is corrupt */
		rc = _sqlite3CorruptError(tls, int32(122753))
		goto drop_column_done
	}
	if iCol < int32((*TTable)(unsafe.Pointer(pTab)).FnCol)-int32(1) {
		pCol = _renameTokenFind(tls, bp, uintptr(0), (**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(iCol)*12))).FzCnName)
		pEnd = _renameTokenFind(tls, bp, uintptr(0), (**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(iCol+int32(1))*12))).FzCnName)
		zEnd = (*TRenameToken)(unsafe.Pointer(pEnd)).Ft.Fz
	} else {
		/* Point pCol->t.z at the "," immediately preceding the definition of
		 ** the column being dropped. To do this, start at the name of the
		 ** previous column, and tokenize until the next ",".  */
		pCol = _renameTokenFind(tls, bp, uintptr(0), (**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(iCol-int32(1))*12))).FzCnName)
		for cond := true; cond; cond = **(**int32)(__ccgo_up(bp + 284)) != int32(TK_COMMA) {
			(*TRenameToken)(unsafe.Pointer(pCol)).Ft.Fz += uintptr(_getConstraintToken(tls, (*TRenameToken)(unsafe.Pointer(pCol)).Ft.Fz, bp+284))
		}
		(*TRenameToken)(unsafe.Pointer(pCol)).Ft.Fz = (*TRenameToken)(unsafe.Pointer(pCol)).Ft.Fz - 1
		zEnd = zSql + uintptr((*(*struct {
			FaddColOffset int32
			FpFKey        uintptr
			FpDfltList    uintptr
		})(unsafe.Pointer(pTab + 44))).FaddColOffset)
	}
	zNew = _sqlite3MPrintf(tls, db, __ccgo_ts+11587, libc.VaList(bp+296, int32((*TRenameToken)(unsafe.Pointer(pCol)).Ft.Fz)-int32(zSql), zSql, zEnd))
	Xsqlite3_result_text(tls, context, zNew, -int32(1), uintptr(-libc.Int32FromInt32(1)))
	Xsqlite3_free(tls, zNew)
	goto drop_column_done
drop_column_done:
	;
	_renameParseCleanup(tls, bp)
	(*Tsqlite3)(unsafe.Pointer(db)).FxAuth = xAuth
	if rc != SQLITE_OK {
		Xsqlite3_result_error_code(tls, context, rc)
	}
}

// C documentation
//
//	/*
//	** Internal SQL function sqlite3_drop_constraint():  Given an input
//	** CREATE TABLE statement, return a revised CREATE TABLE statement
//	** with a constraint removed.  Two forms, depending on the datatype
//	** of argv[2]:
//	**
//	**   sqlite_drop_constraint(SQL, INT)  -- Omit NOT NULL from the INT-th column
//	**   sqlite_drop_constraint(SQL, TEXT) -- OMIT constraint with name TEXT
//	**
//	** In the first case, the left-most column is 0.
//	*/
func _dropConstraintFunc(tls *libc.TLS, ctx uintptr, NotUsed int32, argv uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var db, zCons, zNew, zSpace, zSql uintptr
	var iEnd, iNotNull, iStart, ii, nTok int32
	var _ /* cmp at bp+8 */ int32
	var _ /* iOff at bp+0 */ int32
	var _ /* t at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _ = db, iEnd, iNotNull, iStart, ii, nTok, zCons, zNew, zSpace, zSql
	zSql = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv)))
	zCons = uintptr(0)
	iNotNull = -int32(1)
	**(**int32)(__ccgo_up(bp)) = 0
	iStart = 0
	iEnd = 0
	zNew = uintptr(0)
	**(**int32)(__ccgo_up(bp + 4)) = 0
	_ = NotUsed
	if zSql == uintptr(0) {
		return
	}
	/* Jump past the "CREATE TABLE" bit. */
	if _skipCreateTable(tls, ctx, zSql, bp) != 0 {
		return
	}
	if Xsqlite3_value_type(tls, **(**uintptr)(__ccgo_up(argv + 1*4))) == int32(SQLITE_INTEGER) {
		iNotNull = Xsqlite3_value_int(tls, **(**uintptr)(__ccgo_up(argv + 1*4)))
	} else {
		zCons = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv + 1*4)))
	}
	/* Search for the named constraint within column definitions. */
	ii = 0
	for {
		if !(iEnd == 0) {
			break
		}
		/* Now parse the column or table constraint definition. Search
		 ** for the token CONSTRAINT if this is a DROP CONSTRAINT command, or
		 ** NOT in the right column if this is a DROP NOT NULL. */
		for int32(1) != 0 {
			iStart = **(**int32)(__ccgo_up(bp))
			**(**int32)(__ccgo_up(bp)) = **(**int32)(__ccgo_up(bp)) + _getConstraintToken(tls, zSql+uintptr(**(**int32)(__ccgo_up(bp))), bp+4)
			if **(**int32)(__ccgo_up(bp + 4)) == int32(TK_CONSTRAINT) && (zCons != 0 || iNotNull == ii) {
				/* Check if this is the constraint we are searching for. */
				nTok = 0
				**(**int32)(__ccgo_up(bp + 8)) = int32(1)
				/* Skip past any whitespace. */
				**(**int32)(__ccgo_up(bp)) = **(**int32)(__ccgo_up(bp)) + _getWhitespace(tls, zSql+uintptr(**(**int32)(__ccgo_up(bp))))
				/* Compare the next token - which may be quoted - with the name of
				 ** the constraint being dropped.  */
				nTok = _getConstraintToken(tls, zSql+uintptr(**(**int32)(__ccgo_up(bp))), bp+4)
				if zCons != 0 {
					if _quotedCompare(tls, ctx, **(**int32)(__ccgo_up(bp + 4)), zSql+uintptr(**(**int32)(__ccgo_up(bp))), nTok, zCons, bp+8) != 0 {
						return
					}
				}
				**(**int32)(__ccgo_up(bp)) = **(**int32)(__ccgo_up(bp)) + nTok
				/* The next token is usually the first token of the constraint
				 ** definition. This is enough to tell the type of the constraint -
				 ** TK_NOT means it is a NOT NULL, TK_CHECK a CHECK constraint etc.
				 **
				 ** There is also the chance that the next token is TK_CONSTRAINT
				 ** (or TK_DEFAULT or TK_COLLATE), for example if a table has been
				 ** created as follows:
				 **
				 **    CREATE TABLE t1(cols, CONSTRAINT one CONSTRAINT two NOT NULL);
				 **
				 ** In this case, allow the "CONSTRAINT one" bit to be dropped by
				 ** this command if that is what is requested, or to advance to
				 ** the next iteration of the loop with &zSql[iOff] still pointing
				 ** to the CONSTRAINT keyword.  */
				nTok = _getConstraintToken(tls, zSql+uintptr(**(**int32)(__ccgo_up(bp))), bp+4)
				if **(**int32)(__ccgo_up(bp + 4)) == int32(TK_CONSTRAINT) || **(**int32)(__ccgo_up(bp + 4)) == int32(TK_DEFAULT) || **(**int32)(__ccgo_up(bp + 4)) == int32(TK_COLLATE) || **(**int32)(__ccgo_up(bp + 4)) == int32(TK_COMMA) || **(**int32)(__ccgo_up(bp + 4)) == int32(TK_RP) || **(**int32)(__ccgo_up(bp + 4)) == int32(TK_GENERATED) || **(**int32)(__ccgo_up(bp + 4)) == int32(TK_AS) {
					**(**int32)(__ccgo_up(bp + 4)) = int32(TK_CHECK)
				} else {
					**(**int32)(__ccgo_up(bp)) = **(**int32)(__ccgo_up(bp)) + nTok
					**(**int32)(__ccgo_up(bp)) = **(**int32)(__ccgo_up(bp)) + _getConstraint(tls, zSql+uintptr(**(**int32)(__ccgo_up(bp))))
				}
				if **(**int32)(__ccgo_up(bp + 8)) == 0 || iNotNull >= 0 && **(**int32)(__ccgo_up(bp + 4)) == int32(TK_NOT) {
					if **(**int32)(__ccgo_up(bp + 4)) != int32(TK_NOT) && **(**int32)(__ccgo_up(bp + 4)) != int32(TK_CHECK) {
						_errorMPrintf(tls, ctx, __ccgo_ts+11821, libc.VaList(bp+24, zCons))
						return
					}
					iEnd = **(**int32)(__ccgo_up(bp))
					break
				}
			} else {
				if **(**int32)(__ccgo_up(bp + 4)) == int32(TK_NOT) && iNotNull == ii {
					iEnd = **(**int32)(__ccgo_up(bp)) + _getConstraint(tls, zSql+uintptr(**(**int32)(__ccgo_up(bp))))
					break
				} else {
					if **(**int32)(__ccgo_up(bp + 4)) == int32(TK_RP) || **(**int32)(__ccgo_up(bp + 4)) == int32(TK_ILLEGAL) {
						iEnd = -int32(1)
						break
					} else {
						if **(**int32)(__ccgo_up(bp + 4)) == int32(TK_COMMA) {
							break
						}
					}
				}
			}
		}
		goto _1
	_1:
		;
		ii = ii + 1
	}
	/* If the constraint has not been found it is an error. */
	if iEnd <= 0 {
		if zCons != 0 {
			_errorMPrintf(tls, ctx, __ccgo_ts+11855, libc.VaList(bp+24, zCons))
		} else {
			/* SQLite follows postgres in that a DROP NOT NULL on a column that is
			 ** not NOT NULL is not an error. So just return the original SQL here. */
			Xsqlite3_result_text(tls, ctx, zSql, -int32(1), uintptr(-libc.Int32FromInt32(1)))
		}
	} else {
		/* Figure out if an extra space should be inserted after the constraint
		 ** is removed. And if an additional comma preceding the constraint
		 ** should be removed. */
		zSpace = __ccgo_ts + 11543
		iEnd = iEnd + _getWhitespace(tls, zSql+uintptr(iEnd))
		_sqlite3GetToken(tls, zSql+uintptr(iEnd), bp+4)
		if **(**int32)(__ccgo_up(bp + 4)) == int32(TK_RP) || **(**int32)(__ccgo_up(bp + 4)) == int32(TK_COMMA) {
			zSpace = __ccgo_ts + 1702
			if libc.Int32FromUint8(**(**Tu8)(__ccgo_up(zSql + uintptr(iStart-int32(1))))) == int32(',') {
				iStart = iStart - 1
			}
		}
		db = Xsqlite3_context_db_handle(tls, ctx)
		zNew = _sqlite3MPrintf(tls, db, __ccgo_ts+11878, libc.VaList(bp+24, iStart, zSql, zSpace, zSql+uintptr(iEnd)))
		Xsqlite3_result_text(tls, ctx, zNew, -int32(1), __ccgo_fp(_sqlite3RowSetClear))
	}
}

// C documentation
//
//	/*
//	** Implementation of the sqlite_log() function.  This is a wrapper around
//	** sqlite3_log().  The return value is NULL.  The function exists purely for
//	** its side-effects.
//	*/
func _errlogFunc(tls *libc.TLS, context uintptr, argc int32, argv uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	_ = argc
	_ = context
	Xsqlite3_log(tls, Xsqlite3_value_int(tls, **(**uintptr)(__ccgo_up(argv))), __ccgo_ts+3942, libc.VaList(bp+8, Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv + 1*4)))))
}

// C documentation
//
//	/*
//	** Execute zSql on database db.
//	**
//	** If zSql returns rows, then each row will have exactly one
//	** column.  (This will only happen if zSql begins with "SELECT".)
//	** Take each row of result and call execSql() again recursively.
//	**
//	** The execSqlF() routine does the same thing, except it accepts
//	** a format string as its third argument
//	*/
func _execSql(tls *libc.TLS, db uintptr, pzErrMsg uintptr, zSql uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var rc, v1 int32
	var zSubSql uintptr
	var _ /* pStmt at bp+0 */ uintptr
	_, _, _ = rc, zSubSql, v1
	/* printf("SQL: [%s]\n", zSql); fflush(stdout); */
	rc = Xsqlite3_prepare_v2(tls, db, zSql, -int32(1), bp, uintptr(0))
	if rc != SQLITE_OK {
		return rc
	}
	for {
		v1 = Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp)))
		rc = v1
		if !(int32(SQLITE_ROW) == v1) {
			break
		}
		zSubSql = Xsqlite3_column_text(tls, **(**uintptr)(__ccgo_up(bp)), 0)
		/* The secondary SQL must be one of CREATE TABLE, CREATE INDEX,
		 ** or INSERT.  Historically there have been attacks that first
		 ** corrupt the sqlite_schema.sql field with other kinds of statements
		 ** then run VACUUM to get those statements to execute at inappropriate
		 ** times. */
		if zSubSql != 0 && (libc.Xstrncmp(tls, zSubSql, __ccgo_ts+22731, uint32(3)) == 0 || libc.Xstrncmp(tls, zSubSql, __ccgo_ts+22735, uint32(3)) == 0) {
			rc = _execSql(tls, db, pzErrMsg, zSubSql)
			if rc != SQLITE_OK {
				break
			}
		}
	}
	if rc == int32(SQLITE_DONE) {
		rc = SQLITE_OK
	}
	if rc != 0 {
		_sqlite3SetString(tls, pzErrMsg, db, Xsqlite3_errmsg(tls, db))
	}
	Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp)))
	return rc
}

// C documentation
//
//	/*
//	** Return the name of the i-th column of the pIdx index.
//	*/
func _explainIndexColumnName(tls *libc.TLS, pIdx uintptr, i int32) (r uintptr) {
	i = int32(**(**Ti16)(__ccgo_up((*TIndex)(unsafe.Pointer(pIdx)).FaiColumn + uintptr(i)*2)))
	if i == -int32(2) {
		return __ccgo_ts + 23620
	}
	if i == -int32(1) {
		return __ccgo_ts + 17965
	}
	return (**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer((*TIndex)(unsafe.Pointer(pIdx)).FpTable)).FaCol + uintptr(i)*12))).FzCnName
}

// C documentation
//
//	/*
//	** Add a single OP_Explain instruction to the VDBE to explain a simple
//	** count(*) query ("SELECT count(*) FROM pTab").
//	*/
func _explainSimpleCount(tls *libc.TLS, pParse uintptr, pTab uintptr, pIdx uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var bCover int32
	var v1, v2 uintptr
	_, _, _ = bCover, v1, v2
	if libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).Fexplain) == int32(2) {
		bCover = libc.BoolInt32(pIdx != uintptr(0) && ((*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_WithoutRowid) == uint32(0) || !(int32(uint32(*(*uint16)(unsafe.Pointer(pIdx + 56))&0x3>>0)) == libc.Int32FromInt32(SQLITE_IDXTYPE_PRIMARYKEY))))
		if bCover != 0 {
			v1 = __ccgo_ts + 21527
		} else {
			v1 = __ccgo_ts + 1702
		}
		if bCover != 0 {
			v2 = (*TIndex)(unsafe.Pointer(pIdx)).FzName
		} else {
			v2 = __ccgo_ts + 1702
		}
		_sqlite3VdbeExplain(tls, pParse, uint8(0), __ccgo_ts+21550, libc.VaList(bp+8, (*TTable)(unsafe.Pointer(pTab)).FzName, v1, v2))
	}
}

// C documentation
//
//	/*
//	** Initialize the contents of the unixFile structure pointed to by pId.
//	*/
func _fillInUnixFile(tls *libc.TLS, pVfs uintptr, h int32, pId uintptr, zFilename uintptr, ctrlFlags int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var nFilename, rc int32
	var pLockingStyle, pNew, zLockFile, v1, v2 uintptr
	_, _, _, _, _, _, _ = nFilename, pLockingStyle, pNew, rc, zLockFile, v1, v2
	pNew = pId
	rc = SQLITE_OK
	/* No locking occurs in temporary files */
	(*TunixFile)(unsafe.Pointer(pNew)).Fh = h
	(*TunixFile)(unsafe.Pointer(pNew)).FpVfs = pVfs
	(*TunixFile)(unsafe.Pointer(pNew)).FzPath = zFilename
	(*TunixFile)(unsafe.Pointer(pNew)).FctrlFlags = uint16(libc.Uint8FromInt32(ctrlFlags))
	(*TunixFile)(unsafe.Pointer(pNew)).FmmapSizeMax = _sqlite3Config.FszMmap
	if ctrlFlags&int32(UNIXFILE_URI) != 0 {
		v1 = zFilename
	} else {
		v1 = uintptr(0)
	}
	if Xsqlite3_uri_boolean(tls, v1, __ccgo_ts+3976, int32(SQLITE_POWERSAFE_OVERWRITE)) != 0 {
		v2 = pNew + 18
		*(*uint16)(unsafe.Pointer(v2)) = uint16(int32(*(*uint16)(unsafe.Pointer(v2))) | libc.Int32FromInt32(UNIXFILE_PSOW))
	}
	if libc.Xstrcmp(tls, (*Tsqlite3_vfs)(unsafe.Pointer(pVfs)).FzName, __ccgo_ts+3981) == 0 {
		v1 = pNew + 18
		*(*uint16)(unsafe.Pointer(v1)) = uint16(int32(*(*uint16)(unsafe.Pointer(v1))) | libc.Int32FromInt32(UNIXFILE_EXCL))
	}
	if ctrlFlags&int32(UNIXFILE_NOLOCK) != 0 {
		pLockingStyle = uintptr(unsafe.Pointer(&_nolockIoMethods))
	} else {
		pLockingStyle = (*(*func(*libc.TLS, uintptr, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{*(*uintptr)(unsafe.Pointer((*Tsqlite3_vfs)(unsafe.Pointer(pVfs)).FpAppData))})))(tls, zFilename, pNew)
	}
	if pLockingStyle == uintptr(unsafe.Pointer(&_posixIoMethods)) {
		_unixEnterMutex(tls)
		rc = _findInodeInfo(tls, pNew, pNew+8)
		if rc != SQLITE_OK {
			/* If an error occurred in findInodeInfo(), close the file descriptor
			 ** immediately, before releasing the mutex. findInodeInfo() may fail
			 ** in two scenarios:
			 **
			 **   (a) A call to fstat() failed.
			 **   (b) A malloc failed.
			 **
			 ** Scenario (b) may only occur if the process is holding no other
			 ** file descriptors open on the same file. If there were other file
			 ** descriptors on this file, then no malloc would be required by
			 ** findInodeInfo(). If this is the case, it is quite safe to close
			 ** handle h - as it is guaranteed that no posix locks will be released
			 ** by doing so.
			 **
			 ** If scenario (a) caused the error then things are not so safe. The
			 ** implicit assumption here is that if fstat() fails, things are in
			 ** such bad shape that dropping a lock or two doesn't matter much.
			 */
			_robust_close(tls, pNew, h, int32(46355))
			h = -int32(1)
		}
		_unixLeaveMutex(tls)
	} else {
		if pLockingStyle == uintptr(unsafe.Pointer(&_dotlockIoMethods)) {
			nFilename = libc.Int32FromUint32(libc.Xstrlen(tls, zFilename)) + int32(6)
			zLockFile = Xsqlite3_malloc64(tls, libc.Uint64FromInt32(nFilename))
			if zLockFile == uintptr(0) {
				rc = int32(SQLITE_NOMEM)
			} else {
				Xsqlite3_snprintf(tls, nFilename, zLockFile, __ccgo_ts+3991, libc.VaList(bp+8, zFilename))
			}
			(*TunixFile)(unsafe.Pointer(pNew)).FlockingContext = zLockFile
		}
	}
	_storeLastErrno(tls, pNew, 0)
	if rc != SQLITE_OK {
		if h >= 0 {
			_robust_close(tls, pNew, h, int32(46447))
		}
	} else {
		(*Tsqlite3_file)(unsafe.Pointer(pId)).FpMethods = pLockingStyle
		_verifyDbFile(tls, pNew)
	}
	return rc
}

// C documentation
//
//	/*
//	** Return a pointer corresponding to database zDb (i.e. "main", "temp")
//	** in connection handle pDb. If such a database cannot be found, return
//	** a NULL pointer and write an error message to pErrorDb.
//	**
//	** If the "temp" database is requested, it may need to be opened by this
//	** function. If an error occurs while doing so, return 0 and write an
//	** error message to pErrorDb.
//	*/
func _findBtree(tls *libc.TLS, pErrorDb uintptr, pDb uintptr, zDb uintptr) (r uintptr) {
	bp := tls.Alloc(304)
	defer tls.Free(304)
	var i, rc int32
	var _ /* sParse at bp+0 */ TParse
	_, _ = i, rc
	i = _sqlite3FindDbName(tls, pDb, zDb)
	if i == int32(1) {
		rc = 0
		_sqlite3ParseObjectInit(tls, bp, pDb)
		if _sqlite3OpenTempDatabase(tls, bp) != 0 {
			_sqlite3ErrorWithMsg(tls, pErrorDb, (**(**TParse)(__ccgo_up(bp))).Frc, __ccgo_ts+3942, libc.VaList(bp+296, (**(**TParse)(__ccgo_up(bp))).FzErrMsg))
			rc = int32(SQLITE_ERROR)
		}
		_sqlite3DbFree(tls, pErrorDb, (**(**TParse)(__ccgo_up(bp))).FzErrMsg)
		_sqlite3ParseObjectReset(tls, bp)
		if rc != 0 {
			return uintptr(0)
		}
	}
	if i < 0 {
		_sqlite3ErrorWithMsg(tls, pErrorDb, int32(SQLITE_ERROR), __ccgo_ts+5127, libc.VaList(bp+296, zDb))
		return uintptr(0)
	}
	return (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(pDb)).FaDb + uintptr(i)*16))).FpBt
}

// C documentation
//
//	/*
//	** Expression callback used by sqlite3FixAAAA() routines.
//	*/
func _fixExprCb(tls *libc.TLS, p uintptr, pExpr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var pFix uintptr
	_ = pFix
	pFix = *(*uintptr)(unsafe.Pointer(p + 24))
	if !((*TDbFixer)(unsafe.Pointer(pFix)).FbTemp != 0) {
		**(**Tu32)(__ccgo_up(pExpr + 4)) |= libc.Uint32FromInt32(libc.Int32FromInt32(EP_FromDDL))
	}
	if libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pExpr)).Fop) == int32(TK_VARIABLE) {
		if (*Tsqlite3)(unsafe.Pointer((*TParse)(unsafe.Pointer((*TDbFixer)(unsafe.Pointer(pFix)).FpParse)).Fdb)).Finit1.Fbusy != 0 {
			(*TExpr)(unsafe.Pointer(pExpr)).Fop = uint8(TK_NULL)
		} else {
			_sqlite3ErrorMsg(tls, (*TDbFixer)(unsafe.Pointer(pFix)).FpParse, __ccgo_ts+13541, libc.VaList(bp+8, (*TDbFixer)(unsafe.Pointer(pFix)).FzType))
			return int32(WRC_Abort)
		}
	}
	return WRC_Continue
}

// C documentation
//
//	/*
//	** Select callback used by sqlite3FixAAAA() routines.
//	*/
func _fixSelectCb(tls *libc.TLS, p uintptr, pSelect uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var db, pFix, pItem, pList uintptr
	var i, iDb int32
	_, _, _, _, _, _ = db, i, iDb, pFix, pItem, pList
	pFix = *(*uintptr)(unsafe.Pointer(p + 24))
	db = (*TParse)(unsafe.Pointer((*TDbFixer)(unsafe.Pointer(pFix)).FpParse)).Fdb
	iDb = _sqlite3FindDbName(tls, db, (*TDbFixer)(unsafe.Pointer(pFix)).FzDb)
	pList = (*TSelect)(unsafe.Pointer(pSelect)).FpSrc
	if pList == uintptr(0) {
		return WRC_Continue
	}
	i = 0
	pItem = pList + 8
	for {
		if !(i < (*TSrcList)(unsafe.Pointer(pList)).FnSrc) {
			break
		}
		if libc.Int32FromUint8((*TDbFixer)(unsafe.Pointer(pFix)).FbTemp) == 0 && int32(*(*uint32)(unsafe.Pointer(pItem + 12 + 4))&0x4>>2) == 0 {
			if int32(*(*uint32)(unsafe.Pointer(pItem + 12 + 4))&0x10000>>16) == 0 && *(*uintptr)(unsafe.Pointer(pItem + 44)) != uintptr(0) {
				if iDb != _sqlite3FindDbName(tls, db, *(*uintptr)(unsafe.Pointer(pItem + 44))) {
					_sqlite3ErrorMsg(tls, (*TDbFixer)(unsafe.Pointer(pFix)).FpParse, __ccgo_ts+13565, libc.VaList(bp+8, (*TDbFixer)(unsafe.Pointer(pFix)).FzType, (*TDbFixer)(unsafe.Pointer(pFix)).FpName, *(*uintptr)(unsafe.Pointer(pItem + 44))))
					return int32(WRC_Abort)
				}
				_sqlite3DbFree(tls, db, *(*uintptr)(unsafe.Pointer(pItem + 44)))
				libc.SetBitFieldPtr32Uint32(pItem+12+4, libc.Uint32FromInt32(1), 10, 0x400)
				libc.SetBitFieldPtr32Uint32(pItem+12+4, libc.Uint32FromInt32(1), 17, 0x20000)
			}
			*(*uintptr)(unsafe.Pointer(pItem + 44)) = (*TDbFixer)(unsafe.Pointer(pFix)).FpSchema
			libc.SetBitFieldPtr32Uint32(pItem+12+4, libc.Uint32FromInt32(1), 8, 0x100)
			libc.SetBitFieldPtr32Uint32(pItem+12+4, libc.Uint32FromInt32(1), 16, 0x10000)
		}
		if int32(*(*uint32)(unsafe.Pointer(pList + 8 + uintptr(i)*48 + 12 + 4))&0x800>>11) == 0 && _sqlite3WalkExpr(tls, pFix+4, *(*uintptr)(unsafe.Pointer(pList + 8 + uintptr(i)*48 + 40))) != 0 {
			return int32(WRC_Abort)
		}
		goto _1
	_1:
		;
		i = i + 1
		pItem += 48
	}
	if (*TSelect)(unsafe.Pointer(pSelect)).FpWith != 0 {
		i = 0
		for {
			if !(i < (*TWith)(unsafe.Pointer((*TSelect)(unsafe.Pointer(pSelect)).FpWith)).FnCte) {
				break
			}
			if _sqlite3WalkSelect(tls, p, (*(*TCte)(unsafe.Pointer((*TSelect)(unsafe.Pointer(pSelect)).FpWith + 12 + uintptr(i)*24))).FpSelect) != 0 {
				return int32(WRC_Abort)
			}
			goto _2
		_2:
			;
			i = i + 1
		}
	}
	return WRC_Continue
}

func _fts5ApiCallback(tls *libc.TLS, context uintptr, argc int32, argv uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var iCsrId Ti64
	var pAux, pCsr, pTab uintptr
	_, _, _, _ = iCsrId, pAux, pCsr, pTab
	pAux = Xsqlite3_user_data(tls, context)
	iCsrId = Xsqlite3_value_int64(tls, **(**uintptr)(__ccgo_up(argv)))
	pCsr = _fts5CursorFromCsrid(tls, (*TFts5Auxiliary)(unsafe.Pointer(pAux)).FpGlobal, iCsrId)
	if pCsr == uintptr(0) || ((*TFts5Cursor)(unsafe.Pointer(pCsr)).FePlan == 0 || (*TFts5Cursor)(unsafe.Pointer(pCsr)).FePlan == int32(FTS5_PLAN_SPECIAL)) {
		_fts5ResultError(tls, context, __ccgo_ts+40420, libc.VaList(bp+8, iCsrId))
	} else {
		pTab = (*TFts5Cursor)(unsafe.Pointer(pCsr)).Fbase.FpVtab
		_fts5ApiInvoke(tls, pAux, pCsr, context, argc-int32(1), argv+1*4)
		Xsqlite3_free(tls, (*Tsqlite3_vtab)(unsafe.Pointer(pTab)).FzErrMsg)
		(*Tsqlite3_vtab)(unsafe.Pointer(pTab)).FzErrMsg = uintptr(0)
	}
}

// C documentation
//
//	/*
//	** Create an "ascii" tokenizer.
//	*/
func _fts5AsciiCreate(tls *libc.TLS, pUnused uintptr, azArg uintptr, nArg int32, ppOut uintptr) (r int32) {
	var i, rc int32
	var p, zArg uintptr
	_, _, _, _ = i, p, rc, zArg
	rc = SQLITE_OK
	p = uintptr(0)
	_ = pUnused
	if nArg%int32(2) != 0 {
		rc = int32(SQLITE_ERROR)
	} else {
		p = Xsqlite3_malloc64(tls, uint64(128))
		if p == uintptr(0) {
			rc = int32(SQLITE_NOMEM)
		} else {
			libc.Xmemset(tls, p, 0, uint32(128))
			libc.Xmemcpy(tls, p, uintptr(unsafe.Pointer(&_aAsciiTokenChar)), uint32(128))
			i = 0
			for {
				if !(rc == SQLITE_OK && i < nArg) {
					break
				}
				zArg = **(**uintptr)(__ccgo_up(azArg + uintptr(i+int32(1))*4))
				if 0 == Xsqlite3_stricmp(tls, **(**uintptr)(__ccgo_up(azArg + uintptr(i)*4)), __ccgo_ts+41832) {
					_fts5AsciiAddExceptions(tls, p, zArg, int32(1))
				} else {
					if 0 == Xsqlite3_stricmp(tls, **(**uintptr)(__ccgo_up(azArg + uintptr(i)*4)), __ccgo_ts+41843) {
						_fts5AsciiAddExceptions(tls, p, zArg, 0)
					} else {
						rc = int32(SQLITE_ERROR)
					}
				}
				goto _1
			_1:
				;
				i = i + int32(2)
			}
			if rc != SQLITE_OK {
				_fts5AsciiDelete(tls, p)
				p = uintptr(0)
			}
		}
	}
	**(**uintptr)(__ccgo_up(ppOut)) = p
	return rc
}

// C documentation
//
//	/*
//	** Populate the Fts5Config.zContentExprlist string.
//	*/
func _fts5ConfigMakeExprlist(tls *libc.TLS, p uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var i int32
	var _ /* buf at bp+4 */ TFts5Buffer
	var _ /* rc at bp+0 */ int32
	_ = i
	**(**int32)(__ccgo_up(bp)) = SQLITE_OK
	**(**TFts5Buffer)(__ccgo_up(bp + 4)) = TFts5Buffer{}
	_sqlite3Fts5BufferAppendPrintf(tls, bp, bp+4, __ccgo_ts+38042, libc.VaList(bp+24, (*TFts5Config)(unsafe.Pointer(p)).FzContentRowid))
	if (*TFts5Config)(unsafe.Pointer(p)).FeContent != int32(FTS5_CONTENT_NONE) {
		i = 0
		for {
			if !(i < (*TFts5Config)(unsafe.Pointer(p)).FnCol) {
				break
			}
			if (*TFts5Config)(unsafe.Pointer(p)).FeContent == int32(FTS5_CONTENT_EXTERNAL) {
				_sqlite3Fts5BufferAppendPrintf(tls, bp, bp+4, __ccgo_ts+38047, libc.VaList(bp+24, **(**uintptr)(__ccgo_up((*TFts5Config)(unsafe.Pointer(p)).FazCol + uintptr(i)*4))))
			} else {
				if (*TFts5Config)(unsafe.Pointer(p)).FeContent == FTS5_CONTENT_NORMAL || **(**Tu8)(__ccgo_up((*TFts5Config)(unsafe.Pointer(p)).FabUnindexed + uintptr(i))) != 0 {
					_sqlite3Fts5BufferAppendPrintf(tls, bp, bp+4, __ccgo_ts+38054, libc.VaList(bp+24, i))
				} else {
					_sqlite3Fts5BufferAppendPrintf(tls, bp, bp+4, __ccgo_ts+38062, 0)
				}
			}
			goto _1
		_1:
			;
			i = i + 1
		}
	}
	if (*TFts5Config)(unsafe.Pointer(p)).FeContent == FTS5_CONTENT_NORMAL && (*TFts5Config)(unsafe.Pointer(p)).FbLocale != 0 {
		i = 0
		for {
			if !(i < (*TFts5Config)(unsafe.Pointer(p)).FnCol) {
				break
			}
			if libc.Int32FromUint8(**(**Tu8)(__ccgo_up((*TFts5Config)(unsafe.Pointer(p)).FabUnindexed + uintptr(i)))) == 0 {
				_sqlite3Fts5BufferAppendPrintf(tls, bp, bp+4, __ccgo_ts+38069, libc.VaList(bp+24, i))
			} else {
				_sqlite3Fts5BufferAppendPrintf(tls, bp, bp+4, __ccgo_ts+38062, 0)
			}
			goto _2
		_2:
			;
			i = i + 1
		}
	}
	(*TFts5Config)(unsafe.Pointer(p)).FzContentExprlist = (**(**TFts5Buffer)(__ccgo_up(bp + 4))).Fp
	return **(**int32)(__ccgo_up(bp))
}

func _fts5ConfigParseColumn(tls *libc.TLS, p uintptr, zCol uintptr, zArg uintptr, pzErr uintptr, pbUnindexed uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var rc, v1 int32
	var v2 uintptr
	_, _, _ = rc, v1, v2
	rc = SQLITE_OK
	if 0 == Xsqlite3_stricmp(tls, zCol, __ccgo_ts+37966) || 0 == Xsqlite3_stricmp(tls, zCol, __ccgo_ts+17965) {
		**(**uintptr)(__ccgo_up(pzErr)) = Xsqlite3_mprintf(tls, __ccgo_ts+37971, libc.VaList(bp+8, zCol))
		rc = int32(SQLITE_ERROR)
	} else {
		if zArg != 0 {
			if 0 == Xsqlite3_stricmp(tls, zArg, __ccgo_ts+38001) {
				**(**Tu8)(__ccgo_up((*TFts5Config)(unsafe.Pointer(p)).FabUnindexed + uintptr((*TFts5Config)(unsafe.Pointer(p)).FnCol))) = uint8(1)
				**(**int32)(__ccgo_up(pbUnindexed)) = int32(1)
			} else {
				**(**uintptr)(__ccgo_up(pzErr)) = Xsqlite3_mprintf(tls, __ccgo_ts+38011, libc.VaList(bp+8, zArg))
				rc = int32(SQLITE_ERROR)
			}
		}
	}
	v2 = p + 16
	v1 = *(*int32)(unsafe.Pointer(v2))
	*(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1
	**(**uintptr)(__ccgo_up((*TFts5Config)(unsafe.Pointer(p)).FazCol + uintptr(v1)*4)) = zCol
	return rc
}

// C documentation
//
//	/*
//	**
//	** This function is called when the user attempts an UPDATE on a contentless
//	** table. Parameter bRowidModified is true if the UPDATE statement modifies
//	** the rowid value. Parameter apVal[] contains the new values for each user
//	** defined column of the fts5 table. pConfig is the configuration object of the
//	** table being updated (guaranteed to be contentless). The contentless_delete=1
//	** and contentless_unindexed=1 options may or may not be set.
//	**
//	** This function returns SQLITE_OK if the UPDATE can go ahead, or an SQLite
//	** error code if it cannot. In this case an error message is also loaded into
//	** pConfig. Output parameter (*pbContent) is set to true if the caller should
//	** update the %_content table only - not the FTS index or any other shadow
//	** table. This occurs when an UPDATE modifies only UNINDEXED columns of the
//	** table.
//	**
//	** An UPDATE may proceed if:
//	**
//	**   * The only columns modified are UNINDEXED columns, or
//	**
//	**   * The contentless_delete=1 option was specified and all of the indexed
//	**     columns (not a subset) have been modified.
//	*/
func _fts5ContentlessUpdate(tls *libc.TLS, pConfig uintptr, apVal uintptr, bRowidModified int32, pbContent uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var bSeenIndex, bSeenIndexNC, ii, rc int32
	var v2 uintptr
	_, _, _, _, _ = bSeenIndex, bSeenIndexNC, ii, rc, v2
	bSeenIndex = 0   /* Have seen modified indexed column */
	bSeenIndexNC = 0 /* Have seen unmodified indexed column */
	rc = SQLITE_OK
	ii = 0
	for {
		if !(ii < (*TFts5Config)(unsafe.Pointer(pConfig)).FnCol) {
			break
		}
		if libc.Int32FromUint8(**(**Tu8)(__ccgo_up((*TFts5Config)(unsafe.Pointer(pConfig)).FabUnindexed + uintptr(ii)))) == 0 {
			if Xsqlite3_value_nochange(tls, **(**uintptr)(__ccgo_up(apVal + uintptr(ii)*4))) != 0 {
				bSeenIndexNC = bSeenIndexNC + 1
			} else {
				bSeenIndex = bSeenIndex + 1
			}
		}
		goto _1
	_1:
		;
		ii = ii + 1
	}
	if bSeenIndex == 0 && bRowidModified == 0 {
		**(**int32)(__ccgo_up(pbContent)) = int32(1)
	} else {
		if bSeenIndexNC != 0 || (*TFts5Config)(unsafe.Pointer(pConfig)).FbContentlessDelete == 0 {
			rc = int32(SQLITE_ERROR)
			if (*TFts5Config)(unsafe.Pointer(pConfig)).FbContentlessDelete != 0 {
				v2 = __ccgo_ts + 40179
			} else {
				v2 = __ccgo_ts + 40239
			}
			_sqlite3Fts5ConfigErrmsg(tls, pConfig, v2, libc.VaList(bp+8, __ccgo_ts+40269, (*TFts5Config)(unsafe.Pointer(pConfig)).FzName))
		}
	}
	return rc
}

// C documentation
//
//	/*
//	** Argument pVal is the text of a full-text search expression. It may or
//	** may not have been wrapped by fts5_locale(). This function extracts
//	** the text of the expression, and sets output variable (*pzText) to
//	** point to a nul-terminated buffer containing the expression.
//	**
//	** If pVal was an fts5_locale() value, then sqlite3Fts5SetLocale() is called
//	** to set the tokenizer to use the specified locale.
//	**
//	** If output variable (*pbFreeAndReset) is set to true, then the caller
//	** is required to (a) call sqlite3Fts5ClearLocale() to reset the tokenizer
//	** locale, and (b) call sqlite3_free() to free (*pzText).
//	*/
func _fts5ExtractExprText(tls *libc.TLS, pConfig uintptr, pVal uintptr, pzText uintptr, pbFreeAndReset uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var _ /* nLoc at bp+16 */ int32
	var _ /* nText at bp+8 */ int32
	var _ /* pLoc at bp+12 */ uintptr
	var _ /* pText at bp+4 */ uintptr
	var _ /* rc at bp+0 */ int32
	**(**int32)(__ccgo_up(bp)) = SQLITE_OK
	if _sqlite3Fts5IsLocaleValue(tls, pConfig, pVal) != 0 {
		**(**uintptr)(__ccgo_up(bp + 4)) = uintptr(0)
		**(**int32)(__ccgo_up(bp + 8)) = 0
		**(**uintptr)(__ccgo_up(bp + 12)) = uintptr(0)
		**(**int32)(__ccgo_up(bp + 16)) = 0
		**(**int32)(__ccgo_up(bp)) = _sqlite3Fts5DecodeLocaleValue(tls, pVal, bp+4, bp+8, bp+12, bp+16)
		**(**uintptr)(__ccgo_up(pzText)) = _sqlite3Fts5Mprintf(tls, bp, __ccgo_ts+12048, libc.VaList(bp+32, **(**int32)(__ccgo_up(bp + 8)), **(**uintptr)(__ccgo_up(bp + 4))))
		if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
			_sqlite3Fts5SetLocale(tls, pConfig, **(**uintptr)(__ccgo_up(bp + 12)), **(**int32)(__ccgo_up(bp + 16)))
		}
		**(**int32)(__ccgo_up(pbFreeAndReset)) = int32(1)
	} else {
		**(**uintptr)(__ccgo_up(pzText)) = Xsqlite3_value_text(tls, pVal)
		**(**int32)(__ccgo_up(pbFreeAndReset)) = 0
	}
	return **(**int32)(__ccgo_up(bp))
}

func _fts5FindRankFunction(tls *libc.TLS, pCsr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var i int32
	var nByte Tsqlite3_int64
	var pAux, pConfig, pTab, zRank, zRankArgs, zSql uintptr
	var _ /* pStmt at bp+4 */ uintptr
	var _ /* rc at bp+0 */ int32
	_, _, _, _, _, _, _, _ = i, nByte, pAux, pConfig, pTab, zRank, zRankArgs, zSql
	pTab = (*TFts5Cursor)(unsafe.Pointer(pCsr)).Fbase.FpVtab
	pConfig = (*TFts5FullTable)(unsafe.Pointer(pTab)).Fp.FpConfig
	**(**int32)(__ccgo_up(bp)) = SQLITE_OK
	pAux = uintptr(0)
	zRank = (*TFts5Cursor)(unsafe.Pointer(pCsr)).FzRank
	zRankArgs = (*TFts5Cursor)(unsafe.Pointer(pCsr)).FzRankArgs
	if zRankArgs != 0 {
		zSql = _sqlite3Fts5Mprintf(tls, bp, __ccgo_ts+39851, libc.VaList(bp+16, zRankArgs))
		if zSql != 0 {
			**(**uintptr)(__ccgo_up(bp + 4)) = uintptr(0)
			**(**int32)(__ccgo_up(bp)) = Xsqlite3_prepare_v3(tls, (*TFts5Config)(unsafe.Pointer(pConfig)).Fdb, zSql, -int32(1), uint32(SQLITE_PREPARE_PERSISTENT), bp+4, uintptr(0))
			Xsqlite3_free(tls, zSql)
			if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
				if int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp + 4))) {
					(*TFts5Cursor)(unsafe.Pointer(pCsr)).FnRankArg = Xsqlite3_column_count(tls, **(**uintptr)(__ccgo_up(bp + 4)))
					nByte = libc.Int64FromUint32(uint32(4) * libc.Uint32FromInt32((*TFts5Cursor)(unsafe.Pointer(pCsr)).FnRankArg))
					(*TFts5Cursor)(unsafe.Pointer(pCsr)).FapRankArg = _sqlite3Fts5MallocZero(tls, bp, nByte)
					if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
						i = 0
						for {
							if !(i < (*TFts5Cursor)(unsafe.Pointer(pCsr)).FnRankArg) {
								break
							}
							**(**uintptr)(__ccgo_up((*TFts5Cursor)(unsafe.Pointer(pCsr)).FapRankArg + uintptr(i)*4)) = Xsqlite3_column_value(tls, **(**uintptr)(__ccgo_up(bp + 4)), i)
							goto _1
						_1:
							;
							i = i + 1
						}
					}
					(*TFts5Cursor)(unsafe.Pointer(pCsr)).FpRankArgStmt = **(**uintptr)(__ccgo_up(bp + 4))
				} else {
					**(**int32)(__ccgo_up(bp)) = Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp + 4)))
				}
			}
		}
	}
	if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
		pAux = _fts5FindAuxiliary(tls, pTab, zRank)
		if pAux == uintptr(0) {
			(*TFts5FullTable)(unsafe.Pointer(pTab)).Fp.Fbase.FzErrMsg = Xsqlite3_mprintf(tls, __ccgo_ts+39861, libc.VaList(bp+16, zRank))
			**(**int32)(__ccgo_up(bp)) = int32(SQLITE_ERROR)
		}
	}
	(*TFts5Cursor)(unsafe.Pointer(pCsr)).FpRank = pAux
	return **(**int32)(__ccgo_up(bp))
}

// C documentation
//
//	/*
//	** Implementation of fts5_get_locale() function.
//	*/
func _fts5GetLocaleFunction(tls *libc.TLS, pApi uintptr, pFts uintptr, pCtx uintptr, nVal int32, apVal uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var eType, iCol, rc int32
	var z, z1 uintptr
	var _ /* nLocale at bp+4 */ int32
	var _ /* zLocale at bp+0 */ uintptr
	_, _, _, _, _ = eType, iCol, rc, z, z1
	iCol = 0
	eType = 0
	rc = SQLITE_OK
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	**(**int32)(__ccgo_up(bp + 4)) = 0
	/* xColumnLocale() must be available */
	if nVal != int32(1) {
		z = __ccgo_ts + 37252
		Xsqlite3_result_error(tls, pCtx, z, -int32(1))
		return
	}
	eType = Xsqlite3_value_numeric_type(tls, **(**uintptr)(__ccgo_up(apVal)))
	if eType != int32(SQLITE_INTEGER) {
		z1 = __ccgo_ts + 37308
		Xsqlite3_result_error(tls, pCtx, z1, -int32(1))
		return
	}
	iCol = Xsqlite3_value_int(tls, **(**uintptr)(__ccgo_up(apVal)))
	if iCol < 0 || iCol >= (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExtensionApi)(unsafe.Pointer(pApi)).FxColumnCount})))(tls, pFts) {
		Xsqlite3_result_error_code(tls, pCtx, int32(SQLITE_RANGE))
		return
	}
	rc = (*(*func(*libc.TLS, uintptr, int32, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExtensionApi)(unsafe.Pointer(pApi)).FxColumnLocale})))(tls, pFts, iCol, bp, bp+4)
	if rc != SQLITE_OK {
		Xsqlite3_result_error_code(tls, pCtx, rc)
		return
	}
	Xsqlite3_result_text(tls, pCtx, **(**uintptr)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), uintptr(-libc.Int32FromInt32(1)))
}

// C documentation
//
//	/*
//	** Append text to the HighlightContext output string - p->zOut. Argument
//	** z points to a buffer containing n bytes of text to append. If n is
//	** negative, everything up until the first '\0' is appended to the output.
//	**
//	** If *pRc is set to any value other than SQLITE_OK when this function is
//	** called, it is a no-op. If an error (i.e. an OOM condition) is encountered,
//	** *pRc is set to an error code before returning.
//	*/
func _fts5HighlightAppend(tls *libc.TLS, pRc uintptr, p uintptr, z uintptr, n int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	if **(**int32)(__ccgo_up(pRc)) == SQLITE_OK && z != 0 {
		if n < 0 {
			n = libc.Int32FromUint32(libc.Xstrlen(tls, z))
		}
		(*THighlightContext)(unsafe.Pointer(p)).FzOut = Xsqlite3_mprintf(tls, __ccgo_ts+37147, libc.VaList(bp+8, (*THighlightContext)(unsafe.Pointer(p)).FzOut, n, z))
		if (*THighlightContext)(unsafe.Pointer(p)).FzOut == uintptr(0) {
			**(**int32)(__ccgo_up(pRc)) = int32(SQLITE_NOMEM)
		}
	}
}

// C documentation
//
//	/*
//	** Implementation of highlight() function.
//	*/
func _fts5HighlightFunction(tls *libc.TLS, pApi uintptr, pFts uintptr, pCtx uintptr, nVal int32, apVal uintptr) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var iCol int32
	var zErr uintptr
	var _ /* ctx at bp+0 */ THighlightContext
	var _ /* nLoc at bp+76 */ int32
	var _ /* pLoc at bp+72 */ uintptr
	var _ /* rc at bp+68 */ int32
	_, _ = iCol, zErr
	if nVal != int32(3) {
		zErr = __ccgo_ts + 37154
		Xsqlite3_result_error(tls, pCtx, zErr, -int32(1))
		return
	}
	iCol = Xsqlite3_value_int(tls, **(**uintptr)(__ccgo_up(apVal)))
	libc.Xmemset(tls, bp, 0, uint32(68))
	(**(**THighlightContext)(__ccgo_up(bp))).FzOpen = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(apVal + 1*4)))
	(**(**THighlightContext)(__ccgo_up(bp))).FzClose = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(apVal + 2*4)))
	(**(**THighlightContext)(__ccgo_up(bp))).FiRangeEnd = -int32(1)
	**(**int32)(__ccgo_up(bp + 68)) = (*(*func(*libc.TLS, uintptr, int32, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExtensionApi)(unsafe.Pointer(pApi)).FxColumnText})))(tls, pFts, iCol, bp+16, bp+20)
	if **(**int32)(__ccgo_up(bp + 68)) == int32(SQLITE_RANGE) {
		Xsqlite3_result_text(tls, pCtx, __ccgo_ts+1702, -int32(1), libc.UintptrFromInt32(0))
		**(**int32)(__ccgo_up(bp + 68)) = SQLITE_OK
	} else {
		if (**(**THighlightContext)(__ccgo_up(bp))).FzIn != 0 {
			**(**uintptr)(__ccgo_up(bp + 72)) = uintptr(0) /* Locale of column iCol */
			**(**int32)(__ccgo_up(bp + 76)) = 0            /* Size of pLoc in bytes */
			if **(**int32)(__ccgo_up(bp + 68)) == SQLITE_OK {
				**(**int32)(__ccgo_up(bp + 68)) = _fts5CInstIterInit(tls, pApi, pFts, iCol, bp+24)
			}
			if **(**int32)(__ccgo_up(bp + 68)) == SQLITE_OK {
				**(**int32)(__ccgo_up(bp + 68)) = (*(*func(*libc.TLS, uintptr, int32, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExtensionApi)(unsafe.Pointer(pApi)).FxColumnLocale})))(tls, pFts, iCol, bp+72, bp+76)
			}
			if **(**int32)(__ccgo_up(bp + 68)) == SQLITE_OK {
				**(**int32)(__ccgo_up(bp + 68)) = (*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr, int32, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExtensionApi)(unsafe.Pointer(pApi)).FxTokenize_v2})))(tls, pFts, (**(**THighlightContext)(__ccgo_up(bp))).FzIn, (**(**THighlightContext)(__ccgo_up(bp))).FnIn, **(**uintptr)(__ccgo_up(bp + 72)), **(**int32)(__ccgo_up(bp + 76)), bp, __ccgo_fp(_fts5HighlightCb))
			}
			if (**(**THighlightContext)(__ccgo_up(bp))).FbOpen != 0 {
				_fts5HighlightAppend(tls, bp+68, bp, (**(**THighlightContext)(__ccgo_up(bp))).FzClose, -int32(1))
			}
			_fts5HighlightAppend(tls, bp+68, bp, (**(**THighlightContext)(__ccgo_up(bp))).FzIn+uintptr((**(**THighlightContext)(__ccgo_up(bp))).FiOff), (**(**THighlightContext)(__ccgo_up(bp))).FnIn-(**(**THighlightContext)(__ccgo_up(bp))).FiOff)
			if **(**int32)(__ccgo_up(bp + 68)) == SQLITE_OK {
				Xsqlite3_result_text(tls, pCtx, (**(**THighlightContext)(__ccgo_up(bp))).FzOut, -int32(1), uintptr(-libc.Int32FromInt32(1)))
			}
			Xsqlite3_free(tls, (**(**THighlightContext)(__ccgo_up(bp))).FzOut)
		}
	}
	if **(**int32)(__ccgo_up(bp + 68)) != SQLITE_OK {
		Xsqlite3_result_error_code(tls, pCtx, **(**int32)(__ccgo_up(bp + 68)))
	}
}

/*
** End of highlight() implementation.
**************************************************************************/

func _fts5IndexIntegrityCheckSegment(tls *libc.TLS, p uintptr, pSeg uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var bIdxDlidx, bSecureDelete, iDlidxPrevLeaf, iIdxLeaf, iIdxPrevLeaf, iOff, iPg, iPrevLeaf, iRowidOff, iRowidOff1, iSegid, nIdxTerm, rc2, res, v1, v2, v3 int32
	var iDlRowid, iKey, iRow Ti64
	var pConfig, pDlidx, pLeaf, zIdxTerm uintptr
	var _ /* iRowid at bp+8 */ Ti64
	var _ /* nTerm at bp+4 */ int32
	var _ /* pStmt at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bIdxDlidx, bSecureDelete, iDlRowid, iDlidxPrevLeaf, iIdxLeaf, iIdxPrevLeaf, iKey, iOff, iPg, iPrevLeaf, iRow, iRowidOff, iRowidOff1, iSegid, nIdxTerm, pConfig, pDlidx, pLeaf, rc2, res, zIdxTerm, v1, v2, v3
	pConfig = (*TFts5Index)(unsafe.Pointer(p)).FpConfig
	bSecureDelete = libc.BoolInt32((*TFts5Config)(unsafe.Pointer(pConfig)).FiVersion == int32(FTS5_CURRENT_VERSION_SECUREDELETE))
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	iIdxPrevLeaf = (*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FpgnoFirst - int32(1)
	iDlidxPrevLeaf = (*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FpgnoLast
	if (*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FpgnoFirst == 0 {
		return
	}
	_fts5IndexPrepareStmt(tls, p, bp, Xsqlite3_mprintf(tls, __ccgo_ts+39584, libc.VaList(bp+24, (*TFts5Config)(unsafe.Pointer(pConfig)).FzDb, (*TFts5Config)(unsafe.Pointer(pConfig)).FzName, (*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FiSegid)))
	/* Iterate through the b-tree hierarchy.  */
	for (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK && int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) { /* Data for this leaf */
		zIdxTerm = Xsqlite3_column_blob(tls, **(**uintptr)(__ccgo_up(bp)), int32(1))
		nIdxTerm = Xsqlite3_column_bytes(tls, **(**uintptr)(__ccgo_up(bp)), int32(1))
		iIdxLeaf = Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), int32(2))
		bIdxDlidx = Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), int32(3))
		/* If the leaf in question has already been trimmed from the segment,
		 ** ignore this b-tree entry. Otherwise, load it into memory. */
		if iIdxLeaf < (*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FpgnoFirst {
			continue
		}
		iRow = int64((*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FiSegid)<<(libc.Int32FromInt32(FTS5_DATA_PAGE_B)+libc.Int32FromInt32(FTS5_DATA_HEIGHT_B)+libc.Int32FromInt32(FTS5_DATA_DLI_B)) + int64(libc.Int32FromInt32(0))<<(libc.Int32FromInt32(FTS5_DATA_PAGE_B)+libc.Int32FromInt32(FTS5_DATA_HEIGHT_B)) + int64(libc.Int32FromInt32(0))<<libc.Int32FromInt32(FTS5_DATA_PAGE_B) + int64(iIdxLeaf)
		pLeaf = _fts5LeafRead(tls, p, iRow)
		if pLeaf == uintptr(0) {
			break
		}
		/* Check that the leaf contains at least one term, and that it is equal
		 ** to or larger than the split-key in zIdxTerm.  Also check that if there
		 ** is also a rowid pointer within the leaf page header, it points to a
		 ** location before the term.  */
		if (*TFts5Data)(unsafe.Pointer(pLeaf)).Fnn <= (*TFts5Data)(unsafe.Pointer(pLeaf)).FszLeaf {
			if nIdxTerm == 0 && (*TFts5Config)(unsafe.Pointer(pConfig)).FiVersion == int32(FTS5_CURRENT_VERSION_SECUREDELETE) && (*TFts5Data)(unsafe.Pointer(pLeaf)).Fnn == (*TFts5Data)(unsafe.Pointer(pLeaf)).FszLeaf && (*TFts5Data)(unsafe.Pointer(pLeaf)).Fnn == int32(4) {
				/* special case - the very first page in a segment keeps its %_idx
				 ** entry even if all the terms are removed from it by secure-delete
				 ** operations. */
			} else {
				_fts5IndexCorruptRowid(tls, p, iRow)
			}
		} else { /* Comparison of term and split-key */
			iOff = _fts5LeafFirstTermOff(tls, pLeaf)
			iRowidOff = libc.Int32FromUint16(_fts5GetU16(tls, (*TFts5Data)(unsafe.Pointer(pLeaf)).Fp))
			if iRowidOff >= iOff || iOff >= (*TFts5Data)(unsafe.Pointer(pLeaf)).FszLeaf {
				_fts5IndexCorruptRowid(tls, p, iRow)
			} else {
				iOff = iOff + _sqlite3Fts5GetVarint32(tls, (*TFts5Data)(unsafe.Pointer(pLeaf)).Fp+uintptr(iOff), bp+4)
				if iOff+**(**int32)(__ccgo_up(bp + 4)) > (*TFts5Data)(unsafe.Pointer(pLeaf)).FszLeaf {
					_fts5IndexCorruptRowid(tls, p, iRow)
				} else {
					if **(**int32)(__ccgo_up(bp + 4)) < nIdxTerm {
						v2 = **(**int32)(__ccgo_up(bp + 4))
					} else {
						v2 = nIdxTerm
					}
					if v2 <= 0 {
						v1 = 0
					} else {
						if **(**int32)(__ccgo_up(bp + 4)) < nIdxTerm {
							v3 = **(**int32)(__ccgo_up(bp + 4))
						} else {
							v3 = nIdxTerm
						}
						v1 = libc.Xmemcmp(tls, (*TFts5Data)(unsafe.Pointer(pLeaf)).Fp+uintptr(iOff), zIdxTerm, libc.Uint32FromInt32(v3))
					}
					res = v1
					if res == 0 {
						res = **(**int32)(__ccgo_up(bp + 4)) - nIdxTerm
					}
					if res < 0 {
						_fts5IndexCorruptRowid(tls, p, iRow)
					}
				}
			}
			_fts5IntegrityCheckPgidx(tls, p, iRow, pLeaf)
		}
		_fts5DataRelease(tls, pLeaf)
		if (*TFts5Index)(unsafe.Pointer(p)).Frc != 0 {
			break
		}
		/* Now check that the iter.nEmpty leaves following the current leaf
		 ** (a) exist and (b) contain no terms. */
		_fts5IndexIntegrityCheckEmpty(tls, p, pSeg, iIdxPrevLeaf+int32(1), iDlidxPrevLeaf+int32(1), iIdxLeaf-int32(1))
		if (*TFts5Index)(unsafe.Pointer(p)).Frc != 0 {
			break
		}
		/* If there is a doclist-index, check that it looks right. */
		if bIdxDlidx != 0 {
			pDlidx = uintptr(0) /* For iterating through doclist index */
			iPrevLeaf = iIdxLeaf
			iSegid = (*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FiSegid
			iPg = 0
			pDlidx = _fts5DlidxIterInit(tls, p, 0, iSegid, iIdxLeaf)
			for {
				if !(_fts5DlidxIterEof(tls, p, pDlidx) == 0) {
					break
				}
				/* Check any rowid-less pages that occur before the current leaf. */
				iPg = iPrevLeaf + int32(1)
				for {
					if !(iPg < _fts5DlidxIterPgno(tls, pDlidx)) {
						break
					}
					iKey = int64(iSegid)<<(libc.Int32FromInt32(FTS5_DATA_PAGE_B)+libc.Int32FromInt32(FTS5_DATA_HEIGHT_B)+libc.Int32FromInt32(FTS5_DATA_DLI_B)) + int64(libc.Int32FromInt32(0))<<(libc.Int32FromInt32(FTS5_DATA_PAGE_B)+libc.Int32FromInt32(FTS5_DATA_HEIGHT_B)) + int64(libc.Int32FromInt32(0))<<libc.Int32FromInt32(FTS5_DATA_PAGE_B) + int64(iPg)
					pLeaf = _fts5LeafRead(tls, p, iKey)
					if pLeaf != 0 {
						if libc.Int32FromUint16(_fts5GetU16(tls, (*TFts5Data)(unsafe.Pointer(pLeaf)).Fp)) != 0 {
							_fts5IndexCorruptRowid(tls, p, iKey)
						}
						_fts5DataRelease(tls, pLeaf)
					}
					goto _5
				_5:
					;
					iPg = iPg + 1
				}
				iPrevLeaf = _fts5DlidxIterPgno(tls, pDlidx)
				/* Check that the leaf page indicated by the iterator really does
				 ** contain the rowid suggested by the same. */
				iKey = int64(iSegid)<<(libc.Int32FromInt32(FTS5_DATA_PAGE_B)+libc.Int32FromInt32(FTS5_DATA_HEIGHT_B)+libc.Int32FromInt32(FTS5_DATA_DLI_B)) + int64(libc.Int32FromInt32(0))<<(libc.Int32FromInt32(FTS5_DATA_PAGE_B)+libc.Int32FromInt32(FTS5_DATA_HEIGHT_B)) + int64(libc.Int32FromInt32(0))<<libc.Int32FromInt32(FTS5_DATA_PAGE_B) + int64(iPrevLeaf)
				pLeaf = _fts5LeafRead(tls, p, iKey)
				if pLeaf != 0 {
					iRowidOff1 = libc.Int32FromUint16(_fts5GetU16(tls, (*TFts5Data)(unsafe.Pointer(pLeaf)).Fp))
					if iRowidOff1 >= (*TFts5Data)(unsafe.Pointer(pLeaf)).FszLeaf {
						_fts5IndexCorruptRowid(tls, p, iKey)
					} else {
						if bSecureDelete == 0 || iRowidOff1 > 0 {
							iDlRowid = _fts5DlidxIterRowid(tls, pDlidx)
							_sqlite3Fts5GetVarint(tls, (*TFts5Data)(unsafe.Pointer(pLeaf)).Fp+uintptr(iRowidOff1), bp+8)
							if **(**Ti64)(__ccgo_up(bp + 8)) < iDlRowid || bSecureDelete == 0 && **(**Ti64)(__ccgo_up(bp + 8)) != iDlRowid {
								_fts5IndexCorruptRowid(tls, p, iKey)
							}
						}
					}
					_fts5DataRelease(tls, pLeaf)
				}
				goto _4
			_4:
				;
				_fts5DlidxIterNext(tls, p, pDlidx)
			}
			iDlidxPrevLeaf = iPg
			_fts5DlidxIterFree(tls, pDlidx)
		} else {
			iDlidxPrevLeaf = (*TFts5StructureSegment)(unsafe.Pointer(pSeg)).FpgnoLast
			/* TODO: Check there is no doclist index */
		}
		iIdxPrevLeaf = iIdxLeaf
	}
	rc2 = Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp)))
	if (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK {
		(*TFts5Index)(unsafe.Pointer(p)).Frc = rc2
	}
	/* Page iter.iLeaf must now be the rightmost leaf-page in the segment */
}

// C documentation
//
//	/*
//	** Create a "porter" tokenizer.
//	*/
func _fts5PorterCreate(tls *libc.TLS, pCtx uintptr, azArg uintptr, nArg int32, ppOut uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var az2, pApi, pRet, zBase, v2 uintptr
	var nArg2, rc, v1 int32
	var _ /* pUserdata at bp+0 */ uintptr
	var _ /* pV2 at bp+4 */ uintptr
	_, _, _, _, _, _, _, _ = az2, nArg2, pApi, pRet, rc, zBase, v1, v2
	pApi = pCtx
	rc = SQLITE_OK
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	zBase = __ccgo_ts + 41892
	**(**uintptr)(__ccgo_up(bp + 4)) = uintptr(0)
	for nArg > 0 {
		if Xsqlite3_stricmp(tls, **(**uintptr)(__ccgo_up(azArg)), __ccgo_ts+41902) == 0 {
			nArg = nArg - 1
			azArg += 4
		} else {
			zBase = **(**uintptr)(__ccgo_up(azArg))
			break
		}
	}
	pRet = Xsqlite3_malloc64(tls, uint64(148))
	if pRet != 0 {
		libc.Xmemset(tls, pRet, 0, uint32(148))
		rc = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tfts5_api)(unsafe.Pointer(pApi)).FxFindTokenizer_v2})))(tls, pApi, zBase, bp, bp+4)
	} else {
		rc = int32(SQLITE_NOMEM)
	}
	if rc == SQLITE_OK {
		if nArg > 0 {
			v1 = nArg - int32(1)
		} else {
			v1 = 0
		}
		nArg2 = v1
		if nArg2 != 0 {
			v2 = azArg + 1*4
		} else {
			v2 = uintptr(0)
		}
		az2 = v2
		libc.Xmemcpy(tls, pRet, **(**uintptr)(__ccgo_up(bp + 4)), uint32(16))
		rc = (*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TPorterTokenizer)(unsafe.Pointer(pRet)).Ftokenizer_v2.FxCreate})))(tls, **(**uintptr)(__ccgo_up(bp)), az2, nArg2, pRet+16)
	}
	if rc != SQLITE_OK {
		_fts5PorterDelete(tls, pRet)
		pRet = uintptr(0)
	}
	**(**uintptr)(__ccgo_up(ppOut)) = pRet
	return rc
}

// C documentation
//
//	/*
//	** Implementation of snippet() function.
//	*/
func _fts5SnippetFunction(tls *libc.TLS, pApi uintptr, pFts uintptr, pCtx uintptr, nVal int32, apVal uintptr) {
	bp := tls.Alloc(144)
	defer tls.Free(144)
	var aSeen, zEllips, zErr uintptr
	var i, iBestCol, iBestStart, iCol, ii, jj, nBestScore, nCol, nPhrase, v4 int32
	var nToken Ti64
	var v1, v2, v3 int64
	var _ /* ctx at bp+0 */ THighlightContext
	var _ /* iAdj at bp+128 */ int32
	var _ /* ic at bp+120 */ int32
	var _ /* io at bp+124 */ int32
	var _ /* ip at bp+116 */ int32
	var _ /* nColSize at bp+76 */ int32
	var _ /* nDoc at bp+108 */ int32
	var _ /* nDocsize at bp+112 */ int32
	var _ /* nInst at bp+72 */ int32
	var _ /* nLoc at bp+104 */ int32
	var _ /* nLoc at bp+140 */ int32
	var _ /* nScore at bp+132 */ int32
	var _ /* pLoc at bp+100 */ uintptr
	var _ /* pLoc at bp+136 */ uintptr
	var _ /* rc at bp+68 */ int32
	var _ /* sFinder at bp+80 */ TFts5SFinder
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = aSeen, i, iBestCol, iBestStart, iCol, ii, jj, nBestScore, nCol, nPhrase, nToken, zEllips, zErr, v1, v2, v3, v4
	**(**int32)(__ccgo_up(bp + 68)) = SQLITE_OK /* 5th argument to snippet() */
	**(**int32)(__ccgo_up(bp + 72)) = 0         /* Column containing best snippet */
	iBestStart = 0                              /* First token of best snippet */
	nBestScore = 0                              /* Score of best snippet */
	**(**int32)(__ccgo_up(bp + 76)) = 0
	if nVal != int32(5) {
		zErr = __ccgo_ts + 37204
		Xsqlite3_result_error(tls, pCtx, zErr, -int32(1))
		return
	}
	nCol = (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExtensionApi)(unsafe.Pointer(pApi)).FxColumnCount})))(tls, pFts)
	libc.Xmemset(tls, bp, 0, uint32(68))
	iCol = Xsqlite3_value_int(tls, **(**uintptr)(__ccgo_up(apVal)))
	(**(**THighlightContext)(__ccgo_up(bp))).FzOpen = _fts5ValueToText(tls, **(**uintptr)(__ccgo_up(apVal + 1*4)))
	(**(**THighlightContext)(__ccgo_up(bp))).FzClose = _fts5ValueToText(tls, **(**uintptr)(__ccgo_up(apVal + 2*4)))
	(**(**THighlightContext)(__ccgo_up(bp))).FiRangeEnd = -int32(1)
	zEllips = _fts5ValueToText(tls, **(**uintptr)(__ccgo_up(apVal + 3*4)))
	if Xsqlite3_value_int64(tls, **(**uintptr)(__ccgo_up(apVal + 4*4))) > int64(libc.Int32FromInt32(0)) {
		v2 = Xsqlite3_value_int64(tls, **(**uintptr)(__ccgo_up(apVal + 4*4)))
	} else {
		v2 = int64(libc.Int32FromInt32(0))
	}
	if v2 < int64(libc.Int32FromInt32(64)) {
		if Xsqlite3_value_int64(tls, **(**uintptr)(__ccgo_up(apVal + 4*4))) > int64(libc.Int32FromInt32(0)) {
			v3 = Xsqlite3_value_int64(tls, **(**uintptr)(__ccgo_up(apVal + 4*4)))
		} else {
			v3 = int64(libc.Int32FromInt32(0))
		}
		v1 = v3
	} else {
		v1 = int64(libc.Int32FromInt32(64))
	}
	nToken = int64(int32(v1))
	if iCol >= 0 {
		v4 = iCol
	} else {
		v4 = 0
	}
	iBestCol = v4
	nPhrase = (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExtensionApi)(unsafe.Pointer(pApi)).FxPhraseCount})))(tls, pFts)
	aSeen = Xsqlite3_malloc64(tls, libc.Uint64FromInt32(nPhrase))
	if aSeen == uintptr(0) {
		**(**int32)(__ccgo_up(bp + 68)) = int32(SQLITE_NOMEM)
	}
	if **(**int32)(__ccgo_up(bp + 68)) == SQLITE_OK {
		**(**int32)(__ccgo_up(bp + 68)) = (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExtensionApi)(unsafe.Pointer(pApi)).FxInstCount})))(tls, pFts, bp+72)
	}
	libc.Xmemset(tls, bp+80, 0, uint32(20))
	i = 0
	for {
		if !(i < nCol) {
			break
		}
		if iCol < 0 || iCol == i {
			**(**uintptr)(__ccgo_up(bp + 100)) = uintptr(0) /* Locale of column iCol */
			**(**int32)(__ccgo_up(bp + 104)) = 0
			(**(**TFts5SFinder)(__ccgo_up(bp + 80))).FiPos = 0
			(**(**TFts5SFinder)(__ccgo_up(bp + 80))).FnFirst = 0
			**(**int32)(__ccgo_up(bp + 68)) = (*(*func(*libc.TLS, uintptr, int32, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExtensionApi)(unsafe.Pointer(pApi)).FxColumnText})))(tls, pFts, i, bp+80+16, bp+108)
			if **(**int32)(__ccgo_up(bp + 68)) != SQLITE_OK {
				break
			}
			**(**int32)(__ccgo_up(bp + 68)) = (*(*func(*libc.TLS, uintptr, int32, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExtensionApi)(unsafe.Pointer(pApi)).FxColumnLocale})))(tls, pFts, i, bp+100, bp+104)
			if **(**int32)(__ccgo_up(bp + 68)) != SQLITE_OK {
				break
			}
			**(**int32)(__ccgo_up(bp + 68)) = (*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr, int32, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExtensionApi)(unsafe.Pointer(pApi)).FxTokenize_v2})))(tls, pFts, (**(**TFts5SFinder)(__ccgo_up(bp + 80))).FzDoc, **(**int32)(__ccgo_up(bp + 108)), **(**uintptr)(__ccgo_up(bp + 100)), **(**int32)(__ccgo_up(bp + 104)), bp+80, __ccgo_fp(_fts5SentenceFinderCb))
			if **(**int32)(__ccgo_up(bp + 68)) != SQLITE_OK {
				break
			}
			**(**int32)(__ccgo_up(bp + 68)) = (*(*func(*libc.TLS, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExtensionApi)(unsafe.Pointer(pApi)).FxColumnSize})))(tls, pFts, i, bp+112)
			if **(**int32)(__ccgo_up(bp + 68)) != SQLITE_OK {
				break
			}
			ii = 0
			for {
				if !(**(**int32)(__ccgo_up(bp + 68)) == SQLITE_OK && ii < **(**int32)(__ccgo_up(bp + 72))) {
					break
				}
				**(**int32)(__ccgo_up(bp + 68)) = (*(*func(*libc.TLS, uintptr, int32, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExtensionApi)(unsafe.Pointer(pApi)).FxInst})))(tls, pFts, ii, bp+116, bp+120, bp+124)
				if **(**int32)(__ccgo_up(bp + 120)) != i {
					goto _6
				}
				if **(**int32)(__ccgo_up(bp + 124)) > **(**int32)(__ccgo_up(bp + 112)) {
					**(**int32)(__ccgo_up(bp + 68)) = libc.Int32FromInt32(SQLITE_CORRUPT) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(8)
				}
				if **(**int32)(__ccgo_up(bp + 68)) != SQLITE_OK {
					goto _6
				}
				libc.Xmemset(tls, aSeen, 0, libc.Uint32FromInt32(nPhrase))
				**(**int32)(__ccgo_up(bp + 68)) = _fts5SnippetScore(tls, pApi, pFts, **(**int32)(__ccgo_up(bp + 112)), aSeen, i, **(**int32)(__ccgo_up(bp + 124)), int32(nToken), bp+132, bp+128)
				if **(**int32)(__ccgo_up(bp + 68)) == SQLITE_OK && **(**int32)(__ccgo_up(bp + 132)) > nBestScore {
					nBestScore = **(**int32)(__ccgo_up(bp + 132))
					iBestCol = i
					iBestStart = **(**int32)(__ccgo_up(bp + 128))
					**(**int32)(__ccgo_up(bp + 76)) = **(**int32)(__ccgo_up(bp + 112))
				}
				if **(**int32)(__ccgo_up(bp + 68)) == SQLITE_OK && (**(**TFts5SFinder)(__ccgo_up(bp + 80))).FnFirst != 0 && int64(**(**int32)(__ccgo_up(bp + 112))) > nToken {
					jj = 0
					for {
						if !(jj < (**(**TFts5SFinder)(__ccgo_up(bp + 80))).FnFirst-int32(1)) {
							break
						}
						if **(**int32)(__ccgo_up((**(**TFts5SFinder)(__ccgo_up(bp + 80))).FaFirst + uintptr(jj+int32(1))*4)) > **(**int32)(__ccgo_up(bp + 124)) {
							break
						}
						goto _7
					_7:
						;
						jj = jj + 1
					}
					if **(**int32)(__ccgo_up((**(**TFts5SFinder)(__ccgo_up(bp + 80))).FaFirst + uintptr(jj)*4)) < **(**int32)(__ccgo_up(bp + 124)) {
						libc.Xmemset(tls, aSeen, 0, libc.Uint32FromInt32(nPhrase))
						**(**int32)(__ccgo_up(bp + 68)) = _fts5SnippetScore(tls, pApi, pFts, **(**int32)(__ccgo_up(bp + 112)), aSeen, i, **(**int32)(__ccgo_up((**(**TFts5SFinder)(__ccgo_up(bp + 80))).FaFirst + uintptr(jj)*4)), int32(nToken), bp+132, uintptr(0))
						if **(**int32)(__ccgo_up((**(**TFts5SFinder)(__ccgo_up(bp + 80))).FaFirst + uintptr(jj)*4)) == 0 {
							v4 = int32(120)
						} else {
							v4 = int32(100)
						}
						**(**int32)(__ccgo_up(bp + 132)) = **(**int32)(__ccgo_up(bp + 132)) + v4
						if **(**int32)(__ccgo_up(bp + 68)) == SQLITE_OK && **(**int32)(__ccgo_up(bp + 132)) > nBestScore {
							nBestScore = **(**int32)(__ccgo_up(bp + 132))
							iBestCol = i
							iBestStart = **(**int32)(__ccgo_up((**(**TFts5SFinder)(__ccgo_up(bp + 80))).FaFirst + uintptr(jj)*4))
							**(**int32)(__ccgo_up(bp + 76)) = **(**int32)(__ccgo_up(bp + 112))
						}
					}
				}
				goto _6
			_6:
				;
				ii = ii + 1
			}
		}
		goto _5
	_5:
		;
		i = i + 1
	}
	if **(**int32)(__ccgo_up(bp + 68)) == SQLITE_OK {
		**(**int32)(__ccgo_up(bp + 68)) = (*(*func(*libc.TLS, uintptr, int32, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExtensionApi)(unsafe.Pointer(pApi)).FxColumnText})))(tls, pFts, iBestCol, bp+16, bp+20)
	}
	if **(**int32)(__ccgo_up(bp + 68)) == SQLITE_OK && **(**int32)(__ccgo_up(bp + 76)) == 0 {
		**(**int32)(__ccgo_up(bp + 68)) = (*(*func(*libc.TLS, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExtensionApi)(unsafe.Pointer(pApi)).FxColumnSize})))(tls, pFts, iBestCol, bp+76)
	}
	if (**(**THighlightContext)(__ccgo_up(bp))).FzIn != 0 {
		**(**uintptr)(__ccgo_up(bp + 136)) = uintptr(0) /* Locale of column iBestCol */
		**(**int32)(__ccgo_up(bp + 140)) = 0            /* Bytes in pLoc */
		if **(**int32)(__ccgo_up(bp + 68)) == SQLITE_OK {
			**(**int32)(__ccgo_up(bp + 68)) = _fts5CInstIterInit(tls, pApi, pFts, iBestCol, bp+24)
		}
		(**(**THighlightContext)(__ccgo_up(bp))).FiRangeStart = iBestStart
		(**(**THighlightContext)(__ccgo_up(bp))).FiRangeEnd = int32(int64(iBestStart) + nToken - int64(1))
		if iBestStart > 0 {
			_fts5HighlightAppend(tls, bp+68, bp, zEllips, -int32(1))
		}
		/* Advance iterator ctx.iter so that it points to the first coalesced
		 ** phrase instance at or following position iBestStart. */
		for (**(**THighlightContext)(__ccgo_up(bp))).Fiter.FiStart >= 0 && (**(**THighlightContext)(__ccgo_up(bp))).Fiter.FiStart < iBestStart && **(**int32)(__ccgo_up(bp + 68)) == SQLITE_OK {
			**(**int32)(__ccgo_up(bp + 68)) = _fts5CInstIterNext(tls, bp+24)
		}
		if **(**int32)(__ccgo_up(bp + 68)) == SQLITE_OK {
			**(**int32)(__ccgo_up(bp + 68)) = (*(*func(*libc.TLS, uintptr, int32, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExtensionApi)(unsafe.Pointer(pApi)).FxColumnLocale})))(tls, pFts, iBestCol, bp+136, bp+140)
		}
		if **(**int32)(__ccgo_up(bp + 68)) == SQLITE_OK {
			**(**int32)(__ccgo_up(bp + 68)) = (*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr, int32, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*TFts5ExtensionApi)(unsafe.Pointer(pApi)).FxTokenize_v2})))(tls, pFts, (**(**THighlightContext)(__ccgo_up(bp))).FzIn, (**(**THighlightContext)(__ccgo_up(bp))).FnIn, **(**uintptr)(__ccgo_up(bp + 136)), **(**int32)(__ccgo_up(bp + 140)), bp, __ccgo_fp(_fts5HighlightCb))
		}
		if (**(**THighlightContext)(__ccgo_up(bp))).FbOpen != 0 {
			_fts5HighlightAppend(tls, bp+68, bp, (**(**THighlightContext)(__ccgo_up(bp))).FzClose, -int32(1))
		}
		if (**(**THighlightContext)(__ccgo_up(bp))).FiRangeEnd >= **(**int32)(__ccgo_up(bp + 76))-int32(1) {
			_fts5HighlightAppend(tls, bp+68, bp, (**(**THighlightContext)(__ccgo_up(bp))).FzIn+uintptr((**(**THighlightContext)(__ccgo_up(bp))).FiOff), (**(**THighlightContext)(__ccgo_up(bp))).FnIn-(**(**THighlightContext)(__ccgo_up(bp))).FiOff)
		} else {
			_fts5HighlightAppend(tls, bp+68, bp, zEllips, -int32(1))
		}
	}
	if **(**int32)(__ccgo_up(bp + 68)) == SQLITE_OK {
		Xsqlite3_result_text(tls, pCtx, (**(**THighlightContext)(__ccgo_up(bp))).FzOut, -int32(1), uintptr(-libc.Int32FromInt32(1)))
	} else {
		Xsqlite3_result_error_code(tls, pCtx, **(**int32)(__ccgo_up(bp + 68)))
	}
	Xsqlite3_free(tls, (**(**THighlightContext)(__ccgo_up(bp))).FzOut)
	Xsqlite3_free(tls, aSeen)
	Xsqlite3_free(tls, (**(**TFts5SFinder)(__ccgo_up(bp + 80))).FaFirst)
}

/************************************************************************/

func _fts5StructureReadUncached(tls *libc.TLS, p uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var pConfig, pData uintptr
	var _ /* iCookie at bp+4 */ int32
	var _ /* pRet at bp+0 */ uintptr
	_, _ = pConfig, pData
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	pConfig = (*TFts5Index)(unsafe.Pointer(p)).FpConfig
	pData = _fts5DataRead(tls, p, int64(FTS5_STRUCTURE_ROWID))
	if (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK {
		/* TODO: Do we need this if the leaf-index is appended? Probably... */
		libc.Xmemset(tls, (*TFts5Data)(unsafe.Pointer(pData)).Fp+uintptr((*TFts5Data)(unsafe.Pointer(pData)).Fnn), 0, uint32(FTS5_DATA_PADDING))
		(*TFts5Index)(unsafe.Pointer(p)).Frc = _fts5StructureDecode(tls, (*TFts5Data)(unsafe.Pointer(pData)).Fp, (*TFts5Data)(unsafe.Pointer(pData)).Fnn, bp+4, bp)
		if (*TFts5Index)(unsafe.Pointer(p)).Frc == SQLITE_OK {
			if (*TFts5Config)(unsafe.Pointer(pConfig)).Fpgsz == 0 || (*TFts5Config)(unsafe.Pointer(pConfig)).FiCookie != **(**int32)(__ccgo_up(bp + 4)) {
				(*TFts5Index)(unsafe.Pointer(p)).Frc = _sqlite3Fts5ConfigLoad(tls, pConfig, **(**int32)(__ccgo_up(bp + 4)))
			}
		} else {
			if (*TFts5Index)(unsafe.Pointer(p)).Frc == libc.Int32FromInt32(SQLITE_CORRUPT)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(8) {
				_sqlite3Fts5ConfigErrmsg(tls, (*TFts5Index)(unsafe.Pointer(p)).FpConfig, __ccgo_ts+39091, libc.VaList(bp+16, (*TFts5Config)(unsafe.Pointer((*TFts5Index)(unsafe.Pointer(p)).FpConfig)).FzName))
			}
		}
		_fts5DataRelease(tls, pData)
		if (*TFts5Index)(unsafe.Pointer(p)).Frc != SQLITE_OK {
			_fts5StructureRelease(tls, **(**uintptr)(__ccgo_up(bp)))
			**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
		}
	}
	return **(**uintptr)(__ccgo_up(bp))
}

// C documentation
//
//	/*
//	** This function is the implementation of the xUpdate callback used by
//	** FTS3 virtual tables. It is invoked by SQLite each time a row is to be
//	** inserted, updated or deleted.
//	**
//	** A delete specifies a single argument - the rowid of the row to remove.
//	**
//	** Update and insert operations pass:
//	**
//	**   1. The "old" rowid, or NULL.
//	**   2. The "new" rowid.
//	**   3. Values for each of the nCol matchable columns.
//	**   4. Values for the two hidden columns (<tablename> and "rank").
//	*/
func _fts5UpdateMethod(tls *libc.TLS, pVtab uintptr, nArg int32, apVal uintptr, pRowid uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var eConflict, eType0, eType1, ii int32
	var iDel, iNew, iNew1, iOld Ti64
	var pConfig, pStorage, pTab, pVal, z uintptr
	var _ /* bContent at bp+4 */ int32
	var _ /* rc at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _ = eConflict, eType0, eType1, iDel, iNew, iNew1, iOld, ii, pConfig, pStorage, pTab, pVal, z
	pTab = pVtab
	pConfig = (*TFts5FullTable)(unsafe.Pointer(pTab)).Fp.FpConfig /* value_type() of apVal[0] */
	**(**int32)(__ccgo_up(bp)) = SQLITE_OK                        /* Return code */
	/* A transaction must be open when this is called. */
	if (*TFts5Config)(unsafe.Pointer(pConfig)).Fpgsz == 0 {
		**(**int32)(__ccgo_up(bp)) = _sqlite3Fts5ConfigLoad(tls, (*TFts5FullTable)(unsafe.Pointer(pTab)).Fp.FpConfig, (*TFts5Config)(unsafe.Pointer((*TFts5FullTable)(unsafe.Pointer(pTab)).Fp.FpConfig)).FiCookie)
		if **(**int32)(__ccgo_up(bp)) != SQLITE_OK {
			return **(**int32)(__ccgo_up(bp))
		}
	}
	(*TFts5Config)(unsafe.Pointer((*TFts5FullTable)(unsafe.Pointer(pTab)).Fp.FpConfig)).FpzErrmsg = pTab + 8
	/* Put any active cursors into REQUIRE_SEEK state. */
	_fts5TripCursors(tls, pTab)
	eType0 = Xsqlite3_value_type(tls, **(**uintptr)(__ccgo_up(apVal)))
	if eType0 == int32(SQLITE_NULL) && Xsqlite3_value_type(tls, **(**uintptr)(__ccgo_up(apVal + uintptr(int32(2)+(*TFts5Config)(unsafe.Pointer(pConfig)).FnCol)*4))) != int32(SQLITE_NULL) {
		/* A "special" INSERT op. These are handled separately. */
		z = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(apVal + uintptr(int32(2)+(*TFts5Config)(unsafe.Pointer(pConfig)).FnCol)*4)))
		if (*TFts5Config)(unsafe.Pointer(pConfig)).FeContent != FTS5_CONTENT_NORMAL && 0 == Xsqlite3_stricmp(tls, __ccgo_ts+19152, z) {
			if (*TFts5Config)(unsafe.Pointer(pConfig)).FbContentlessDelete != 0 {
				_fts5SetVtabError(tls, pTab, __ccgo_ts+40283, 0)
				**(**int32)(__ccgo_up(bp)) = int32(SQLITE_ERROR)
			} else {
				**(**int32)(__ccgo_up(bp)) = _fts5SpecialDelete(tls, pTab, apVal)
			}
		} else {
			**(**int32)(__ccgo_up(bp)) = _fts5SpecialInsert(tls, pTab, z, **(**uintptr)(__ccgo_up(apVal + uintptr(int32(2)+(*TFts5Config)(unsafe.Pointer(pConfig)).FnCol+int32(1))*4)))
		}
	} else {
		/* A regular INSERT, UPDATE or DELETE statement. The trick here is that
		 ** any conflict on the rowid value must be detected before any
		 ** modifications are made to the database file. There are 4 cases:
		 **
		 **   1) DELETE
		 **   2) UPDATE (rowid not modified)
		 **   3) UPDATE (rowid modified)
		 **   4) INSERT
		 **
		 ** Cases 3 and 4 may violate the rowid constraint.
		 */
		eConflict = int32(SQLITE_ABORT)
		if (*TFts5Config)(unsafe.Pointer(pConfig)).FeContent == FTS5_CONTENT_NORMAL || (*TFts5Config)(unsafe.Pointer(pConfig)).FbContentlessDelete != 0 {
			eConflict = Xsqlite3_vtab_on_conflict(tls, (*TFts5Config)(unsafe.Pointer(pConfig)).Fdb)
		}
		/* DELETE */
		if nArg == int32(1) {
			/* It is only possible to DELETE from a contentless table if the
			 ** contentless_delete=1 flag is set. */
			if _fts5IsContentless(tls, pTab, int32(1)) != 0 && (*TFts5Config)(unsafe.Pointer(pConfig)).FbContentlessDelete == 0 {
				_fts5SetVtabError(tls, pTab, __ccgo_ts+40342, libc.VaList(bp+16, (*TFts5Config)(unsafe.Pointer(pConfig)).FzName))
				**(**int32)(__ccgo_up(bp)) = int32(SQLITE_ERROR)
			} else {
				iDel = Xsqlite3_value_int64(tls, **(**uintptr)(__ccgo_up(apVal))) /* Rowid to delete */
				**(**int32)(__ccgo_up(bp)) = _sqlite3Fts5StorageDelete(tls, (*TFts5FullTable)(unsafe.Pointer(pTab)).FpStorage, iDel, uintptr(0), 0)
			}
		} else {
			eType1 = Xsqlite3_value_numeric_type(tls, **(**uintptr)(__ccgo_up(apVal + 1*4)))
			/* It is an error to write an fts5_locale() value to a table without
			 ** the locale=1 option. */
			if (*TFts5Config)(unsafe.Pointer(pConfig)).FbLocale == 0 {
				ii = 0
				for {
					if !(ii < (*TFts5Config)(unsafe.Pointer(pConfig)).FnCol) {
						break
					}
					pVal = **(**uintptr)(__ccgo_up(apVal + uintptr(ii+int32(2))*4))
					if _sqlite3Fts5IsLocaleValue(tls, pConfig, pVal) != 0 {
						_fts5SetVtabError(tls, pTab, __ccgo_ts+40388, 0)
						**(**int32)(__ccgo_up(bp)) = int32(SQLITE_MISMATCH)
						goto update_out
					}
					goto _1
				_1:
					;
					ii = ii + 1
				}
			}
			if eType0 != int32(SQLITE_INTEGER) {
				/* An INSERT statement. If the conflict-mode is REPLACE, first remove
				 ** the current entry (if any). */
				if eConflict == int32(SQLITE_REPLACE) && eType1 == int32(SQLITE_INTEGER) {
					iNew = Xsqlite3_value_int64(tls, **(**uintptr)(__ccgo_up(apVal + 1*4))) /* Rowid to delete */
					**(**int32)(__ccgo_up(bp)) = _sqlite3Fts5StorageDelete(tls, (*TFts5FullTable)(unsafe.Pointer(pTab)).FpStorage, iNew, uintptr(0), 0)
				}
				_fts5StorageInsert(tls, bp, pTab, apVal, pRowid)
			} else {
				pStorage = (*TFts5FullTable)(unsafe.Pointer(pTab)).FpStorage
				iOld = Xsqlite3_value_int64(tls, **(**uintptr)(__ccgo_up(apVal)))        /* Old rowid */
				iNew1 = Xsqlite3_value_int64(tls, **(**uintptr)(__ccgo_up(apVal + 1*4))) /* New rowid */
				**(**int32)(__ccgo_up(bp + 4)) = 0                                       /* Content only update */
				/* If this is a contentless table (including contentless_unindexed=1
				 ** tables), check if the UPDATE may proceed.  */
				if _fts5IsContentless(tls, pTab, int32(1)) != 0 {
					**(**int32)(__ccgo_up(bp)) = _fts5ContentlessUpdate(tls, pConfig, apVal+2*4, libc.BoolInt32(iOld != iNew1), bp+4)
					if **(**int32)(__ccgo_up(bp)) != SQLITE_OK {
						goto update_out
					}
				}
				if eType1 != int32(SQLITE_INTEGER) {
					**(**int32)(__ccgo_up(bp)) = int32(SQLITE_MISMATCH)
				} else {
					if iOld != iNew1 {
						if eConflict == int32(SQLITE_REPLACE) {
							**(**int32)(__ccgo_up(bp)) = _sqlite3Fts5StorageDelete(tls, pStorage, iOld, uintptr(0), int32(1))
							if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
								**(**int32)(__ccgo_up(bp)) = _sqlite3Fts5StorageDelete(tls, pStorage, iNew1, uintptr(0), 0)
							}
							_fts5StorageInsert(tls, bp, pTab, apVal, pRowid)
						} else {
							**(**int32)(__ccgo_up(bp)) = _sqlite3Fts5StorageFindDeleteRow(tls, pStorage, iOld)
							if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
								**(**int32)(__ccgo_up(bp)) = _sqlite3Fts5StorageContentInsert(tls, pStorage, 0, apVal, pRowid)
							}
							if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
								**(**int32)(__ccgo_up(bp)) = _sqlite3Fts5StorageDelete(tls, pStorage, iOld, uintptr(0), 0)
							}
							if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
								**(**int32)(__ccgo_up(bp)) = _sqlite3Fts5StorageIndexInsert(tls, pStorage, apVal, **(**Tsqlite_int64)(__ccgo_up(pRowid)))
							}
						}
					} else {
						if **(**int32)(__ccgo_up(bp + 4)) != 0 {
							/* This occurs when an UPDATE on a contentless table affects *only*
							 ** UNINDEXED columns. This is a no-op for contentless_unindexed=0
							 ** tables, or a write to the %_content table only for =1 tables.  */
							**(**int32)(__ccgo_up(bp)) = _sqlite3Fts5StorageFindDeleteRow(tls, pStorage, iOld)
							if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
								**(**int32)(__ccgo_up(bp)) = _sqlite3Fts5StorageContentInsert(tls, pStorage, int32(1), apVal, pRowid)
							}
						} else {
							**(**int32)(__ccgo_up(bp)) = _sqlite3Fts5StorageDelete(tls, pStorage, iOld, uintptr(0), int32(1))
							_fts5StorageInsert(tls, bp, pTab, apVal, pRowid)
						}
					}
				}
				_sqlite3Fts5StorageReleaseDeleteRow(tls, pStorage)
			}
		}
	}
	goto update_out
update_out:
	;
	_sqlite3Fts5IndexCloseReader(tls, (*TFts5FullTable)(unsafe.Pointer(pTab)).Fp.FpIndex)
	(*TFts5Config)(unsafe.Pointer((*TFts5FullTable)(unsafe.Pointer(pTab)).Fp.FpConfig)).FpzErrmsg = uintptr(0)
	return **(**int32)(__ccgo_up(bp))
}

// C documentation
//
//	/*
//	** This is the xFilter implementation for the virtual table.
//	*/
func _fts5VocabFilterMethod(tls *libc.TLS, pCursor uintptr, idxNum int32, zUnused uintptr, nUnused int32, apVal uintptr) (r int32) {
	var eType, f, iVal, nTerm, rc, v1 int32
	var pCsr, pEq, pGe, pIndex, pLe, pTab, zCopy, zTerm uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = eType, f, iVal, nTerm, pCsr, pEq, pGe, pIndex, pLe, pTab, rc, zCopy, zTerm, v1
	pTab = (*Tsqlite3_vtab_cursor)(unsafe.Pointer(pCursor)).FpVtab
	pCsr = pCursor
	eType = (*TFts5VocabTable)(unsafe.Pointer(pTab)).FeType
	rc = SQLITE_OK
	iVal = 0
	f = int32(FTS5INDEX_QUERY_SCAN)
	zTerm = uintptr(0)
	nTerm = 0
	pEq = uintptr(0)
	pGe = uintptr(0)
	pLe = uintptr(0)
	_ = zUnused
	_ = nUnused
	_fts5VocabResetCursor(tls, pCsr)
	if idxNum&int32(FTS5_VOCAB_TERM_EQ) != 0 {
		v1 = iVal
		iVal = iVal + 1
		pEq = **(**uintptr)(__ccgo_up(apVal + uintptr(v1)*4))
	}
	if idxNum&int32(FTS5_VOCAB_TERM_GE) != 0 {
		v1 = iVal
		iVal = iVal + 1
		pGe = **(**uintptr)(__ccgo_up(apVal + uintptr(v1)*4))
	}
	if idxNum&int32(FTS5_VOCAB_TERM_LE) != 0 {
		v1 = iVal
		iVal = iVal + 1
		pLe = **(**uintptr)(__ccgo_up(apVal + uintptr(v1)*4))
	}
	(*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FcolUsed = idxNum & int32(FTS5_VOCAB_COLUSED_MASK)
	if pEq != 0 {
		zTerm = Xsqlite3_value_text(tls, pEq)
		nTerm = Xsqlite3_value_bytes(tls, pEq)
		f = int32(FTS5INDEX_QUERY_NOTOKENDATA)
	} else {
		if pGe != 0 {
			zTerm = Xsqlite3_value_text(tls, pGe)
			nTerm = Xsqlite3_value_bytes(tls, pGe)
		}
		if pLe != 0 {
			zCopy = Xsqlite3_value_text(tls, pLe)
			if zCopy == uintptr(0) {
				zCopy = __ccgo_ts + 1702
			}
			(*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FnLeTerm = Xsqlite3_value_bytes(tls, pLe)
			(*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FzLeTerm = Xsqlite3_malloc64(tls, libc.Uint64FromInt64(int64((*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FnLeTerm)+int64(1)))
			if (*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FzLeTerm == uintptr(0) {
				rc = int32(SQLITE_NOMEM)
			} else {
				libc.Xmemcpy(tls, (*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FzLeTerm, zCopy, libc.Uint32FromInt32((*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FnLeTerm+int32(1)))
			}
		}
	}
	if rc == SQLITE_OK {
		pIndex = (*TFts5Table)(unsafe.Pointer((*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FpFts5)).FpIndex
		rc = _sqlite3Fts5IndexQuery(tls, pIndex, zTerm, nTerm, f, uintptr(0), pCsr+16)
		if rc == SQLITE_OK {
			(*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FpStruct = _sqlite3Fts5StructureRef(tls, pIndex)
		}
	}
	if rc == SQLITE_OK && eType == int32(FTS5_VOCAB_INSTANCE) {
		rc = _fts5VocabInstanceNewTerm(tls, pCsr)
	}
	if rc == SQLITE_OK && !((*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FbEof != 0) && (eType != int32(FTS5_VOCAB_INSTANCE) || (*TFts5Config)(unsafe.Pointer((*TFts5Table)(unsafe.Pointer((*TFts5VocabCursor)(unsafe.Pointer(pCsr)).FpFts5)).FpConfig)).FeDetail != int32(FTS5_DETAIL_NONE)) {
		rc = _fts5VocabNextMethod(tls, pCursor)
	}
	return rc
}

// C documentation
//
//	/*
//	** This function is the implementation of both the xConnect and xCreate
//	** methods of the FTS3 virtual table.
//	**
//	** The argv[] array contains the following:
//	**
//	**   argv[0]   -> module name  ("fts5vocab")
//	**   argv[1]   -> database name
//	**   argv[2]   -> table name
//	**
//	** then:
//	**
//	**   argv[3]   -> name of fts5 table
//	**   argv[4]   -> type of fts5vocab table
//	**
//	** or, for tables in the TEMP schema only.
//	**
//	**   argv[3]   -> name of fts5 tables database
//	**   argv[4]   -> name of fts5 table
//	**   argv[5]   -> type of fts5vocab table
//	*/
func _fts5VocabInitVtab(tls *libc.TLS, db uintptr, pAux uintptr, argc int32, argv uintptr, ppVTab uintptr, pzErr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var azSchema [3]uintptr
	var bDb int32
	var nByte, nDb, nTab Ti64
	var pRet, zDb, zTab, zType, v1, v2, v3 uintptr
	var _ /* eType at bp+4 */ int32
	var _ /* rc at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _ = azSchema, bDb, nByte, nDb, nTab, pRet, zDb, zTab, zType, v1, v2, v3
	azSchema = [3]uintptr{
		0: __ccgo_ts + 42268,
		1: __ccgo_ts + 42308,
		2: __ccgo_ts + 42343,
	}
	pRet = uintptr(0)
	**(**int32)(__ccgo_up(bp)) = SQLITE_OK
	bDb = libc.BoolInt32(argc == int32(6) && libc.Xstrlen(tls, **(**uintptr)(__ccgo_up(argv + 1*4))) == uint32(4) && libc.Xmemcmp(tls, __ccgo_ts+25262, **(**uintptr)(__ccgo_up(argv + 1*4)), uint32(4)) == 0)
	if argc != int32(5) && bDb == 0 {
		**(**uintptr)(__ccgo_up(pzErr)) = Xsqlite3_mprintf(tls, __ccgo_ts+42386, 0)
		**(**int32)(__ccgo_up(bp)) = int32(SQLITE_ERROR)
	} else {
		if bDb != 0 {
			v1 = **(**uintptr)(__ccgo_up(argv + 3*4))
		} else {
			v1 = **(**uintptr)(__ccgo_up(argv + 1*4))
		} /* Bytes of space to allocate */
		zDb = v1
		if bDb != 0 {
			v2 = **(**uintptr)(__ccgo_up(argv + 4*4))
		} else {
			v2 = **(**uintptr)(__ccgo_up(argv + 3*4))
		}
		zTab = v2
		if bDb != 0 {
			v3 = **(**uintptr)(__ccgo_up(argv + 5*4))
		} else {
			v3 = **(**uintptr)(__ccgo_up(argv + 4*4))
		}
		zType = v3
		nDb = libc.Int64FromUint32(libc.Xstrlen(tls, zDb) + uint32(1))
		nTab = libc.Int64FromUint32(libc.Xstrlen(tls, zTab) + uint32(1))
		**(**int32)(__ccgo_up(bp + 4)) = 0
		**(**int32)(__ccgo_up(bp)) = _fts5VocabTableType(tls, zType, pzErr, bp+4)
		if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
			**(**int32)(__ccgo_up(bp)) = Xsqlite3_declare_vtab(tls, db, azSchema[**(**int32)(__ccgo_up(bp + 4))])
		}
		nByte = int64(36) + nDb + nTab
		pRet = _sqlite3Fts5MallocZero(tls, bp, nByte)
		if pRet != 0 {
			(*TFts5VocabTable)(unsafe.Pointer(pRet)).FpGlobal = pAux
			(*TFts5VocabTable)(unsafe.Pointer(pRet)).FeType = **(**int32)(__ccgo_up(bp + 4))
			(*TFts5VocabTable)(unsafe.Pointer(pRet)).Fdb = db
			(*TFts5VocabTable)(unsafe.Pointer(pRet)).FzFts5Tbl = pRet + 1*36
			(*TFts5VocabTable)(unsafe.Pointer(pRet)).FzFts5Db = (*TFts5VocabTable)(unsafe.Pointer(pRet)).FzFts5Tbl + uintptr(nTab)
			libc.Xmemcpy(tls, (*TFts5VocabTable)(unsafe.Pointer(pRet)).FzFts5Tbl, zTab, libc.Uint32FromInt64(nTab))
			libc.Xmemcpy(tls, (*TFts5VocabTable)(unsafe.Pointer(pRet)).FzFts5Db, zDb, libc.Uint32FromInt64(nDb))
			_sqlite3Fts5Dequote(tls, (*TFts5VocabTable)(unsafe.Pointer(pRet)).FzFts5Tbl)
			_sqlite3Fts5Dequote(tls, (*TFts5VocabTable)(unsafe.Pointer(pRet)).FzFts5Db)
		}
	}
	**(**uintptr)(__ccgo_up(ppVTab)) = pRet
	return **(**int32)(__ccgo_up(bp))
}

// C documentation
//
//	/*
//	** Code an output subroutine for a coroutine implementation of a
//	** SELECT statement.
//	**
//	** The data to be output is contained in an array of pIn->nSdst registers
//	** starting at register pIn->iSdst.  pDest is where the output should
//	** be sent.
//	**
//	** regReturn is the number of the register holding the subroutine
//	** return address.
//	**
//	** If regPrev>0 then it is the first register in a vector that
//	** records the previous output.  mem[regPrev] is a flag that is false
//	** if there has been no previous output.  If regPrev>0 then code is
//	** generated to suppress duplicates.  pKeyInfo is used for comparing
//	** keys.
//	**
//	** If the LIMIT found in p->iLimit is reached, jump immediately to
//	** iBreak.
//	*/
func _generateOutputSubroutine(tls *libc.TLS, pParse uintptr, p uintptr, pIn uintptr, pDest uintptr, regReturn int32, regPrev int32, pKeyInfo uintptr, iBreak int32) (r int32) {
	var addr, addr1, addr2, iContinue, iParm, iParm1, ii, nKey, r1, r11, r12, r2, r21, r3 int32
	var pSO, v uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = addr, addr1, addr2, iContinue, iParm, iParm1, ii, nKey, pSO, r1, r11, r12, r2, r21, r3, v
	v = (*TParse)(unsafe.Pointer(pParse)).FpVdbe
	addr = _sqlite3VdbeCurrentAddr(tls, v)
	iContinue = _sqlite3VdbeMakeLabel(tls, pParse)
	/* Suppress duplicates for UNION, EXCEPT, and INTERSECT
	 */
	if regPrev != 0 {
		addr1 = _sqlite3VdbeAddOp1(tls, v, int32(OP_IfNot), regPrev)
		addr2 = _sqlite3VdbeAddOp4(tls, v, int32(OP_Compare), (*TSelectDest)(unsafe.Pointer(pIn)).FiSdst, regPrev+int32(1), (*TSelectDest)(unsafe.Pointer(pIn)).FnSdst, _sqlite3KeyInfoRef(tls, pKeyInfo), -int32(9))
		_sqlite3VdbeAddOp3(tls, v, int32(OP_Jump), addr2+int32(2), iContinue, addr2+int32(2))
		_sqlite3VdbeJumpHere(tls, v, addr1)
		_sqlite3VdbeAddOp3(tls, v, int32(OP_Copy), (*TSelectDest)(unsafe.Pointer(pIn)).FiSdst, regPrev+int32(1), (*TSelectDest)(unsafe.Pointer(pIn)).FnSdst-int32(1))
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), int32(1), regPrev)
	}
	if (*Tsqlite3)(unsafe.Pointer((*TParse)(unsafe.Pointer(pParse)).Fdb)).FmallocFailed != 0 {
		return 0
	}
	/* Suppress the first OFFSET entries if there is an OFFSET clause
	 */
	_codeOffset(tls, v, (*TSelect)(unsafe.Pointer(p)).FiOffset, iContinue)
	switch libc.Int32FromUint8((*TSelectDest)(unsafe.Pointer(pDest)).FeDest) {
	/* Store the result as data using a unique key.
	 */
	case int32(SRT_Fifo):
		fallthrough
	case int32(SRT_DistFifo):
		fallthrough
	case int32(SRT_Table):
		fallthrough
	case int32(SRT_EphemTab):
		r1 = _sqlite3GetTempReg(tls, pParse)
		r2 = _sqlite3GetTempReg(tls, pParse)
		iParm = (*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm
		_sqlite3VdbeAddOp3(tls, v, int32(OP_MakeRecord), (*TSelectDest)(unsafe.Pointer(pIn)).FiSdst, (*TSelectDest)(unsafe.Pointer(pIn)).FnSdst, r1)
		if libc.Int32FromUint8((*TSelectDest)(unsafe.Pointer(pDest)).FeDest) == int32(SRT_DistFifo) {
			/* If the destination is DistFifo, then cursor (iParm+1) is open
			 ** on an ephemeral index that is used to enforce uniqueness on the
			 ** total result.  At this point, we are processing the setup portion
			 ** of the recursive CTE using the merge algorithm, so the results are
			 ** guaranteed to be unique anyhow.  But we still need to populate the
			 ** (iParm+1) cursor for use by the subsequent recursive phase.
			 */
			_sqlite3VdbeAddOp4Int(tls, v, int32(OP_IdxInsert), iParm+int32(1), r1, (*TSelectDest)(unsafe.Pointer(pIn)).FiSdst, (*TSelectDest)(unsafe.Pointer(pIn)).FnSdst)
		}
		_sqlite3VdbeAddOp2(tls, v, int32(OP_NewRowid), iParm, r2)
		_sqlite3VdbeAddOp3(tls, v, int32(OP_Insert), iParm, r1, r2)
		_sqlite3VdbeChangeP5(tls, v, uint16(OPFLAG_APPEND))
		_sqlite3ReleaseTempReg(tls, pParse, r2)
		_sqlite3ReleaseTempReg(tls, pParse, r1)
		break
		/* If any row exist in the result set, record that fact and abort.
		 */
		fallthrough
	case int32(SRT_Exists):
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), int32(1), (*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm)
		/* The LIMIT clause will terminate the loop for us */
		break
		/* If we are creating a set for an "expr IN (SELECT ...)".
		 */
		fallthrough
	case int32(SRT_Set):
		r11 = _sqlite3GetTempReg(tls, pParse)
		_sqlite3VdbeAddOp4(tls, v, int32(OP_MakeRecord), (*TSelectDest)(unsafe.Pointer(pIn)).FiSdst, (*TSelectDest)(unsafe.Pointer(pIn)).FnSdst, r11, (*TSelectDest)(unsafe.Pointer(pDest)).FzAffSdst, (*TSelectDest)(unsafe.Pointer(pIn)).FnSdst)
		_sqlite3VdbeAddOp4Int(tls, v, int32(OP_IdxInsert), (*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm, r11, (*TSelectDest)(unsafe.Pointer(pIn)).FiSdst, (*TSelectDest)(unsafe.Pointer(pIn)).FnSdst)
		if (*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm2 > 0 {
			_sqlite3VdbeAddOp4Int(tls, v, int32(OP_FilterAdd), (*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm2, 0, (*TSelectDest)(unsafe.Pointer(pIn)).FiSdst, (*TSelectDest)(unsafe.Pointer(pIn)).FnSdst)
			_sqlite3VdbeExplain(tls, pParse, uint8(0), __ccgo_ts+20467, 0)
		}
		_sqlite3ReleaseTempReg(tls, pParse, r11)
		break
		/* If this is a scalar select that is part of an expression, then
		 ** store the results in the appropriate memory cell and break out
		 ** of the scan loop.  Note that the select might return multiple columns
		 ** if it is the RHS of a row-value IN operator.
		 */
		fallthrough
	case int32(SRT_Mem):
		_sqlite3ExprCodeMove(tls, pParse, (*TSelectDest)(unsafe.Pointer(pIn)).FiSdst, (*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm, (*TSelectDest)(unsafe.Pointer(pIn)).FnSdst)
		/* The LIMIT clause will jump out of the loop for us */
		break
		/* The results are stored in a sequence of registers
		 ** starting at pDest->iSdst.  Then the co-routine yields.
		 */
		fallthrough
	case int32(SRT_Coroutine):
		if (*TSelectDest)(unsafe.Pointer(pDest)).FiSdst == 0 {
			(*TSelectDest)(unsafe.Pointer(pDest)).FiSdst = _sqlite3GetTempRange(tls, pParse, (*TSelectDest)(unsafe.Pointer(pIn)).FnSdst)
			(*TSelectDest)(unsafe.Pointer(pDest)).FnSdst = (*TSelectDest)(unsafe.Pointer(pIn)).FnSdst
		}
		_sqlite3ExprCodeMove(tls, pParse, (*TSelectDest)(unsafe.Pointer(pIn)).FiSdst, (*TSelectDest)(unsafe.Pointer(pDest)).FiSdst, (*TSelectDest)(unsafe.Pointer(pIn)).FnSdst)
		_sqlite3VdbeAddOp1(tls, v, int32(OP_Yield), (*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm)
		break
		/* Write the results into a priority queue that is order according to
		 ** pDest->pOrderBy (in pSO).  pDest->iSDParm (in iParm) is the cursor for an
		 ** index with pSO->nExpr+2 columns.  Build a key using pSO for the first
		 ** pSO->nExpr columns, then make sure all keys are unique by adding a
		 ** final OP_Sequence column.  The last column is the record as a blob.
		 */
		fallthrough
	case int32(SRT_DistQueue):
		fallthrough
	case int32(SRT_Queue):
		iParm1 = (*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm
		pSO = (*TSelectDest)(unsafe.Pointer(pDest)).FpOrderBy
		nKey = (*TExprList)(unsafe.Pointer(pSO)).FnExpr
		r12 = _sqlite3GetTempReg(tls, pParse)
		r21 = _sqlite3GetTempRange(tls, pParse, nKey+int32(2))
		r3 = r21 + nKey + int32(1)
		_sqlite3VdbeAddOp3(tls, v, int32(OP_MakeRecord), (*TSelectDest)(unsafe.Pointer(pIn)).FiSdst, (*TSelectDest)(unsafe.Pointer(pIn)).FnSdst, r3)
		if libc.Int32FromUint8((*TSelectDest)(unsafe.Pointer(pDest)).FeDest) == int32(SRT_DistQueue) {
			_sqlite3VdbeAddOp2(tls, v, int32(OP_IdxInsert), iParm1+int32(1), r3)
		}
		ii = 0
		for {
			if !(ii < nKey) {
				break
			}
			_sqlite3VdbeAddOp2(tls, v, int32(OP_SCopy), (*TSelectDest)(unsafe.Pointer(pIn)).FiSdst+libc.Int32FromUint16(*(*Tu16)(unsafe.Pointer(pSO + 8 + uintptr(ii)*20 + 16)))-int32(1), r21+ii)
			goto _1
		_1:
			;
			ii = ii + 1
		}
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Sequence), iParm1, r21+nKey)
		_sqlite3VdbeAddOp3(tls, v, int32(OP_MakeRecord), r21, nKey+int32(2), r12)
		_sqlite3VdbeAddOp4Int(tls, v, int32(OP_IdxInsert), iParm1, r12, r21, nKey+int32(2))
		_sqlite3ReleaseTempReg(tls, pParse, r12)
		_sqlite3ReleaseTempRange(tls, pParse, r21, nKey+int32(2))
		break
		/* Ignore the output */
		fallthrough
	case int32(SRT_Discard):
		break
		/* If none of the above, then the result destination must be
		 ** SRT_Output.
		 **
		 ** For SRT_Output, results are stored in a sequence of registers.
		 ** Then the OP_ResultRow opcode is used to cause sqlite3_step() to
		 ** return the next row of result.
		 */
		fallthrough
	default:
		_sqlite3VdbeAddOp2(tls, v, int32(OP_ResultRow), (*TSelectDest)(unsafe.Pointer(pIn)).FiSdst, (*TSelectDest)(unsafe.Pointer(pIn)).FnSdst)
		break
	}
	/* Jump to the end of the loop if the LIMIT is reached.
	 */
	if (*TSelect)(unsafe.Pointer(p)).FiLimit != 0 {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_DecrJumpZero), (*TSelect)(unsafe.Pointer(p)).FiLimit, iBreak)
	}
	/* Generate the subroutine return
	 */
	_sqlite3VdbeResolveLabel(tls, v, iContinue)
	_sqlite3VdbeAddOp1(tls, v, int32(OP_Return), regReturn)
	return addr
}

// C documentation
//
//	/*
//	** If the inner loop was generated using a non-null pOrderBy argument,
//	** then the results were placed in a sorter.  After the loop is terminated
//	** we need to run the sorter and output the results.  The following
//	** routine generates the code needed to do that.
//	*/
func _generateSortTail(tls *libc.TLS, pParse uintptr, p uintptr, pSort uintptr, nColumn int32, pDest uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var aOutEx, pOrderBy, v, v1, v3 uintptr
	var addr, addrBreak, addrContinue, addrOnce, bSeq, eDest, i, i2, iCol, iParm, iRead, iSortTab, iTab, nKey, nRefKey, r1, regRow, regRowid, regSortOut, v2, v4 int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = aOutEx, addr, addrBreak, addrContinue, addrOnce, bSeq, eDest, i, i2, iCol, iParm, iRead, iSortTab, iTab, nKey, nRefKey, pOrderBy, r1, regRow, regRowid, regSortOut, v, v1, v2, v3, v4
	v = (*TParse)(unsafe.Pointer(pParse)).FpVdbe              /* The prepared statement */
	addrBreak = (*TSortCtx)(unsafe.Pointer(pSort)).FlabelDone /* Jump here to exit loop */
	addrContinue = _sqlite3VdbeMakeLabel(tls, pParse)         /* Top of output loop. Jump for Next. */
	addrOnce = 0
	pOrderBy = (*TSortCtx)(unsafe.Pointer(pSort)).FpOrderBy
	eDest = libc.Int32FromUint8((*TSelectDest)(unsafe.Pointer(pDest)).FeDest)
	iParm = (*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm /* True if sorter record includes seq. no. */
	nRefKey = 0
	aOutEx = (*TSelect)(unsafe.Pointer(p)).FpEList + 8
	nKey = (*TExprList)(unsafe.Pointer(pOrderBy)).FnExpr - (*TSortCtx)(unsafe.Pointer(pSort)).FnOBSat
	if (*TSortCtx)(unsafe.Pointer(pSort)).FnOBSat == 0 || nKey == int32(1) {
		if (*TSortCtx)(unsafe.Pointer(pSort)).FnOBSat != 0 {
			v1 = __ccgo_ts + 20543
		} else {
			v1 = __ccgo_ts + 1702
		}
		_sqlite3VdbeExplain(tls, pParse, uint8(0), __ccgo_ts+20557, libc.VaList(bp+8, v1))
	} else {
		_sqlite3VdbeExplain(tls, pParse, uint8(0), __ccgo_ts+20588, libc.VaList(bp+8, nKey))
	}
	if (*TSortCtx)(unsafe.Pointer(pSort)).FlabelBkOut != 0 {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Gosub), (*TSortCtx)(unsafe.Pointer(pSort)).FregReturn, (*TSortCtx)(unsafe.Pointer(pSort)).FlabelBkOut)
		_sqlite3VdbeGoto(tls, v, addrBreak)
		_sqlite3VdbeResolveLabel(tls, v, (*TSortCtx)(unsafe.Pointer(pSort)).FlabelBkOut)
	}
	iTab = (*TSortCtx)(unsafe.Pointer(pSort)).FiECursor
	if eDest == int32(SRT_Output) || eDest == int32(SRT_Coroutine) || eDest == int32(SRT_Mem) {
		if eDest == int32(SRT_Mem) && (*TSelect)(unsafe.Pointer(p)).FiOffset != 0 {
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Null), 0, (*TSelectDest)(unsafe.Pointer(pDest)).FiSdst)
		}
		regRowid = 0
		regRow = (*TSelectDest)(unsafe.Pointer(pDest)).FiSdst
	} else {
		regRowid = _sqlite3GetTempReg(tls, pParse)
		if eDest == int32(SRT_EphemTab) || eDest == int32(SRT_Table) {
			regRow = _sqlite3GetTempReg(tls, pParse)
			nColumn = 0
		} else {
			regRow = _sqlite3GetTempRange(tls, pParse, nColumn)
		}
	}
	if libc.Int32FromUint8((*TSortCtx)(unsafe.Pointer(pSort)).FsortFlags)&int32(SORTFLAG_UseSorter) != 0 {
		v1 = pParse + 48
		*(*int32)(unsafe.Pointer(v1)) = *(*int32)(unsafe.Pointer(v1)) + 1
		v2 = *(*int32)(unsafe.Pointer(v1))
		regSortOut = v2
		v3 = pParse + 44
		v4 = *(*int32)(unsafe.Pointer(v3))
		*(*int32)(unsafe.Pointer(v3)) = *(*int32)(unsafe.Pointer(v3)) + 1
		iSortTab = v4
		if (*TSortCtx)(unsafe.Pointer(pSort)).FlabelBkOut != 0 {
			addrOnce = _sqlite3VdbeAddOp0(tls, v, int32(OP_Once))
		}
		_sqlite3VdbeAddOp3(tls, v, int32(OP_OpenPseudo), iSortTab, regSortOut, nKey+int32(1)+nColumn+nRefKey)
		if addrOnce != 0 {
			_sqlite3VdbeJumpHere(tls, v, addrOnce)
		}
		addr = int32(1) + _sqlite3VdbeAddOp2(tls, v, int32(OP_SorterSort), iTab, addrBreak)
		_sqlite3VdbeAddOp3(tls, v, int32(OP_SorterData), iTab, regSortOut, iSortTab)
		bSeq = 0
	} else {
		addr = int32(1) + _sqlite3VdbeAddOp2(tls, v, int32(OP_Sort), iTab, addrBreak)
		_codeOffset(tls, v, (*TSelect)(unsafe.Pointer(p)).FiOffset, addrContinue)
		iSortTab = iTab
		bSeq = int32(1)
		if (*TSelect)(unsafe.Pointer(p)).FiOffset > 0 {
			_sqlite3VdbeAddOp2(tls, v, int32(OP_AddImm), (*TSelect)(unsafe.Pointer(p)).FiLimit, -int32(1))
		}
	}
	i = 0
	iCol = nKey + bSeq - libc.Int32FromInt32(1)
	for {
		if !(i < nColumn) {
			break
		}
		if libc.Int32FromUint16(*(*Tu16)(unsafe.Pointer(aOutEx + uintptr(i)*20 + 16))) == 0 {
			iCol = iCol + 1
		}
		goto _6
	_6:
		;
		i = i + 1
	}
	i = nColumn - int32(1)
	for {
		if !(i >= 0) {
			break
		}
		if *(*Tu16)(unsafe.Pointer(aOutEx + uintptr(i)*20 + 16)) != 0 {
			iRead = libc.Int32FromUint16(*(*Tu16)(unsafe.Pointer(aOutEx + uintptr(i)*20 + 16))) - int32(1)
		} else {
			v2 = iCol
			iCol = iCol - 1
			iRead = v2
		}
		_sqlite3VdbeAddOp3(tls, v, int32(OP_Column), iSortTab, iRead, regRow+i)
		goto _7
	_7:
		;
		i = i - 1
	}
	switch eDest {
	case int32(SRT_Table):
		fallthrough
	case int32(SRT_EphemTab):
		_sqlite3VdbeAddOp3(tls, v, int32(OP_Column), iSortTab, nKey+bSeq, regRow)
		_sqlite3VdbeAddOp2(tls, v, int32(OP_NewRowid), iParm, regRowid)
		_sqlite3VdbeAddOp3(tls, v, int32(OP_Insert), iParm, regRow, regRowid)
		_sqlite3VdbeChangeP5(tls, v, uint16(OPFLAG_APPEND))
	case int32(SRT_Set):
		_sqlite3VdbeAddOp4(tls, v, int32(OP_MakeRecord), regRow, nColumn, regRowid, (*TSelectDest)(unsafe.Pointer(pDest)).FzAffSdst, nColumn)
		_sqlite3VdbeAddOp4Int(tls, v, int32(OP_IdxInsert), iParm, regRowid, regRow, nColumn)
	case int32(SRT_Mem):
		/* The LIMIT clause will terminate the loop for us */
	case int32(SRT_Upfrom):
		i2 = (*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm2
		r1 = _sqlite3GetTempReg(tls, pParse)
		_sqlite3VdbeAddOp3(tls, v, int32(OP_MakeRecord), regRow+libc.BoolInt32(i2 < 0), nColumn-libc.BoolInt32(i2 < 0), r1)
		if i2 < 0 {
			_sqlite3VdbeAddOp3(tls, v, int32(OP_Insert), iParm, r1, regRow)
		} else {
			_sqlite3VdbeAddOp4Int(tls, v, int32(OP_IdxInsert), iParm, r1, regRow, i2)
		}
	default:
		if eDest == int32(SRT_Output) {
			_sqlite3VdbeAddOp2(tls, v, int32(OP_ResultRow), (*TSelectDest)(unsafe.Pointer(pDest)).FiSdst, nColumn)
		} else {
			_sqlite3VdbeAddOp1(tls, v, int32(OP_Yield), (*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm)
		}
		break
	}
	if regRowid != 0 {
		if eDest == int32(SRT_Set) {
			_sqlite3ReleaseTempRange(tls, pParse, regRow, nColumn)
		} else {
			_sqlite3ReleaseTempReg(tls, pParse, regRow)
		}
		_sqlite3ReleaseTempReg(tls, pParse, regRowid)
	}
	/* The bottom of the loop
	 */
	_sqlite3VdbeResolveLabel(tls, v, addrContinue)
	if libc.Int32FromUint8((*TSortCtx)(unsafe.Pointer(pSort)).FsortFlags)&int32(SORTFLAG_UseSorter) != 0 {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_SorterNext), iTab, addr)
	} else {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Next), iTab, addr)
	}
	if (*TSortCtx)(unsafe.Pointer(pSort)).FregReturn != 0 {
		_sqlite3VdbeAddOp1(tls, v, int32(OP_Return), (*TSortCtx)(unsafe.Pointer(pSort)).FregReturn)
	}
	_sqlite3VdbeResolveLabel(tls, v, addrBreak)
}

// C documentation
//
//	/*
//	** This routine generates VDBE code to compute the content of a WITH RECURSIVE
//	** query of the form:
//	**
//	**   <recursive-table> AS (<setup-query> UNION [ALL] <recursive-query>)
//	**                         \___________/             \_______________/
//	**                           p->pPrior                      p
//	**
//	**
//	** There is exactly one reference to the recursive-table in the FROM clause
//	** of recursive-query, marked with the SrcList->a[].fg.isRecursive flag.
//	**
//	** The setup-query runs once to generate an initial set of rows that go
//	** into a Queue table.  Rows are extracted from the Queue table one by
//	** one.  Each row extracted from Queue is output to pDest.  Then the single
//	** extracted row (now in the iCurrent table) becomes the content of the
//	** recursive-table for a recursive-query run.  The output of the recursive-query
//	** is added back into the Queue table.  Then another row is extracted from Queue
//	** and the iteration continues until the Queue table is empty.
//	**
//	** If the compound query operator is UNION then no duplicate rows are ever
//	** inserted into the Queue table.  The iDistinct table keeps a copy of all rows
//	** that have ever been inserted into Queue and causes duplicates to be
//	** discarded.  If the operator is UNION ALL, then duplicates are allowed.
//	**
//	** If the query has an ORDER BY, then entries in the Queue table are kept in
//	** ORDER BY order and the first entry is extracted for each cycle.  Without
//	** an ORDER BY, the Queue table is just a FIFO.
//	**
//	** If a LIMIT clause is provided, then the iteration stops after LIMIT rows
//	** have been output to pDest.  A LIMIT of zero means to output no rows and a
//	** negative LIMIT means to output all rows.  If there is also an OFFSET clause
//	** with a positive value, then the first OFFSET outputs are discarded rather
//	** than being sent to pDest.  The LIMIT count does not begin until after OFFSET
//	** rows have been skipped.
//	*/
func _generateWithRecursiveQuery(tls *libc.TLS, pParse uintptr, p uintptr, pDest uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var addrBreak, addrCont, addrTop, eDest, i, iCurrent, iDistinct, iQueue, nCol, rc, regCurrent, regLimit, regOffset, v1 int32
	var apColl, pFirstRec, pKeyInfo, pKeyInfo1, pLimit, pOrderBy, pSetup, pSrc, v, v4 uintptr
	var _ /* destQueue at bp+0 */ TSelectDest
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = addrBreak, addrCont, addrTop, apColl, eDest, i, iCurrent, iDistinct, iQueue, nCol, pFirstRec, pKeyInfo, pKeyInfo1, pLimit, pOrderBy, pSetup, pSrc, rc, regCurrent, regLimit, regOffset, v, v1, v4
	pSrc = (*TSelect)(unsafe.Pointer(p)).FpSrc                                        /* The FROM clause of the recursive query */
	nCol = (*TExprList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpEList)).FnExpr /* Number of columns in the recursive table */
	v = (*TParse)(unsafe.Pointer(pParse)).FpVdbe                                      /* CONTINUE and BREAK addresses */
	iCurrent = 0                                                                      /* The Queue table */
	iDistinct = 0                                                                     /* To ensure unique results if UNION */
	eDest = int32(SRT_Fifo)                                                           /* Registers used by LIMIT and OFFSET */
	if (*TSelect)(unsafe.Pointer(p)).FpWin != 0 {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+20695, 0)
		return
	}
	/* Obtain authorization to do a recursive query */
	if _sqlite3AuthCheck(tls, pParse, int32(SQLITE_RECURSIVE), uintptr(0), uintptr(0), uintptr(0)) != 0 {
		return
	}
	/* Process the LIMIT and OFFSET clauses, if they exist */
	addrBreak = _sqlite3VdbeMakeLabel(tls, pParse)
	(*TSelect)(unsafe.Pointer(p)).FnSelectRow = int16(320) /* 4 billion rows */
	_computeLimitRegisters(tls, pParse, p, addrBreak)
	pLimit = (*TSelect)(unsafe.Pointer(p)).FpLimit
	regLimit = (*TSelect)(unsafe.Pointer(p)).FiLimit
	regOffset = (*TSelect)(unsafe.Pointer(p)).FiOffset
	(*TSelect)(unsafe.Pointer(p)).FpLimit = uintptr(0)
	v1 = libc.Int32FromInt32(0)
	(*TSelect)(unsafe.Pointer(p)).FiOffset = v1
	(*TSelect)(unsafe.Pointer(p)).FiLimit = v1
	pOrderBy = (*TSelect)(unsafe.Pointer(p)).FpOrderBy
	/* Locate the cursor number of the Current table */
	i = 0
	for {
		if !(i < (*TSrcList)(unsafe.Pointer(pSrc)).FnSrc) {
			break
		}
		if int32(*(*uint32)(unsafe.Pointer(pSrc + 8 + uintptr(i)*48 + 12 + 4))&0x80>>7) != 0 {
			iCurrent = (*(*TSrcItem)(unsafe.Pointer(pSrc + 8 + uintptr(i)*48))).FiCursor
			break
		}
		goto _2
	_2:
		;
		i = i + 1
	}
	/* Allocate cursors numbers for Queue and Distinct.  The cursor number for
	 ** the Distinct table must be exactly one greater than Queue in order
	 ** for the SRT_DistFifo and SRT_DistQueue destinations to work. */
	v4 = pParse + 44
	v1 = *(*int32)(unsafe.Pointer(v4))
	*(*int32)(unsafe.Pointer(v4)) = *(*int32)(unsafe.Pointer(v4)) + 1
	iQueue = v1
	if libc.Int32FromUint8((*TSelect)(unsafe.Pointer(p)).Fop) == int32(TK_UNION) {
		if pOrderBy != 0 {
			v1 = int32(SRT_DistQueue)
		} else {
			v1 = int32(SRT_DistFifo)
		}
		eDest = v1
		v4 = pParse + 44
		v1 = *(*int32)(unsafe.Pointer(v4))
		*(*int32)(unsafe.Pointer(v4)) = *(*int32)(unsafe.Pointer(v4)) + 1
		iDistinct = v1
	} else {
		if pOrderBy != 0 {
			v1 = int32(SRT_Queue)
		} else {
			v1 = int32(SRT_Fifo)
		}
		eDest = v1
	}
	_sqlite3SelectDestInit(tls, bp, eDest, iQueue)
	/* Allocate cursors for Current, Queue, and Distinct. */
	v4 = pParse + 48
	*(*int32)(unsafe.Pointer(v4)) = *(*int32)(unsafe.Pointer(v4)) + 1
	v1 = *(*int32)(unsafe.Pointer(v4))
	regCurrent = v1
	_sqlite3VdbeAddOp3(tls, v, int32(OP_OpenPseudo), iCurrent, regCurrent, nCol)
	if pOrderBy != 0 {
		pKeyInfo = _multiSelectByMergeKeyInfo(tls, pParse, p, int32(1))
		_sqlite3VdbeAddOp4(tls, v, int32(OP_OpenEphemeral), iQueue, (*TExprList)(unsafe.Pointer(pOrderBy)).FnExpr+int32(2), 0, pKeyInfo, -int32(9))
		(**(**TSelectDest)(__ccgo_up(bp))).FpOrderBy = pOrderBy
	} else {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_OpenEphemeral), iQueue, nCol)
	}
	if iDistinct != 0 { /* For looping through pKeyInfo->aColl[] */
		nCol = (*TExprList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpEList)).FnExpr
		pKeyInfo1 = _sqlite3KeyInfoAlloc(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, nCol, int32(1))
		if pKeyInfo1 != 0 {
			i = 0
			apColl = pKeyInfo1 + 20
			for {
				if !(i < nCol) {
					break
				}
				**(**uintptr)(__ccgo_up(apColl)) = _multiSelectCollSeq(tls, pParse, p, i)
				if uintptr(0) == **(**uintptr)(__ccgo_up(apColl)) {
					**(**uintptr)(__ccgo_up(apColl)) = (*Tsqlite3)(unsafe.Pointer((*TParse)(unsafe.Pointer(pParse)).Fdb)).FpDfltColl
				}
				goto _11
			_11:
				;
				i = i + 1
				apColl += 4
			}
			_sqlite3VdbeAddOp4(tls, v, int32(OP_OpenEphemeral), iDistinct, nCol, 0, pKeyInfo1, -int32(9))
		} else {
		}
	}
	/* Detach the ORDER BY clause from the compound SELECT */
	(*TSelect)(unsafe.Pointer(p)).FpOrderBy = uintptr(0)
	/* Figure out how many elements of the compound SELECT are part of the
	 ** recursive query.  Make sure no recursive elements use aggregate
	 ** functions.  Mark the recursive elements as UNION ALL even if they
	 ** are really UNION because the distinctness will be enforced by the
	 ** iDistinct table.  pFirstRec is left pointing to the left-most
	 ** recursive term of the CTE.
	 */
	pFirstRec = p
	for {
		if !(pFirstRec != uintptr(0)) {
			break
		}
		if (*TSelect)(unsafe.Pointer(pFirstRec)).FselFlags&uint32(SF_Aggregate) != 0 {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+20744, 0)
			goto end_of_recursive_query
		}
		(*TSelect)(unsafe.Pointer(pFirstRec)).Fop = uint8(TK_ALL)
		if (*TSelect)(unsafe.Pointer((*TSelect)(unsafe.Pointer(pFirstRec)).FpPrior)).FselFlags&uint32(SF_Recursive) == uint32(0) {
			break
		}
		goto _12
	_12:
		;
		pFirstRec = (*TSelect)(unsafe.Pointer(pFirstRec)).FpPrior
	}
	/* Store the results of the setup-query in Queue. */
	pSetup = (*TSelect)(unsafe.Pointer(pFirstRec)).FpPrior
	(*TSelect)(unsafe.Pointer(pSetup)).FpNext = uintptr(0)
	_sqlite3VdbeExplain(tls, pParse, uint8(1), __ccgo_ts+20786, 0)
	rc = _sqlite3Select(tls, pParse, pSetup, bp)
	(*TSelect)(unsafe.Pointer(pSetup)).FpNext = p
	if rc != 0 {
		goto end_of_recursive_query
	}
	/* Find the next row in the Queue and output that row */
	addrTop = _sqlite3VdbeAddOp2(tls, v, int32(OP_Rewind), iQueue, addrBreak)
	/* Transfer the next row in Queue over to Current */
	_sqlite3VdbeAddOp1(tls, v, int32(OP_NullRow), iCurrent) /* To reset column cache */
	if pOrderBy != 0 {
		_sqlite3VdbeAddOp3(tls, v, int32(OP_Column), iQueue, (*TExprList)(unsafe.Pointer(pOrderBy)).FnExpr+int32(1), regCurrent)
	} else {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_RowData), iQueue, regCurrent)
	}
	_sqlite3VdbeAddOp1(tls, v, int32(OP_Delete), iQueue)
	/* Output the single row in Current */
	addrCont = _sqlite3VdbeMakeLabel(tls, pParse)
	_codeOffset(tls, v, regOffset, addrCont)
	_selectInnerLoop(tls, pParse, p, iCurrent, uintptr(0), uintptr(0), pDest, addrCont, addrBreak)
	if regLimit != 0 {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_DecrJumpZero), regLimit, addrBreak)
	}
	_sqlite3VdbeResolveLabel(tls, v, addrCont)
	/* Execute the recursive SELECT taking the single row in Current as
	 ** the value for the recursive-table. Store the results in the Queue.
	 */
	(*TSelect)(unsafe.Pointer(pFirstRec)).FpPrior = uintptr(0)
	_sqlite3VdbeExplain(tls, pParse, uint8(1), __ccgo_ts+20792, 0)
	_sqlite3Select(tls, pParse, p, bp)
	(*TSelect)(unsafe.Pointer(pFirstRec)).FpPrior = pSetup
	/* Keep running the loop until the Queue is empty */
	_sqlite3VdbeGoto(tls, v, addrTop)
	_sqlite3VdbeResolveLabel(tls, v, addrBreak)
	goto end_of_recursive_query
end_of_recursive_query:
	;
	_sqlite3ExprListDelete(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, (*TSelect)(unsafe.Pointer(p)).FpOrderBy)
	(*TSelect)(unsafe.Pointer(p)).FpOrderBy = pOrderBy
	(*TSelect)(unsafe.Pointer(p)).FpLimit = pLimit
	return
}

// C documentation
//
//	/*
//	** This function is called from within the xConnect() or xCreate() method to
//	** determine the node-size used by the rtree table being created or connected
//	** to. If successful, pRtree->iNodeSize is populated and SQLITE_OK returned.
//	** Otherwise, an SQLite error code is returned.
//	**
//	** If this function is being called as part of an xConnect(), then the rtree
//	** table already exists. In this case the node-size is determined by inspecting
//	** the root node of the tree.
//	**
//	** Otherwise, for an xCreate(), use 64 bytes less than the database page-size.
//	** This ensures that each node is stored on a single database page. If the
//	** database page-size is so large that more than RTREE_MAXCELLS entries
//	** would fit in a single node, use a smaller node-size.
//	*/
func _getNodeSize(tls *libc.TLS, db uintptr, pRtree uintptr, isCreate int32, pzErr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var rc int32
	var zSql uintptr
	var _ /* iPageSize at bp+0 */ int32
	_, _ = rc, zSql
	if isCreate != 0 {
		**(**int32)(__ccgo_up(bp)) = 0
		zSql = Xsqlite3_mprintf(tls, __ccgo_ts+28687, libc.VaList(bp+16, (*TRtree)(unsafe.Pointer(pRtree)).FzDb))
		rc = _getIntFromStmt(tls, db, zSql, bp)
		if rc == SQLITE_OK {
			(*TRtree)(unsafe.Pointer(pRtree)).FiNodeSize = **(**int32)(__ccgo_up(bp)) - int32(64)
			if int32(4)+libc.Int32FromUint8((*TRtree)(unsafe.Pointer(pRtree)).FnBytesPerCell)*int32(RTREE_MAXCELLS) < (*TRtree)(unsafe.Pointer(pRtree)).FiNodeSize {
				(*TRtree)(unsafe.Pointer(pRtree)).FiNodeSize = int32(4) + libc.Int32FromUint8((*TRtree)(unsafe.Pointer(pRtree)).FnBytesPerCell)*int32(RTREE_MAXCELLS)
			}
		} else {
			**(**uintptr)(__ccgo_up(pzErr)) = Xsqlite3_mprintf(tls, __ccgo_ts+3942, libc.VaList(bp+16, Xsqlite3_errmsg(tls, db)))
		}
	} else {
		zSql = Xsqlite3_mprintf(tls, __ccgo_ts+28707, libc.VaList(bp+16, (*TRtree)(unsafe.Pointer(pRtree)).FzDb, (*TRtree)(unsafe.Pointer(pRtree)).FzName))
		rc = _getIntFromStmt(tls, db, zSql, pRtree+16)
		if rc != SQLITE_OK {
			**(**uintptr)(__ccgo_up(pzErr)) = Xsqlite3_mprintf(tls, __ccgo_ts+3942, libc.VaList(bp+16, Xsqlite3_errmsg(tls, db)))
		} else {
			if (*TRtree)(unsafe.Pointer(pRtree)).FiNodeSize < libc.Int32FromInt32(512)-libc.Int32FromInt32(64) {
				rc = libc.Int32FromInt32(SQLITE_CORRUPT) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(8)
				**(**uintptr)(__ccgo_up(pzErr)) = Xsqlite3_mprintf(tls, __ccgo_ts+28764, libc.VaList(bp+16, (*TRtree)(unsafe.Pointer(pRtree)).FzName))
			}
		}
	}
	Xsqlite3_free(tls, zSql)
	return rc
}

// C documentation
//
//	/*
//	** Invalidate temp storage, either when the temp storage is changed
//	** from default, or when 'file' and the temp_store_directory has changed
//	*/
func _invalidateTempStorage(tls *libc.TLS, pParse uintptr) (r int32) {
	var db uintptr
	_ = db
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	if (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + 1*16))).FpBt != uintptr(0) {
		if !((*Tsqlite3)(unsafe.Pointer(db)).FautoCommit != 0) || _sqlite3BtreeTxnState(tls, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + 1*16))).FpBt) != SQLITE_TXN_NONE {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+19042, 0)
			return int32(SQLITE_ERROR)
		}
		_sqlite3BtreeClose(tls, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + 1*16))).FpBt)
		(**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + 1*16))).FpBt = uintptr(0)
		_sqlite3ResetAllSchemasOfConnection(tls, db)
	}
	return SQLITE_OK
}

// C documentation
//
//	/*
//	** Append an sqlite3_value (such as a function parameter) to the JSON
//	** string under construction in p.
//	*/
func _jsonAppendSqlValue(tls *libc.TLS, p uintptr, pValue uintptr) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var n, n1 Tu32
	var z, z1 uintptr
	var _ /* px at bp+0 */ TJsonParse
	_, _, _, _ = n, n1, z, z1
	switch Xsqlite3_value_type(tls, pValue) {
	case int32(SQLITE_NULL):
		_jsonAppendRawNZ(tls, p, __ccgo_ts+1688, uint32(4))
	case int32(SQLITE_FLOAT):
		_jsonPrintf(tls, int32(100), p, __ccgo_ts+16561, libc.VaList(bp+64, Xsqlite3_value_double(tls, pValue)))
	case int32(SQLITE_INTEGER):
		z = Xsqlite3_value_text(tls, pValue)
		n = libc.Uint32FromInt32(Xsqlite3_value_bytes(tls, pValue))
		_jsonAppendRaw(tls, p, z, n)
	case int32(SQLITE_TEXT):
		z1 = Xsqlite3_value_text(tls, pValue)
		n1 = libc.Uint32FromInt32(Xsqlite3_value_bytes(tls, pValue))
		if Xsqlite3_value_subtype(tls, pValue) == uint32(JSON_SUBTYPE) {
			_jsonAppendRaw(tls, p, z1, n1)
		} else {
			_jsonAppendString(tls, p, z1, n1)
		}
	default:
		libc.Xmemset(tls, bp, 0, uint32(56))
		if _jsonArgIsJsonb(tls, pValue, bp) != 0 {
			_jsonTranslateBlobToText(tls, bp, uint32(0), p)
		} else {
			if libc.Int32FromUint8((*TJsonString)(unsafe.Pointer(p)).FeErr) == 0 {
				Xsqlite3_result_error(tls, (*TJsonString)(unsafe.Pointer(p)).FpCtx, __ccgo_ts+26431, -int32(1))
				(*TJsonString)(unsafe.Pointer(p)).FeErr = uint8(JSTRING_ERR)
				_jsonStringReset(tls, p)
			}
		}
		break
	}
}

func _jsonArrayCompute(tls *libc.TLS, ctx uintptr, isFinal int32) {
	var flags int32
	var pStr uintptr
	var v1 Tsqlite3_destructor_type
	_, _, _ = flags, pStr, v1
	flags = int32(Xsqlite3_user_data(tls, ctx))
	pStr = Xsqlite3_aggregate_context(tls, ctx, 0)
	if pStr != 0 {
		(*TJsonString)(unsafe.Pointer(pStr)).FpCtx = ctx
		_jsonAppendRawNZ(tls, pStr, __ccgo_ts+5314, uint32(2))
		_jsonStringTrimOneChar(tls, pStr)
		if (*TJsonString)(unsafe.Pointer(pStr)).FeErr != 0 {
			_jsonReturnString(tls, pStr, uintptr(0), uintptr(0))
			return
		} else {
			if flags&int32(JSON_BLOB) != 0 {
				_jsonReturnStringAsBlob(tls, pStr)
				if isFinal != 0 {
					if !((*TJsonString)(unsafe.Pointer(pStr)).FbStatic != 0) {
						_sqlite3RCStrUnref(tls, (*TJsonString)(unsafe.Pointer(pStr)).FzBuf)
					}
				} else {
					_jsonStringTrimOneChar(tls, pStr)
				}
				return
			} else {
				if isFinal != 0 {
					if (*TJsonString)(unsafe.Pointer(pStr)).FbStatic != 0 {
						v1 = uintptr(-libc.Int32FromInt32(1))
					} else {
						v1 = __ccgo_fp(_sqlite3RCStrUnref)
					}
					Xsqlite3_result_text(tls, ctx, (*TJsonString)(unsafe.Pointer(pStr)).FzBuf, libc.Int32FromUint64((*TJsonString)(unsafe.Pointer(pStr)).FnUsed), v1)
					(*TJsonString)(unsafe.Pointer(pStr)).FbStatic = uint8(1)
				} else {
					Xsqlite3_result_text(tls, ctx, (*TJsonString)(unsafe.Pointer(pStr)).FzBuf, libc.Int32FromUint64((*TJsonString)(unsafe.Pointer(pStr)).FnUsed), uintptr(-libc.Int32FromInt32(1)))
					_jsonStringTrimOneChar(tls, pStr)
				}
			}
		}
	} else {
		if flags&int32(JSON_BLOB) != 0 {
			Xsqlite3_result_blob(tls, ctx, uintptr(unsafe.Pointer(&_emptyArray)), int32(1), libc.UintptrFromInt32(0))
		} else {
			Xsqlite3_result_text(tls, ctx, __ccgo_ts+26852, int32(2), libc.UintptrFromInt32(0))
		}
	}
	Xsqlite3_result_subtype(tls, ctx, uint32(JSON_SUBTYPE))
}

// C documentation
//
//	/*
//	** Implementation of the json_mergepatch(JSON1,JSON2) function.  Return a JSON
//	** object that is the result of running the RFC 7396 MergePatch() algorithm
//	** on the two arguments.
//	*/
func _jsonPatchFunc(tls *libc.TLS, ctx uintptr, argc int32, argv uintptr) {
	var pPatch, pTarget uintptr
	var rc int32
	_, _, _ = pPatch, pTarget, rc /* Result code */
	_ = argc
	pTarget = _jsonParseFuncArg(tls, ctx, **(**uintptr)(__ccgo_up(argv)), uint32(JSON_EDITABLE))
	if pTarget == uintptr(0) {
		return
	}
	pPatch = _jsonParseFuncArg(tls, ctx, **(**uintptr)(__ccgo_up(argv + 1*4)), uint32(0))
	if pPatch != 0 {
		rc = _jsonMergePatch(tls, pTarget, uint32(0), pPatch, uint32(0), uint32(0))
		if rc == JSON_MERGE_OK {
			_jsonReturnParse(tls, ctx, pTarget)
		} else {
			if rc == int32(JSON_MERGE_OOM) {
				Xsqlite3_result_error_nomem(tls, ctx)
			} else {
				if rc == int32(JSON_MERGE_TOODEEP) {
					Xsqlite3_result_error(tls, ctx, __ccgo_ts+26410, -int32(1))
				} else {
					Xsqlite3_result_error(tls, ctx, __ccgo_ts+26460, -int32(1))
				}
			}
		}
		_jsonParseFree(tls, pPatch)
	}
	_jsonParseFree(tls, pTarget)
}

// C documentation
//
//	/*
//	** json_pretty(JSON)
//	** json_pretty(JSON, INDENT)
//	**
//	** Return text that is a pretty-printed rendering of the input JSON.
//	** If the argument is not valid JSON, return NULL.
//	**
//	** The INDENT argument is text that is used for indentation.  If omitted,
//	** it defaults to four spaces (the same as PostgreSQL).
//	*/
func _jsonPrettyFunc(tls *libc.TLS, ctx uintptr, argc int32, argv uintptr) {
	bp := tls.Alloc(160)
	defer tls.Free(160)
	var v1 uintptr
	var v2 bool
	var _ /* s at bp+0 */ TJsonString
	var _ /* x at bp+128 */ TJsonPretty
	_, _ = v1, v2 /* Pretty printing context */
	libc.Xmemset(tls, bp+128, 0, uint32(20))
	(**(**TJsonPretty)(__ccgo_up(bp + 128))).FpParse = _jsonParseFuncArg(tls, ctx, **(**uintptr)(__ccgo_up(argv)), uint32(0))
	if (**(**TJsonPretty)(__ccgo_up(bp + 128))).FpParse == uintptr(0) {
		return
	}
	(**(**TJsonPretty)(__ccgo_up(bp + 128))).FpOut = bp
	_jsonStringInit(tls, bp, ctx)
	if v2 = argc == int32(1); !v2 {
		v1 = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv + 1*4)))
		(**(**TJsonPretty)(__ccgo_up(bp + 128))).FzIndent = v1
	}
	if v2 || v1 == uintptr(0) {
		(**(**TJsonPretty)(__ccgo_up(bp + 128))).FzIndent = __ccgo_ts + 26790
		(**(**TJsonPretty)(__ccgo_up(bp + 128))).FszIndent = uint32(4)
	} else {
		(**(**TJsonPretty)(__ccgo_up(bp + 128))).FszIndent = libc.Xstrlen(tls, (**(**TJsonPretty)(__ccgo_up(bp + 128))).FzIndent)
	}
	_jsonTranslateBlobToPrettyText(tls, bp+128, uint32(0))
	_jsonReturnString(tls, bp, uintptr(0), uintptr(0))
	_jsonParseFree(tls, (**(**TJsonPretty)(__ccgo_up(bp + 128))).FpParse)
}

// C documentation
//
//	/* Make the text in p (which is probably a generated JSON text string)
//	** the result of the SQL function.
//	**
//	** The JsonString is reset.
//	**
//	** If pParse and ctx are both non-NULL, then the SQL string in p is
//	** loaded into the zJson field of the pParse object as a RCStr and the
//	** pParse is added to the cache.
//	*/
func _jsonReturnString(tls *libc.TLS, p uintptr, pParse uintptr, ctx uintptr) {
	var flags, rc int32
	_, _ = flags, rc
	_jsonStringTerminate(tls, p)
	if libc.Int32FromUint8((*TJsonString)(unsafe.Pointer(p)).FeErr) == 0 {
		flags = int32(Xsqlite3_user_data(tls, (*TJsonString)(unsafe.Pointer(p)).FpCtx))
		if flags&int32(JSON_BLOB) != 0 {
			_jsonReturnStringAsBlob(tls, p)
		} else {
			if (*TJsonString)(unsafe.Pointer(p)).FbStatic != 0 {
				Xsqlite3_result_text64(tls, (*TJsonString)(unsafe.Pointer(p)).FpCtx, (*TJsonString)(unsafe.Pointer(p)).FzBuf, (*TJsonString)(unsafe.Pointer(p)).FnUsed, uintptr(-libc.Int32FromInt32(1)), uint8(SQLITE_UTF8))
			} else {
				if pParse != 0 && libc.Int32FromUint8((*TJsonParse)(unsafe.Pointer(pParse)).FbJsonIsRCStr) == 0 && (*TJsonParse)(unsafe.Pointer(pParse)).FnBlobAlloc > uint32(0) {
					(*TJsonParse)(unsafe.Pointer(pParse)).FzJson = _sqlite3RCStrRef(tls, (*TJsonString)(unsafe.Pointer(p)).FzBuf)
					(*TJsonParse)(unsafe.Pointer(pParse)).FnJson = libc.Int32FromUint64((*TJsonString)(unsafe.Pointer(p)).FnUsed)
					(*TJsonParse)(unsafe.Pointer(pParse)).FbJsonIsRCStr = uint8(1)
					rc = _jsonCacheInsert(tls, ctx, pParse)
					if rc == int32(SQLITE_NOMEM) {
						Xsqlite3_result_error_nomem(tls, ctx)
						_jsonStringReset(tls, p)
						return
					}
				}
				Xsqlite3_result_text64(tls, (*TJsonString)(unsafe.Pointer(p)).FpCtx, _sqlite3RCStrRef(tls, (*TJsonString)(unsafe.Pointer(p)).FzBuf), (*TJsonString)(unsafe.Pointer(p)).FnUsed, __ccgo_fp(_sqlite3RCStrUnref), uint8(SQLITE_UTF8))
			}
		}
	} else {
		if libc.Int32FromUint8((*TJsonString)(unsafe.Pointer(p)).FeErr)&int32(JSTRING_OOM) != 0 {
			Xsqlite3_result_error_nomem(tls, (*TJsonString)(unsafe.Pointer(p)).FpCtx)
		} else {
			if libc.Int32FromUint8((*TJsonString)(unsafe.Pointer(p)).FeErr)&int32(JSTRING_TOODEEP) != 0 {
				/* error already in p->pCtx */
			} else {
				if libc.Int32FromUint8((*TJsonString)(unsafe.Pointer(p)).FeErr)&int32(JSTRING_MALFORMED) != 0 {
					Xsqlite3_result_error(tls, (*TJsonString)(unsafe.Pointer(p)).FpCtx, __ccgo_ts+26460, -int32(1))
				}
			}
		}
	}
	_jsonStringReset(tls, p)
}

/**************************************************************************
** Utility routines for dealing with JsonParse objects
**************************************************************************/

// C documentation
//
//	/* Report JSON nested too deep
//	*/
func _jsonStringTooDeep(tls *libc.TLS, p uintptr) {
	var v1 uintptr
	_ = v1
	v1 = p + 25
	*(*Tu8)(unsafe.Pointer(v1)) = Tu8(int32(*(*Tu8)(unsafe.Pointer(v1))) | libc.Int32FromInt32(JSTRING_TOODEEP))
	Xsqlite3_result_error(tls, (*TJsonString)(unsafe.Pointer(p)).FpCtx, __ccgo_ts+26410, -int32(1))
	_jsonStringReset(tls, p)
}

// C documentation
//
//	/*
//	** json_valid(JSON)
//	** json_valid(JSON, FLAGS)
//	**
//	** Check the JSON argument to see if it is well-formed.  The FLAGS argument
//	** encodes the various constraints on what is meant by "well-formed":
//	**
//	**     0x01      Canonical RFC-8259 JSON text
//	**     0x02      JSON text with optional JSON-5 extensions
//	**     0x04      Superficially appears to be JSONB
//	**     0x08      Strictly well-formed JSONB
//	**
//	** If the FLAGS argument is omitted, it defaults to 1.  Useful values for
//	** FLAGS include:
//	**
//	**    1          Strict canonical JSON text
//	**    2          JSON text perhaps with JSON-5 extensions
//	**    4          Superficially appears to be JSONB
//	**    5          Canonical JSON text or superficial JSONB
//	**    6          JSON-5 text or superficial JSONB
//	**    8          Strict JSONB
//	**    9          Canonical JSON text or strict JSONB
//	**    10         JSON-5 text or strict JSONB
//	**
//	** Other flag combinations are redundant.  For example, every canonical
//	** JSON text is also well-formed JSON-5 text, so FLAG values 2 and 3
//	** are the same.  Similarly, any input that passes a strict JSONB validation
//	** will also pass the superficial validation so 12 through 15 are the same
//	** as 8 through 11 respectively.
//	**
//	** This routine runs in linear time to validate text and when doing strict
//	** JSONB validation.  Superficial JSONB validation is constant time,
//	** assuming the BLOB is already in memory.  The performance advantage
//	** of superficial JSONB validation is why that option is provided.
//	** Application developers can choose to do fast superficial validation or
//	** slower strict validation, according to their specific needs.
//	**
//	** Only the lower four bits of the FLAGS argument are currently used.
//	** Higher bits are reserved for future expansion.   To facilitate
//	** compatibility, the current implementation raises an error if any bit
//	** in FLAGS is set other than the lower four bits.
//	**
//	** The original circa 2015 implementation of the JSON routines in
//	** SQLite only supported canonical RFC-8259 JSON text and the json_valid()
//	** function only accepted one argument.  That is why the default value
//	** for the FLAGS argument is 1, since FLAGS=1 causes this routine to only
//	** recognize canonical RFC-8259 JSON text as valid.  The extra FLAGS
//	** argument was added when the JSON routines were extended to support
//	** JSON5-like extensions and binary JSONB stored in BLOBs.
//	**
//	** Return Values:
//	**
//	**   *   Raise an error if FLAGS is outside the range of 1 to 15.
//	**   *   Return NULL if the input is NULL
//	**   *   Return 1 if the input is well-formed.
//	**   *   Return 0 if the input is not well-formed.
//	*/
func _jsonValidFunc(tls *libc.TLS, ctx uintptr, argc int32, argv uintptr) {
	bp := tls.Alloc(112)
	defer tls.Free(112)
	var f Ti64
	var flags, res Tu8
	var p uintptr
	var _ /* px at bp+56 */ TJsonParse
	var _ /* py at bp+0 */ TJsonParse
	_, _, _, _ = f, flags, p, res /* The parse */
	flags = uint8(1)
	res = uint8(0)
	if argc == int32(2) {
		f = Xsqlite3_value_int64(tls, **(**uintptr)(__ccgo_up(argv + 1*4)))
		if f < int64(1) || f > int64(15) {
			Xsqlite3_result_error(tls, ctx, __ccgo_ts+26795, -int32(1))
			return
		}
		flags = libc.Uint8FromInt64(f & int64(0x0f))
	}
	switch Xsqlite3_value_type(tls, **(**uintptr)(__ccgo_up(argv))) {
	case int32(SQLITE_NULL):
		return
	case int32(SQLITE_BLOB):
		libc.Xmemset(tls, bp, 0, uint32(56))
		if _jsonArgIsJsonb(tls, **(**uintptr)(__ccgo_up(argv)), bp) != 0 {
			if libc.Int32FromUint8(flags)&int32(0x04) != 0 {
				/* Superficial checking only - accomplished by the
				 ** jsonArgIsJsonb() call above. */
				res = uint8(1)
			} else {
				if libc.Int32FromUint8(flags)&int32(0x08) != 0 {
					/* Strict checking.  Check by translating BLOB->TEXT->BLOB.  If
					 ** no errors occur, call that a "strict check". */
					res = libc.BoolUint8(uint32(0) == _jsonbValidityCheck(tls, bp, uint32(0), (**(**TJsonParse)(__ccgo_up(bp))).FnBlob, uint32(1)))
				}
			}
			break
		}
		/* Fall through into interpreting the input as text.  See note
		 ** above at tag-20240123-a. */
		fallthrough
	default:
		if libc.Int32FromUint8(flags)&int32(0x3) == 0 {
			break
		}
		libc.Xmemset(tls, bp+56, 0, uint32(56))
		p = _jsonParseFuncArg(tls, ctx, **(**uintptr)(__ccgo_up(argv)), uint32(JSON_KEEPERROR))
		if p != 0 {
			if (*TJsonParse)(unsafe.Pointer(p)).Foom != 0 {
				Xsqlite3_result_error_nomem(tls, ctx)
			} else {
				if (*TJsonParse)(unsafe.Pointer(p)).FnErr != 0 {
					/* no-op */
				} else {
					if libc.Int32FromUint8(flags)&int32(0x02) != 0 || libc.Int32FromUint8((*TJsonParse)(unsafe.Pointer(p)).FhasNonstd) == 0 {
						res = uint8(1)
					}
				}
			}
			_jsonParseFree(tls, p)
		} else {
			Xsqlite3_result_error_nomem(tls, ctx)
		}
		break
	}
	Xsqlite3_result_int(tls, ctx, libc.Int32FromUint8(res))
}

// C documentation
//
//	/*
//	** A function that loads a shared-library extension then returns NULL.
//	*/
func _loadExt(tls *libc.TLS, context uintptr, argc int32, argv uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var db, zFile, zProc uintptr
	var _ /* zErrMsg at bp+0 */ uintptr
	_, _, _ = db, zFile, zProc
	zFile = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv)))
	db = Xsqlite3_context_db_handle(tls, context)
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	/* Disallow the load_extension() SQL function unless the SQLITE_LoadExtFunc
	 ** flag is set.  See the sqlite3_enable_load_extension() API.
	 */
	if (*Tsqlite3)(unsafe.Pointer(db)).Fflags&uint64(SQLITE_LoadExtFunc) == uint64(0) {
		Xsqlite3_result_error(tls, context, __ccgo_ts+13673, -int32(1))
		return
	}
	if argc == int32(2) {
		zProc = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv + 1*4)))
	} else {
		zProc = uintptr(0)
	}
	if zFile != 0 && Xsqlite3_load_extension(tls, db, zFile, zProc, bp) != 0 {
		Xsqlite3_result_error(tls, context, **(**uintptr)(__ccgo_up(bp)), -int32(1))
		Xsqlite3_free(tls, **(**uintptr)(__ccgo_up(bp)))
	}
}

// C documentation
//
//	/*
//	** Get a reference to pPage1 of the database file.  This will
//	** also acquire a readlock on that file.
//	**
//	** SQLITE_OK is returned on success.  If the file is not a
//	** well-formed database file, then SQLITE_CORRUPT is returned.
//	** SQLITE_BUSY is returned if the database is locked.  SQLITE_NOMEM
//	** is returned if we run out of memory.
//	*/
func _lockBtree(tls *libc.TLS, pBt uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var nPage, pageSize, usableSize Tu32
	var page1, v1 uintptr
	var rc, v4 int32
	var _ /* isOpen at bp+8 */ int32
	var _ /* nPageFile at bp+4 */ Tu32
	var _ /* pPage1 at bp+0 */ uintptr
	_, _, _, _, _, _, _ = nPage, page1, pageSize, rc, usableSize, v1, v4 /* Number of pages in the database */
	**(**Tu32)(__ccgo_up(bp + 4)) = uint32(0)                            /* Number of pages in the database file */
	rc = _sqlite3PagerSharedLock(tls, (*TBtShared)(unsafe.Pointer(pBt)).FpPager)
	if rc != SQLITE_OK {
		return rc
	}
	rc = _btreeGetPage(tls, pBt, uint32(1), bp, 0)
	if rc != SQLITE_OK {
		return rc
	}
	/* Do some checking to help insure the file we opened really is
	 ** a valid database file.
	 */
	nPage = _sqlite3Get4byte(tls, uintptr(28)+(*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp)))).FaData)
	_sqlite3PagerPagecount(tls, (*TBtShared)(unsafe.Pointer(pBt)).FpPager, bp+4)
	if nPage == uint32(0) || libc.Xmemcmp(tls, uintptr(24)+(*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp)))).FaData, uintptr(92)+(*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp)))).FaData, uint32(4)) != 0 {
		nPage = **(**Tu32)(__ccgo_up(bp + 4))
	}
	if (*Tsqlite3)(unsafe.Pointer((*TBtShared)(unsafe.Pointer(pBt)).Fdb)).Fflags&uint64(SQLITE_ResetDatabase) != uint64(0) {
		nPage = uint32(0)
	}
	if nPage > uint32(0) {
		page1 = (*TMemPage)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp)))).FaData
		rc = int32(SQLITE_NOTADB)
		/* EVIDENCE-OF: R-43737-39999 Every valid SQLite database file begins
		 ** with the following 16 bytes (in hex): 53 51 4c 69 74 65 20 66 6f 72 6d
		 ** 61 74 20 33 00. */
		if libc.Xmemcmp(tls, page1, uintptr(unsafe.Pointer(&_zMagicHeader)), uint32(16)) != 0 {
			goto page1_init_failed
		}
		if libc.Int32FromUint8(**(**Tu8)(__ccgo_up(page1 + 18))) > int32(2) {
			v1 = pBt + 24
			*(*Tu16)(unsafe.Pointer(v1)) = Tu16(int32(*(*Tu16)(unsafe.Pointer(v1))) | libc.Int32FromInt32(BTS_READ_ONLY))
		}
		if libc.Int32FromUint8(**(**Tu8)(__ccgo_up(page1 + 19))) > int32(2) {
			goto page1_init_failed
		}
		/* If the read version is set to 2, this database should be accessed
		 ** in WAL mode. If the log is not already open, open it now. Then
		 ** return SQLITE_OK and return without populating BtShared.pPage1.
		 ** The caller detects this and calls this function again. This is
		 ** required as the version of page 1 currently in the page1 buffer
		 ** may not be the latest version - there may be a newer one in the log
		 ** file.
		 */
		if libc.Int32FromUint8(**(**Tu8)(__ccgo_up(page1 + 19))) == int32(2) && libc.Int32FromUint16((*TBtShared)(unsafe.Pointer(pBt)).FbtsFlags)&int32(BTS_NO_WAL) == 0 {
			**(**int32)(__ccgo_up(bp + 8)) = 0
			rc = _sqlite3PagerOpenWal(tls, (*TBtShared)(unsafe.Pointer(pBt)).FpPager, bp+8)
			if rc != SQLITE_OK {
				goto page1_init_failed
			} else {
				if **(**int32)(__ccgo_up(bp + 8)) == 0 {
					_releasePageOne(tls, **(**uintptr)(__ccgo_up(bp)))
					return SQLITE_OK
				}
			}
			rc = int32(SQLITE_NOTADB)
		} else {
		}
		/* EVIDENCE-OF: R-15465-20813 The maximum and minimum embedded payload
		 ** fractions and the leaf payload fraction values must be 64, 32, and 32.
		 **
		 ** The original design allowed these amounts to vary, but as of
		 ** version 3.6.0, we require them to be fixed.
		 */
		if libc.Xmemcmp(tls, page1+21, __ccgo_ts+4350, uint32(3)) != 0 {
			goto page1_init_failed
		}
		/* EVIDENCE-OF: R-51873-39618 The page size for a database file is
		 ** determined by the 2-byte integer located at an offset of 16 bytes from
		 ** the beginning of the database file. */
		pageSize = libc.Uint32FromInt32(libc.Int32FromUint8(**(**Tu8)(__ccgo_up(page1 + 16)))<<int32(8) | libc.Int32FromUint8(**(**Tu8)(__ccgo_up(page1 + 17)))<<int32(16))
		/* EVIDENCE-OF: R-25008-21688 The size of a page is a power of two
		 ** between 512 and 65536 inclusive. */
		if (pageSize-uint32(1))&pageSize != uint32(0) || pageSize > uint32(SQLITE_MAX_PAGE_SIZE) || pageSize <= uint32(256) {
			goto page1_init_failed
		}
		/* EVIDENCE-OF: R-59310-51205 The "reserved space" size in the 1-byte
		 ** integer at offset 20 is the number of bytes of space at the end of
		 ** each page to reserve for extensions.
		 **
		 ** EVIDENCE-OF: R-37497-42412 The size of the reserved region is
		 ** determined by the one-byte unsigned integer found at an offset of 20
		 ** into the database file header. */
		usableSize = pageSize - uint32(**(**Tu8)(__ccgo_up(page1 + 20)))
		if pageSize != (*TBtShared)(unsafe.Pointer(pBt)).FpageSize {
			/* After reading the first page of the database assuming a page size
			 ** of BtShared.pageSize, we have discovered that the page-size is
			 ** actually pageSize. Unlock the database, leave pBt->pPage1 at
			 ** zero and return SQLITE_OK. The caller will call this function
			 ** again with the correct page-size.
			 */
			_releasePageOne(tls, **(**uintptr)(__ccgo_up(bp)))
			(*TBtShared)(unsafe.Pointer(pBt)).FusableSize = usableSize
			(*TBtShared)(unsafe.Pointer(pBt)).FpageSize = pageSize
			v1 = pBt + 24
			*(*Tu16)(unsafe.Pointer(v1)) = Tu16(int32(*(*Tu16)(unsafe.Pointer(v1))) | libc.Int32FromInt32(BTS_PAGESIZE_FIXED))
			_freeTempSpace(tls, pBt)
			rc = _sqlite3PagerSetPagesize(tls, (*TBtShared)(unsafe.Pointer(pBt)).FpPager, pBt+36, libc.Int32FromUint32(pageSize-usableSize))
			return rc
		}
		if nPage > **(**Tu32)(__ccgo_up(bp + 4)) {
			if _sqlite3WritableSchema(tls, (*TBtShared)(unsafe.Pointer(pBt)).Fdb) == 0 {
				rc = _sqlite3CorruptError(tls, int32(76633))
				goto page1_init_failed
			} else {
				nPage = **(**Tu32)(__ccgo_up(bp + 4))
			}
		}
		/* EVIDENCE-OF: R-28312-64704 However, the usable size is not allowed to
		 ** be less than 480. In other words, if the page size is 512, then the
		 ** reserved space size cannot exceed 32. */
		if usableSize < uint32(480) {
			goto page1_init_failed
		}
		v1 = pBt + 24
		*(*Tu16)(unsafe.Pointer(v1)) = Tu16(int32(*(*Tu16)(unsafe.Pointer(v1))) | libc.Int32FromInt32(BTS_PAGESIZE_FIXED))
		(*TBtShared)(unsafe.Pointer(pBt)).FpageSize = pageSize
		(*TBtShared)(unsafe.Pointer(pBt)).FusableSize = usableSize
		if _sqlite3Get4byte(tls, page1+uintptr(libc.Int32FromInt32(36)+libc.Int32FromInt32(4)*libc.Int32FromInt32(4))) != 0 {
			v4 = int32(1)
		} else {
			v4 = 0
		}
		(*TBtShared)(unsafe.Pointer(pBt)).FautoVacuum = libc.Uint8FromInt32(v4)
		if _sqlite3Get4byte(tls, page1+uintptr(libc.Int32FromInt32(36)+libc.Int32FromInt32(7)*libc.Int32FromInt32(4))) != 0 {
			v4 = int32(1)
		} else {
			v4 = 0
		}
		(*TBtShared)(unsafe.Pointer(pBt)).FincrVacuum = libc.Uint8FromInt32(v4)
	}
	/* maxLocal is the maximum amount of payload to store locally for
	 ** a cell.  Make sure it is small enough so that at least minFanout
	 ** cells can will fit on one page.  We assume a 10-byte page header.
	 ** Besides the payload, the cell must store:
	 **     2-byte pointer to the cell
	 **     4-byte child pointer
	 **     9-byte nKey value
	 **     4-byte nData value
	 **     4-byte overflow page pointer
	 ** So a cell consists of a 2-byte pointer, a header which is as much as
	 ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow
	 ** page pointer.
	 */
	(*TBtShared)(unsafe.Pointer(pBt)).FmaxLocal = uint16(((*TBtShared)(unsafe.Pointer(pBt)).FusableSize-libc.Uint32FromInt32(12))*libc.Uint32FromInt32(64)/libc.Uint32FromInt32(255) - libc.Uint32FromInt32(23))
	(*TBtShared)(unsafe.Pointer(pBt)).FminLocal = uint16(((*TBtShared)(unsafe.Pointer(pBt)).FusableSize-libc.Uint32FromInt32(12))*libc.Uint32FromInt32(32)/libc.Uint32FromInt32(255) - libc.Uint32FromInt32(23))
	(*TBtShared)(unsafe.Pointer(pBt)).FmaxLeaf = uint16((*TBtShared)(unsafe.Pointer(pBt)).FusableSize - libc.Uint32FromInt32(35))
	(*TBtShared)(unsafe.Pointer(pBt)).FminLeaf = uint16(((*TBtShared)(unsafe.Pointer(pBt)).FusableSize-libc.Uint32FromInt32(12))*libc.Uint32FromInt32(32)/libc.Uint32FromInt32(255) - libc.Uint32FromInt32(23))
	if libc.Int32FromUint16((*TBtShared)(unsafe.Pointer(pBt)).FmaxLocal) > int32(127) {
		(*TBtShared)(unsafe.Pointer(pBt)).Fmax1bytePayload = uint8(127)
	} else {
		(*TBtShared)(unsafe.Pointer(pBt)).Fmax1bytePayload = uint8((*TBtShared)(unsafe.Pointer(pBt)).FmaxLocal)
	}
	(*TBtShared)(unsafe.Pointer(pBt)).FpPage1 = **(**uintptr)(__ccgo_up(bp))
	(*TBtShared)(unsafe.Pointer(pBt)).FnPage = nPage
	return SQLITE_OK
	goto page1_init_failed
page1_init_failed:
	;
	_releasePageOne(tls, **(**uintptr)(__ccgo_up(bp)))
	(*TBtShared)(unsafe.Pointer(pBt)).FpPage1 = uintptr(0)
	return rc
}

// C documentation
//
//	/*
//	** Tag the given column as being part of the PRIMARY KEY
//	*/
func _makeColumnPartOfPrimaryKey(tls *libc.TLS, pParse uintptr, pCol uintptr) {
	var v1 uintptr
	_ = v1
	v1 = pCol + 10
	*(*Tu16)(unsafe.Pointer(v1)) = Tu16(int32(*(*Tu16)(unsafe.Pointer(v1))) | libc.Int32FromInt32(COLFLAG_PRIMKEY))
	if libc.Int32FromUint16((*TColumn)(unsafe.Pointer(pCol)).FcolFlags)&int32(COLFLAG_GENERATED) != 0 {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+14110, 0)
	}
}

// C documentation
//
//	/*
//	** The pFunc is the only aggregate function in the query.  Check to see
//	** if the query is a candidate for the min/max optimization.
//	**
//	** If the query is a candidate for the min/max optimization, then set
//	** *ppMinMax to be an ORDER BY clause to be used for the optimization
//	** and return either WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX depending on
//	** whether pFunc is a min() or max() function.
//	**
//	** If the query is not a candidate for the min/max optimization, return
//	** WHERE_ORDERBY_NORMAL (which must be zero).
//	**
//	** This routine must be called after aggregate functions have been
//	** located but before their arguments have been subjected to aggregate
//	** analysis.
//	*/
func _minMaxQuery(tls *libc.TLS, db uintptr, pFunc uintptr, ppMinMax uintptr) (r Tu8) {
	var eRet int32
	var pEList, pOrderBy, zFunc, v1 uintptr
	var sortFlags Tu8
	_, _, _, _, _, _ = eRet, pEList, pOrderBy, sortFlags, zFunc, v1
	eRet = WHERE_ORDERBY_NORMAL
	sortFlags = uint8(0)
	pEList = *(*uintptr)(unsafe.Pointer(pFunc + 20))
	if pEList == uintptr(0) || (*TExprList)(unsafe.Pointer(pEList)).FnExpr != int32(1) || (*TExpr)(unsafe.Pointer(pFunc)).Fflags&libc.Uint32FromInt32(libc.Int32FromInt32(EP_WinFunc)) != uint32(0) || (*Tsqlite3)(unsafe.Pointer(db)).FdbOptFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_MinMaxOpt)) != uint32(0) {
		return libc.Uint8FromInt32(eRet)
	}
	zFunc = *(*uintptr)(unsafe.Pointer(pFunc + 8))
	if _sqlite3StrICmp(tls, zFunc, __ccgo_ts+16804) == 0 {
		eRet = int32(WHERE_ORDERBY_MIN)
		if _sqlite3ExprCanBeNull(tls, (*(*TExprList_item)(unsafe.Pointer(pEList + 8))).FpExpr) != 0 {
			sortFlags = uint8(KEYINFO_ORDER_BIGNULL)
		}
	} else {
		if _sqlite3StrICmp(tls, zFunc, __ccgo_ts+16808) == 0 {
			eRet = int32(WHERE_ORDERBY_MAX)
			sortFlags = uint8(KEYINFO_ORDER_DESC)
		} else {
			return libc.Uint8FromInt32(eRet)
		}
	}
	v1 = _sqlite3ExprListDup(tls, db, pEList, 0)
	pOrderBy = v1
	**(**uintptr)(__ccgo_up(ppMinMax)) = v1
	if pOrderBy != 0 {
		(*(*TExprList_item)(unsafe.Pointer(pOrderBy + 8))).Ffg.FsortFlags = sortFlags
	}
	return libc.Uint8FromInt32(eRet)
}

// C documentation
//
//	/*
//	** This routine is called to process a compound query form from
//	** two or more separate queries using UNION, UNION ALL, EXCEPT, or
//	** INTERSECT
//	**
//	** "p" points to the right-most of the two queries.  the query on the
//	** left is p->pPrior.  The left query could also be a compound query
//	** in which case this routine will be called recursively.
//	**
//	** The results of the total query are to be written into a destination
//	** of type eDest with parameter iParm.
//	**
//	** Example 1:  Consider a three-way compound SQL statement.
//	**
//	**     SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3
//	**
//	** This statement is parsed up as follows:
//	**
//	**     SELECT c FROM t3
//	**      |
//	**      `----->  SELECT b FROM t2
//	**                |
//	**                `------>  SELECT a FROM t1
//	**
//	** The arrows in the diagram above represent the Select.pPrior pointer.
//	** So if this routine is called with p equal to the t3 query, then
//	** pPrior will be the t2 query.  p->op will be TK_UNION in this case.
//	**
//	** Notice that because of the way SQLite parses compound SELECTs, the
//	** individual selects always group from left to right.
//	*/
func _multiSelect(tls *libc.TLS, pParse uintptr, p uintptr, pDest uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var addr, rc int32
	var db, pDelete, pOne, pPrior, v uintptr
	var _ /* dest at bp+0 */ TSelectDest
	var _ /* nLimit at bp+28 */ int32
	_, _, _, _, _, _, _ = addr, db, pDelete, pOne, pPrior, rc, v
	rc = SQLITE_OK       /* Alternative data destination */
	pDelete = uintptr(0) /* Database connection */
	/* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs.  Only
	 ** the last (right-most) SELECT in the series may have an ORDER BY or LIMIT.
	 */
	/* Calling function guarantees this much */
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	pPrior = (*TSelect)(unsafe.Pointer(p)).FpPrior
	**(**TSelectDest)(__ccgo_up(bp)) = **(**TSelectDest)(__ccgo_up(pDest))
	v = _sqlite3GetVdbe(tls, pParse)
	/* The VDBE already created by calling function */
	/* Create the destination temporary table if necessary
	 */
	if libc.Int32FromUint8((**(**TSelectDest)(__ccgo_up(bp))).FeDest) == int32(SRT_EphemTab) {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_OpenEphemeral), (**(**TSelectDest)(__ccgo_up(bp))).FiSDParm, (*TExprList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpEList)).FnExpr)
		(**(**TSelectDest)(__ccgo_up(bp))).FeDest = uint8(SRT_Table)
	}
	/* Special handling for a compound-select that originates as a VALUES clause.
	 */
	if (*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_MultiValue) != 0 {
		rc = _multiSelectValues(tls, pParse, p, bp)
		if rc >= 0 {
			goto multi_select_end
		}
		rc = SQLITE_OK
	}
	/* Make sure all SELECTs in the statement have the same number of elements
	 ** in their result sets.
	 */
	if (*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_Recursive) != uint32(0) && _hasAnchor(tls, p) != 0 {
		_generateWithRecursiveQuery(tls, pParse, p, bp)
	} else {
		if (*TSelect)(unsafe.Pointer(p)).FpOrderBy != 0 {
			/* If the compound has an ORDER BY clause, then always use the merge
			 ** algorithm. */
			return _multiSelectByMerge(tls, pParse, p, pDest)
		} else {
			if libc.Int32FromUint8((*TSelect)(unsafe.Pointer(p)).Fop) != int32(TK_ALL) {
				/* If the compound is EXCEPT, INTERSECT, or UNION (anything other than
				 ** UNION ALL) then also always use the merge algorithm.  However, the
				 ** multiSelectByMerge() routine requires that the compound have an
				 ** ORDER BY clause, and it doesn't right now.  So invent one first. */
				pOne = _sqlite3ExprInt32(tls, db, int32(1))
				(*TSelect)(unsafe.Pointer(p)).FpOrderBy = _sqlite3ExprListAppend(tls, pParse, uintptr(0), pOne)
				if (*TParse)(unsafe.Pointer(pParse)).FnErr != 0 {
					goto multi_select_end
				}
				*(*Tu16)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpOrderBy + 8 + 16)) = uint16(1)
				return _multiSelectByMerge(tls, pParse, p, pDest)
			} else {
				/* For a UNION ALL compound without ORDER BY, simply run the left
				 ** query, then run the right query */
				addr = 0
				**(**int32)(__ccgo_up(bp + 28)) = 0 /* Initialize to suppress harmless compiler warning */
				if (*TSelect)(unsafe.Pointer(pPrior)).FpPrior == uintptr(0) {
					_sqlite3VdbeExplain(tls, pParse, uint8(1), __ccgo_ts+20832, 0)
					_sqlite3VdbeExplain(tls, pParse, uint8(1), __ccgo_ts+20847, 0)
				}
				(*TSelect)(unsafe.Pointer(pPrior)).FiLimit = (*TSelect)(unsafe.Pointer(p)).FiLimit
				(*TSelect)(unsafe.Pointer(pPrior)).FiOffset = (*TSelect)(unsafe.Pointer(p)).FiOffset
				(*TSelect)(unsafe.Pointer(pPrior)).FpLimit = _sqlite3ExprDup(tls, db, (*TSelect)(unsafe.Pointer(p)).FpLimit, 0)
				rc = _sqlite3Select(tls, pParse, pPrior, bp)
				_sqlite3ExprDelete(tls, db, (*TSelect)(unsafe.Pointer(pPrior)).FpLimit)
				(*TSelect)(unsafe.Pointer(pPrior)).FpLimit = uintptr(0)
				if rc != 0 {
					goto multi_select_end
				}
				(*TSelect)(unsafe.Pointer(p)).FpPrior = uintptr(0)
				(*TSelect)(unsafe.Pointer(p)).FiLimit = (*TSelect)(unsafe.Pointer(pPrior)).FiLimit
				(*TSelect)(unsafe.Pointer(p)).FiOffset = (*TSelect)(unsafe.Pointer(pPrior)).FiOffset
				if (*TSelect)(unsafe.Pointer(p)).FiLimit != 0 {
					addr = _sqlite3VdbeAddOp1(tls, v, int32(OP_IfNot), (*TSelect)(unsafe.Pointer(p)).FiLimit)
					if (*TSelect)(unsafe.Pointer(p)).FiOffset != 0 {
						_sqlite3VdbeAddOp3(tls, v, int32(OP_OffsetLimit), (*TSelect)(unsafe.Pointer(p)).FiLimit, (*TSelect)(unsafe.Pointer(p)).FiOffset+int32(1), (*TSelect)(unsafe.Pointer(p)).FiOffset)
					}
				}
				_sqlite3VdbeExplain(tls, pParse, uint8(1), __ccgo_ts+20487, 0)
				rc = _sqlite3Select(tls, pParse, p, bp)
				pDelete = (*TSelect)(unsafe.Pointer(p)).FpPrior
				(*TSelect)(unsafe.Pointer(p)).FpPrior = pPrior
				(*TSelect)(unsafe.Pointer(p)).FnSelectRow = _sqlite3LogEstAdd(tls, (*TSelect)(unsafe.Pointer(p)).FnSelectRow, (*TSelect)(unsafe.Pointer(pPrior)).FnSelectRow)
				if (*TSelect)(unsafe.Pointer(p)).FpLimit != 0 && _sqlite3ExprIsInteger(tls, (*TExpr)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpLimit)).FpLeft, bp+28, pParse) != 0 && **(**int32)(__ccgo_up(bp + 28)) > 0 && int32((*TSelect)(unsafe.Pointer(p)).FnSelectRow) > int32(_sqlite3LogEst(tls, libc.Uint64FromInt32(**(**int32)(__ccgo_up(bp + 28))))) {
					(*TSelect)(unsafe.Pointer(p)).FnSelectRow = _sqlite3LogEst(tls, libc.Uint64FromInt32(**(**int32)(__ccgo_up(bp + 28))))
				}
				if addr != 0 {
					_sqlite3VdbeJumpHere(tls, v, addr)
				}
				if (*TSelect)(unsafe.Pointer(p)).FpNext == uintptr(0) {
					_sqlite3VdbeExplainPop(tls, pParse)
				}
			}
		}
	}
	goto multi_select_end
multi_select_end:
	;
	(*TSelectDest)(unsafe.Pointer(pDest)).FiSdst = (**(**TSelectDest)(__ccgo_up(bp))).FiSdst
	(*TSelectDest)(unsafe.Pointer(pDest)).FnSdst = (**(**TSelectDest)(__ccgo_up(bp))).FnSdst
	(*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm2 = (**(**TSelectDest)(__ccgo_up(bp))).FiSDParm2
	if pDelete != 0 {
		_sqlite3ParserAddCleanup(tls, pParse, __ccgo_fp(_sqlite3SelectDeleteGeneric), pDelete)
	}
	return rc
}

// C documentation
//
//	/*
//	** Generate code for a compound SELECT statement using a merge
//	** algorithm.  The compound must have an ORDER BY clause for this
//	** to work.
//	**
//	** We assume a query of the following form:
//	**
//	**      <selectA>  <operator>  <selectB>  ORDER BY <orderbylist>
//	**
//	** <operator> is one of UNION ALL, UNION, EXCEPT, or INTERSECT.  The idea
//	** is to code both <selectA> and <selectB> with the ORDER BY clause as
//	** co-routines.  Then run the co-routines in parallel and merge the results
//	** into the output.  In addition to the two coroutines (called selectA and
//	** selectB) there are 7 subroutines:
//	**
//	**    outA:    Move the output of the selectA coroutine into the output
//	**             of the compound query.
//	**
//	**    outB:    Move the output of the selectB coroutine into the output
//	**             of the compound query.  (Only generated for UNION and
//	**             UNION ALL.  EXCEPT and INTERSECT never output a row that
//	**             appears only in B.)
//	**
//	**    AltB:    Called when there is data from both coroutines and A<B.
//	**
//	**    AeqB:    Called when there is data from both coroutines and A==B.
//	**
//	**    AgtB:    Called when there is data from both coroutines and A>B.
//	**
//	**    EofA:    Called when data is exhausted from selectA.
//	**
//	**    EofB:    Called when data is exhausted from selectB.
//	**
//	** The implementation of the latter five subroutines depend on which
//	** <operator> is used:
//	**
//	**
//	**             UNION ALL         UNION            EXCEPT          INTERSECT
//	**          -------------  -----------------  --------------  -----------------
//	**   AltB:   outA, nextA      outA, nextA       outA, nextA         nextA
//	**
//	**   AeqB:   outA, nextA         nextA             nextA         outA, nextA
//	**
//	**   AgtB:   outB, nextB      outB, nextB          nextB            nextB
//	**
//	**   EofA:   outB, nextB      outB, nextB          halt             halt
//	**
//	**   EofB:   outA, nextA      outA, nextA       outA, nextA         halt
//	**
//	** In the AltB, AeqB, and AgtB subroutines, an EOF on A following nextA
//	** causes an immediate jump to EofA and an EOF on B following nextB causes
//	** an immediate jump to EofB.  Within EofA and EofB, and EOF on entry or
//	** following nextX causes a jump to the end of the select processing.
//	**
//	** Duplicate removal in the UNION, EXCEPT, and INTERSECT cases is handled
//	** within the output subroutine.  The regPrev register set holds the previously
//	** output value.  A comparison is made against this value and the output
//	** is skipped if the next results would be the same as the previous.
//	**
//	** The implementation plan is to implement the two coroutines and seven
//	** subroutines first, then put the control logic at the bottom.  Like this:
//	**
//	**          goto Init
//	**     coA: coroutine for left query (A)
//	**     coB: coroutine for right query (B)
//	**    outA: output one row of A
//	**    outB: output one row of B (UNION and UNION ALL only)
//	**    EofA: ...
//	**    EofB: ...
//	**    AltB: ...
//	**    AeqB: ...
//	**    AgtB: ...
//	**    Init: initialize coroutine registers
//	**          yield coA, on eof goto EofA
//	**          yield coB, on eof goto EofB
//	**    Cmpr: Compare A, B
//	**          Jump AltB, AeqB, AgtB
//	**     End: ...
//	**
//	** We call AltB, AeqB, AgtB, EofA, and EofB "subroutines" but they are not
//	** actually called using Gosub and they do not Return.  EofA and EofB loop
//	** until all data is exhausted then jump to the "end" label.  AltB, AeqB,
//	** and AgtB jump to either Cmpr or to one of EofA or EofB.
//	*/
func _multiSelectByMerge(tls *libc.TLS, pParse uintptr, p uintptr, pDest uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var aPermute, db, pItem, pItem1, pKeyDup, pKeyMerge, pNew, pOrderBy, pPrior, pSplit, v, v3 uintptr
	var addr1, addrAeqB, addrAgtB, addrAltB, addrEofA, addrEofA_noB, addrEofB, addrOutA, addrOutB, addrSelectA, addrSelectB, bKeep, i, j, labelCmpr, labelEnd, nExpr, nOrderBy, nSelect, op, regAddrA, regAddrB, regLimitA, regLimitB, regOutA, regOutB, regPrev, savedLimit, savedOffset, v4 int32
	var _ /* destA at bp+0 */ TSelectDest
	var _ /* destB at bp+28 */ TSelectDest
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = aPermute, addr1, addrAeqB, addrAgtB, addrAltB, addrEofA, addrEofA_noB, addrEofB, addrOutA, addrOutB, addrSelectA, addrSelectB, bKeep, db, i, j, labelCmpr, labelEnd, nExpr, nOrderBy, nSelect, op, pItem, pItem1, pKeyDup, pKeyMerge, pNew, pOrderBy, pPrior, pSplit, regAddrA, regAddrB, regLimitA, regLimitB, regOutA, regOutB, regPrev, savedLimit, savedOffset, v, v3, v4 /* Address of the output-A subroutine */
	addrOutB = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */
	pKeyDup = uintptr(0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /* Mapping from ORDER BY terms to result set columns */
	/* "Managed" code needs this.  Ticket #3382. */
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	v = (*TParse)(unsafe.Pointer(pParse)).FpVdbe
	/* Already thrown the error if VDBE alloc failed */
	labelEnd = _sqlite3VdbeMakeLabel(tls, pParse)
	labelCmpr = _sqlite3VdbeMakeLabel(tls, pParse)
	/* Patch up the ORDER BY clause
	 */
	op = libc.Int32FromUint8((*TSelect)(unsafe.Pointer(p)).Fop)
	pOrderBy = (*TSelect)(unsafe.Pointer(p)).FpOrderBy
	nOrderBy = (*TExprList)(unsafe.Pointer(pOrderBy)).FnExpr
	/* For operators other than UNION ALL we have to make sure that
	 ** the ORDER BY clause covers every term of the result set.  Add
	 ** terms to the ORDER BY clause as necessary.
	 */
	if op != int32(TK_ALL) {
		i = int32(1)
		for {
			if !(libc.Int32FromUint8((*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed) == 0 && i <= (*TExprList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpEList)).FnExpr) {
				break
			}
			j = 0
			pItem = pOrderBy + 8
			for {
				if !(j < nOrderBy) {
					break
				}
				if libc.Int32FromUint16((*(*struct {
					FiOrderByCol Tu16
					FiAlias      Tu16
				})(unsafe.Pointer(pItem + 16))).FiOrderByCol) == i {
					break
				}
				goto _2
			_2:
				;
				j = j + 1
				pItem += 20
			}
			if j == nOrderBy {
				pNew = _sqlite3ExprInt32(tls, db, i)
				if pNew == uintptr(0) {
					return int32(SQLITE_NOMEM)
				}
				v3 = _sqlite3ExprListAppend(tls, pParse, pOrderBy, pNew)
				pOrderBy = v3
				(*TSelect)(unsafe.Pointer(p)).FpOrderBy = v3
				if pOrderBy != 0 {
					v4 = nOrderBy
					nOrderBy = nOrderBy + 1
					*(*Tu16)(unsafe.Pointer(pOrderBy + 8 + uintptr(v4)*20 + 16)) = libc.Uint16FromInt32(i)
				}
			}
			goto _1
		_1:
			;
			i = i + 1
		}
	}
	/* Compute the comparison permutation and keyinfo that is used with
	 ** the permutation to determine if the next row of results comes
	 ** from selectA or selectB.  Also add literal collations to the
	 ** ORDER BY clause terms so that when selectA and selectB are
	 ** evaluated, they use the correct collation.
	 */
	aPermute = _sqlite3DbMallocRawNN(tls, db, uint64(uint32(4)*libc.Uint32FromInt32(nOrderBy+libc.Int32FromInt32(1))))
	if aPermute != 0 {
		bKeep = 0
		**(**Tu32)(__ccgo_up(aPermute)) = libc.Uint32FromInt32(nOrderBy)
		i = int32(1)
		pItem1 = pOrderBy + 8
		for {
			if !(i <= nOrderBy) {
				break
			}
			**(**Tu32)(__ccgo_up(aPermute + uintptr(i)*4)) = libc.Uint32FromInt32(libc.Int32FromUint16((*(*struct {
				FiOrderByCol Tu16
				FiAlias      Tu16
			})(unsafe.Pointer(pItem1 + 16))).FiOrderByCol) - int32(1))
			if **(**Tu32)(__ccgo_up(aPermute + uintptr(i)*4)) != libc.Uint32FromInt32(i)-uint32(1) {
				bKeep = int32(1)
			}
			goto _5
		_5:
			;
			i = i + 1
			pItem1 += 20
		}
		if bKeep == 0 {
			_sqlite3DbFreeNN(tls, db, aPermute)
			aPermute = uintptr(0)
		}
	}
	pKeyMerge = _multiSelectByMergeKeyInfo(tls, pParse, p, int32(1))
	/* Allocate a range of temporary registers and the KeyInfo needed
	 ** for the logic that removes duplicate result rows when the
	 ** operator is UNION, EXCEPT, or INTERSECT (but not UNION ALL).
	 */
	if op == int32(TK_ALL) {
		regPrev = 0
	} else {
		nExpr = (*TExprList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpEList)).FnExpr
		regPrev = (*TParse)(unsafe.Pointer(pParse)).FnMem + int32(1)
		**(**int32)(__ccgo_up(pParse + 48)) += nExpr + int32(1)
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), 0, regPrev)
		pKeyDup = _sqlite3KeyInfoAlloc(tls, db, nExpr, int32(1))
		if pKeyDup != 0 {
			i = 0
			for {
				if !(i < nExpr) {
					break
				}
				*(*uintptr)(unsafe.Pointer(pKeyDup + 20 + uintptr(i)*4)) = _multiSelectCollSeq(tls, pParse, p, i)
				**(**Tu8)(__ccgo_up((*TKeyInfo)(unsafe.Pointer(pKeyDup)).FaSortFlags + uintptr(i))) = uint8(0)
				goto _6
			_6:
				;
				i = i + 1
			}
		}
	}
	/* Separate the left and the right query from one another
	 */
	nSelect = int32(1)
	if (op == int32(TK_ALL) || op == int32(TK_UNION)) && (*Tsqlite3)(unsafe.Pointer(db)).FdbOptFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_BalancedMerge)) == uint32(0) {
		pSplit = p
		for {
			if !((*TSelect)(unsafe.Pointer(pSplit)).FpPrior != uintptr(0) && libc.Int32FromUint8((*TSelect)(unsafe.Pointer(pSplit)).Fop) == op) {
				break
			}
			nSelect = nSelect + 1
			goto _7
		_7:
			;
			pSplit = (*TSelect)(unsafe.Pointer(pSplit)).FpPrior
		}
	}
	if nSelect <= int32(3) {
		pSplit = p
	} else {
		pSplit = p
		i = int32(2)
		for {
			if !(i < nSelect) {
				break
			}
			pSplit = (*TSelect)(unsafe.Pointer(pSplit)).FpPrior
			goto _8
		_8:
			;
			i = i + int32(2)
		}
	}
	pPrior = (*TSelect)(unsafe.Pointer(pSplit)).FpPrior
	(*TSelect)(unsafe.Pointer(pSplit)).FpPrior = uintptr(0)
	(*TSelect)(unsafe.Pointer(pPrior)).FpNext = uintptr(0)
	(*TSelect)(unsafe.Pointer(pPrior)).FpOrderBy = _sqlite3ExprListDup(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, pOrderBy, 0)
	_sqlite3ResolveOrderGroupBy(tls, pParse, p, (*TSelect)(unsafe.Pointer(p)).FpOrderBy, __ccgo_ts+7661)
	_sqlite3ResolveOrderGroupBy(tls, pParse, pPrior, (*TSelect)(unsafe.Pointer(pPrior)).FpOrderBy, __ccgo_ts+7661)
	/* Compute the limit registers */
	_computeLimitRegisters(tls, pParse, p, labelEnd)
	if (*TSelect)(unsafe.Pointer(p)).FiLimit != 0 && op == int32(TK_ALL) {
		v3 = pParse + 48
		*(*int32)(unsafe.Pointer(v3)) = *(*int32)(unsafe.Pointer(v3)) + 1
		v4 = *(*int32)(unsafe.Pointer(v3))
		regLimitA = v4
		v3 = pParse + 48
		*(*int32)(unsafe.Pointer(v3)) = *(*int32)(unsafe.Pointer(v3)) + 1
		v4 = *(*int32)(unsafe.Pointer(v3))
		regLimitB = v4
		if (*TSelect)(unsafe.Pointer(p)).FiOffset != 0 {
			v4 = (*TSelect)(unsafe.Pointer(p)).FiOffset + int32(1)
		} else {
			v4 = (*TSelect)(unsafe.Pointer(p)).FiLimit
		}
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Copy), v4, regLimitA)
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Copy), regLimitA, regLimitB)
	} else {
		v4 = libc.Int32FromInt32(0)
		regLimitB = v4
		regLimitA = v4
	}
	_sqlite3ExprDelete(tls, db, (*TSelect)(unsafe.Pointer(p)).FpLimit)
	(*TSelect)(unsafe.Pointer(p)).FpLimit = uintptr(0)
	v3 = pParse + 48
	*(*int32)(unsafe.Pointer(v3)) = *(*int32)(unsafe.Pointer(v3)) + 1
	v4 = *(*int32)(unsafe.Pointer(v3))
	regAddrA = v4
	v3 = pParse + 48
	*(*int32)(unsafe.Pointer(v3)) = *(*int32)(unsafe.Pointer(v3)) + 1
	v4 = *(*int32)(unsafe.Pointer(v3))
	regAddrB = v4
	v3 = pParse + 48
	*(*int32)(unsafe.Pointer(v3)) = *(*int32)(unsafe.Pointer(v3)) + 1
	v4 = *(*int32)(unsafe.Pointer(v3))
	regOutA = v4
	v3 = pParse + 48
	*(*int32)(unsafe.Pointer(v3)) = *(*int32)(unsafe.Pointer(v3)) + 1
	v4 = *(*int32)(unsafe.Pointer(v3))
	regOutB = v4
	_sqlite3SelectDestInit(tls, bp, int32(SRT_Coroutine), regAddrA)
	_sqlite3SelectDestInit(tls, bp+28, int32(SRT_Coroutine), regAddrB)
	_sqlite3VdbeExplain(tls, pParse, uint8(1), __ccgo_ts+20994, libc.VaList(bp+64, _sqlite3SelectOpName(tls, libc.Int32FromUint8((*TSelect)(unsafe.Pointer(p)).Fop))))
	/* Generate a coroutine to evaluate the SELECT statement to the
	 ** left of the compound operator - the "A" select.
	 */
	addrSelectA = _sqlite3VdbeCurrentAddr(tls, v) + int32(1)
	addr1 = _sqlite3VdbeAddOp3(tls, v, int32(OP_InitCoroutine), regAddrA, 0, addrSelectA)
	(*TSelect)(unsafe.Pointer(pPrior)).FiLimit = regLimitA
	_sqlite3VdbeExplain(tls, pParse, uint8(1), __ccgo_ts+21005, 0)
	_sqlite3Select(tls, pParse, pPrior, bp)
	_sqlite3VdbeEndCoroutine(tls, v, regAddrA)
	_sqlite3VdbeJumpHere(tls, v, addr1)
	/* Generate a coroutine to evaluate the SELECT statement on
	 ** the right - the "B" select
	 */
	addrSelectB = _sqlite3VdbeCurrentAddr(tls, v) + int32(1)
	addr1 = _sqlite3VdbeAddOp3(tls, v, int32(OP_InitCoroutine), regAddrB, 0, addrSelectB)
	savedLimit = (*TSelect)(unsafe.Pointer(p)).FiLimit
	savedOffset = (*TSelect)(unsafe.Pointer(p)).FiOffset
	(*TSelect)(unsafe.Pointer(p)).FiLimit = regLimitB
	(*TSelect)(unsafe.Pointer(p)).FiOffset = 0
	_sqlite3VdbeExplain(tls, pParse, uint8(1), __ccgo_ts+21010, 0)
	_sqlite3Select(tls, pParse, p, bp+28)
	(*TSelect)(unsafe.Pointer(p)).FiLimit = savedLimit
	(*TSelect)(unsafe.Pointer(p)).FiOffset = savedOffset
	_sqlite3VdbeEndCoroutine(tls, v, regAddrB)
	/* Generate a subroutine that outputs the current row of the A
	 ** select as the next output row of the compound select.
	 */
	addrOutA = _generateOutputSubroutine(tls, pParse, p, bp, pDest, regOutA, regPrev, pKeyDup, labelEnd)
	/* Generate a subroutine that outputs the current row of the B
	 ** select as the next output row of the compound select.
	 */
	if op == int32(TK_ALL) || op == int32(TK_UNION) {
		addrOutB = _generateOutputSubroutine(tls, pParse, p, bp+28, pDest, regOutB, regPrev, pKeyDup, labelEnd)
	}
	_sqlite3KeyInfoUnref(tls, pKeyDup)
	/* Generate a subroutine to run when the results from select A
	 ** are exhausted and only data in select B remains.
	 */
	if op == int32(TK_EXCEPT) || op == int32(TK_INTERSECT) {
		v4 = labelEnd
		addrEofA = v4
		addrEofA_noB = v4
	} else {
		addrEofA = _sqlite3VdbeAddOp2(tls, v, int32(OP_Gosub), regOutB, addrOutB)
		addrEofA_noB = _sqlite3VdbeAddOp2(tls, v, int32(OP_Yield), regAddrB, labelEnd)
		_sqlite3VdbeGoto(tls, v, addrEofA)
		(*TSelect)(unsafe.Pointer(p)).FnSelectRow = _sqlite3LogEstAdd(tls, (*TSelect)(unsafe.Pointer(p)).FnSelectRow, (*TSelect)(unsafe.Pointer(pPrior)).FnSelectRow)
	}
	/* Generate a subroutine to run when the results from select B
	 ** are exhausted and only data in select A remains.
	 */
	if op == int32(TK_INTERSECT) {
		addrEofB = addrEofA
		if int32((*TSelect)(unsafe.Pointer(p)).FnSelectRow) > int32((*TSelect)(unsafe.Pointer(pPrior)).FnSelectRow) {
			(*TSelect)(unsafe.Pointer(p)).FnSelectRow = (*TSelect)(unsafe.Pointer(pPrior)).FnSelectRow
		}
	} else {
		addrEofB = _sqlite3VdbeAddOp2(tls, v, int32(OP_Gosub), regOutA, addrOutA)
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Yield), regAddrA, labelEnd)
		_sqlite3VdbeGoto(tls, v, addrEofB)
	}
	/* Generate code to handle the case of A<B
	 */
	addrAltB = _sqlite3VdbeAddOp2(tls, v, int32(OP_Gosub), regOutA, addrOutA)
	_sqlite3VdbeAddOp2(tls, v, int32(OP_Yield), regAddrA, addrEofA)
	_sqlite3VdbeGoto(tls, v, labelCmpr)
	/* Generate code to handle the case of A==B
	 */
	if op == int32(TK_ALL) {
		addrAeqB = addrAltB
	} else {
		if op == int32(TK_INTERSECT) {
			addrAeqB = addrAltB
			addrAltB = addrAltB + 1
		} else {
			addrAeqB = addrAltB + int32(1)
		}
	}
	/* Generate code to handle the case of A>B
	 */
	addrAgtB = _sqlite3VdbeCurrentAddr(tls, v)
	if op == int32(TK_ALL) || op == int32(TK_UNION) {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Gosub), regOutB, addrOutB)
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Yield), regAddrB, addrEofB)
		_sqlite3VdbeGoto(tls, v, labelCmpr)
	} else {
		addrAgtB = addrAgtB + 1 /* Just do next-B.  Might as well use the next-B call
		 ** in the next code block */
	}
	/* This code runs once to initialize everything.
	 */
	_sqlite3VdbeJumpHere(tls, v, addr1)
	_sqlite3VdbeAddOp2(tls, v, int32(OP_Yield), regAddrA, addrEofA_noB)
	/* v---  Also the A>B case for EXCEPT and INTERSECT */
	_sqlite3VdbeAddOp2(tls, v, int32(OP_Yield), regAddrB, addrEofB)
	/* Implement the main merge loop
	 */
	if aPermute != uintptr(0) {
		_sqlite3VdbeAddOp4(tls, v, int32(OP_Permutation), 0, 0, 0, aPermute, -int32(15))
	}
	_sqlite3VdbeResolveLabel(tls, v, labelCmpr)
	_sqlite3VdbeAddOp4(tls, v, int32(OP_Compare), (**(**TSelectDest)(__ccgo_up(bp))).FiSdst, (**(**TSelectDest)(__ccgo_up(bp + 28))).FiSdst, nOrderBy, pKeyMerge, -int32(9))
	if aPermute != uintptr(0) {
		_sqlite3VdbeChangeP5(tls, v, uint16(OPFLAG_PERMUTE))
	}
	_sqlite3VdbeAddOp3(tls, v, int32(OP_Jump), addrAltB, addrAeqB, addrAgtB)
	/* Jump to the this point in order to terminate the query.
	 */
	_sqlite3VdbeResolveLabel(tls, v, labelEnd)
	/* Make arrangements to free the 2nd and subsequent arms of the compound
	 ** after the parse has finished */
	if (*TSelect)(unsafe.Pointer(pSplit)).FpPrior != 0 {
		_sqlite3ParserAddCleanup(tls, pParse, __ccgo_fp(_sqlite3SelectDeleteGeneric), (*TSelect)(unsafe.Pointer(pSplit)).FpPrior)
	}
	(*TSelect)(unsafe.Pointer(pSplit)).FpPrior = pPrior
	(*TSelect)(unsafe.Pointer(pPrior)).FpNext = pSplit
	_sqlite3ExprListDelete(tls, db, (*TSelect)(unsafe.Pointer(pPrior)).FpOrderBy)
	(*TSelect)(unsafe.Pointer(pPrior)).FpOrderBy = uintptr(0)
	/*** TBD:  Insert subroutine calls to close cursors on incomplete
	 **** subqueries ****/
	_sqlite3VdbeExplainPop(tls, pParse)
	return libc.BoolInt32((*TParse)(unsafe.Pointer(pParse)).FnErr != 0)
}

// C documentation
//
//	/*
//	** This routine generates code that opens the sqlite_statN tables.
//	** The sqlite_stat1 table is always relevant.  sqlite_stat2 is now
//	** obsolete.  sqlite_stat3 and sqlite_stat4 are only opened when
//	** appropriate compile-time options are provided.
//	**
//	** If the sqlite_statN tables do not previously exist, it is created.
//	**
//	** Argument zWhere may be a pointer to a buffer containing a table name,
//	** or it may be a NULL pointer. If it is not NULL, then all entries in
//	** the sqlite_statN tables associated with the named table are deleted.
//	** If zWhere==0, then code is generated to delete all stat table entries.
//	*/
func _openStatTable(tls *libc.TLS, pParse uintptr, iDb int32, iStatCur int32, zWhere uintptr, zWhereType uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var aCreateTbl [3]Tu8
	var aRoot [3]Tu32
	var db, pDb, pStat, v, zTab, v3 uintptr
	var i, nToOpen, v1 int32
	_, _, _, _, _, _, _, _, _, _, _ = aCreateTbl, aRoot, db, i, nToOpen, pDb, pStat, v, zTab, v1, v3
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	v = _sqlite3GetVdbe(tls, pParse)
	if (*Tsqlite3)(unsafe.Pointer(db)).FdbOptFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_Stat4)) == uint32(0) {
		v1 = int32(2)
	} else {
		v1 = int32(1)
	}
	nToOpen = v1
	if v == uintptr(0) {
		return
	}
	pDb = (*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16
	/* Create new statistic tables if they do not exist, or clear them
	 ** if they do already exist.
	 */
	i = 0
	for {
		if !(i < libc.Int32FromUint32(libc.Uint32FromInt64(24)/libc.Uint32FromInt64(8))) {
			break
		}
		zTab = _aTable[i].FzName
		aCreateTbl[i] = uint8(0)
		v3 = _sqlite3FindTable(tls, db, zTab, (*TDb)(unsafe.Pointer(pDb)).FzDbSName)
		pStat = v3
		if v3 == uintptr(0) {
			if i < nToOpen {
				/* The sqlite_statN table does not exist. Create it. Note that a
				 ** side-effect of the CREATE TABLE statement is to leave the rootpage
				 ** of the new table in register pParse->regRoot. This is important
				 ** because the OpenWrite opcode below will be needing it. */
				_sqlite3NestedParse(tls, pParse, __ccgo_ts+12915, libc.VaList(bp+8, (*TDb)(unsafe.Pointer(pDb)).FzDbSName, zTab, _aTable[i].FzCols))
				aRoot[i] = libc.Uint32FromInt32((*(*struct {
					FaddrCrTab      int32
					FregRowid       int32
					FregRoot        int32
					FconstraintName TToken
				})(unsafe.Pointer(pParse + 188))).FregRoot)
				aCreateTbl[i] = uint8(OPFLAG_P2ISREG)
			}
		} else {
			/* The table already exists. If zWhere is not NULL, delete all entries
			 ** associated with the table zWhere. If zWhere is NULL, delete the
			 ** entire contents of the table. */
			aRoot[i] = (*TTable)(unsafe.Pointer(pStat)).Ftnum
			_sqlite3TableLock(tls, pParse, iDb, aRoot[i], uint8(1), zTab)
			if zWhere != 0 {
				_sqlite3NestedParse(tls, pParse, __ccgo_ts+12938, libc.VaList(bp+8, (*TDb)(unsafe.Pointer(pDb)).FzDbSName, zTab, zWhereType, zWhere))
			} else {
				if (*Tsqlite3)(unsafe.Pointer(db)).FxPreUpdateCallback != 0 {
					_sqlite3NestedParse(tls, pParse, __ccgo_ts+12968, libc.VaList(bp+8, (*TDb)(unsafe.Pointer(pDb)).FzDbSName, zTab))
				} else {
					/* The sqlite_stat[134] table already exists.  Delete all rows. */
					_sqlite3VdbeAddOp2(tls, v, int32(OP_Clear), libc.Int32FromUint32(aRoot[i]), iDb)
				}
			}
		}
		goto _2
	_2:
		;
		i = i + 1
	}
	/* Open the sqlite_stat[134] tables for writing. */
	i = 0
	for {
		if !(i < nToOpen) {
			break
		}
		_sqlite3VdbeAddOp4Int(tls, v, int32(OP_OpenWrite), iStatCur+i, libc.Int32FromUint32(aRoot[i]), iDb, int32(3))
		_sqlite3VdbeChangeP5(tls, v, uint16(aCreateTbl[i]))
		goto _4
	_4:
		;
		i = i + 1
	}
}

// C documentation
//
//	/*
//	** Lower the locking level on file descriptor pFile to eFileLock.  eFileLock
//	** must be either NO_LOCK or SHARED_LOCK.
//	**
//	** If the locking level of the file descriptor is already at or below
//	** the requested locking level, this routine is a no-op.
//	**
//	** If handleNFSUnlock is true, then on downgrading an EXCLUSIVE_LOCK to SHARED
//	** the byte range is divided into 2 parts and the first part is unlocked then
//	** set to a read lock, then the other part is simply unlocked.  This works
//	** around a bug in BSD NFS lockd (also seen on MacOSX 10.3+) that fails to
//	** remove the write lock on a region when a read lock is set.
//	*/
func _posixUnlock(tls *libc.TLS, id uintptr, eFileLock int32, handleNFSUnlock int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var pFile, pInode uintptr
	var rc int32
	var v1 Toff_t
	var _ /* lock at bp+0 */ Tflock
	_, _, _, _ = pFile, pInode, rc, v1
	pFile = id
	rc = SQLITE_OK
	if libc.Int32FromUint8((*TunixFile)(unsafe.Pointer(pFile)).FeFileLock) <= eFileLock {
		return SQLITE_OK
	}
	pInode = (*TunixFile)(unsafe.Pointer(pFile)).FpInode
	Xsqlite3_mutex_enter(tls, (*TunixInodeInfo)(unsafe.Pointer(pInode)).FpLockMutex)
	if libc.Int32FromUint8((*TunixFile)(unsafe.Pointer(pFile)).FeFileLock) > int32(SHARED_LOCK) {
		/* downgrading to a shared lock on NFS involves clearing the write lock
		 ** before establishing the readlock - to avoid a race condition we downgrade
		 ** the lock in 2 blocks, so that part of the range will be covered by a
		 ** write lock until the rest is covered by a read lock:
		 **  1:   [WWWWW]
		 **  2:   [....W]
		 **  3:   [RRRRW]
		 **  4:   [RRRR.]
		 */
		if eFileLock == int32(SHARED_LOCK) {
			_ = handleNFSUnlock
			(**(**Tflock)(__ccgo_up(bp))).Fl_type = int16(F_RDLCK)
			(**(**Tflock)(__ccgo_up(bp))).Fl_whence = SEEK_SET
			(**(**Tflock)(__ccgo_up(bp))).Fl_start = int64(_sqlite3PendingByte + libc.Int32FromInt32(2))
			(**(**Tflock)(__ccgo_up(bp))).Fl_len = int64(SHARED_SIZE)
			if _unixFileLock(tls, pFile, bp) != 0 {
				/* In theory, the call to unixFileLock() cannot fail because another
				 ** process is holding an incompatible lock. If it does, this
				 ** indicates that the other process is not following the locking
				 ** protocol. If this happens, return SQLITE_IOERR_RDLOCK. Returning
				 ** SQLITE_BUSY would confuse the upper layer (in practice it causes
				 ** an assert to fail). */
				rc = libc.Int32FromInt32(SQLITE_IOERR) | libc.Int32FromInt32(9)<<libc.Int32FromInt32(8)
				_storeLastErrno(tls, pFile, **(**int32)(__ccgo_up(libc.X__error(tls))))
				goto end_unlock
			}
		}
		(**(**Tflock)(__ccgo_up(bp))).Fl_type = int16(F_UNLCK)
		(**(**Tflock)(__ccgo_up(bp))).Fl_whence = SEEK_SET
		(**(**Tflock)(__ccgo_up(bp))).Fl_start = int64(_sqlite3PendingByte)
		(**(**Tflock)(__ccgo_up(bp))).Fl_len = int64(2)
		if _unixFileLock(tls, pFile, bp) == 0 {
			(*TunixInodeInfo)(unsafe.Pointer(pInode)).FeFileLock = uint8(SHARED_LOCK)
		} else {
			rc = libc.Int32FromInt32(SQLITE_IOERR) | libc.Int32FromInt32(8)<<libc.Int32FromInt32(8)
			_storeLastErrno(tls, pFile, **(**int32)(__ccgo_up(libc.X__error(tls))))
			goto end_unlock
		}
	}
	if eFileLock == NO_LOCK {
		/* Decrement the shared lock counter.  Release the lock using an
		 ** OS call only when all threads in this same process have released
		 ** the lock.
		 */
		(*TunixInodeInfo)(unsafe.Pointer(pInode)).FnShared = (*TunixInodeInfo)(unsafe.Pointer(pInode)).FnShared - 1
		if (*TunixInodeInfo)(unsafe.Pointer(pInode)).FnShared == 0 {
			(**(**Tflock)(__ccgo_up(bp))).Fl_type = int16(F_UNLCK)
			(**(**Tflock)(__ccgo_up(bp))).Fl_whence = SEEK_SET
			v1 = libc.Int64FromInt32(0)
			(**(**Tflock)(__ccgo_up(bp))).Fl_len = v1
			(**(**Tflock)(__ccgo_up(bp))).Fl_start = v1
			if _unixFileLock(tls, pFile, bp) == 0 {
				(*TunixInodeInfo)(unsafe.Pointer(pInode)).FeFileLock = uint8(NO_LOCK)
			} else {
				rc = libc.Int32FromInt32(SQLITE_IOERR) | libc.Int32FromInt32(8)<<libc.Int32FromInt32(8)
				_storeLastErrno(tls, pFile, **(**int32)(__ccgo_up(libc.X__error(tls))))
				(*TunixInodeInfo)(unsafe.Pointer(pInode)).FeFileLock = uint8(NO_LOCK)
				(*TunixFile)(unsafe.Pointer(pFile)).FeFileLock = uint8(NO_LOCK)
			}
		}
		/* Decrement the count of locks against this same file.  When the
		 ** count reaches zero, close any other file descriptors whose close
		 ** was deferred because of outstanding locks.
		 */
		(*TunixInodeInfo)(unsafe.Pointer(pInode)).FnLock = (*TunixInodeInfo)(unsafe.Pointer(pInode)).FnLock - 1
		if (*TunixInodeInfo)(unsafe.Pointer(pInode)).FnLock == 0 {
			_closePendingFds(tls, pFile)
		}
	}
	goto end_unlock
end_unlock:
	;
	Xsqlite3_mutex_leave(tls, (*TunixInodeInfo)(unsafe.Pointer(pInode)).FpLockMutex)
	if rc == SQLITE_OK {
		(*TunixFile)(unsafe.Pointer(pFile)).FeFileLock = libc.Uint8FromInt32(eFileLock)
	}
	return rc
}

// C documentation
//
//	/*
//	** The second argument passed to this function is the name of a PRAGMA
//	** setting - "page_size", "auto_vacuum", "user_version" or "application_id".
//	** This function executes the following on sqlite3rbu.dbRbu:
//	**
//	**   "PRAGMA main.$zPragma"
//	**
//	** where $zPragma is the string passed as the second argument, then
//	** on sqlite3rbu.dbMain:
//	**
//	**   "PRAGMA main.$zPragma = $val"
//	**
//	** where $val is the value returned by the first PRAGMA invocation.
//	**
//	** In short, it copies the value  of the specified PRAGMA setting from
//	** dbRbu to dbMain.
//	*/
func _rbuCopyPragma(tls *libc.TLS, p uintptr, zPragma uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var _ /* pPragma at bp+0 */ uintptr
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
		**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbRbu, bp, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+33973, libc.VaList(bp+16, zPragma)))
		if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) {
			(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _rbuMPrintfExec(tls, p, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+33988, libc.VaList(bp+16, zPragma, Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), 0)))
		}
		_rbuFinalize(tls, p, **(**uintptr)(__ccgo_up(bp)))
	}
}

// C documentation
//
//	/*
//	** If an error has already occurred when this function is called, it
//	** immediately returns zero (without doing any work). Or, if an error
//	** occurs during the execution of this function, it sets the error code
//	** in the sqlite3rbu object indicated by the first argument and returns
//	** zero.
//	**
//	** The iterator passed as the second argument is guaranteed to point to
//	** a table (not an index) when this function is called. This function
//	** attempts to create any imposter table required to write to the main
//	** table b-tree of the table before returning. Non-zero is returned if
//	** an imposter table are created, or zero otherwise.
//	**
//	** An imposter table is required in all cases except RBU_PK_VTAB. Only
//	** virtual tables are written to directly. The imposter table has the
//	** same schema as the actual target table (less any UNIQUE constraints).
//	** More precisely, the "same schema" means the same columns, types,
//	** collation sequences. For tables that do not have an external PRIMARY
//	** KEY, it also means the same PRIMARY KEY declaration.
//	*/
func _rbuCreateImposterTable(tls *libc.TLS, p uintptr, pIter uintptr) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var iCol, tnum int32
	var zCol, zComma, zPk, zPk1, zSql, v2 uintptr
	var _ /* zColl at bp+0 */ uintptr
	_, _, _, _, _, _, _, _ = iCol, tnum, zCol, zComma, zPk, zPk1, zSql, v2
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType != int32(RBU_PK_VTAB) {
		tnum = (*TRbuObjIter)(unsafe.Pointer(pIter)).FiTnum
		zComma = __ccgo_ts + 1702
		zSql = uintptr(0)
		Xsqlite3_test_control(tls, int32(SQLITE_TESTCTRL_IMPOSTER), libc.VaList(bp+16, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+6818, 0, int32(1)))
		iCol = 0
		for {
			if !((*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && iCol < (*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol) {
				break
			}
			zPk = __ccgo_ts + 1702
			zCol = **(**uintptr)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblCol + uintptr(iCol)*4))
			**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
			(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = Xsqlite3_table_column_metadata(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+6818, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzTbl, zCol, uintptr(0), bp, uintptr(0), uintptr(0), uintptr(0))
			if (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_IPK) && **(**Tu8)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FabTblPk + uintptr(iCol))) != 0 {
				/* If the target table column is an "INTEGER PRIMARY KEY", add
				 ** "PRIMARY KEY" to the imposter table column declaration. */
				zPk = __ccgo_ts + 32024
			}
			if **(**Tu8)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FabNotNull + uintptr(iCol))) != 0 {
				v2 = __ccgo_ts + 32037
			} else {
				v2 = __ccgo_ts + 1702
			}
			zSql = _rbuMPrintf(tls, p, __ccgo_ts+32047, libc.VaList(bp+16, zSql, zComma, zCol, **(**uintptr)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblType + uintptr(iCol)*4)), zPk, **(**uintptr)(__ccgo_up(bp)), v2))
			zComma = __ccgo_ts + 16216
			goto _1
		_1:
			;
			iCol = iCol + 1
		}
		if (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_WITHOUT_ROWID) {
			zPk1 = _rbuWithoutRowidPK(tls, p, pIter)
			if zPk1 != 0 {
				zSql = _rbuMPrintf(tls, p, __ccgo_ts+32074, libc.VaList(bp+16, zSql, zPk1))
			}
		}
		Xsqlite3_test_control(tls, int32(SQLITE_TESTCTRL_IMPOSTER), libc.VaList(bp+16, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+6818, int32(1), tnum))
		if (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_WITHOUT_ROWID) {
			v2 = __ccgo_ts + 32081
		} else {
			v2 = __ccgo_ts + 1702
		}
		_rbuMPrintfExec(tls, p, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+32096, libc.VaList(bp+16, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzTbl, zSql, v2))
		Xsqlite3_test_control(tls, int32(SQLITE_TESTCTRL_IMPOSTER), libc.VaList(bp+16, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+6818, 0, 0))
	}
}

// C documentation
//
//	/*
//	** This function creates the second imposter table used when writing to
//	** a table b-tree where the table has an external primary key. If the
//	** iterator passed as the second argument does not currently point to
//	** a table (not index) with an external primary key, this function is a
//	** no-op.
//	**
//	** Assuming the iterator does point to a table with an external PK, this
//	** function creates a WITHOUT ROWID imposter table named "rbu_imposter2"
//	** used to access that PK index. For example, if the target table is
//	** declared as follows:
//	**
//	**   CREATE TABLE t1(a, b TEXT, c REAL, PRIMARY KEY(b, c));
//	**
//	** then the imposter table schema is:
//	**
//	**   CREATE TABLE rbu_imposter2(c1 TEXT, c2 REAL, id INTEGER) WITHOUT ROWID;
//	**
//	*/
func _rbuCreateImposterTable2(tls *libc.TLS, p uintptr, pIter uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var bDesc, bKey, iCid, tnum int32
	var zCollate, zCols, zComma, zIdx, zPk, v1 uintptr
	var _ /* pQuery at bp+0 */ uintptr
	var _ /* pXInfo at bp+4 */ uintptr
	_, _, _, _, _, _, _, _, _, _ = bDesc, bKey, iCid, tnum, zCollate, zCols, zComma, zIdx, zPk, v1
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_EXTERNAL) {
		tnum = (*TRbuObjIter)(unsafe.Pointer(pIter)).FiPkTnum /* Root page of PK index */
		**(**uintptr)(__ccgo_up(bp)) = uintptr(0)             /* SELECT name ... WHERE rootpage = $tnum */
		zIdx = uintptr(0)                                     /* Name of PK index */
		**(**uintptr)(__ccgo_up(bp + 4)) = uintptr(0)         /* PRAGMA main.index_xinfo = $zIdx */
		zComma = __ccgo_ts + 1702
		zCols = uintptr(0) /* Used to build up list of table cols */
		zPk = uintptr(0)   /* Used to build up table PK declaration */
		/* Figure out the name of the primary key index for the current table.
		 ** This is needed for the argument to "PRAGMA index_xinfo". Set
		 ** zIdx to point to a nul-terminated string containing this name. */
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, bp, p+36, __ccgo_ts+31865)
		if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
			Xsqlite3_bind_int(tls, **(**uintptr)(__ccgo_up(bp)), int32(1), tnum)
			if int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) {
				zIdx = Xsqlite3_column_text(tls, **(**uintptr)(__ccgo_up(bp)), 0)
			}
		}
		if zIdx != 0 {
			(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, bp+4, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+31017, libc.VaList(bp+16, zIdx)))
		}
		_rbuFinalize(tls, p, **(**uintptr)(__ccgo_up(bp)))
		for (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp + 4))) {
			bKey = Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp + 4)), int32(5))
			if bKey != 0 {
				iCid = Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp + 4)), int32(1))
				bDesc = Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp + 4)), int32(3))
				zCollate = Xsqlite3_column_text(tls, **(**uintptr)(__ccgo_up(bp + 4)), int32(4))
				zCols = _rbuMPrintf(tls, p, __ccgo_ts+31915, libc.VaList(bp+16, zCols, zComma, iCid, **(**uintptr)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblType + uintptr(iCid)*4)), zCollate))
				if bDesc != 0 {
					v1 = __ccgo_ts + 31257
				} else {
					v1 = __ccgo_ts + 1702
				}
				zPk = _rbuMPrintf(tls, p, __ccgo_ts+31937, libc.VaList(bp+16, zPk, zComma, iCid, v1))
				zComma = __ccgo_ts + 16216
			}
		}
		zCols = _rbuMPrintf(tls, p, __ccgo_ts+31947, libc.VaList(bp+16, zCols))
		_rbuFinalize(tls, p, **(**uintptr)(__ccgo_up(bp + 4)))
		Xsqlite3_test_control(tls, int32(SQLITE_TESTCTRL_IMPOSTER), libc.VaList(bp+16, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+6818, int32(1), tnum))
		_rbuMPrintfExec(tls, p, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+31962, libc.VaList(bp+16, zCols, zPk))
		Xsqlite3_test_control(tls, int32(SQLITE_TESTCTRL_IMPOSTER), libc.VaList(bp+16, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+6818, 0, 0))
	}
}

// C documentation
//
//	/*
//	** The RBU handle passed as the only argument has just been opened and
//	** the state database is empty. If this RBU handle was opened for an
//	** RBU vacuum operation, create the schema in the target db.
//	*/
func _rbuCreateTargetSchema(tls *libc.TLS, p uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var i int32
	var zSql uintptr
	var _ /* pInsert at bp+4 */ uintptr
	var _ /* pSql at bp+0 */ uintptr
	_, _ = i, zSql
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	**(**uintptr)(__ccgo_up(bp + 4)) = uintptr(0)
	(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = Xsqlite3_exec(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+34008, uintptr(0), uintptr(0), p+36)
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbRbu, bp, p+36, __ccgo_ts+34033)
	}
	for (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) == int32(SQLITE_ROW) {
		zSql = Xsqlite3_column_text(tls, **(**uintptr)(__ccgo_up(bp)), 0)
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = Xsqlite3_exec(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, zSql, uintptr(0), uintptr(0), p+36)
	}
	_rbuFinalize(tls, p, **(**uintptr)(__ccgo_up(bp)))
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc != SQLITE_OK {
		return
	}
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbRbu, bp, p+36, __ccgo_ts+34141)
	}
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, bp+4, p+36, __ccgo_ts+34206)
	}
	for (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) == int32(SQLITE_ROW) {
		i = 0
		for {
			if !(i < int32(5)) {
				break
			}
			Xsqlite3_bind_value(tls, **(**uintptr)(__ccgo_up(bp + 4)), i+int32(1), Xsqlite3_column_value(tls, **(**uintptr)(__ccgo_up(bp)), i))
			goto _1
		_1:
			;
			i = i + 1
		}
		Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp + 4)))
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = Xsqlite3_reset(tls, **(**uintptr)(__ccgo_up(bp + 4)))
	}
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = Xsqlite3_exec(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+34250, uintptr(0), uintptr(0), p+36)
	}
	_rbuFinalize(tls, p, **(**uintptr)(__ccgo_up(bp)))
	_rbuFinalize(tls, p, **(**uintptr)(__ccgo_up(bp + 4)))
}

// C documentation
//
//	/*
//	** Implementation of SQL scalar function rbu_fossil_delta().
//	**
//	** This function applies a fossil delta patch to a blob. Exactly two
//	** arguments must be passed to this function. The first is the blob to
//	** patch and the second the patch to apply. If no error occurs, this
//	** function returns the patched blob.
//	*/
func _rbuFossilDeltaFunc(tls *libc.TLS, context uintptr, argc int32, argv uintptr) {
	var aDelta, aOrig, aOut uintptr
	var nDelta, nOrig, nOut, nOut2 int32
	_, _, _, _, _, _, _ = aDelta, aOrig, aOut, nDelta, nOrig, nOut, nOut2
	_ = argc
	nOrig = Xsqlite3_value_bytes(tls, **(**uintptr)(__ccgo_up(argv)))
	aOrig = Xsqlite3_value_blob(tls, **(**uintptr)(__ccgo_up(argv)))
	nDelta = Xsqlite3_value_bytes(tls, **(**uintptr)(__ccgo_up(argv + 1*4)))
	aDelta = Xsqlite3_value_blob(tls, **(**uintptr)(__ccgo_up(argv + 1*4)))
	/* Figure out the size of the output */
	nOut = _rbuDeltaOutputSize(tls, aDelta, nDelta)
	if nOut < 0 {
		Xsqlite3_result_error(tls, context, __ccgo_ts+30269, -int32(1))
		return
	}
	aOut = Xsqlite3_malloc64(tls, libc.Uint64FromInt64(int64(nOut)+int64(1)))
	if aOut == uintptr(0) {
		Xsqlite3_result_error_nomem(tls, context)
	} else {
		nOut2 = _rbuDeltaApply(tls, aOrig, nOrig, aDelta, nDelta, aOut)
		if nOut2 != nOut {
			Xsqlite3_free(tls, aOut)
			Xsqlite3_result_error(tls, context, __ccgo_ts+30269, -int32(1))
		} else {
			Xsqlite3_result_blob(tls, context, aOut, nOut, __ccgo_fp(Xsqlite3_free))
		}
	}
}

// C documentation
//
//	/*
//	** Set output variable *ppStmt to point to an UPDATE statement that may
//	** be used to update the imposter table for the main table b-tree of the
//	** table object that pIter currently points to, assuming that the
//	** rbu_control column of the data_xyz table contains zMask.
//	**
//	** If the zMask string does not specify any columns to update, then this
//	** is not an error. Output variable *ppStmt is set to NULL in this case.
//	*/
func _rbuGetUpdateStmt(tls *libc.TLS, p uintptr, pIter uintptr, zMask uintptr, ppStmt uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var nUp int32
	var pUp, pp, zPrefix, zSet, zUpdate, zWhere uintptr
	_, _, _, _, _, _, _ = nUp, pUp, pp, zPrefix, zSet, zUpdate, zWhere
	pUp = uintptr(0)
	nUp = 0
	/* In case an error occurs */
	**(**uintptr)(__ccgo_up(ppStmt)) = uintptr(0)
	/* Search for an existing statement. If one is found, shift it to the front
	 ** of the LRU queue and return immediately. Otherwise, leave nUp pointing
	 ** to the number of statements currently in the cache and pUp to the
	 ** last object in the list.  */
	pp = pIter + 104
	for {
		if !(**(**uintptr)(__ccgo_up(pp)) != 0) {
			break
		}
		pUp = **(**uintptr)(__ccgo_up(pp))
		if libc.Xstrcmp(tls, (*TRbuUpdateStmt)(unsafe.Pointer(pUp)).FzMask, zMask) == 0 {
			**(**uintptr)(__ccgo_up(pp)) = (*TRbuUpdateStmt)(unsafe.Pointer(pUp)).FpNext
			(*TRbuUpdateStmt)(unsafe.Pointer(pUp)).FpNext = (*TRbuObjIter)(unsafe.Pointer(pIter)).FpRbuUpdate
			(*TRbuObjIter)(unsafe.Pointer(pIter)).FpRbuUpdate = pUp
			**(**uintptr)(__ccgo_up(ppStmt)) = (*TRbuUpdateStmt)(unsafe.Pointer(pUp)).FpUpdate
			return SQLITE_OK
		}
		nUp = nUp + 1
		goto _1
	_1:
		;
		pp = **(**uintptr)(__ccgo_up(pp)) + 8
	}
	if nUp >= int32(SQLITE_RBU_UPDATE_CACHESIZE) {
		pp = pIter + 104
		for {
			if !(**(**uintptr)(__ccgo_up(pp)) != pUp) {
				break
			}
			goto _2
		_2:
			;
			pp = **(**uintptr)(__ccgo_up(pp)) + 8
		}
		**(**uintptr)(__ccgo_up(pp)) = uintptr(0)
		Xsqlite3_finalize(tls, (*TRbuUpdateStmt)(unsafe.Pointer(pUp)).FpUpdate)
		(*TRbuUpdateStmt)(unsafe.Pointer(pUp)).FpUpdate = uintptr(0)
	} else {
		pUp = _rbuMalloc(tls, p, libc.Int64FromUint32(uint32(12)+libc.Uint32FromInt32((*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol)+uint32(1)))
	}
	if pUp != 0 {
		zWhere = _rbuObjIterGetWhere(tls, p, pIter)
		zSet = _rbuObjIterGetSetlist(tls, p, pIter, zMask)
		zUpdate = uintptr(0)
		(*TRbuUpdateStmt)(unsafe.Pointer(pUp)).FzMask = pUp + 1*12
		libc.Xmemcpy(tls, (*TRbuUpdateStmt)(unsafe.Pointer(pUp)).FzMask, zMask, libc.Uint32FromInt32((*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol))
		(*TRbuUpdateStmt)(unsafe.Pointer(pUp)).FpNext = (*TRbuObjIter)(unsafe.Pointer(pIter)).FpRbuUpdate
		(*TRbuObjIter)(unsafe.Pointer(pIter)).FpRbuUpdate = pUp
		if zSet != 0 {
			zPrefix = __ccgo_ts + 1702
			if (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType != int32(RBU_PK_VTAB) {
				zPrefix = __ccgo_ts + 32697
			}
			zUpdate = Xsqlite3_mprintf(tls, __ccgo_ts+33358, libc.VaList(bp+8, zPrefix, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzTbl, zSet, zWhere))
			(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, pUp+4, p+36, zUpdate)
			**(**uintptr)(__ccgo_up(ppStmt)) = (*TRbuUpdateStmt)(unsafe.Pointer(pUp)).FpUpdate
		}
		Xsqlite3_free(tls, zWhere)
		Xsqlite3_free(tls, zSet)
	}
	return (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc
}

// C documentation
//
//	/*
//	** Increment the schema cookie of the main database opened by p->dbMain.
//	**
//	** Or, if this is an RBU vacuum, set the schema cookie of the main db
//	** opened by p->dbMain to one more than the schema cookie of the main
//	** db opened by p->dbRbu.
//	*/
func _rbuIncrSchemaCookie(tls *libc.TLS, p uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var dbread, v1 uintptr
	var iCookie int32
	var _ /* pStmt at bp+0 */ uintptr
	_, _, _ = dbread, iCookie, v1
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
		if (*Tsqlite3rbu)(unsafe.Pointer(p)).FzTarget == uintptr(0) {
			v1 = (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbRbu
		} else {
			v1 = (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain
		}
		dbread = v1
		iCookie = int32(1000000)
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareAndCollectError(tls, dbread, bp, p+36, __ccgo_ts+33764)
		if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
			/* Coverage: it may be that this sqlite3_step() cannot fail. There
			 ** is already a transaction open, so the prepared statement cannot
			 ** throw an SQLITE_SCHEMA exception. The only database page the
			 ** statement reads is page 1, which is guaranteed to be in the cache.
			 ** And no memory allocations are required.  */
			if int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) {
				iCookie = Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), 0)
			}
			_rbuFinalize(tls, p, **(**uintptr)(__ccgo_up(bp)))
		}
		if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
			_rbuMPrintfExec(tls, p, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+33786, libc.VaList(bp+16, iCookie+int32(1)))
		}
	}
}

// C documentation
//
//	/*
//	** This user-defined SQL function is invoked with a single argument - the
//	** name of a table expected to appear in the target database. It returns
//	** the number of auxilliary indexes on the table.
//	*/
func _rbuIndexCntFunc(tls *libc.TLS, pCtx uintptr, nVal int32, apVal uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var db, p, v1 uintptr
	var nIndex, rc int32
	var _ /* pStmt at bp+0 */ uintptr
	var _ /* zErrmsg at bp+4 */ uintptr
	_, _, _, _, _ = db, nIndex, p, rc, v1
	p = Xsqlite3_user_data(tls, pCtx)
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	**(**uintptr)(__ccgo_up(bp + 4)) = uintptr(0)
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).FzTarget == uintptr(0) {
		v1 = (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbRbu
	} else {
		v1 = (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain
	}
	db = v1
	_ = nVal
	rc = _prepareFreeAndCollectError(tls, db, bp, bp+4, Xsqlite3_mprintf(tls, __ccgo_ts+34339, libc.VaList(bp+16, Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(apVal))))))
	if rc != SQLITE_OK {
		Xsqlite3_result_error(tls, pCtx, **(**uintptr)(__ccgo_up(bp + 4)), -int32(1))
	} else {
		nIndex = 0
		if int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) {
			nIndex = Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), 0)
		}
		rc = Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp)))
		if rc == SQLITE_OK {
			Xsqlite3_result_int(tls, pCtx, nIndex)
		} else {
			Xsqlite3_result_error(tls, pCtx, Xsqlite3_errmsg(tls, db), -int32(1))
		}
	}
	Xsqlite3_free(tls, **(**uintptr)(__ccgo_up(bp + 4)))
}

// C documentation
//
//	/*
//	** If the RBU database contains the rbu_count table, use it to initialize
//	** the sqlite3rbu.nPhaseOneStep variable. The schema of the rbu_count table
//	** is assumed to contain the same columns as:
//	**
//	**   CREATE TABLE rbu_count(tbl TEXT PRIMARY KEY, cnt INTEGER) WITHOUT ROWID;
//	**
//	** There should be one row in the table for each data_xxx table in the
//	** database. The 'tbl' column should contain the name of a data_xxx table,
//	** and the cnt column the number of rows it contains.
//	**
//	** sqlite3rbu.nPhaseOneStep is initialized to the sum of (1 + nIndex) * cnt
//	** for all rows in the rbu_count table, where nIndex is the number of
//	** indexes on the corresponding target database table.
//	*/
func _rbuInitPhaseOneSteps(tls *libc.TLS, p uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var bExists int32
	var _ /* pStmt at bp+0 */ uintptr
	_ = bExists
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
		**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
		bExists = 0 /* True if rbu_count exists */
		(*Tsqlite3rbu)(unsafe.Pointer(p)).FnPhaseOneStep = int64(-int32(1))
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = Xsqlite3_create_function(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbRbu, __ccgo_ts+34411, int32(1), int32(SQLITE_UTF8), p, __ccgo_fp(_rbuIndexCntFunc), uintptr(0), uintptr(0))
		/* Check for the rbu_count table. If it does not exist, or if an error
		 ** occurs, nPhaseOneStep will be left set to -1. */
		if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
			(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbRbu, bp, p+36, __ccgo_ts+34425)
		}
		if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
			if int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) {
				bExists = int32(1)
			}
			(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp)))
		}
		if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && bExists != 0 {
			(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbRbu, bp, p+36, __ccgo_ts+34482)
			if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
				if int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) {
					(*Tsqlite3rbu)(unsafe.Pointer(p)).FnPhaseOneStep = Xsqlite3_column_int64(tls, **(**uintptr)(__ccgo_up(bp)), 0)
				}
				(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp)))
			}
		}
	}
}

// C documentation
//
//	/*
//	** This is a helper function for rbuObjIterCacheTableInfo(). It populates
//	** the pIter->abIndexed[] array.
//	*/
func _rbuObjIterCacheIndexedCols(tls *libc.TLS, p uintptr, pIter uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var bIndex, bPartial, iCid int32
	var zIdx uintptr
	var _ /* pList at bp+0 */ uintptr
	var _ /* pXInfo at bp+4 */ uintptr
	_, _, _, _ = bIndex, bPartial, iCid, zIdx
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	bIndex = 0
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
		libc.Xmemcpy(tls, (*TRbuObjIter)(unsafe.Pointer(pIter)).FabIndexed, (*TRbuObjIter)(unsafe.Pointer(pIter)).FabTblPk, uint32(1)*libc.Uint32FromInt32((*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol))
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, bp, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+30989, libc.VaList(bp+16, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzTbl)))
	}
	(*TRbuObjIter)(unsafe.Pointer(pIter)).FnIndex = 0
	for (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) {
		zIdx = Xsqlite3_column_text(tls, **(**uintptr)(__ccgo_up(bp)), int32(1))
		bPartial = Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), int32(4))
		**(**uintptr)(__ccgo_up(bp + 4)) = uintptr(0)
		if zIdx == uintptr(0) {
			break
		}
		if bPartial != 0 {
			libc.Xmemset(tls, (*TRbuObjIter)(unsafe.Pointer(pIter)).FabIndexed, int32(0x01), uint32(1)*libc.Uint32FromInt32((*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol))
		}
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, bp+4, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+31017, libc.VaList(bp+16, zIdx)))
		for (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp + 4))) {
			iCid = Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp + 4)), int32(1))
			if iCid >= 0 {
				**(**Tu8)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FabIndexed + uintptr(iCid))) = uint8(1)
			}
			if iCid == -int32(2) {
				libc.Xmemset(tls, (*TRbuObjIter)(unsafe.Pointer(pIter)).FabIndexed, int32(0x01), uint32(1)*libc.Uint32FromInt32((*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol))
			}
		}
		_rbuFinalize(tls, p, **(**uintptr)(__ccgo_up(bp + 4)))
		bIndex = int32(1)
		(*TRbuObjIter)(unsafe.Pointer(pIter)).FnIndex = (*TRbuObjIter)(unsafe.Pointer(pIter)).FnIndex + 1
	}
	if (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_WITHOUT_ROWID) {
		/* "PRAGMA index_list" includes the main PK b-tree */
		(*TRbuObjIter)(unsafe.Pointer(pIter)).FnIndex = (*TRbuObjIter)(unsafe.Pointer(pIter)).FnIndex - 1
	}
	_rbuFinalize(tls, p, **(**uintptr)(__ccgo_up(bp)))
	if bIndex == 0 {
		(*TRbuObjIter)(unsafe.Pointer(pIter)).FabIndexed = uintptr(0)
	}
}

// C documentation
//
//	/*
//	** If they are not already populated, populate the pIter->azTblCol[],
//	** pIter->abTblPk[], pIter->nTblCol and pIter->bRowid variables according to
//	** the table (not index) that the iterator currently points to.
//	**
//	** Return SQLITE_OK if successful, or an SQLite error code otherwise. If
//	** an error does occur, an error code and error message are also left in
//	** the RBU handle.
//	*/
func _rbuObjIterCacheTableInfo(tls *libc.TLS, p uintptr, pIter uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var bNotNull, bRbuRowid, i, iOrder, iPk, nCol, t, v2 int32
	var t1, zCopy, zName, zName1, zType, v3 uintptr
	var _ /* iTnum at bp+4 */ int32
	var _ /* pStmt at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = bNotNull, bRbuRowid, i, iOrder, iPk, nCol, t, t1, zCopy, zName, zName1, zType, v2, v3
	if (*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblCol == uintptr(0) {
		**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
		nCol = 0      /* for() loop iterator variable */
		bRbuRowid = 0 /* If input table has column "rbu_rowid" */
		iOrder = 0
		**(**int32)(__ccgo_up(bp + 4)) = 0
		/* Figure out the type of table this step will deal with. */
		_rbuTableType(tls, p, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzTbl, pIter+36, bp+4, pIter+60)
		if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == RBU_PK_NOTABLE {
			(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = int32(SQLITE_ERROR)
			(*Tsqlite3rbu)(unsafe.Pointer(p)).FzErrmsg = Xsqlite3_mprintf(tls, __ccgo_ts+21341, libc.VaList(bp+16, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzTbl))
		}
		if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc != 0 {
			return (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc
		}
		if (*TRbuObjIter)(unsafe.Pointer(pIter)).FzIdx == uintptr(0) {
			(*TRbuObjIter)(unsafe.Pointer(pIter)).FiTnum = **(**int32)(__ccgo_up(bp + 4))
		}
		/* Populate the azTblCol[] and nTblCol variables based on the columns
		 ** of the input table. Ignore any input table columns that begin with
		 ** "rbu_".  */
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbRbu, bp, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+31046, libc.VaList(bp+16, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzDataTbl)))
		if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
			nCol = Xsqlite3_column_count(tls, **(**uintptr)(__ccgo_up(bp)))
			_rbuAllocateIterArrays(tls, p, pIter, nCol)
		}
		i = 0
		for {
			if !((*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && i < nCol) {
				break
			}
			zName = Xsqlite3_column_name(tls, **(**uintptr)(__ccgo_up(bp)), i)
			if Xsqlite3_strnicmp(tls, __ccgo_ts+31065, zName, int32(4)) != 0 {
				zCopy = _rbuStrndup(tls, zName, p+32)
				**(**int32)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FaiSrcOrder + uintptr((*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol)*4)) = (*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol
				v3 = pIter + 8
				v2 = *(*int32)(unsafe.Pointer(v3))
				*(*int32)(unsafe.Pointer(v3)) = *(*int32)(unsafe.Pointer(v3)) + 1
				**(**uintptr)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblCol + uintptr(v2)*4)) = zCopy
			} else {
				if 0 == Xsqlite3_stricmp(tls, __ccgo_ts+31070, zName) {
					bRbuRowid = int32(1)
				}
			}
			goto _1
		_1:
			;
			i = i + 1
		}
		Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp)))
		**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
		if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && libc.BoolInt32((*Tsqlite3rbu)(unsafe.Pointer(p)).FzTarget == uintptr(0)) == 0 && bRbuRowid != libc.BoolInt32((*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_VTAB) || (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_NONE)) {
			(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = int32(SQLITE_ERROR)
			if bRbuRowid != 0 {
				v3 = __ccgo_ts + 31080
			} else {
				v3 = __ccgo_ts + 31093
			}
			(*Tsqlite3rbu)(unsafe.Pointer(p)).FzErrmsg = Xsqlite3_mprintf(tls, __ccgo_ts+31102, libc.VaList(bp+16, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzDataTbl, v3))
		}
		/* Check that all non-HIDDEN columns in the destination table are also
		 ** present in the input table. Populate the abTblPk[], azTblType[] and
		 ** aiTblOrder[] arrays at the same time.  */
		if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
			(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, bp, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+31131, libc.VaList(bp+16, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzTbl)))
		}
		for (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) {
			zName1 = Xsqlite3_column_text(tls, **(**uintptr)(__ccgo_up(bp)), int32(1))
			if zName1 == uintptr(0) {
				break
			} /* An OOM - finalize() below returns S_NOMEM */
			i = iOrder
			for {
				if !(i < (*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol) {
					break
				}
				if 0 == libc.Xstrcmp(tls, zName1, **(**uintptr)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblCol + uintptr(i)*4))) {
					break
				}
				goto _5
			_5:
				;
				i = i + 1
			}
			if i == (*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol {
				(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = int32(SQLITE_ERROR)
				(*Tsqlite3rbu)(unsafe.Pointer(p)).FzErrmsg = Xsqlite3_mprintf(tls, __ccgo_ts+31153, libc.VaList(bp+16, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzDataTbl, zName1))
			} else {
				iPk = Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), int32(5))
				bNotNull = Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), int32(3))
				zType = Xsqlite3_column_text(tls, **(**uintptr)(__ccgo_up(bp)), int32(2))
				if i != iOrder {
					t = **(**int32)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FaiSrcOrder + uintptr(i)*4))
					**(**int32)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FaiSrcOrder + uintptr(i)*4)) = **(**int32)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FaiSrcOrder + uintptr(iOrder)*4))
					**(**int32)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FaiSrcOrder + uintptr(iOrder)*4)) = t
					t1 = **(**uintptr)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblCol + uintptr(i)*4))
					**(**uintptr)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblCol + uintptr(i)*4)) = **(**uintptr)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblCol + uintptr(iOrder)*4))
					**(**uintptr)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblCol + uintptr(iOrder)*4)) = t1
				}
				**(**uintptr)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblType + uintptr(iOrder)*4)) = _rbuStrndup(tls, zType, p+32)
				**(**Tu8)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FabTblPk + uintptr(iOrder))) = libc.Uint8FromInt32(iPk)
				**(**Tu8)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FabNotNull + uintptr(iOrder))) = libc.BoolUint8(libc.Uint8FromInt32(bNotNull) != 0 || iPk != 0)
				iOrder = iOrder + 1
			}
		}
		_rbuFinalize(tls, p, **(**uintptr)(__ccgo_up(bp)))
		_rbuObjIterCacheIndexedCols(tls, p, pIter)
	}
	return (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc
}

// C documentation
//
//	/*
//	** Initialize the iterator structure passed as the second argument.
//	**
//	** If no error occurs, SQLITE_OK is returned and the iterator is left
//	** pointing to the first entry. Otherwise, an error code and message is
//	** left in the RBU handle passed as the first argument. A copy of the
//	** error code is returned.
//	*/
func _rbuObjIterFirst(tls *libc.TLS, p uintptr, pIter uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var rc int32
	var v1 uintptr
	_, _ = rc, v1
	libc.Xmemset(tls, pIter, 0, uint32(108))
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).FzTarget == uintptr(0) {
		v1 = __ccgo_ts + 30461
	} else {
		v1 = __ccgo_ts + 1702
	}
	rc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbRbu, pIter, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+30502, libc.VaList(bp+8, v1)))
	if rc == SQLITE_OK {
		rc = _prepareAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, pIter+4, p+36, __ccgo_ts+30652)
	}
	(*TRbuObjIter)(unsafe.Pointer(pIter)).FbCleanup = int32(1)
	(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = rc
	return _rbuObjIterNext(tls, p, pIter)
}

// C documentation
//
//	/*
//	** This function constructs and returns a pointer to a nul-terminated
//	** string containing some SQL clause or list based on one or more of the
//	** column names currently stored in the pIter->azTblCol[] array.
//	*/
func _rbuObjIterGetCollist(tls *libc.TLS, p uintptr, pIter uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var i int32
	var z, zList, zSep uintptr
	_, _, _, _ = i, z, zList, zSep
	zList = uintptr(0)
	zSep = __ccgo_ts + 1702
	i = 0
	for {
		if !(i < (*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol) {
			break
		}
		z = **(**uintptr)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblCol + uintptr(i)*4))
		zList = _rbuMPrintf(tls, p, __ccgo_ts+31180, libc.VaList(bp+8, zList, zSep, z))
		zSep = __ccgo_ts + 16216
		goto _1
	_1:
		;
		i = i + 1
	}
	return zList
}

// C documentation
//
//	/*
//	** This function is used to create a SELECT list (the list of SQL
//	** expressions that follows a SELECT keyword) for a SELECT statement
//	** used to read from an data_xxx or rbu_tmp_xxx table while updating the
//	** index object currently indicated by the iterator object passed as the
//	** second argument. A "PRAGMA index_xinfo = <idxname>" statement is used
//	** to obtain the required information.
//	**
//	** If the index is of the following form:
//	**
//	**   CREATE INDEX i1 ON t1(c, b COLLATE nocase);
//	**
//	** and "t1" is a table with an explicit INTEGER PRIMARY KEY column
//	** "ipk", the returned string is:
//	**
//	**   "`c` COLLATE 'BINARY', `b` COLLATE 'NOCASE', `ipk` COLLATE 'BINARY'"
//	**
//	** As well as the returned string, three other malloc'd strings are
//	** returned via output parameters. As follows:
//	**
//	**   pzImposterCols: ...
//	**   pzImposterPk: ...
//	**   pzWhere: ...
//	*/
func _rbuObjIterGetIndexCols(tls *libc.TLS, p uintptr, pIter uintptr, pzImposterCols uintptr, pzImposterPk uintptr, pzWhere uintptr, pnBind uintptr) (r uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var bDesc, i, iCid, iSeq, nBind, rc, rc2 int32
	var zAnd, zCol, zCollate, zCom, zImpCols, zImpPK, zOrder, zRet, zType, zWhere, v2 uintptr
	var _ /* pXInfo at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bDesc, i, iCid, iSeq, nBind, rc, rc2, zAnd, zCol, zCollate, zCom, zImpCols, zImpPK, zOrder, zRet, zType, zWhere, v2
	rc = (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc /* sqlite3_finalize() return code */
	zRet = uintptr(0)                          /* String to return */
	zImpCols = uintptr(0)                      /* String to return via *pzImposterCols */
	zImpPK = uintptr(0)                        /* String to return via *pzImposterPK */
	zWhere = uintptr(0)                        /* String to return via *pzWhere */
	nBind = 0                                  /* Value to return via *pnBind */
	zCom = __ccgo_ts + 1702                    /* Set to ", " later on */
	zAnd = __ccgo_ts + 1702                    /* Set to " AND " later on */
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)  /* PRAGMA index_xinfo = ? */
	if rc == SQLITE_OK {
		rc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, bp, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+31017, libc.VaList(bp+16, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzIdx)))
	}
	for rc == SQLITE_OK && int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) {
		iCid = Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), int32(1))
		bDesc = Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), int32(3))
		zCollate = Xsqlite3_column_text(tls, **(**uintptr)(__ccgo_up(bp)), int32(4))
		zCol = uintptr(0)
		if iCid == -int32(2) {
			iSeq = Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), 0)
			zRet = Xsqlite3_mprintf(tls, __ccgo_ts+31499, libc.VaList(bp+16, zRet, zCom, (**(**TRbuSpan)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FaIdxCol + uintptr(iSeq)*8))).FnSpan, (**(**TRbuSpan)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FaIdxCol + uintptr(iSeq)*8))).FzSpan, zCollate))
			zType = __ccgo_ts + 1702
		} else {
			if iCid < 0 {
				/* An integer primary key. If the table has an explicit IPK, use
				 ** its name. Otherwise, use "rbu_rowid".  */
				if (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_IPK) {
					i = 0
					for {
						if !(libc.Int32FromUint8(**(**Tu8)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FabTblPk + uintptr(i)))) == 0) {
							break
						}
						goto _1
					_1:
						;
						i = i + 1
					}
					zCol = **(**uintptr)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblCol + uintptr(i)*4))
				} else {
					if (*Tsqlite3rbu)(unsafe.Pointer(p)).FzTarget == uintptr(0) {
						zCol = __ccgo_ts + 31340
					} else {
						zCol = __ccgo_ts + 31070
					}
				}
				zType = __ccgo_ts + 1176
			} else {
				zCol = **(**uintptr)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblCol + uintptr(iCid)*4))
				zType = **(**uintptr)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblType + uintptr(iCid)*4))
			}
			zRet = Xsqlite3_mprintf(tls, __ccgo_ts+31521, libc.VaList(bp+16, zRet, zCom, zCol, zCollate))
		}
		if (*TRbuObjIter)(unsafe.Pointer(pIter)).FbUnique == 0 || Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), int32(5)) != 0 {
			if bDesc != 0 {
				v2 = __ccgo_ts + 31257
			} else {
				v2 = __ccgo_ts + 1702
			}
			zOrder = v2
			zImpPK = Xsqlite3_mprintf(tls, __ccgo_ts+31541, libc.VaList(bp+16, zImpPK, zCom, nBind, zCol, zOrder))
		}
		zImpCols = Xsqlite3_mprintf(tls, __ccgo_ts+31562, libc.VaList(bp+16, zImpCols, zCom, nBind, zCol, zType, zCollate))
		zWhere = Xsqlite3_mprintf(tls, __ccgo_ts+31595, libc.VaList(bp+16, zWhere, zAnd, nBind, zCol))
		if zRet == uintptr(0) || zImpPK == uintptr(0) || zImpCols == uintptr(0) || zWhere == uintptr(0) {
			rc = int32(SQLITE_NOMEM)
		}
		zCom = __ccgo_ts + 16216
		zAnd = __ccgo_ts + 23627
		nBind = nBind + 1
	}
	rc2 = Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp)))
	if rc == SQLITE_OK {
		rc = rc2
	}
	if rc != SQLITE_OK {
		Xsqlite3_free(tls, zRet)
		Xsqlite3_free(tls, zImpCols)
		Xsqlite3_free(tls, zImpPK)
		Xsqlite3_free(tls, zWhere)
		zRet = uintptr(0)
		zImpCols = uintptr(0)
		zImpPK = uintptr(0)
		zWhere = uintptr(0)
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = rc
	}
	**(**uintptr)(__ccgo_up(pzImposterCols)) = zImpCols
	**(**uintptr)(__ccgo_up(pzImposterPk)) = zImpPK
	**(**uintptr)(__ccgo_up(pzWhere)) = zWhere
	**(**int32)(__ccgo_up(pnBind)) = nBind
	return zRet
}

// C documentation
//
//	/*
//	** Assuming the current table columns are "a", "b" and "c", and the zObj
//	** paramter is passed "old", return a string of the form:
//	**
//	**     "old.a, old.b, old.b"
//	**
//	** With the column names escaped.
//	**
//	** For tables with implicit rowids - RBU_PK_EXTERNAL and RBU_PK_NONE, append
//	** the text ", old._rowid_" to the returned value.
//	*/
func _rbuObjIterGetOldlist(tls *libc.TLS, p uintptr, pIter uintptr, zObj uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var i int32
	var zCol, zList, zS uintptr
	_, _, _, _ = i, zCol, zList, zS
	zList = uintptr(0)
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && (*TRbuObjIter)(unsafe.Pointer(pIter)).FabIndexed != 0 {
		zS = __ccgo_ts + 1702
		i = 0
		for {
			if !(i < (*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol) {
				break
			}
			if **(**Tu8)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FabIndexed + uintptr(i))) != 0 {
				zCol = **(**uintptr)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblCol + uintptr(i)*4))
				zList = Xsqlite3_mprintf(tls, __ccgo_ts+31619, libc.VaList(bp+8, zList, zS, zObj, zCol))
			} else {
				zList = Xsqlite3_mprintf(tls, __ccgo_ts+31631, libc.VaList(bp+8, zList, zS))
			}
			zS = __ccgo_ts + 16216
			if zList == uintptr(0) {
				(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = int32(SQLITE_NOMEM)
				break
			}
			goto _1
		_1:
			;
			i = i + 1
		}
		/* For a table with implicit rowids, append "old._rowid_" to the list. */
		if (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_EXTERNAL) || (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_NONE) {
			zList = _rbuMPrintf(tls, p, __ccgo_ts+31640, libc.VaList(bp+8, zList, zObj))
		}
	}
	return zList
}

// C documentation
//
//	/*
//	** Return a comma separated list of the quoted PRIMARY KEY column names,
//	** in order, for the current table. Before each column name, add the text
//	** zPre. After each column name, add the zPost text. Use zSeparator as
//	** the separator text (usually ", ").
//	*/
func _rbuObjIterGetPkList(tls *libc.TLS, p uintptr, pIter uintptr, zPre uintptr, zSeparator uintptr, zPost uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var i, iPk int32
	var zCol, zRet, zSep uintptr
	_, _, _, _, _ = i, iPk, zCol, zRet, zSep
	iPk = int32(1)
	zRet = uintptr(0)
	zSep = __ccgo_ts + 1702
	for int32(1) != 0 {
		i = 0
		for {
			if !(i < (*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol) {
				break
			}
			if libc.Int32FromUint8(**(**Tu8)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FabTblPk + uintptr(i)))) == iPk {
				zCol = **(**uintptr)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblCol + uintptr(i)*4))
				zRet = _rbuMPrintf(tls, p, __ccgo_ts+31189, libc.VaList(bp+8, zRet, zSep, zPre, zCol, zPost))
				zSep = zSeparator
				break
			}
			goto _1
		_1:
			;
			i = i + 1
		}
		if i == (*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol {
			break
		}
		iPk = iPk + 1
	}
	return zRet
}

// C documentation
//
//	/*
//	** Return an expression that can be used in a WHERE clause to match the
//	** primary key of the current table. For example, if the table is:
//	**
//	**   CREATE TABLE t1(a, b, c, PRIMARY KEY(b, c));
//	**
//	** Return the string:
//	**
//	**   "b = ?1 AND c = ?2"
//	*/
func _rbuObjIterGetWhere(tls *libc.TLS, p uintptr, pIter uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var i, i1 int32
	var zCol, zList, zSep, zSep1 uintptr
	_, _, _, _, _, _ = i, i1, zCol, zList, zSep, zSep1
	zList = uintptr(0)
	if (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_VTAB) || (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_NONE) {
		zList = _rbuMPrintf(tls, p, __ccgo_ts+31655, libc.VaList(bp+8, (*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol+int32(1)))
	} else {
		if (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_EXTERNAL) {
			zSep = __ccgo_ts + 1702
			i = 0
			for {
				if !(i < (*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol) {
					break
				}
				if **(**Tu8)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FabTblPk + uintptr(i))) != 0 {
					zList = _rbuMPrintf(tls, p, __ccgo_ts+31669, libc.VaList(bp+8, zList, zSep, i, i+int32(1)))
					zSep = __ccgo_ts + 23627
				}
				goto _1
			_1:
				;
				i = i + 1
			}
			zList = _rbuMPrintf(tls, p, __ccgo_ts+31681, libc.VaList(bp+8, zList))
		} else {
			zSep1 = __ccgo_ts + 1702
			i1 = 0
			for {
				if !(i1 < (*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol) {
					break
				}
				if **(**Tu8)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FabTblPk + uintptr(i1))) != 0 {
					zCol = **(**uintptr)(__ccgo_up((*TRbuObjIter)(unsafe.Pointer(pIter)).FazTblCol + uintptr(i1)*4))
					zList = _rbuMPrintf(tls, p, __ccgo_ts+31731, libc.VaList(bp+8, zList, zSep1, zCol, i1+int32(1)))
					zSep1 = __ccgo_ts + 23627
				}
				goto _2
			_2:
				;
				i1 = i1 + 1
			}
		}
	}
	return zList
}

// C documentation
//
//	/*
//	** Advance the iterator to the next position.
//	**
//	** If no error occurs, SQLITE_OK is returned and the iterator is left
//	** pointing to the next entry. Otherwise, an error code and message is
//	** left in the RBU handle passed as the first argument. A copy of the
//	** error code is returned.
//	*/
func _rbuObjIterNext(tls *libc.TLS, p uintptr, pIter uintptr) (r int32) {
	var pIdx uintptr
	var rc, v1 int32
	_, _, _ = pIdx, rc, v1
	rc = (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc
	if rc == SQLITE_OK {
		/* Free any SQLite statements used while processing the previous object */
		_rbuObjIterClearStatements(tls, pIter)
		if (*TRbuObjIter)(unsafe.Pointer(pIter)).FzIdx == uintptr(0) {
			rc = Xsqlite3_exec(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+30290, uintptr(0), uintptr(0), p+36)
		}
		if rc == SQLITE_OK {
			if (*TRbuObjIter)(unsafe.Pointer(pIter)).FbCleanup != 0 {
				_rbuObjIterFreeCols(tls, pIter)
				(*TRbuObjIter)(unsafe.Pointer(pIter)).FbCleanup = 0
				rc = Xsqlite3_step(tls, (*TRbuObjIter)(unsafe.Pointer(pIter)).FpTblIter)
				if rc != int32(SQLITE_ROW) {
					rc = _resetAndCollectError(tls, (*TRbuObjIter)(unsafe.Pointer(pIter)).FpTblIter, p+36)
					(*TRbuObjIter)(unsafe.Pointer(pIter)).FzTbl = uintptr(0)
					(*TRbuObjIter)(unsafe.Pointer(pIter)).FzDataTbl = uintptr(0)
				} else {
					(*TRbuObjIter)(unsafe.Pointer(pIter)).FzTbl = Xsqlite3_column_text(tls, (*TRbuObjIter)(unsafe.Pointer(pIter)).FpTblIter, 0)
					(*TRbuObjIter)(unsafe.Pointer(pIter)).FzDataTbl = Xsqlite3_column_text(tls, (*TRbuObjIter)(unsafe.Pointer(pIter)).FpTblIter, int32(1))
					if (*TRbuObjIter)(unsafe.Pointer(pIter)).FzDataTbl != 0 && (*TRbuObjIter)(unsafe.Pointer(pIter)).FzTbl != 0 {
						v1 = SQLITE_OK
					} else {
						v1 = int32(SQLITE_NOMEM)
					}
					rc = v1
				}
			} else {
				if (*TRbuObjIter)(unsafe.Pointer(pIter)).FzIdx == uintptr(0) {
					pIdx = (*TRbuObjIter)(unsafe.Pointer(pIter)).FpIdxIter
					rc = Xsqlite3_bind_text(tls, pIdx, int32(1), (*TRbuObjIter)(unsafe.Pointer(pIter)).FzTbl, -int32(1), libc.UintptrFromInt32(0))
				}
				if rc == SQLITE_OK {
					rc = Xsqlite3_step(tls, (*TRbuObjIter)(unsafe.Pointer(pIter)).FpIdxIter)
					if rc != int32(SQLITE_ROW) {
						rc = _resetAndCollectError(tls, (*TRbuObjIter)(unsafe.Pointer(pIter)).FpIdxIter, p+36)
						(*TRbuObjIter)(unsafe.Pointer(pIter)).FbCleanup = int32(1)
						(*TRbuObjIter)(unsafe.Pointer(pIter)).FzIdx = uintptr(0)
					} else {
						(*TRbuObjIter)(unsafe.Pointer(pIter)).FzIdx = Xsqlite3_column_text(tls, (*TRbuObjIter)(unsafe.Pointer(pIter)).FpIdxIter, 0)
						(*TRbuObjIter)(unsafe.Pointer(pIter)).FiTnum = Xsqlite3_column_int(tls, (*TRbuObjIter)(unsafe.Pointer(pIter)).FpIdxIter, int32(1))
						(*TRbuObjIter)(unsafe.Pointer(pIter)).FbUnique = Xsqlite3_column_int(tls, (*TRbuObjIter)(unsafe.Pointer(pIter)).FpIdxIter, int32(2))
						if (*TRbuObjIter)(unsafe.Pointer(pIter)).FzIdx != 0 {
							v1 = SQLITE_OK
						} else {
							v1 = int32(SQLITE_NOMEM)
						}
						rc = v1
					}
				}
			}
		}
	}
	if rc != SQLITE_OK {
		_rbuObjIterFinalize(tls, pIter)
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = rc
	}
	return rc
}

// C documentation
//
//	/*
//	** Ensure that the SQLite statement handles required to update the
//	** target database object currently indicated by the iterator passed
//	** as the second argument are available.
//	*/
func _rbuObjIterPrepareAll(tls *libc.TLS, p uintptr, pIter uintptr, nOffset int32) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112)
	var bRbuRowid, tnum int32
	var pz, zBind, zBindings, zCollist, zIdx, zLimit, zNewlist, zOldlist, zOrder, zPart, zRbuRowid, zRbuRowid1, zSql, zStart, zStart1, zTbl, zTbl1, zWhere1, zWrite, v1, v2, v3 uintptr
	var _ /* nBind at bp+12 */ int32
	var _ /* zImposterCols at bp+0 */ uintptr
	var _ /* zImposterPK at bp+4 */ uintptr
	var _ /* zWhere at bp+8 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bRbuRowid, pz, tnum, zBind, zBindings, zCollist, zIdx, zLimit, zNewlist, zOldlist, zOrder, zPart, zRbuRowid, zRbuRowid1, zSql, zStart, zStart1, zTbl, zTbl1, zWhere1, zWrite, v1, v2, v3
	if (*TRbuObjIter)(unsafe.Pointer(pIter)).FpSelect == uintptr(0) && _rbuObjIterCacheTableInfo(tls, p, pIter) == SQLITE_OK {
		tnum = (*TRbuObjIter)(unsafe.Pointer(pIter)).FiTnum
		zCollist = uintptr(0) /* List of indexed columns */
		pz = p + 36
		zIdx = (*TRbuObjIter)(unsafe.Pointer(pIter)).FzIdx
		zLimit = uintptr(0)
		if nOffset != 0 {
			zLimit = Xsqlite3_mprintf(tls, __ccgo_ts+32251, libc.VaList(bp+24, nOffset))
			if !(zLimit != 0) {
				(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = int32(SQLITE_NOMEM)
			}
		}
		if zIdx != 0 {
			zTbl = (*TRbuObjIter)(unsafe.Pointer(pIter)).FzTbl
			**(**uintptr)(__ccgo_up(bp)) = uintptr(0)     /* Columns for imposter table */
			**(**uintptr)(__ccgo_up(bp + 4)) = uintptr(0) /* Primary key declaration for imposter */
			**(**uintptr)(__ccgo_up(bp + 8)) = uintptr(0) /* WHERE clause on PK columns */
			zBind = uintptr(0)
			zPart = uintptr(0)
			**(**int32)(__ccgo_up(bp + 12)) = 0
			zPart = _rbuObjIterGetIndexWhere(tls, p, pIter)
			zCollist = _rbuObjIterGetIndexCols(tls, p, pIter, bp, bp+4, bp+8, bp+12)
			zBind = _rbuObjIterGetBindlist(tls, p, **(**int32)(__ccgo_up(bp + 12)))
			/* Create the imposter table used to write to this index. */
			Xsqlite3_test_control(tls, int32(SQLITE_TESTCTRL_IMPOSTER), libc.VaList(bp+24, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+6818, 0, int32(1)))
			Xsqlite3_test_control(tls, int32(SQLITE_TESTCTRL_IMPOSTER), libc.VaList(bp+24, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+6818, int32(1), tnum))
			_rbuMPrintfExec(tls, p, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+32271, libc.VaList(bp+24, zTbl, **(**uintptr)(__ccgo_up(bp)), **(**uintptr)(__ccgo_up(bp + 4))))
			Xsqlite3_test_control(tls, int32(SQLITE_TESTCTRL_IMPOSTER), libc.VaList(bp+24, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+6818, 0, 0))
			/* Create the statement to insert index entries */
			(*TRbuObjIter)(unsafe.Pointer(pIter)).FnCol = **(**int32)(__ccgo_up(bp + 12))
			if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
				(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, pIter+80, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+32336, libc.VaList(bp+24, zTbl, zBind)))
			}
			/* And to delete index entries */
			if libc.BoolInt32((*Tsqlite3rbu)(unsafe.Pointer(p)).FzTarget == uintptr(0)) == 0 && (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
				(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, pIter+84, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+32372, libc.VaList(bp+24, zTbl, **(**uintptr)(__ccgo_up(bp + 8)))))
			}
			/* Create the SELECT statement to read keys in sorted order */
			if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
				if (*Tsqlite3rbu)(unsafe.Pointer(p)).FzTarget == uintptr(0) {
					zStart = uintptr(0)
					if nOffset != 0 {
						zStart = _rbuVacuumIndexStart(tls, p, pIter)
						if zStart != 0 {
							Xsqlite3_free(tls, zLimit)
							zLimit = uintptr(0)
						}
					}
					if zStart != 0 {
						if zPart != 0 {
							v2 = __ccgo_ts + 32406
						} else {
							v2 = __ccgo_ts + 32410
						}
						v1 = v2
					} else {
						v1 = __ccgo_ts + 1702
					}
					zSql = Xsqlite3_mprintf(tls, __ccgo_ts+32416, libc.VaList(bp+24, zCollist, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzDataTbl, zPart, v1, zStart, zCollist, zLimit))
					Xsqlite3_free(tls, zStart)
				} else {
					if (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_EXTERNAL) || (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_NONE) {
						zSql = Xsqlite3_mprintf(tls, __ccgo_ts+32477, libc.VaList(bp+24, zCollist, p+24, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzDataTbl, zPart, zCollist, zLimit))
					} else {
						if zPart != 0 {
							v1 = __ccgo_ts + 32406
						} else {
							v1 = __ccgo_ts + 32410
						}
						zSql = Xsqlite3_mprintf(tls, __ccgo_ts+32538, libc.VaList(bp+24, zCollist, p+24, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzDataTbl, zPart, zCollist, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzDataTbl, zPart, v1, zCollist, zLimit))
					}
				}
				if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
					(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbRbu, pIter+76, pz, zSql)
				} else {
					Xsqlite3_free(tls, zSql)
				}
			}
			Xsqlite3_free(tls, **(**uintptr)(__ccgo_up(bp)))
			Xsqlite3_free(tls, **(**uintptr)(__ccgo_up(bp + 4)))
			Xsqlite3_free(tls, **(**uintptr)(__ccgo_up(bp + 8)))
			Xsqlite3_free(tls, zBind)
			Xsqlite3_free(tls, zPart)
		} else {
			bRbuRowid = libc.BoolInt32((*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_VTAB) || (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_NONE) || (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_EXTERNAL) && (*Tsqlite3rbu)(unsafe.Pointer(p)).FzTarget == uintptr(0))
			zTbl1 = (*TRbuObjIter)(unsafe.Pointer(pIter)).FzTbl /* Imposter table name */
			zBindings = _rbuObjIterGetBindlist(tls, p, (*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol+bRbuRowid)
			zWhere1 = _rbuObjIterGetWhere(tls, p, pIter)
			zOldlist = _rbuObjIterGetOldlist(tls, p, pIter, __ccgo_ts+6829)
			zNewlist = _rbuObjIterGetOldlist(tls, p, pIter, __ccgo_ts+6825)
			zCollist = _rbuObjIterGetCollist(tls, p, pIter)
			(*TRbuObjIter)(unsafe.Pointer(pIter)).FnCol = (*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol
			/* Create the imposter table or tables (if required). */
			_rbuCreateImposterTable(tls, p, pIter)
			_rbuCreateImposterTable2(tls, p, pIter)
			if (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_VTAB) {
				v1 = __ccgo_ts + 1702
			} else {
				v1 = __ccgo_ts + 32697
			}
			zWrite = v1
			/* Create the INSERT statement to write to the target PK b-tree */
			if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
				if bRbuRowid != 0 {
					v1 = __ccgo_ts + 32706
				} else {
					v1 = __ccgo_ts + 1702
				}
				(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, pIter+80, pz, Xsqlite3_mprintf(tls, __ccgo_ts+32716, libc.VaList(bp+24, zWrite, zTbl1, zCollist, v1, zBindings)))
			}
			/* Create the DELETE statement to write to the target PK b-tree.
			 ** Because it only performs INSERT operations, this is not required for
			 ** an rbu vacuum handle.  */
			if libc.BoolInt32((*Tsqlite3rbu)(unsafe.Pointer(p)).FzTarget == uintptr(0)) == 0 && (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
				(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, pIter+84, pz, Xsqlite3_mprintf(tls, __ccgo_ts+32752, libc.VaList(bp+24, zWrite, zTbl1, zWhere1)))
			}
			if libc.BoolInt32((*Tsqlite3rbu)(unsafe.Pointer(p)).FzTarget == uintptr(0)) == 0 && (*TRbuObjIter)(unsafe.Pointer(pIter)).FabIndexed != 0 {
				zRbuRowid = __ccgo_ts + 1702
				if (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_EXTERNAL) || (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_NONE) {
					zRbuRowid = __ccgo_ts + 32780
				}
				/* Create the rbu_tmp_xxx table and the triggers to populate it. */
				if (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_EXTERNAL) {
					v1 = __ccgo_ts + 32792
				} else {
					v1 = __ccgo_ts + 1702
				}
				_rbuMPrintfExec(tls, p, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbRbu, __ccgo_ts+32809, libc.VaList(bp+24, p+24, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzDataTbl, v1, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzDataTbl))
				_rbuMPrintfExec(tls, p, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+32885, libc.VaList(bp+24, zWrite, zTbl1, zOldlist, zWrite, zTbl1, zOldlist, zWrite, zTbl1, zNewlist))
				if (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_EXTERNAL) || (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_NONE) {
					_rbuMPrintfExec(tls, p, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, __ccgo_ts+33184, libc.VaList(bp+24, zWrite, zTbl1, zNewlist))
				}
				_rbuObjIterPrepareTmpInsert(tls, p, pIter, zCollist, zRbuRowid)
			}
			/* Create the SELECT statement to read keys from data_xxx */
			if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
				zRbuRowid1 = __ccgo_ts + 1702
				zStart1 = uintptr(0)
				zOrder = uintptr(0)
				if bRbuRowid != 0 {
					if (*Tsqlite3rbu)(unsafe.Pointer(p)).FzTarget == uintptr(0) {
						v1 = __ccgo_ts + 33283
					} else {
						v1 = __ccgo_ts + 33293
					}
					zRbuRowid1 = v1
				}
				if (*Tsqlite3rbu)(unsafe.Pointer(p)).FzTarget == uintptr(0) {
					if nOffset != 0 {
						zStart1 = _rbuVacuumTableStart(tls, p, pIter, bRbuRowid, zWrite)
						if zStart1 != 0 {
							Xsqlite3_free(tls, zLimit)
							zLimit = uintptr(0)
						}
					}
					if bRbuRowid != 0 {
						zOrder = _rbuMPrintf(tls, p, __ccgo_ts+31340, 0)
					} else {
						zOrder = _rbuObjIterGetPkList(tls, p, pIter, __ccgo_ts+1702, __ccgo_ts+16216, __ccgo_ts+1702)
					}
				}
				if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
					if (*Tsqlite3rbu)(unsafe.Pointer(p)).FzTarget == uintptr(0) {
						v1 = __ccgo_ts + 33304
					} else {
						v1 = __ccgo_ts + 1702
					}
					if zStart1 != 0 {
						v2 = zStart1
					} else {
						v2 = __ccgo_ts + 1702
					}
					if zOrder != 0 {
						v3 = __ccgo_ts + 24852
					} else {
						v3 = __ccgo_ts + 1702
					}
					(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbRbu, pIter+76, pz, Xsqlite3_mprintf(tls, __ccgo_ts+33310, libc.VaList(bp+24, zCollist, v1, zRbuRowid1, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzDataTbl, v2, v3, zOrder, zLimit)))
				}
				Xsqlite3_free(tls, zStart1)
				Xsqlite3_free(tls, zOrder)
			}
			Xsqlite3_free(tls, zWhere1)
			Xsqlite3_free(tls, zOldlist)
			Xsqlite3_free(tls, zNewlist)
			Xsqlite3_free(tls, zBindings)
		}
		Xsqlite3_free(tls, zCollist)
		Xsqlite3_free(tls, zLimit)
	}
	return (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc
}

// C documentation
//
//	/*
//	** Prepare a statement used to insert rows into the "rbu_tmp_xxx" table.
//	** Specifically a statement of the form:
//	**
//	**     INSERT INTO rbu_tmp_xxx VALUES(?, ?, ? ...);
//	**
//	** The number of bound variables is equal to the number of columns in
//	** the target table, plus one (for the rbu_control column), plus one more
//	** (for the rbu_rowid column) if the target table is an implicit IPK or
//	** virtual table.
//	*/
func _rbuObjIterPrepareTmpInsert(tls *libc.TLS, p uintptr, pIter uintptr, zCollist uintptr, zRbuRowid uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var bRbuRowid int32
	var zBind uintptr
	_, _ = bRbuRowid, zBind
	bRbuRowid = libc.BoolInt32((*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_EXTERNAL) || (*TRbuObjIter)(unsafe.Pointer(pIter)).FeType == int32(RBU_PK_NONE))
	zBind = _rbuObjIterGetBindlist(tls, p, (*TRbuObjIter)(unsafe.Pointer(pIter)).FnTblCol+int32(1)+bRbuRowid)
	if zBind != 0 {
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbRbu, pIter+88, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+32128, libc.VaList(bp+8, p+24, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzDataTbl, zCollist, zRbuRowid, zBind)))
	}
}

// C documentation
//
//	/*
//	** Update the contents of the rbu_state table within the rbu database. The
//	** value stored in the RBU_STATE_STAGE column is eStage. All other values
//	** are determined by inspecting the rbu handle passed as the first argument.
//	*/
func _rbuSaveState(tls *libc.TLS, p uintptr, eStage int32) {
	bp := tls.Alloc(192)
	defer tls.Free(192)
	var pFd, v1 uintptr
	var rc int32
	var _ /* pInsert at bp+0 */ uintptr
	_, _, _ = pFd, rc, v1
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK || (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == int32(SQLITE_DONE) {
		**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
		if (*Tsqlite3rbu)(unsafe.Pointer(p)).FzTarget == uintptr(0) {
			v1 = (*Tsqlite3rbu)(unsafe.Pointer(p)).FpRbuFd
		} else {
			v1 = (*Tsqlite3rbu)(unsafe.Pointer(p)).FpTargetFd
		}
		pFd = v1
		rc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbRbu, bp, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+33813, libc.VaList(bp+16, p+24, int32(RBU_STATE_STAGE), eStage, int32(RBU_STATE_TBL), (*Tsqlite3rbu)(unsafe.Pointer(p)).Fobjiter.FzTbl, int32(RBU_STATE_IDX), (*Tsqlite3rbu)(unsafe.Pointer(p)).Fobjiter.FzIdx, int32(RBU_STATE_ROW), (*Tsqlite3rbu)(unsafe.Pointer(p)).FnStep, int32(RBU_STATE_PROGRESS), (*Tsqlite3rbu)(unsafe.Pointer(p)).FnProgress, int32(RBU_STATE_CKPT), (*Tsqlite3rbu)(unsafe.Pointer(p)).FiWalCksum, int32(RBU_STATE_COOKIE), libc.Int64FromUint32((*Trbu_file)(unsafe.Pointer(pFd)).FiCookie), int32(RBU_STATE_OALSZ), (*Tsqlite3rbu)(unsafe.Pointer(p)).FiOalSz, int32(RBU_STATE_PHASEONESTEP), (*Tsqlite3rbu)(unsafe.Pointer(p)).FnPhaseOneStep, int32(RBU_STATE_DATATBL), (*Tsqlite3rbu)(unsafe.Pointer(p)).Fobjiter.FzDataTbl)))
		if rc == SQLITE_OK {
			Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp)))
			rc = Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp)))
		}
		if rc != SQLITE_OK {
			(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = rc
		}
	}
}

// C documentation
//
//	/* Determine the type of a table.
//	**
//	**   peType is of type (int*), a pointer to an output parameter of type
//	**   (int). This call sets the output parameter as follows, depending
//	**   on the type of the table specified by parameters dbName and zTbl.
//	**
//	**     RBU_PK_NOTABLE:       No such table.
//	**     RBU_PK_NONE:          Table has an implicit rowid.
//	**     RBU_PK_IPK:           Table has an explicit IPK column.
//	**     RBU_PK_EXTERNAL:      Table has an external PK index.
//	**     RBU_PK_WITHOUT_ROWID: Table is WITHOUT ROWID.
//	**     RBU_PK_VTAB:          Table is a virtual table.
//	**
//	**   Argument *piPk is also of type (int*), and also points to an output
//	**   parameter. Unless the table has an external primary key index
//	**   (i.e. unless *peType is set to 3), then *piPk is set to zero. Or,
//	**   if the table does have an external primary key index, then *piPk
//	**   is set to the root page number of the primary key index before
//	**   returning.
//	**
//	** ALGORITHM:
//	**
//	**   if( no entry exists in sqlite_schema ){
//	**     return RBU_PK_NOTABLE
//	**   }else if( sql for the entry starts with "CREATE VIRTUAL" ){
//	**     return RBU_PK_VTAB
//	**   }else if( "PRAGMA index_list()" for the table contains a "pk" index ){
//	**     if( the index that is the pk exists in sqlite_schema ){
//	**       *piPK = rootpage of that index.
//	**       return RBU_PK_EXTERNAL
//	**     }else{
//	**       return RBU_PK_WITHOUT_ROWID
//	**     }
//	**   }else if( "PRAGMA table_info()" lists one or more "pk" columns ){
//	**     return RBU_PK_IPK
//	**   }else{
//	**     return RBU_PK_NONE
//	**   }
//	*/
func _rbuTableType(tls *libc.TLS, p uintptr, zTab uintptr, peType uintptr, piTnum uintptr, piPk uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var i uint32
	var zIdx, zOrig uintptr
	var _ /* aStmt at bp+0 */ [4]uintptr
	_, _, _ = i, zIdx, zOrig
	/*
	 ** 0) SELECT count(*) FROM sqlite_schema where name=%Q AND IsVirtual(%Q)
	 ** 1) PRAGMA index_list = ?
	 ** 2) SELECT count(*) FROM sqlite_schema where name=%Q
	 ** 3) PRAGMA table_info = ?
	 */
	**(**[4]uintptr)(__ccgo_up(bp)) = [4]uintptr{}
	**(**int32)(__ccgo_up(peType)) = RBU_PK_NOTABLE
	**(**int32)(__ccgo_up(piPk)) = 0
	(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, bp, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+30777, libc.VaList(bp+24, zTab)))
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc != SQLITE_OK || Xsqlite3_step(tls, (**(**[4]uintptr)(__ccgo_up(bp)))[0]) != int32(SQLITE_ROW) {
		/* Either an error, or no such table. */
		goto rbuTableType_end
	}
	if Xsqlite3_column_int(tls, (**(**[4]uintptr)(__ccgo_up(bp)))[0], 0) != 0 {
		**(**int32)(__ccgo_up(peType)) = int32(RBU_PK_VTAB) /* virtual table */
		goto rbuTableType_end
	}
	**(**int32)(__ccgo_up(piTnum)) = Xsqlite3_column_int(tls, (**(**[4]uintptr)(__ccgo_up(bp)))[0], int32(1))
	(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, bp+1*4, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+30896, libc.VaList(bp+24, zTab)))
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc != 0 {
		goto rbuTableType_end
	}
	for Xsqlite3_step(tls, (**(**[4]uintptr)(__ccgo_up(bp)))[int32(1)]) == int32(SQLITE_ROW) {
		zOrig = Xsqlite3_column_text(tls, (**(**[4]uintptr)(__ccgo_up(bp)))[int32(1)], int32(3))
		zIdx = Xsqlite3_column_text(tls, (**(**[4]uintptr)(__ccgo_up(bp)))[int32(1)], int32(1))
		if zOrig != 0 && zIdx != 0 && libc.Int32FromUint8(**(**Tu8)(__ccgo_up(zOrig))) == int32('p') {
			(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, bp+2*4, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+30917, libc.VaList(bp+24, zIdx)))
			if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
				if Xsqlite3_step(tls, (**(**[4]uintptr)(__ccgo_up(bp)))[int32(2)]) == int32(SQLITE_ROW) {
					**(**int32)(__ccgo_up(piPk)) = Xsqlite3_column_int(tls, (**(**[4]uintptr)(__ccgo_up(bp)))[int32(2)], 0)
					**(**int32)(__ccgo_up(peType)) = int32(RBU_PK_EXTERNAL)
				} else {
					**(**int32)(__ccgo_up(peType)) = int32(RBU_PK_WITHOUT_ROWID)
				}
			}
			goto rbuTableType_end
		}
	}
	(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, bp+3*4, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+30968, libc.VaList(bp+24, zTab)))
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
		for Xsqlite3_step(tls, (**(**[4]uintptr)(__ccgo_up(bp)))[int32(3)]) == int32(SQLITE_ROW) {
			if Xsqlite3_column_int(tls, (**(**[4]uintptr)(__ccgo_up(bp)))[int32(3)], int32(5)) > 0 {
				**(**int32)(__ccgo_up(peType)) = int32(RBU_PK_IPK) /* explicit IPK column */
				goto rbuTableType_end
			}
		}
		**(**int32)(__ccgo_up(peType)) = int32(RBU_PK_NONE)
	}
	goto rbuTableType_end
rbuTableType_end:
	;
	i = uint32(0)
	for {
		if !(i < libc.Uint32FromInt64(16)/libc.Uint32FromInt64(4)) {
			break
		}
		_rbuFinalize(tls, p, (**(**[4]uintptr)(__ccgo_up(bp)))[i])
		goto _1
	_1:
		;
		i = i + 1
	}
}

// C documentation
//
//	/*
//	** This function is called as part of restarting an RBU vacuum within
//	** stage 1 of the process (while the *-oal file is being built) while
//	** updating a table (not an index). The table may be a rowid table or
//	** a WITHOUT ROWID table. It queries the target database to find the
//	** largest key that has already been written to the target table and
//	** constructs a WHERE clause that can be used to extract the remaining
//	** rows from the source table. For a rowid table, the WHERE clause
//	** is of the form:
//	**
//	**     "WHERE _rowid_ > ?"
//	**
//	** and for WITHOUT ROWID tables:
//	**
//	**     "WHERE (key1, key2) > (?, ?)"
//	**
//	** Instead of "?" placeholders, the actual WHERE clauses created by
//	** this function contain literal SQL values.
//	*/
func _rbuVacuumTableStart(tls *libc.TLS, p uintptr, pIter uintptr, bRowid int32, zWrite uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var iMax Tsqlite3_int64
	var zList, zOrder, zRet, zSelect, zVal uintptr
	var _ /* pMax at bp+0 */ uintptr
	_, _, _, _, _, _ = iMax, zList, zOrder, zRet, zSelect, zVal
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	zRet = uintptr(0)
	if bRowid != 0 {
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, bp, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+31202, libc.VaList(bp+16, zWrite, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzTbl)))
		if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) {
			iMax = Xsqlite3_column_int64(tls, **(**uintptr)(__ccgo_up(bp)), 0)
			zRet = _rbuMPrintf(tls, p, __ccgo_ts+31234, libc.VaList(bp+16, iMax))
		}
		_rbuFinalize(tls, p, **(**uintptr)(__ccgo_up(bp)))
	} else {
		zOrder = _rbuObjIterGetPkList(tls, p, pIter, __ccgo_ts+1702, __ccgo_ts+16216, __ccgo_ts+31257)
		zSelect = _rbuObjIterGetPkList(tls, p, pIter, __ccgo_ts+31263, __ccgo_ts+31270, __ccgo_ts+5259)
		zList = _rbuObjIterGetPkList(tls, p, pIter, __ccgo_ts+1702, __ccgo_ts+16216, __ccgo_ts+1702)
		if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
			(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, bp, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+31278, libc.VaList(bp+16, zSelect, zWrite, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzTbl, zOrder)))
			if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) {
				zVal = Xsqlite3_column_text(tls, **(**uintptr)(__ccgo_up(bp)), 0)
				zRet = _rbuMPrintf(tls, p, __ccgo_ts+31320, libc.VaList(bp+16, zList, zVal))
			}
			_rbuFinalize(tls, p, **(**uintptr)(__ccgo_up(bp)))
		}
		Xsqlite3_free(tls, zOrder)
		Xsqlite3_free(tls, zSelect)
		Xsqlite3_free(tls, zList)
	}
	return zRet
}

// C documentation
//
//	/*
//	** The iterator currently points to a table (not index) of type
//	** RBU_PK_WITHOUT_ROWID. This function creates the PRIMARY KEY
//	** declaration for the corresponding imposter table. For example,
//	** if the iterator points to a table created as:
//	**
//	**   CREATE TABLE t1(a, b, c, PRIMARY KEY(b, a DESC)) WITHOUT ROWID
//	**
//	** this function returns:
//	**
//	**   PRIMARY KEY("b", "a" DESC)
//	*/
func _rbuWithoutRowidPK(tls *libc.TLS, p uintptr, pIter uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var z, zCol, zDesc, zIdx, zOrig, zSep, v1 uintptr
	var _ /* pXInfo at bp+4 */ uintptr
	var _ /* pXList at bp+0 */ uintptr
	_, _, _, _, _, _, _ = z, zCol, zDesc, zIdx, zOrig, zSep, v1
	z = uintptr(0)
	if (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK {
		zSep = __ccgo_ts + 31837
		**(**uintptr)(__ccgo_up(bp)) = uintptr(0)     /* PRAGMA index_list = (pIter->zTbl) */
		**(**uintptr)(__ccgo_up(bp + 4)) = uintptr(0) /* PRAGMA index_xinfo = <pk-index> */
		(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, bp, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+30989, libc.VaList(bp+16, (*TRbuObjIter)(unsafe.Pointer(pIter)).FzTbl)))
		for (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) {
			zOrig = Xsqlite3_column_text(tls, **(**uintptr)(__ccgo_up(bp)), int32(3))
			if zOrig != 0 && libc.Xstrcmp(tls, zOrig, __ccgo_ts+17853) == 0 {
				zIdx = Xsqlite3_column_text(tls, **(**uintptr)(__ccgo_up(bp)), int32(1))
				if zIdx != 0 {
					(*Tsqlite3rbu)(unsafe.Pointer(p)).Frc = _prepareFreeAndCollectError(tls, (*Tsqlite3rbu)(unsafe.Pointer(p)).FdbMain, bp+4, p+36, Xsqlite3_mprintf(tls, __ccgo_ts+31017, libc.VaList(bp+16, zIdx)))
				}
				break
			}
		}
		_rbuFinalize(tls, p, **(**uintptr)(__ccgo_up(bp)))
		for (*Tsqlite3rbu)(unsafe.Pointer(p)).Frc == SQLITE_OK && int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp + 4))) {
			if Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp + 4)), int32(5)) != 0 {
				/* int iCid = sqlite3_column_int(pXInfo, 0); */
				zCol = Xsqlite3_column_text(tls, **(**uintptr)(__ccgo_up(bp + 4)), int32(2))
				if Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp + 4)), int32(3)) != 0 {
					v1 = __ccgo_ts + 31257
				} else {
					v1 = __ccgo_ts + 1702
				}
				zDesc = v1
				z = _rbuMPrintf(tls, p, __ccgo_ts+31850, libc.VaList(bp+16, z, zSep, zCol, zDesc))
				zSep = __ccgo_ts + 16216
			}
		}
		z = _rbuMPrintf(tls, p, __ccgo_ts+31861, libc.VaList(bp+16, z))
		_rbuFinalize(tls, p, **(**uintptr)(__ccgo_up(bp + 4)))
	}
	return z
}

// C documentation
//
//	/*
//	** SQL function:
//	**
//	**     sqlite_rename_column(SQL,TYPE,OBJ,DB,TABLE,COL,NEWNAME,QUOTE,TEMP)
//	**
//	**   0. zSql:     SQL statement to rewrite
//	**   1. type:     Type of object ("table", "view" etc.)
//	**   2. object:   Name of object
//	**   3. Database: Database name (e.g. "main")
//	**   4. Table:    Table name
//	**   5. iCol:     Index of column to rename
//	**   6. zNew:     New column name
//	**   7. bQuote:   Non-zero if the new column name should be quoted.
//	**   8. bTemp:    True if zSql comes from temp schema
//	**
//	** Do a column rename operation on the CREATE statement given in zSql.
//	** The iCol-th column (left-most is 0) of table zTable is renamed from zCol
//	** into zNew.  The name should be quoted if bQuote is true.
//	**
//	** This function is used internally by the ALTER TABLE RENAME COLUMN command.
//	** It is only accessible to SQL created using sqlite3NestedParse().  It is
//	** not reachable from ordinary SQL passed into sqlite3_prepare() unless the
//	** SQLITE_TESTCTRL_INTERNAL_FUNCTIONS test setting is enabled.
//	*/
func _renameColumnFunc(tls *libc.TLS, context uintptr, NotUsed int32, argv uintptr) {
	bp := tls.Alloc(336)
	defer tls.Free(336)
	var bFKOnly, bQuote, bTemp, i, iCol, rc, v1 int32
	var db, pExpr, pFKey, pIdx, pSelect, pStep, pTab, pTarget, pUpsertSet, zDb, zNew, zOld, zSql, zTable uintptr
	var xAuth Tsqlite3_xauth
	var _ /* sCtx at bp+0 */ TRenameCtx
	var _ /* sParse at bp+20 */ TParse
	var _ /* sWalker at bp+304 */ TWalker
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bFKOnly, bQuote, bTemp, db, i, iCol, pExpr, pFKey, pIdx, pSelect, pStep, pTab, pTarget, pUpsertSet, rc, xAuth, zDb, zNew, zOld, zSql, zTable, v1
	db = Xsqlite3_context_db_handle(tls, context)
	zSql = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv)))
	zDb = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv + 3*4)))
	zTable = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv + 4*4)))
	iCol = Xsqlite3_value_int(tls, **(**uintptr)(__ccgo_up(argv + 5*4)))
	zNew = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv + 6*4)))
	bQuote = Xsqlite3_value_int(tls, **(**uintptr)(__ccgo_up(argv + 7*4)))
	bTemp = Xsqlite3_value_int(tls, **(**uintptr)(__ccgo_up(argv + 8*4)))
	xAuth = (*Tsqlite3)(unsafe.Pointer(db)).FxAuth
	_ = NotUsed
	if zSql == uintptr(0) {
		return
	}
	if zTable == uintptr(0) {
		return
	}
	if zNew == uintptr(0) {
		return
	}
	if iCol < 0 {
		return
	}
	_sqlite3BtreeEnterAll(tls, db)
	pTab = _sqlite3FindTable(tls, db, zTable, zDb)
	if pTab == uintptr(0) || iCol >= int32((*TTable)(unsafe.Pointer(pTab)).FnCol) {
		_sqlite3BtreeLeaveAll(tls, db)
		return
	}
	zOld = (**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(iCol)*12))).FzCnName
	libc.Xmemset(tls, bp, 0, uint32(20))
	if iCol == int32((*TTable)(unsafe.Pointer(pTab)).FiPKey) {
		v1 = -int32(1)
	} else {
		v1 = iCol
	}
	(**(**TRenameCtx)(__ccgo_up(bp))).FiCol = v1
	(*Tsqlite3)(unsafe.Pointer(db)).FxAuth = uintptr(0)
	rc = _renameParseSql(tls, bp+20, zDb, db, zSql, bTemp)
	/* Find tokens that need to be replaced. */
	libc.Xmemset(tls, bp+304, 0, uint32(28))
	(**(**TWalker)(__ccgo_up(bp + 304))).FpParse = bp + 20
	(**(**TWalker)(__ccgo_up(bp + 304))).FxExprCallback = __ccgo_fp(_renameColumnExprCb)
	(**(**TWalker)(__ccgo_up(bp + 304))).FxSelectCallback = __ccgo_fp(_renameColumnSelectCb)
	*(*uintptr)(unsafe.Pointer(bp + 304 + 24)) = bp
	(**(**TRenameCtx)(__ccgo_up(bp))).FpTab = pTab
	if rc != SQLITE_OK {
		goto renameColumnFunc_done
	}
	if (**(**TParse)(__ccgo_up(bp + 20))).FpNewTable != 0 {
		if libc.Int32FromUint8((*TTable)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp + 20))).FpNewTable)).FeTabType) == int32(TABTYP_VIEW) {
			pSelect = (*(*struct {
				FpSelect uintptr
			})(unsafe.Pointer(&(*TTable)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp + 20))).FpNewTable)).Fu))).FpSelect
			**(**Tu32)(__ccgo_up(pSelect + 4)) &= ^libc.Uint32FromInt32(SF_View)
			(**(**TParse)(__ccgo_up(bp + 20))).Frc = SQLITE_OK
			_sqlite3SelectPrep(tls, bp+20, pSelect, uintptr(0))
			if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
				v1 = int32(SQLITE_NOMEM)
			} else {
				v1 = (**(**TParse)(__ccgo_up(bp + 20))).Frc
			}
			rc = v1
			if rc == SQLITE_OK {
				_sqlite3WalkSelect(tls, bp+304, pSelect)
			}
			if rc != SQLITE_OK {
				goto renameColumnFunc_done
			}
		} else {
			if libc.Int32FromUint8((*TTable)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp + 20))).FpNewTable)).FeTabType) == TABTYP_NORM {
				/* A regular table */
				bFKOnly = Xsqlite3_stricmp(tls, zTable, (*TTable)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp + 20))).FpNewTable)).FzName)
				(**(**TRenameCtx)(__ccgo_up(bp))).FpTab = (**(**TParse)(__ccgo_up(bp + 20))).FpNewTable
				if bFKOnly == 0 {
					if iCol < int32((*TTable)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp + 20))).FpNewTable)).FnCol) {
						_renameTokenFind(tls, bp+20, bp, (**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp + 20))).FpNewTable)).FaCol + uintptr(iCol)*12))).FzCnName)
					}
					if (**(**TRenameCtx)(__ccgo_up(bp))).FiCol < 0 {
						_renameTokenFind(tls, bp+20, bp, (**(**TParse)(__ccgo_up(bp + 20))).FpNewTable+32)
					}
					_sqlite3WalkExprList(tls, bp+304, (*TTable)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp + 20))).FpNewTable)).FpCheck)
					pIdx = (*TTable)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp + 20))).FpNewTable)).FpIndex
					for {
						if !(pIdx != 0) {
							break
						}
						_sqlite3WalkExprList(tls, bp+304, (*TIndex)(unsafe.Pointer(pIdx)).FaColExpr)
						goto _3
					_3:
						;
						pIdx = (*TIndex)(unsafe.Pointer(pIdx)).FpNext
					}
					pIdx = (**(**TParse)(__ccgo_up(bp + 20))).FpNewIndex
					for {
						if !(pIdx != 0) {
							break
						}
						_sqlite3WalkExprList(tls, bp+304, (*TIndex)(unsafe.Pointer(pIdx)).FaColExpr)
						goto _4
					_4:
						;
						pIdx = (*TIndex)(unsafe.Pointer(pIdx)).FpNext
					}
					i = 0
					for {
						if !(i < int32((*TTable)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp + 20))).FpNewTable)).FnCol)) {
							break
						}
						pExpr = _sqlite3ColumnExpr(tls, (**(**TParse)(__ccgo_up(bp + 20))).FpNewTable, (*TTable)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp + 20))).FpNewTable)).FaCol+uintptr(i)*12)
						_sqlite3WalkExpr(tls, bp+304, pExpr)
						goto _5
					_5:
						;
						i = i + 1
					}
				}
				pFKey = (*(*struct {
					FaddColOffset int32
					FpFKey        uintptr
					FpDfltList    uintptr
				})(unsafe.Pointer((**(**TParse)(__ccgo_up(bp + 20))).FpNewTable + 44))).FpFKey
				for {
					if !(pFKey != 0) {
						break
					}
					i = 0
					for {
						if !(i < (*TFKey)(unsafe.Pointer(pFKey)).FnCol) {
							break
						}
						if bFKOnly == 0 && (*(*TsColMap)(unsafe.Pointer(pFKey + 36 + uintptr(i)*8))).FiFrom == iCol {
							_renameTokenFind(tls, bp+20, bp, pFKey+36+uintptr(i)*8)
						}
						if 0 == Xsqlite3_stricmp(tls, (*TFKey)(unsafe.Pointer(pFKey)).FzTo, zTable) && 0 == Xsqlite3_stricmp(tls, (*(*TsColMap)(unsafe.Pointer(pFKey + 36 + uintptr(i)*8))).FzCol, zOld) {
							_renameTokenFind(tls, bp+20, bp, (*(*TsColMap)(unsafe.Pointer(pFKey + 36 + uintptr(i)*8))).FzCol)
						}
						goto _7
					_7:
						;
						i = i + 1
					}
					goto _6
				_6:
					;
					pFKey = (*TFKey)(unsafe.Pointer(pFKey)).FpNextFrom
				}
			}
		}
	} else {
		if (**(**TParse)(__ccgo_up(bp + 20))).FpNewIndex != 0 {
			_sqlite3WalkExprList(tls, bp+304, (*TIndex)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp + 20))).FpNewIndex)).FaColExpr)
			_sqlite3WalkExpr(tls, bp+304, (*TIndex)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp + 20))).FpNewIndex)).FpPartIdxWhere)
		} else {
			rc = _renameResolveTrigger(tls, bp+20)
			if rc != SQLITE_OK {
				goto renameColumnFunc_done
			}
			pStep = (*TTrigger)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp + 20))).FpNewTrigger)).Fstep_list
			for {
				if !(pStep != 0) {
					break
				}
				if (*TTriggerStep)(unsafe.Pointer(pStep)).FpSrc != 0 {
					pTarget = _sqlite3LocateTableItem(tls, bp+20, uint32(0), (*TTriggerStep)(unsafe.Pointer(pStep)).FpSrc+8)
					if pTarget == pTab {
						if (*TTriggerStep)(unsafe.Pointer(pStep)).FpUpsert != 0 {
							pUpsertSet = (*TUpsert)(unsafe.Pointer((*TTriggerStep)(unsafe.Pointer(pStep)).FpUpsert)).FpUpsertSet
							_renameColumnElistNames(tls, bp+20, bp, pUpsertSet, zOld)
						}
						_renameColumnIdlistNames(tls, bp+20, bp, (*TTriggerStep)(unsafe.Pointer(pStep)).FpIdList, zOld)
						_renameColumnElistNames(tls, bp+20, bp, (*TTriggerStep)(unsafe.Pointer(pStep)).FpExprList, zOld)
					}
				}
				goto _8
			_8:
				;
				pStep = (*TTriggerStep)(unsafe.Pointer(pStep)).FpNext
			}
			/* Find tokens to edit in UPDATE OF clause */
			if (**(**TParse)(__ccgo_up(bp + 20))).FpTriggerTab == pTab {
				_renameColumnIdlistNames(tls, bp+20, bp, (*TTrigger)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp + 20))).FpNewTrigger)).FpColumns, zOld)
			}
			/* Find tokens to edit in various expressions and selects */
			_renameWalkTrigger(tls, bp+304, (**(**TParse)(__ccgo_up(bp + 20))).FpNewTrigger)
		}
	}
	rc = _renameEditSql(tls, context, bp, zSql, zNew, bQuote)
	goto renameColumnFunc_done
renameColumnFunc_done:
	;
	if rc != SQLITE_OK {
		if rc == int32(SQLITE_ERROR) && _sqlite3WritableSchema(tls, db) != 0 {
			Xsqlite3_result_value(tls, context, **(**uintptr)(__ccgo_up(argv)))
		} else {
			if (**(**TParse)(__ccgo_up(bp + 20))).FzErrMsg != 0 {
				_renameColumnParseError(tls, context, __ccgo_ts+1702, **(**uintptr)(__ccgo_up(argv + 1*4)), **(**uintptr)(__ccgo_up(argv + 2*4)), bp+20)
			} else {
				Xsqlite3_result_error_code(tls, context, rc)
			}
		}
	}
	_renameParseCleanup(tls, bp+20)
	_renameTokenFree(tls, db, (**(**TRenameCtx)(__ccgo_up(bp))).FpList)
	(*Tsqlite3)(unsafe.Pointer(db)).FxAuth = xAuth
	_sqlite3BtreeLeaveAll(tls, db)
}

// C documentation
//
//	/*
//	** This C function implements an SQL user function that is used by SQL code
//	** generated by the ALTER TABLE ... RENAME command to modify the definition
//	** of any foreign key constraints that use the table being renamed as the
//	** parent table. It is passed three arguments:
//	**
//	**   0: The database containing the table being renamed.
//	**   1. type:     Type of object ("table", "view" etc.)
//	**   2. object:   Name of object
//	**   3: The complete text of the schema statement being modified,
//	**   4: The old name of the table being renamed, and
//	**   5: The new name of the table being renamed.
//	**   6: True if the schema statement comes from the temp db.
//	**
//	** It returns the new schema statement. For example:
//	**
//	** sqlite_rename_table('main', 'CREATE TABLE t1(a REFERENCES t2)','t2','t3',0)
//	**       -> 'CREATE TABLE t1(a REFERENCES t3)'
//	*/
func _renameTableFunc(tls *libc.TLS, context uintptr, NotUsed int32, argv uintptr) {
	bp := tls.Alloc(368)
	defer tls.Free(368)
	var bQuote, bTemp, i, isLegacy, rc int32
	var db, pFKey, pItem, pSelect, pStep, pTab, pTrigger, zDb, zInput, zNew, zOld uintptr
	var xAuth Tsqlite3_xauth
	var _ /* sCtx at bp+284 */ TRenameCtx
	var _ /* sNC at bp+332 */ TNameContext
	var _ /* sParse at bp+0 */ TParse
	var _ /* sWalker at bp+304 */ TWalker
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bQuote, bTemp, db, i, isLegacy, pFKey, pItem, pSelect, pStep, pTab, pTrigger, rc, xAuth, zDb, zInput, zNew, zOld
	db = Xsqlite3_context_db_handle(tls, context)
	zDb = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv)))
	zInput = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv + 3*4)))
	zOld = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv + 4*4)))
	zNew = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv + 5*4)))
	bTemp = Xsqlite3_value_int(tls, **(**uintptr)(__ccgo_up(argv + 6*4)))
	_ = NotUsed
	if zInput != 0 && zOld != 0 && zNew != 0 {
		bQuote = int32(1)
		xAuth = (*Tsqlite3)(unsafe.Pointer(db)).FxAuth
		(*Tsqlite3)(unsafe.Pointer(db)).FxAuth = uintptr(0)
		_sqlite3BtreeEnterAll(tls, db)
		libc.Xmemset(tls, bp+284, 0, uint32(20))
		(**(**TRenameCtx)(__ccgo_up(bp + 284))).FpTab = _sqlite3FindTable(tls, db, zOld, zDb)
		libc.Xmemset(tls, bp+304, 0, uint32(28))
		(**(**TWalker)(__ccgo_up(bp + 304))).FpParse = bp
		(**(**TWalker)(__ccgo_up(bp + 304))).FxExprCallback = __ccgo_fp(_renameTableExprCb)
		(**(**TWalker)(__ccgo_up(bp + 304))).FxSelectCallback = __ccgo_fp(_renameTableSelectCb)
		*(*uintptr)(unsafe.Pointer(bp + 304 + 24)) = bp + 284
		rc = _renameParseSql(tls, bp, zDb, db, zInput, bTemp)
		if rc == SQLITE_OK {
			isLegacy = libc.Int32FromUint64((*Tsqlite3)(unsafe.Pointer(db)).Fflags & libc.Uint64FromInt32(SQLITE_LegacyAlter))
			if (**(**TParse)(__ccgo_up(bp))).FpNewTable != 0 {
				pTab = (**(**TParse)(__ccgo_up(bp))).FpNewTable
				if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VIEW) {
					if isLegacy == 0 {
						pSelect = (*(*struct {
							FpSelect uintptr
						})(unsafe.Pointer(&(*TTable)(unsafe.Pointer(pTab)).Fu))).FpSelect
						libc.Xmemset(tls, bp+332, 0, uint32(36))
						(**(**TNameContext)(__ccgo_up(bp + 332))).FpParse = bp
						**(**Tu32)(__ccgo_up(pSelect + 4)) &= ^libc.Uint32FromInt32(SF_View)
						_sqlite3SelectPrep(tls, bp, (*(*struct {
							FpSelect uintptr
						})(unsafe.Pointer(&(*TTable)(unsafe.Pointer(pTab)).Fu))).FpSelect, bp+332)
						if (**(**TParse)(__ccgo_up(bp))).FnErr != 0 {
							rc = (**(**TParse)(__ccgo_up(bp))).Frc
						} else {
							_sqlite3WalkSelect(tls, bp+304, (*(*struct {
								FpSelect uintptr
							})(unsafe.Pointer(&(*TTable)(unsafe.Pointer(pTab)).Fu))).FpSelect)
						}
					}
				} else {
					/* Modify any FK definitions to point to the new table. */
					if (isLegacy == 0 || (*Tsqlite3)(unsafe.Pointer(db)).Fflags&uint64(SQLITE_ForeignKeys) != 0) && !(libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == libc.Int32FromInt32(TABTYP_VTAB)) {
						pFKey = (*(*struct {
							FaddColOffset int32
							FpFKey        uintptr
							FpDfltList    uintptr
						})(unsafe.Pointer(pTab + 44))).FpFKey
						for {
							if !(pFKey != 0) {
								break
							}
							if Xsqlite3_stricmp(tls, (*TFKey)(unsafe.Pointer(pFKey)).FzTo, zOld) == 0 {
								_renameTokenFind(tls, bp, bp+284, (*TFKey)(unsafe.Pointer(pFKey)).FzTo)
							}
							goto _1
						_1:
							;
							pFKey = (*TFKey)(unsafe.Pointer(pFKey)).FpNextFrom
						}
					}
					/* If this is the table being altered, fix any table refs in CHECK
					 ** expressions. Also update the name that appears right after the
					 ** "CREATE [VIRTUAL] TABLE" bit. */
					if Xsqlite3_stricmp(tls, zOld, (*TTable)(unsafe.Pointer(pTab)).FzName) == 0 {
						(**(**TRenameCtx)(__ccgo_up(bp + 284))).FpTab = pTab
						if isLegacy == 0 {
							_sqlite3WalkExprList(tls, bp+304, (*TTable)(unsafe.Pointer(pTab)).FpCheck)
						}
						_renameTokenFind(tls, bp, bp+284, (*TTable)(unsafe.Pointer(pTab)).FzName)
					}
				}
			} else {
				if (**(**TParse)(__ccgo_up(bp))).FpNewIndex != 0 {
					_renameTokenFind(tls, bp, bp+284, (*TIndex)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp))).FpNewIndex)).FzName)
					if isLegacy == 0 {
						_sqlite3WalkExpr(tls, bp+304, (*TIndex)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp))).FpNewIndex)).FpPartIdxWhere)
					}
				} else {
					pTrigger = (**(**TParse)(__ccgo_up(bp))).FpNewTrigger
					if 0 == Xsqlite3_stricmp(tls, (*TTrigger)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp))).FpNewTrigger)).Ftable, zOld) && (*TTable)(unsafe.Pointer((**(**TRenameCtx)(__ccgo_up(bp + 284))).FpTab)).FpSchema == (*TTrigger)(unsafe.Pointer(pTrigger)).FpTabSchema {
						_renameTokenFind(tls, bp, bp+284, (*TTrigger)(unsafe.Pointer((**(**TParse)(__ccgo_up(bp))).FpNewTrigger)).Ftable)
					}
					if isLegacy == 0 {
						rc = _renameResolveTrigger(tls, bp)
						if rc == SQLITE_OK {
							_renameWalkTrigger(tls, bp+304, pTrigger)
							pStep = (*TTrigger)(unsafe.Pointer(pTrigger)).Fstep_list
							for {
								if !(pStep != 0) {
									break
								}
								if (*TTriggerStep)(unsafe.Pointer(pStep)).FpSrc != 0 {
									i = 0
									for {
										if !(i < (*TSrcList)(unsafe.Pointer((*TTriggerStep)(unsafe.Pointer(pStep)).FpSrc)).FnSrc) {
											break
										}
										pItem = (*TTriggerStep)(unsafe.Pointer(pStep)).FpSrc + 8 + uintptr(i)*48
										if 0 == Xsqlite3_stricmp(tls, (*TSrcItem)(unsafe.Pointer(pItem)).FzName, zOld) {
											_renameTokenFind(tls, bp, bp+284, (*TSrcItem)(unsafe.Pointer(pItem)).FzName)
										}
										goto _3
									_3:
										;
										i = i + 1
									}
								}
								goto _2
							_2:
								;
								pStep = (*TTriggerStep)(unsafe.Pointer(pStep)).FpNext
							}
						}
					}
				}
			}
		}
		if rc == SQLITE_OK {
			rc = _renameEditSql(tls, context, bp+284, zInput, zNew, bQuote)
		}
		if rc != SQLITE_OK {
			if rc == int32(SQLITE_ERROR) && _sqlite3WritableSchema(tls, db) != 0 {
				Xsqlite3_result_value(tls, context, **(**uintptr)(__ccgo_up(argv + 3*4)))
			} else {
				if (**(**TParse)(__ccgo_up(bp))).FzErrMsg != 0 {
					_renameColumnParseError(tls, context, __ccgo_ts+1702, **(**uintptr)(__ccgo_up(argv + 1*4)), **(**uintptr)(__ccgo_up(argv + 2*4)), bp)
				} else {
					Xsqlite3_result_error_code(tls, context, rc)
				}
			}
		}
		_renameParseCleanup(tls, bp)
		_renameTokenFree(tls, db, (**(**TRenameCtx)(__ccgo_up(bp + 284))).FpList)
		_sqlite3BtreeLeaveAll(tls, db)
		(*Tsqlite3)(unsafe.Pointer(db)).FxAuth = xAuth
	}
	return
}

// C documentation
//
//	/*
//	** Generate code to verify that the schemas of database zDb and, if
//	** bTemp is not true, database "temp", can still be parsed. This is
//	** called at the end of the generation of an ALTER TABLE ... RENAME ...
//	** statement to ensure that the operation has not rendered any schema
//	** objects unusable.
//	*/
func _renameTestSchema(tls *libc.TLS, pParse uintptr, zDb uintptr, bTemp int32, zWhen uintptr, bNoDQS int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	libc.SetBitFieldPtr16Uint32(pParse+28, libc.Uint32FromInt32(1), 5, 0x20)
	_sqlite3NestedParse(tls, pParse, __ccgo_ts+8673, libc.VaList(bp+8, zDb, zDb, bTemp, zWhen, bNoDQS))
	if bTemp == 0 {
		_sqlite3NestedParse(tls, pParse, __ccgo_ts+8848, libc.VaList(bp+8, zDb, zWhen, bNoDQS))
	}
}

// C documentation
//
//	/*
//	** Reset the aggregate accumulator.
//	**
//	** The aggregate accumulator is a set of memory cells that hold
//	** intermediate results while calculating an aggregate.  This
//	** routine generates code that stores NULLs in all of those memory
//	** cells.
//	*/
func _resetAccumulator(tls *libc.TLS, pParse uintptr, pAggInfo uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var i, nExtra, nReg int32
	var pE, pFunc, pKeyInfo, pKeyInfo1, pOBList, v uintptr
	_, _, _, _, _, _, _, _, _ = i, nExtra, nReg, pE, pFunc, pKeyInfo, pKeyInfo1, pOBList, v
	v = (*TParse)(unsafe.Pointer(pParse)).FpVdbe
	nReg = (*TAggInfo)(unsafe.Pointer(pAggInfo)).FnFunc + (*TAggInfo)(unsafe.Pointer(pAggInfo)).FnColumn
	if nReg == 0 {
		return
	}
	if (*TParse)(unsafe.Pointer(pParse)).FnErr != 0 {
		return
	}
	_sqlite3VdbeAddOp3(tls, v, int32(OP_Null), 0, (*TAggInfo)(unsafe.Pointer(pAggInfo)).FiFirstReg, (*TAggInfo)(unsafe.Pointer(pAggInfo)).FiFirstReg+nReg-int32(1))
	pFunc = (*TAggInfo)(unsafe.Pointer(pAggInfo)).FaFunc
	i = libc.Int32FromInt32(0)
	for {
		if !(i < (*TAggInfo)(unsafe.Pointer(pAggInfo)).FnFunc) {
			break
		}
		if (*TAggInfo_func)(unsafe.Pointer(pFunc)).FiDistinct >= 0 {
			pE = (*TAggInfo_func)(unsafe.Pointer(pFunc)).FpFExpr
			if *(*uintptr)(unsafe.Pointer(pE + 20)) == uintptr(0) || (*TExprList)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pE + 20)))).FnExpr != int32(1) {
				_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+21410, 0)
				(*TAggInfo_func)(unsafe.Pointer(pFunc)).FiDistinct = -int32(1)
			} else {
				pKeyInfo = _sqlite3KeyInfoFromExprList(tls, pParse, *(*uintptr)(unsafe.Pointer(pE + 20)), 0, 0)
				(*TAggInfo_func)(unsafe.Pointer(pFunc)).FiDistAddr = _sqlite3VdbeAddOp4(tls, v, int32(OP_OpenEphemeral), (*TAggInfo_func)(unsafe.Pointer(pFunc)).FiDistinct, 0, 0, pKeyInfo, -int32(9))
				_sqlite3VdbeExplain(tls, pParse, uint8(0), __ccgo_ts+21461, libc.VaList(bp+8, (*TFuncDef)(unsafe.Pointer((*TAggInfo_func)(unsafe.Pointer(pFunc)).FpFunc)).FzName))
			}
		}
		if (*TAggInfo_func)(unsafe.Pointer(pFunc)).FiOBTab >= 0 {
			nExtra = 0
			pOBList = *(*uintptr)(unsafe.Pointer((*TExpr)(unsafe.Pointer((*TAggInfo_func)(unsafe.Pointer(pFunc)).FpFExpr)).FpLeft + 20))
			if !((*TAggInfo_func)(unsafe.Pointer(pFunc)).FbOBUnique != 0) {
				nExtra = nExtra + 1 /* One extra column for the OP_Sequence */
			}
			if (*TAggInfo_func)(unsafe.Pointer(pFunc)).FbOBPayload != 0 {
				/* extra columns for the function arguments */
				nExtra = nExtra + (*TExprList)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TAggInfo_func)(unsafe.Pointer(pFunc)).FpFExpr + 20)))).FnExpr
			}
			if (*TAggInfo_func)(unsafe.Pointer(pFunc)).FbUseSubtype != 0 {
				nExtra = nExtra + (*TExprList)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TAggInfo_func)(unsafe.Pointer(pFunc)).FpFExpr + 20)))).FnExpr
			}
			pKeyInfo1 = _sqlite3KeyInfoFromExprList(tls, pParse, pOBList, 0, nExtra)
			if !((*TAggInfo_func)(unsafe.Pointer(pFunc)).FbOBUnique != 0) && (*TParse)(unsafe.Pointer(pParse)).FnErr == 0 {
				(*TKeyInfo)(unsafe.Pointer(pKeyInfo1)).FnKeyField = (*TKeyInfo)(unsafe.Pointer(pKeyInfo1)).FnKeyField + 1
			}
			_sqlite3VdbeAddOp4(tls, v, int32(OP_OpenEphemeral), (*TAggInfo_func)(unsafe.Pointer(pFunc)).FiOBTab, (*TExprList)(unsafe.Pointer(pOBList)).FnExpr+nExtra, 0, pKeyInfo1, -int32(9))
			_sqlite3VdbeExplain(tls, pParse, uint8(0), __ccgo_ts+21494, libc.VaList(bp+8, (*TFuncDef)(unsafe.Pointer((*TAggInfo_func)(unsafe.Pointer(pFunc)).FpFunc)).FzName))
		}
		goto _1
	_1:
		;
		i = i + 1
		pFunc += 24
	}
}

// C documentation
//
//	/*
//	** This function checks if argument pFrom refers to a CTE declared by
//	** a WITH clause on the stack currently maintained by the parser (on the
//	** pParse->pWith linked list).  And if currently processing a CTE
//	** CTE expression, through routine checks to see if the reference is
//	** a recursive reference to the CTE.
//	**
//	** If pFrom matches a CTE according to either of these two above, pFrom->pSTab
//	** and other fields are populated accordingly.
//	**
//	** Return 0 if no match is found.
//	** Return 1 if a match is found.
//	** Return 2 if an error condition is detected.
//	*/
func _resolveFromTermToCte(tls *libc.TLS, pParse uintptr, pWalker uintptr, pFrom uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var bMayRecursive, i, iRecTab, rc, v3 int32
	var db, pCte, pCteUse, pEList, pItem, pLeft, pRecTerm, pSavedWith, pSel, pSrc, pTab, v1 uintptr
	var _ /* pWith at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bMayRecursive, db, i, iRecTab, pCte, pCteUse, pEList, pItem, pLeft, pRecTerm, pSavedWith, pSel, pSrc, pTab, rc, v1, v3 /* The matching WITH */
	if (*TParse)(unsafe.Pointer(pParse)).FpWith == uintptr(0) {
		/* There are no WITH clauses in the stack.  No match is possible */
		return 0
	}
	if (*TParse)(unsafe.Pointer(pParse)).FnErr != 0 {
		/* Prior errors might have left pParse->pWith in a goofy state, so
		 ** go no further. */
		return 0
	}
	if int32(*(*uint32)(unsafe.Pointer(pFrom + 12 + 4))&0x10000>>16) == 0 && *(*uintptr)(unsafe.Pointer(pFrom + 44)) != uintptr(0) {
		/* The FROM term contains a schema qualifier (ex: main.t1) and so
		 ** it cannot possibly be a CTE reference. */
		return 0
	}
	if int32(*(*uint32)(unsafe.Pointer(pFrom + 12 + 4))&0x400>>10) != 0 {
		/* The FROM term is specifically excluded from matching a CTE.
		 **   (1)  It is part of a trigger that used to have zDatabase but had
		 **        zDatabase removed by sqlite3FixTriggerStep().
		 **   (2)  This is the first term in the FROM clause of an UPDATE.
		 */
		return 0
	}
	pCte = _searchWith(tls, (*TParse)(unsafe.Pointer(pParse)).FpWith, pFrom, bp)
	if pCte != 0 {
		db = (*TParse)(unsafe.Pointer(pParse)).Fdb /* Initial value of pParse->pWith */
		iRecTab = -int32(1)
		/* If pCte->zCteErr is non-NULL at this point, then this is an illegal
		 ** recursive reference to CTE pCte. Leave an error in pParse and return
		 ** early. If pCte->zCteErr is NULL, then this is not a recursive reference.
		 ** In this case, proceed.  */
		if (*TCte)(unsafe.Pointer(pCte)).FzCteErr != 0 {
			_sqlite3ErrorMsg(tls, pParse, (*TCte)(unsafe.Pointer(pCte)).FzCteErr, libc.VaList(bp+16, (*TCte)(unsafe.Pointer(pCte)).FzName))
			return int32(2)
		}
		if _cannotBeFunction(tls, pParse, pFrom) != 0 {
			return int32(2)
		}
		pTab = _sqlite3DbMallocZero(tls, db, uint64(80))
		if pTab == uintptr(0) {
			return int32(2)
		}
		pCteUse = (*TCte)(unsafe.Pointer(pCte)).FpUse
		if pCteUse == uintptr(0) {
			v1 = _sqlite3DbMallocZero(tls, db, uint64(20))
			pCteUse = v1
			(*TCte)(unsafe.Pointer(pCte)).FpUse = v1
			if pCteUse == uintptr(0) || _sqlite3ParserAddCleanup(tls, pParse, __ccgo_fp(_sqlite3DbFree), pCteUse) == uintptr(0) {
				_sqlite3DbFree(tls, db, pTab)
				return int32(2)
			}
			(*TCteUse)(unsafe.Pointer(pCteUse)).FeM10d = (*TCte)(unsafe.Pointer(pCte)).FeM10d
		}
		(*TSrcItem)(unsafe.Pointer(pFrom)).FpSTab = pTab
		(*TTable)(unsafe.Pointer(pTab)).FnTabRef = uint32(1)
		(*TTable)(unsafe.Pointer(pTab)).FzName = _sqlite3DbStrDup(tls, db, (*TCte)(unsafe.Pointer(pCte)).FzName)
		(*TTable)(unsafe.Pointer(pTab)).FiPKey = int16(-int32(1))
		(*TTable)(unsafe.Pointer(pTab)).FnRowLogEst = int16(200)
		**(**Tu32)(__ccgo_up(pTab + 28)) |= libc.Uint32FromInt32(libc.Int32FromInt32(TF_Ephemeral) | libc.Int32FromInt32(TF_NoVisibleRowid))
		_sqlite3SrcItemAttachSubquery(tls, pParse, pFrom, (*TCte)(unsafe.Pointer(pCte)).FpSelect, int32(1))
		if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
			return int32(2)
		}
		pSel = (*TSubquery)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pFrom + 44)))).FpSelect
		**(**Tu32)(__ccgo_up(pSel + 4)) |= uint32(SF_CopyCte)
		if int32(*(*uint32)(unsafe.Pointer(pFrom + 12 + 4))&0x2>>1) != 0 {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+21057, libc.VaList(bp+16, *(*uintptr)(unsafe.Pointer(pFrom + 32))))
			return int32(2)
		}
		libc.SetBitFieldPtr32Uint32(pFrom+12+4, libc.Uint32FromInt32(1), 9, 0x200)
		*(*uintptr)(unsafe.Pointer(pFrom + 36)) = pCteUse
		(*TCteUse)(unsafe.Pointer(pCteUse)).FnUse = (*TCteUse)(unsafe.Pointer(pCteUse)).FnUse + 1
		/* Check if this is a recursive CTE. */
		pRecTerm = pSel
		bMayRecursive = libc.BoolInt32(libc.Int32FromUint8((*TSelect)(unsafe.Pointer(pSel)).Fop) == int32(TK_ALL) || libc.Int32FromUint8((*TSelect)(unsafe.Pointer(pSel)).Fop) == int32(TK_UNION))
		for bMayRecursive != 0 && libc.Int32FromUint8((*TSelect)(unsafe.Pointer(pRecTerm)).Fop) == libc.Int32FromUint8((*TSelect)(unsafe.Pointer(pSel)).Fop) {
			pSrc = (*TSelect)(unsafe.Pointer(pRecTerm)).FpSrc
			i = 0
			for {
				if !(i < (*TSrcList)(unsafe.Pointer(pSrc)).FnSrc) {
					break
				}
				pItem = pSrc + 8 + uintptr(i)*48
				if (*TSrcItem)(unsafe.Pointer(pItem)).FzName != uintptr(0) && !(int32(*(*uint32)(unsafe.Pointer(pItem + 12 + 4))&0x20000>>17) != 0) && !(int32(*(*uint32)(unsafe.Pointer(pItem + 12 + 4))&0x4>>2) != 0) && (int32(*(*uint32)(unsafe.Pointer(pItem + 12 + 4))&0x10000>>16) != 0 || *(*uintptr)(unsafe.Pointer(pItem + 44)) == uintptr(0)) && 0 == _sqlite3StrICmp(tls, (*TSrcItem)(unsafe.Pointer(pItem)).FzName, (*TCte)(unsafe.Pointer(pCte)).FzName) {
					(*TSrcItem)(unsafe.Pointer(pItem)).FpSTab = pTab
					(*TTable)(unsafe.Pointer(pTab)).FnTabRef = (*TTable)(unsafe.Pointer(pTab)).FnTabRef + 1
					libc.SetBitFieldPtr32Uint32(pItem+12+4, libc.Uint32FromInt32(1), 7, 0x80)
					if (*TSelect)(unsafe.Pointer(pRecTerm)).FselFlags&uint32(SF_Recursive) != 0 {
						_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+21077, libc.VaList(bp+16, (*TCte)(unsafe.Pointer(pCte)).FzName))
						return int32(2)
					}
					**(**Tu32)(__ccgo_up(pRecTerm + 4)) |= uint32(SF_Recursive)
					if iRecTab < 0 {
						v1 = pParse + 44
						v3 = *(*int32)(unsafe.Pointer(v1))
						*(*int32)(unsafe.Pointer(v1)) = *(*int32)(unsafe.Pointer(v1)) + 1
						iRecTab = v3
					}
					(*TSrcItem)(unsafe.Pointer(pItem)).FiCursor = iRecTab
				}
				goto _2
			_2:
				;
				i = i + 1
			}
			if (*TSelect)(unsafe.Pointer(pRecTerm)).FselFlags&uint32(SF_Recursive) == uint32(0) {
				break
			}
			pRecTerm = (*TSelect)(unsafe.Pointer(pRecTerm)).FpPrior
		}
		(*TCte)(unsafe.Pointer(pCte)).FzCteErr = __ccgo_ts + 21120
		pSavedWith = (*TParse)(unsafe.Pointer(pParse)).FpWith
		(*TParse)(unsafe.Pointer(pParse)).FpWith = **(**uintptr)(__ccgo_up(bp))
		if (*TSelect)(unsafe.Pointer(pSel)).FselFlags&uint32(SF_Recursive) != 0 {
			(*TSelect)(unsafe.Pointer(pRecTerm)).FpWith = (*TSelect)(unsafe.Pointer(pSel)).FpWith
			rc = _sqlite3WalkSelect(tls, pWalker, pRecTerm)
			(*TSelect)(unsafe.Pointer(pRecTerm)).FpWith = uintptr(0)
			if rc != 0 {
				(*TParse)(unsafe.Pointer(pParse)).FpWith = pSavedWith
				return int32(2)
			}
		} else {
			if _sqlite3WalkSelect(tls, pWalker, pSel) != 0 {
				(*TParse)(unsafe.Pointer(pParse)).FpWith = pSavedWith
				return int32(2)
			}
		}
		(*TParse)(unsafe.Pointer(pParse)).FpWith = **(**uintptr)(__ccgo_up(bp))
		pLeft = pSel
		for {
			if !((*TSelect)(unsafe.Pointer(pLeft)).FpPrior != 0) {
				break
			}
			goto _5
		_5:
			;
			pLeft = (*TSelect)(unsafe.Pointer(pLeft)).FpPrior
		}
		pEList = (*TSelect)(unsafe.Pointer(pLeft)).FpEList
		if (*TCte)(unsafe.Pointer(pCte)).FpCols != 0 {
			if pEList != 0 && (*TExprList)(unsafe.Pointer(pEList)).FnExpr != (*TExprList)(unsafe.Pointer((*TCte)(unsafe.Pointer(pCte)).FpCols)).FnExpr {
				_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+21143, libc.VaList(bp+16, (*TCte)(unsafe.Pointer(pCte)).FzName, (*TExprList)(unsafe.Pointer(pEList)).FnExpr, (*TExprList)(unsafe.Pointer((*TCte)(unsafe.Pointer(pCte)).FpCols)).FnExpr))
				(*TParse)(unsafe.Pointer(pParse)).FpWith = pSavedWith
				return int32(2)
			}
			pEList = (*TCte)(unsafe.Pointer(pCte)).FpCols
		}
		_sqlite3ColumnsFromExprList(tls, pParse, pEList, pTab+34, pTab+4)
		if bMayRecursive != 0 {
			if (*TSelect)(unsafe.Pointer(pSel)).FselFlags&uint32(SF_Recursive) != 0 {
				(*TCte)(unsafe.Pointer(pCte)).FzCteErr = __ccgo_ts + 21181
			} else {
				(*TCte)(unsafe.Pointer(pCte)).FzCteErr = __ccgo_ts + 21215
			}
			_sqlite3WalkSelect(tls, pWalker, pSel)
		}
		(*TCte)(unsafe.Pointer(pCte)).FzCteErr = uintptr(0)
		(*TParse)(unsafe.Pointer(pParse)).FpWith = pSavedWith
		return int32(1) /* Success */
	}
	return 0 /* No match */
}

// C documentation
//
//	/*
//	** Resolve names in the SELECT statement p and all of its descendants.
//	*/
func _resolveSelectStep(tls *libc.TLS, pWalker uintptr, p uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var db, pGroupBy, pItem, pItem1, pItem2, pLeftmost, pOuterNC, pParse, pSub, pSub1, pWin, zSavedContext uintptr
	var i, isCompound, nCompound, nRef, v1 int32
	var _ /* sNC at bp+0 */ TNameContext
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = db, i, isCompound, nCompound, nRef, pGroupBy, pItem, pItem1, pItem2, pLeftmost, pOuterNC, pParse, pSub, pSub1, pWin, zSavedContext, v1 /* Database connection */
	if (*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_Resolved) != 0 {
		return int32(WRC_Prune)
	}
	pOuterNC = *(*uintptr)(unsafe.Pointer(pWalker + 24))
	pParse = (*TWalker)(unsafe.Pointer(pWalker)).FpParse
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	/* Normally sqlite3SelectExpand() will be called first and will have
	 ** already expanded this SELECT.  However, if this is a subquery within
	 ** an expression, sqlite3ResolveExprNames() will be called without a
	 ** prior call to sqlite3SelectExpand().  When that happens, let
	 ** sqlite3SelectPrep() do all of the processing for this SELECT.
	 ** sqlite3SelectPrep() will invoke both sqlite3SelectExpand() and
	 ** this routine in the correct order.
	 */
	if (*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_Expanded) == uint32(0) {
		_sqlite3SelectPrep(tls, pParse, p, pOuterNC)
		if (*TParse)(unsafe.Pointer(pParse)).FnErr != 0 {
			v1 = int32(WRC_Abort)
		} else {
			v1 = int32(WRC_Prune)
		}
		return v1
	}
	isCompound = libc.BoolInt32((*TSelect)(unsafe.Pointer(p)).FpPrior != uintptr(0))
	nCompound = 0
	pLeftmost = p
	for p != 0 {
		**(**Tu32)(__ccgo_up(p + 4)) |= uint32(SF_Resolved)
		/* Resolve the expressions in the LIMIT and OFFSET clauses. These
		 ** are not allowed to refer to any names, so pass an empty NameContext.
		 */
		libc.Xmemset(tls, bp, 0, uint32(36))
		(**(**TNameContext)(__ccgo_up(bp))).FpParse = pParse
		(**(**TNameContext)(__ccgo_up(bp))).FpWinSelect = p
		if _sqlite3ResolveExprNames(tls, bp, (*TSelect)(unsafe.Pointer(p)).FpLimit) != 0 {
			return int32(WRC_Abort)
		}
		/* If the SF_Converted flags is set, then this Select object was
		 ** was created by the convertCompoundSelectToSubquery() function.
		 ** In this case the ORDER BY clause (p->pOrderBy) should be resolved
		 ** as if it were part of the sub-query, not the parent. This block
		 ** moves the pOrderBy down to the sub-query. It will be moved back
		 ** after the names have been resolved.  */
		if (*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_Converted) != 0 {
			pSub = (*TSubquery)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpSrc + 8 + 44)))).FpSelect
			(*TSelect)(unsafe.Pointer(pSub)).FpOrderBy = (*TSelect)(unsafe.Pointer(p)).FpOrderBy
			(*TSelect)(unsafe.Pointer(p)).FpOrderBy = uintptr(0)
		}
		/* Recursively resolve names in all subqueries in the FROM clause
		 */
		if pOuterNC != 0 {
			(*TNameContext)(unsafe.Pointer(pOuterNC)).FnNestedSelect = (*TNameContext)(unsafe.Pointer(pOuterNC)).FnNestedSelect + 1
		}
		i = 0
		for {
			if !(i < (*TSrcList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpSrc)).FnSrc) {
				break
			}
			pItem = (*TSelect)(unsafe.Pointer(p)).FpSrc + 8 + uintptr(i)*48
			/* Test of tag-20240424-1*/
			if int32(*(*uint32)(unsafe.Pointer(pItem + 12 + 4))&0x4>>2) != 0 && (*TSelect)(unsafe.Pointer((*TSubquery)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pItem + 44)))).FpSelect)).FselFlags&uint32(SF_Resolved) == uint32(0) {
				if pOuterNC != 0 {
					v1 = (*TNameContext)(unsafe.Pointer(pOuterNC)).FnRef
				} else {
					v1 = 0
				}
				nRef = v1
				zSavedContext = (*TParse)(unsafe.Pointer(pParse)).FzAuthContext
				if (*TSrcItem)(unsafe.Pointer(pItem)).FzName != 0 {
					(*TParse)(unsafe.Pointer(pParse)).FzAuthContext = (*TSrcItem)(unsafe.Pointer(pItem)).FzName
				}
				_sqlite3ResolveSelectNames(tls, pParse, (*TSubquery)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pItem + 44)))).FpSelect, pOuterNC)
				(*TParse)(unsafe.Pointer(pParse)).FzAuthContext = zSavedContext
				if (*TParse)(unsafe.Pointer(pParse)).FnErr != 0 {
					return int32(WRC_Abort)
				}
				/* If the number of references to the outer context changed when
				 ** expressions in the sub-select were resolved, the sub-select
				 ** is correlated. It is not required to check the refcount on any
				 ** but the innermost outer context object, as lookupName() increments
				 ** the refcount on all contexts between the current one and the
				 ** context containing the column when it resolves a name. */
				if pOuterNC != 0 {
					libc.SetBitFieldPtr32Uint32(pItem+12+4, libc.BoolUint32((*TNameContext)(unsafe.Pointer(pOuterNC)).FnRef > nRef), 4, 0x10)
				}
			}
			goto _2
		_2:
			;
			i = i + 1
		}
		if pOuterNC != 0 && (*TNameContext)(unsafe.Pointer(pOuterNC)).FnNestedSelect > uint32(0) {
			(*TNameContext)(unsafe.Pointer(pOuterNC)).FnNestedSelect = (*TNameContext)(unsafe.Pointer(pOuterNC)).FnNestedSelect - 1
		}
		/* Set up the local name-context to pass to sqlite3ResolveExprNames() to
		 ** resolve the result-set expression list.
		 */
		(**(**TNameContext)(__ccgo_up(bp))).FncFlags = libc.Int32FromInt32(NC_AllowAgg) | libc.Int32FromInt32(NC_AllowWin)
		(**(**TNameContext)(__ccgo_up(bp))).FpSrcList = (*TSelect)(unsafe.Pointer(p)).FpSrc
		(**(**TNameContext)(__ccgo_up(bp))).FpNext = pOuterNC
		/* Resolve names in the result set. */
		if _sqlite3ResolveExprListNames(tls, bp, (*TSelect)(unsafe.Pointer(p)).FpEList) != 0 {
			return int32(WRC_Abort)
		}
		(**(**TNameContext)(__ccgo_up(bp))).FncFlags &= ^libc.Int32FromInt32(NC_AllowWin)
		/* If there are no aggregate functions in the result-set, and no GROUP BY
		 ** expression, do not allow aggregates in any of the other expressions.
		 */
		pGroupBy = (*TSelect)(unsafe.Pointer(p)).FpGroupBy
		if pGroupBy != 0 || (**(**TNameContext)(__ccgo_up(bp))).FncFlags&int32(NC_HasAgg) != 0 {
			**(**Tu32)(__ccgo_up(p + 4)) |= libc.Uint32FromInt32(int32(SF_Aggregate) | (**(**TNameContext)(__ccgo_up(bp))).FncFlags&(libc.Int32FromInt32(NC_MinMaxAgg)|libc.Int32FromInt32(NC_OrderAgg)))
		} else {
			(**(**TNameContext)(__ccgo_up(bp))).FncFlags &= ^libc.Int32FromInt32(NC_AllowAgg)
		}
		/* Add the output column list to the name-context before parsing the
		 ** other expressions in the SELECT statement. This is so that
		 ** expressions in the WHERE clause (etc.) can refer to expressions by
		 ** aliases in the result set.
		 **
		 ** Minor point: If this is the case, then the expression will be
		 ** re-evaluated for each reference to it.
		 */
		*(*uintptr)(unsafe.Pointer(bp + 8)) = (*TSelect)(unsafe.Pointer(p)).FpEList
		(**(**TNameContext)(__ccgo_up(bp))).FncFlags |= int32(NC_UEList)
		if (*TSelect)(unsafe.Pointer(p)).FpHaving != 0 {
			if (*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_Aggregate) == uint32(0) {
				_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+7759, 0)
				return int32(WRC_Abort)
			}
			if _sqlite3ResolveExprNames(tls, bp, (*TSelect)(unsafe.Pointer(p)).FpHaving) != 0 {
				return int32(WRC_Abort)
			}
		}
		(**(**TNameContext)(__ccgo_up(bp))).FncFlags |= int32(NC_Where)
		if _sqlite3ResolveExprNames(tls, bp, (*TSelect)(unsafe.Pointer(p)).FpWhere) != 0 {
			return int32(WRC_Abort)
		}
		(**(**TNameContext)(__ccgo_up(bp))).FncFlags &= ^libc.Int32FromInt32(NC_Where)
		/* Resolve names in table-valued-function arguments */
		i = 0
		for {
			if !(i < (*TSrcList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpSrc)).FnSrc) {
				break
			}
			pItem1 = (*TSelect)(unsafe.Pointer(p)).FpSrc + 8 + uintptr(i)*48
			if int32(*(*uint32)(unsafe.Pointer(pItem1 + 12 + 4))&0x8>>3) != 0 && _sqlite3ResolveExprListNames(tls, bp, *(*uintptr)(unsafe.Pointer(pItem1 + 32))) != 0 {
				return int32(WRC_Abort)
			}
			goto _4
		_4:
			;
			i = i + 1
		}
		if libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).FeParseMode) >= int32(PARSE_MODE_RENAME) {
			pWin = (*TSelect)(unsafe.Pointer(p)).FpWinDefn
			for {
				if !(pWin != 0) {
					break
				}
				if _sqlite3ResolveExprListNames(tls, bp, (*TWindow)(unsafe.Pointer(pWin)).FpOrderBy) != 0 || _sqlite3ResolveExprListNames(tls, bp, (*TWindow)(unsafe.Pointer(pWin)).FpPartition) != 0 {
					return int32(WRC_Abort)
				}
				goto _5
			_5:
				;
				pWin = (*TWindow)(unsafe.Pointer(pWin)).FpNextWin
			}
		}
		(**(**TNameContext)(__ccgo_up(bp))).FncFlags |= libc.Int32FromInt32(NC_AllowAgg) | libc.Int32FromInt32(NC_AllowWin)
		/* If this is a converted compound query, move the ORDER BY clause from
		 ** the sub-query back to the parent query. At this point each term
		 ** within the ORDER BY clause has been transformed to an integer value.
		 ** These integers will be replaced by copies of the corresponding result
		 ** set expressions by the call to resolveOrderGroupBy() below.  */
		if (*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_Converted) != 0 {
			pSub1 = (*TSubquery)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpSrc + 8 + 44)))).FpSelect
			(*TSelect)(unsafe.Pointer(p)).FpOrderBy = (*TSelect)(unsafe.Pointer(pSub1)).FpOrderBy
			(*TSelect)(unsafe.Pointer(pSub1)).FpOrderBy = uintptr(0)
		}
		/* Process the ORDER BY clause for singleton SELECT statements.
		 ** The ORDER BY clause for compounds SELECT statements is handled
		 ** below, after all of the result-sets for all of the elements of
		 ** the compound have been resolved.
		 **
		 ** If there is an ORDER BY clause on a term of a compound-select other
		 ** than the right-most term, then that is a syntax error.  But the error
		 ** is not detected until much later, and so we need to go ahead and
		 ** resolve those symbols on the incorrect ORDER BY for consistency.
		 */
		if (*TSelect)(unsafe.Pointer(p)).FpOrderBy != uintptr(0) && isCompound <= nCompound && _resolveOrderGroupBy(tls, bp, p, (*TSelect)(unsafe.Pointer(p)).FpOrderBy, __ccgo_ts+7661) != 0 {
			return int32(WRC_Abort)
		}
		if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
			return int32(WRC_Abort)
		}
		(**(**TNameContext)(__ccgo_up(bp))).FncFlags &= ^libc.Int32FromInt32(NC_AllowWin)
		/* Resolve the GROUP BY clause.  At the same time, make sure
		 ** the GROUP BY clause does not contain aggregate functions.
		 */
		if pGroupBy != 0 {
			if _resolveOrderGroupBy(tls, bp, p, pGroupBy, __ccgo_ts+7798) != 0 || (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
				return int32(WRC_Abort)
			}
			i = 0
			pItem2 = pGroupBy + 8
			for {
				if !(i < (*TExprList)(unsafe.Pointer(pGroupBy)).FnExpr) {
					break
				}
				if (*TExpr)(unsafe.Pointer((*TExprList_item)(unsafe.Pointer(pItem2)).FpExpr)).Fflags&libc.Uint32FromInt32(libc.Int32FromInt32(EP_Agg)) != uint32(0) {
					_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+7804, 0)
					return int32(WRC_Abort)
				}
				goto _6
			_6:
				;
				i = i + 1
				pItem2 += 20
			}
		}
		/* If this is part of a compound SELECT, check that it has the right
		 ** number of expressions in the select list. */
		if (*TSelect)(unsafe.Pointer(p)).FpNext != 0 && (*TExprList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpEList)).FnExpr != (*TExprList)(unsafe.Pointer((*TSelect)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpNext)).FpEList)).FnExpr {
			_sqlite3SelectWrongNumTermsError(tls, pParse, (*TSelect)(unsafe.Pointer(p)).FpNext)
			return int32(WRC_Abort)
		}
		/* If the SELECT statement contains ON clauses that were moved into
		 ** the WHERE clause, go through and verify that none of the terms
		 ** in the ON clauses reference tables to the right of the ON clause. */
		if (*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_OnToWhere) != 0 {
			_sqlite3SelectCheckOnClauses(tls, pParse, p)
			if (*TParse)(unsafe.Pointer(pParse)).FnErr != 0 {
				return int32(WRC_Abort)
			}
		}
		/* Advance to the next term of the compound
		 */
		p = (*TSelect)(unsafe.Pointer(p)).FpPrior
		nCompound = nCompound + 1
	}
	/* Resolve the ORDER BY on a compound SELECT after all terms of
	 ** the compound have been resolved.
	 */
	if isCompound != 0 && _resolveCompoundOrderBy(tls, pParse, pLeftmost) != 0 {
		return int32(WRC_Abort)
	}
	return int32(WRC_Prune)
}

// C documentation
//
//	/*
//	** Implementation of the round() function
//	*/
func _roundFunc(tls *libc.TLS, context uintptr, argc int32, argv uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var n Ti64
	var zBuf uintptr
	var v1 float64
	var _ /* r at bp+0 */ float64
	_, _, _ = n, zBuf, v1
	n = 0
	if argc == int32(2) {
		if int32(SQLITE_NULL) == Xsqlite3_value_type(tls, **(**uintptr)(__ccgo_up(argv + 1*4))) {
			return
		}
		n = Xsqlite3_value_int64(tls, **(**uintptr)(__ccgo_up(argv + 1*4)))
		if n > int64(30) {
			n = int64(30)
		}
		if n < 0 {
			n = 0
		}
	}
	if Xsqlite3_value_type(tls, **(**uintptr)(__ccgo_up(argv))) == int32(SQLITE_NULL) {
		return
	}
	**(**float64)(__ccgo_up(bp)) = Xsqlite3_value_double(tls, **(**uintptr)(__ccgo_up(argv)))
	/* If Y==0 and X will fit in a 64-bit int,
	 ** handle the rounding directly,
	 ** otherwise use printf.
	 */
	if **(**float64)(__ccgo_up(bp)) < -libc.Float64FromFloat64(4.503599627370496e+15) || **(**float64)(__ccgo_up(bp)) > +libc.Float64FromFloat64(4.503599627370496e+15) {
		/* The value has no fractional part so there is nothing to round */
	} else {
		if n == 0 {
			if **(**float64)(__ccgo_up(bp)) < libc.Float64FromInt32(0) {
				v1 = -libc.Float64FromFloat64(0.5)
			} else {
				v1 = +libc.Float64FromFloat64(0.5)
			}
			**(**float64)(__ccgo_up(bp)) = float64(int64(**(**float64)(__ccgo_up(bp)) + v1))
		} else {
			zBuf = Xsqlite3_mprintf(tls, __ccgo_ts+16477, libc.VaList(bp+16, int32(n), **(**float64)(__ccgo_up(bp))))
			if zBuf == uintptr(0) {
				Xsqlite3_result_error_nomem(tls, context)
				return
			}
			_sqlite3AtoF(tls, zBuf, bp)
			Xsqlite3_free(tls, zBuf)
		}
	}
	Xsqlite3_result_double(tls, context, **(**float64)(__ccgo_up(bp)))
}

// C documentation
//
//	/*
//	** This function is a no-op if there is already an error code stored
//	** in the RtreeCheck object indicated by the first argument. NULL is
//	** returned in this case.
//	**
//	** Otherwise, the contents of rtree table node iNode are loaded from
//	** the database and copied into a buffer obtained from sqlite3_malloc().
//	** If no error occurs, a pointer to the buffer is returned and (*pnNode)
//	** is set to the size of the buffer in bytes.
//	**
//	** Or, if an error does occur, NULL is returned and an error code left
//	** in the RtreeCheck object. The final value of *pnNode is undefined in
//	** this case.
//	*/
func _rtreeCheckGetNode(tls *libc.TLS, pCheck uintptr, iNode Ti64, pnNode uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var nNode int32
	var pNode, pRet uintptr
	_, _, _ = nNode, pNode, pRet
	pRet = uintptr(0) /* Return value */
	if (*TRtreeCheck)(unsafe.Pointer(pCheck)).Frc == SQLITE_OK && (*TRtreeCheck)(unsafe.Pointer(pCheck)).FpGetNode == uintptr(0) {
		(*TRtreeCheck)(unsafe.Pointer(pCheck)).FpGetNode = _rtreeCheckPrepare(tls, pCheck, __ccgo_ts+29060, libc.VaList(bp+8, (*TRtreeCheck)(unsafe.Pointer(pCheck)).FzDb, (*TRtreeCheck)(unsafe.Pointer(pCheck)).FzTab))
	}
	if (*TRtreeCheck)(unsafe.Pointer(pCheck)).Frc == SQLITE_OK {
		Xsqlite3_bind_int64(tls, (*TRtreeCheck)(unsafe.Pointer(pCheck)).FpGetNode, int32(1), iNode)
		if Xsqlite3_step(tls, (*TRtreeCheck)(unsafe.Pointer(pCheck)).FpGetNode) == int32(SQLITE_ROW) {
			nNode = Xsqlite3_column_bytes(tls, (*TRtreeCheck)(unsafe.Pointer(pCheck)).FpGetNode, 0)
			pNode = Xsqlite3_column_blob(tls, (*TRtreeCheck)(unsafe.Pointer(pCheck)).FpGetNode, 0)
			pRet = Xsqlite3_malloc64(tls, libc.Uint64FromInt32(nNode))
			if pRet == uintptr(0) {
				(*TRtreeCheck)(unsafe.Pointer(pCheck)).Frc = int32(SQLITE_NOMEM)
			} else {
				libc.Xmemcpy(tls, pRet, pNode, libc.Uint32FromInt32(nNode))
				**(**int32)(__ccgo_up(pnNode)) = nNode
			}
		}
		_rtreeCheckReset(tls, pCheck, (*TRtreeCheck)(unsafe.Pointer(pCheck)).FpGetNode)
		if (*TRtreeCheck)(unsafe.Pointer(pCheck)).Frc == SQLITE_OK && pRet == uintptr(0) {
			_rtreeCheckAppendMsg(tls, pCheck, __ccgo_ts+29105, libc.VaList(bp+8, iNode))
		}
	}
	return pRet
}

// C documentation
//
//	/*
//	** This function is used to check that the %_parent (if bLeaf==0) or %_rowid
//	** (if bLeaf==1) table contains a specified entry. The schemas of the
//	** two tables are:
//	**
//	**   CREATE TABLE %_parent(nodeno INTEGER PRIMARY KEY, parentnode INTEGER)
//	**   CREATE TABLE %_rowid(rowid INTEGER PRIMARY KEY, nodeno INTEGER, ...)
//	**
//	** In both cases, this function checks that there exists an entry with
//	** IPK value iKey and the second column set to iVal.
//	**
//	*/
func _rtreeCheckMapping(tls *libc.TLS, pCheck uintptr, bLeaf int32, iKey Ti64, iVal Ti64) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var azSql [2]uintptr
	var ii Ti64
	var pStmt, v1 uintptr
	var rc int32
	_, _, _, _, _ = azSql, ii, pStmt, rc, v1
	azSql = [2]uintptr{
		0: __ccgo_ts + 29137,
		1: __ccgo_ts + 29191,
	}
	if **(**uintptr)(__ccgo_up(pCheck + 24 + uintptr(bLeaf)*4)) == uintptr(0) {
		**(**uintptr)(__ccgo_up(pCheck + 24 + uintptr(bLeaf)*4)) = _rtreeCheckPrepare(tls, pCheck, azSql[bLeaf], libc.VaList(bp+8, (*TRtreeCheck)(unsafe.Pointer(pCheck)).FzDb, (*TRtreeCheck)(unsafe.Pointer(pCheck)).FzTab))
	}
	if (*TRtreeCheck)(unsafe.Pointer(pCheck)).Frc != SQLITE_OK {
		return
	}
	pStmt = **(**uintptr)(__ccgo_up(pCheck + 24 + uintptr(bLeaf)*4))
	Xsqlite3_bind_int64(tls, pStmt, int32(1), iKey)
	rc = Xsqlite3_step(tls, pStmt)
	if rc == int32(SQLITE_DONE) {
		if bLeaf != 0 {
			v1 = __ccgo_ts + 29239
		} else {
			v1 = __ccgo_ts + 29247
		}
		_rtreeCheckAppendMsg(tls, pCheck, __ccgo_ts+29256, libc.VaList(bp+8, iKey, iVal, v1))
	} else {
		if rc == int32(SQLITE_ROW) {
			ii = Xsqlite3_column_int64(tls, pStmt, 0)
			if ii != iVal {
				if bLeaf != 0 {
					v1 = __ccgo_ts + 29239
				} else {
					v1 = __ccgo_ts + 29247
				}
				_rtreeCheckAppendMsg(tls, pCheck, __ccgo_ts+29301, libc.VaList(bp+8, iKey, ii, v1, iKey, iVal))
			}
		}
	}
	_rtreeCheckReset(tls, pCheck, pStmt)
}

// C documentation
//
//	/*
//	** This function does the bulk of the work for the rtree integrity-check.
//	** It is called by rtreecheck(), which is the SQL function implementation.
//	*/
func _rtreeCheckTable(tls *libc.TLS, db uintptr, zDb uintptr, zTab uintptr, pzReport uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var nAux, rc int32
	var pStmt uintptr
	var _ /* check at bp+0 */ TRtreeCheck
	_, _, _ = nAux, pStmt, rc /* Common context for various routines */
	pStmt = uintptr(0)        /* Used to find column count of rtree table */
	nAux = 0                  /* Number of extra columns. */
	/* Initialize the context object */
	libc.Xmemset(tls, bp, 0, uint32(52))
	(**(**TRtreeCheck)(__ccgo_up(bp))).Fdb = db
	(**(**TRtreeCheck)(__ccgo_up(bp))).FzDb = zDb
	(**(**TRtreeCheck)(__ccgo_up(bp))).FzTab = zTab
	/* Find the number of auxiliary columns */
	pStmt = _rtreeCheckPrepare(tls, bp, __ccgo_ts+29691, libc.VaList(bp+64, zDb, zTab))
	if pStmt != 0 {
		nAux = Xsqlite3_column_count(tls, pStmt) - int32(2)
		Xsqlite3_finalize(tls, pStmt)
	} else {
		if (**(**TRtreeCheck)(__ccgo_up(bp))).Frc != int32(SQLITE_NOMEM) {
			(**(**TRtreeCheck)(__ccgo_up(bp))).Frc = SQLITE_OK
		}
	}
	/* Find number of dimensions in the rtree table. */
	pStmt = _rtreeCheckPrepare(tls, bp, __ccgo_ts+27507, libc.VaList(bp+64, zDb, zTab))
	if pStmt != 0 {
		(**(**TRtreeCheck)(__ccgo_up(bp))).FnDim = (Xsqlite3_column_count(tls, pStmt) - int32(1) - nAux) / int32(2)
		if (**(**TRtreeCheck)(__ccgo_up(bp))).FnDim < int32(1) {
			_rtreeCheckAppendMsg(tls, bp, __ccgo_ts+29719, 0)
		} else {
			if int32(SQLITE_ROW) == Xsqlite3_step(tls, pStmt) {
				(**(**TRtreeCheck)(__ccgo_up(bp))).FbInt = libc.BoolInt32(Xsqlite3_column_type(tls, pStmt, int32(1)) == int32(SQLITE_INTEGER))
			}
		}
		rc = Xsqlite3_finalize(tls, pStmt)
		if rc != int32(SQLITE_CORRUPT) {
			(**(**TRtreeCheck)(__ccgo_up(bp))).Frc = rc
		}
	}
	/* Do the actual integrity-check */
	if (**(**TRtreeCheck)(__ccgo_up(bp))).FnDim >= int32(1) {
		if (**(**TRtreeCheck)(__ccgo_up(bp))).Frc == SQLITE_OK {
			_rtreeCheckNode(tls, bp, 0, uintptr(0), int64(1))
		}
		_rtreeCheckCount(tls, bp, __ccgo_ts+29750, int64((**(**TRtreeCheck)(__ccgo_up(bp))).FnLeaf))
		_rtreeCheckCount(tls, bp, __ccgo_ts+29757, int64((**(**TRtreeCheck)(__ccgo_up(bp))).FnNonLeaf))
	}
	/* Finalize SQL statements used by the integrity-check */
	Xsqlite3_finalize(tls, (**(**TRtreeCheck)(__ccgo_up(bp))).FpGetNode)
	Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp + 24)))
	Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp + 24 + 1*4)))
	**(**uintptr)(__ccgo_up(pzReport)) = (**(**TRtreeCheck)(__ccgo_up(bp))).FzReport
	return (**(**TRtreeCheck)(__ccgo_up(bp))).Frc
}

// C documentation
//
//	/*
//	** Usage:
//	**
//	**   rtreecheck(<rtree-table>);
//	**   rtreecheck(<database>, <rtree-table>);
//	**
//	** Invoking this SQL function runs an integrity-check on the named rtree
//	** table. The integrity-check verifies the following:
//	**
//	**   1. For each cell in the r-tree structure (%_node table), that:
//	**
//	**       a) for each dimension, (coord1 <= coord2).
//	**
//	**       b) unless the cell is on the root node, that the cell is bounded
//	**          by the parent cell on the parent node.
//	**
//	**       c) for leaf nodes, that there is an entry in the %_rowid
//	**          table corresponding to the cell's rowid value that
//	**          points to the correct node.
//	**
//	**       d) for cells on non-leaf nodes, that there is an entry in the
//	**          %_parent table mapping from the cell's child node to the
//	**          node that it resides on.
//	**
//	**   2. That there are the same number of entries in the %_rowid table
//	**      as there are leaf cells in the r-tree structure, and that there
//	**      is a leaf cell that corresponds to each entry in the %_rowid table.
//	**
//	**   3. That there are the same number of entries in the %_parent table
//	**      as there are non-leaf cells in the r-tree structure, and that
//	**      there is a non-leaf cell that corresponds to each entry in the
//	**      %_parent table.
//	*/
func _rtreecheck(tls *libc.TLS, ctx uintptr, nArg int32, apArg uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var rc int32
	var zDb, zTab, v1 uintptr
	var _ /* zReport at bp+0 */ uintptr
	_, _, _, _ = rc, zDb, zTab, v1
	if nArg != int32(1) && nArg != int32(2) {
		Xsqlite3_result_error(tls, ctx, __ccgo_ts+29784, -int32(1))
	} else {
		**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
		zDb = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(apArg)))
		if nArg == int32(1) {
			zTab = zDb
			zDb = __ccgo_ts + 6818
		} else {
			zTab = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(apArg + 1*4)))
		}
		rc = _rtreeCheckTable(tls, Xsqlite3_context_db_handle(tls, ctx), zDb, zTab, bp)
		if rc == SQLITE_OK {
			if **(**uintptr)(__ccgo_up(bp)) != 0 {
				v1 = **(**uintptr)(__ccgo_up(bp))
			} else {
				v1 = __ccgo_ts + 19791
			}
			Xsqlite3_result_text(tls, ctx, v1, -int32(1), uintptr(-libc.Int32FromInt32(1)))
		} else {
			Xsqlite3_result_error_code(tls, ctx, rc)
		}
		Xsqlite3_free(tls, **(**uintptr)(__ccgo_up(bp)))
	}
}

/* Conditionally include the geopoly code */
/************** Include geopoly.c in the middle of rtree.c *******************/
/************** Begin file geopoly.c *****************************************/
/*
** 2018-05-25
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:
**
**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
******************************************************************************
**
** This file implements an alternative R-Tree virtual table that
** uses polygons to express the boundaries of 2-dimensional objects.
**
** This file is #include-ed onto the end of "rtree.c" so that it has
** access to all of the R-Tree internals.
 */
/* #include <stdlib.h> */

/* Enable -DGEOPOLY_ENABLE_DEBUG for debugging facilities */

/* Character class routines */
/* Use the SQLite core versions if this routine is part of the
 ** SQLite amalgamation */

// C documentation
//
//	/*
//	** Seek to the offset passed as the second argument, then read cnt
//	** bytes into pBuf. Return the number of bytes actually read.
//	**
//	** To avoid stomping the errno value on a failed read the lastErrno value
//	** is set before returning.
//	*/
func _seekAndRead(tls *libc.TLS, id uintptr, offset Tsqlite3_int64, pBuf uintptr, cnt int32) (r int32) {
	var got, prior int32
	var newOffset Ti64
	_, _, _ = got, newOffset, prior
	prior = 0
	for cond := true; cond; cond = got > 0 {
		newOffset = libc.Xlseek(tls, (*TunixFile)(unsafe.Pointer(id)).Fh, offset, SEEK_SET)
		if newOffset < 0 {
			_storeLastErrno(tls, id, **(**int32)(__ccgo_up(libc.X__error(tls))))
			return -int32(1)
		}
		got = (*(*func(*libc.TLS, int32, uintptr, Tsize_t) Tssize_t)(unsafe.Pointer(&struct{ uintptr }{_aSyscall[int32(8)].FpCurrent})))(tls, (*TunixFile)(unsafe.Pointer(id)).Fh, pBuf, libc.Uint32FromInt32(cnt))
		if got == cnt {
			break
		}
		if got < 0 {
			if **(**int32)(__ccgo_up(libc.X__error(tls))) == int32(EINTR) {
				got = int32(1)
				continue
			}
			prior = 0
			_storeLastErrno(tls, id, **(**int32)(__ccgo_up(libc.X__error(tls))))
			break
		} else {
			if got > 0 {
				cnt = cnt - got
				offset = offset + int64(got)
				prior = prior + got
				pBuf = uintptr(got) + pBuf
			}
		}
	}
	return got + prior
}

// C documentation
//
//	/*
//	** Attempt to seek the file-descriptor passed as the first argument to
//	** absolute offset iOff, then attempt to write nBuf bytes of data from
//	** pBuf to it. If an error occurs, return -1 and set *piErrno. Otherwise,
//	** return the actual number of bytes written (which may be less than
//	** nBuf).
//	*/
func _seekAndWriteFd(tls *libc.TLS, fd int32, iOff Ti64, pBuf uintptr, nBuf int32, piErrno uintptr) (r int32) {
	var iSeek Ti64
	var rc int32
	_, _ = iSeek, rc
	rc = 0 /* Value returned by system call */
	nBuf = nBuf & int32(0x1ffff)
	for cond := true; cond; cond = rc < 0 && **(**int32)(__ccgo_up(libc.X__error(tls))) == int32(EINTR) {
		iSeek = libc.Xlseek(tls, fd, iOff, SEEK_SET)
		if iSeek < 0 {
			rc = -int32(1)
			break
		}
		rc = (*(*func(*libc.TLS, int32, uintptr, Tsize_t) Tssize_t)(unsafe.Pointer(&struct{ uintptr }{_aSyscall[int32(11)].FpCurrent})))(tls, fd, pBuf, libc.Uint32FromInt32(nBuf))
	}
	if rc < 0 {
		**(**int32)(__ccgo_up(piErrno)) = **(**int32)(__ccgo_up(libc.X__error(tls)))
	}
	return rc
}

// C documentation
//
//	/*
//	** The xExpr callback for the search of invalid ON clause terms.
//	*/
func _selectCheckOnClausesExpr(tls *libc.TLS, pWalker uintptr, pExpr uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var iTab, ii, nSrc int32
	var pCtx, pSrc, v2 uintptr
	_, _, _, _, _, _ = iTab, ii, nSrc, pCtx, pSrc, v2
	pCtx = *(*uintptr)(unsafe.Pointer(pWalker + 24))
	/* Check if pExpr is root or near-root of an ON clause constraint that needs
	 ** to be checked to ensure that it does not refer to tables in its FROM
	 ** clause to the right of itself. i.e. it is either:
	 **
	 **   + an ON clause on an OUTER join, or
	 **   + an ON clause on an INNER join within a FROM that features at
	 **     least one RIGHT or FULL join.
	 */
	if (*TExpr)(unsafe.Pointer(pExpr)).Fflags&libc.Uint32FromInt32(libc.Int32FromInt32(EP_OuterON)) != uint32(0) || (*TExpr)(unsafe.Pointer(pExpr)).Fflags&libc.Uint32FromInt32(libc.Int32FromInt32(EP_InnerON)) != uint32(0) && libc.Int32FromUint8((*(*TSrcItem)(unsafe.Pointer((*TCheckOnCtx)(unsafe.Pointer(pCtx)).FpSrc + 8))).Ffg.Fjointype)&int32(JT_LTORJ) != 0 {
		/* If CheckOnCtx.iJoin is already set, then fall through and process
		 ** this expression node as normal. Or, if CheckOnCtx.iJoin is still 0,
		 ** set it to the cursor number of the RHS of the join to which this
		 ** ON expression was attached and then iterate through the entire
		 ** expression.  */
		if (*TCheckOnCtx)(unsafe.Pointer(pCtx)).FiJoin == 0 {
			(*TCheckOnCtx)(unsafe.Pointer(pCtx)).FiJoin = *(*int32)(unsafe.Pointer(pExpr + 36))
			_sqlite3WalkExprNN(tls, pWalker, pExpr)
			(*TCheckOnCtx)(unsafe.Pointer(pCtx)).FiJoin = 0
			return int32(WRC_Prune)
		}
	}
	if libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pExpr)).Fop) == int32(TK_COLUMN) {
		/* A column expression. Find the SrcList (if any) to which it refers.
		 ** Then, if CheckOnCtx.iJoin indicates that this expression is part of an
		 ** ON clause from that SrcList (i.e. if iJoin is non-zero), check that it
		 ** does not refer to a table to the right of CheckOnCtx.iJoin. */
		for cond := true; cond; cond = pCtx != 0 {
			pSrc = (*TCheckOnCtx)(unsafe.Pointer(pCtx)).FpSrc
			nSrc = (*TSrcList)(unsafe.Pointer(pSrc)).FnSrc
			iTab = (*TExpr)(unsafe.Pointer(pExpr)).FiTable
			ii = 0
			for {
				if !(ii < nSrc && (*(*TSrcItem)(unsafe.Pointer(pSrc + 8 + uintptr(ii)*48))).FiCursor != iTab) {
					break
				}
				goto _1
			_1:
				;
				ii = ii + 1
			}
			if ii < nSrc {
				if (*TCheckOnCtx)(unsafe.Pointer(pCtx)).FiJoin != 0 && iTab > (*TCheckOnCtx)(unsafe.Pointer(pCtx)).FiJoin {
					if (*TCheckOnCtx)(unsafe.Pointer(pCtx)).FbFuncArg != 0 {
						v2 = __ccgo_ts + 21562
					} else {
						v2 = __ccgo_ts + 21586
					}
					_sqlite3ErrorMsg(tls, (*TWalker)(unsafe.Pointer(pWalker)).FpParse, __ccgo_ts+21596, libc.VaList(bp+8, v2))
					return int32(WRC_Abort)
				}
				break
			}
			pCtx = (*TCheckOnCtx)(unsafe.Pointer(pCtx)).FpParent
		}
	}
	return WRC_Continue
}

// C documentation
//
//	/*
//	** This routine generates the code for the inside of the inner loop
//	** of a SELECT.
//	**
//	** If srcTab is negative, then the p->pEList expressions
//	** are evaluated in order to get the data for this row.  If srcTab is
//	** zero or more, then data is pulled from srcTab and p->pEList is used only
//	** to get the number of columns and the collation sequence for each column.
//	*/
func _selectInnerLoop(tls *libc.TLS, pParse uintptr, p uintptr, srcTab int32, pSort uintptr, pDistinct uintptr, pDest uintptr, iContinue int32, iBreak int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var addr, addrTest, eDest, eType, hasDistinct, i, i2, iParm, iTab, j, nKey, nPrefixReg, nResultCol, r1, r11, r12, r13, r2, r21, r3, regOrig, regResult, v1 int32
	var ecelFlags Tu8
	var pEList, pSO, v uintptr
	var _ /* sRowLoadInfo at bp+0 */ TRowLoadInfo
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = addr, addrTest, eDest, eType, ecelFlags, hasDistinct, i, i2, iParm, iTab, j, nKey, nPrefixReg, nResultCol, pEList, pSO, r1, r11, r12, r13, r2, r21, r3, regOrig, regResult, v, v1
	v = (*TParse)(unsafe.Pointer(pParse)).FpVdbe                              /* True if the DISTINCT keyword is present */
	eDest = libc.Int32FromUint8((*TSelectDest)(unsafe.Pointer(pDest)).FeDest) /* How to dispose of results */
	iParm = (*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm                    /* Number of result columns */
	nPrefixReg = 0                                                            /* Start of memory holding full result (or 0) */
	if pDistinct != 0 {
		v1 = libc.Int32FromUint8((*TDistinctCtx)(unsafe.Pointer(pDistinct)).FeTnctType)
	} else {
		v1 = WHERE_DISTINCT_NOOP
	}
	hasDistinct = v1
	if pSort != 0 && (*TSortCtx)(unsafe.Pointer(pSort)).FpOrderBy == uintptr(0) {
		pSort = uintptr(0)
	}
	if pSort == uintptr(0) && !(hasDistinct != 0) {
		_codeOffset(tls, v, (*TSelect)(unsafe.Pointer(p)).FiOffset, iContinue)
	}
	/* Pull the requested columns.
	 */
	nResultCol = (*TExprList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpEList)).FnExpr
	if (*TSelectDest)(unsafe.Pointer(pDest)).FiSdst == 0 {
		if pSort != 0 {
			nPrefixReg = (*TExprList)(unsafe.Pointer((*TSortCtx)(unsafe.Pointer(pSort)).FpOrderBy)).FnExpr
			if !(libc.Int32FromUint8((*TSortCtx)(unsafe.Pointer(pSort)).FsortFlags)&libc.Int32FromInt32(SORTFLAG_UseSorter) != 0) {
				nPrefixReg = nPrefixReg + 1
			}
			**(**int32)(__ccgo_up(pParse + 48)) += nPrefixReg
		}
		(*TSelectDest)(unsafe.Pointer(pDest)).FiSdst = (*TParse)(unsafe.Pointer(pParse)).FnMem + int32(1)
		**(**int32)(__ccgo_up(pParse + 48)) += nResultCol
	} else {
		if (*TSelectDest)(unsafe.Pointer(pDest)).FiSdst+nResultCol > (*TParse)(unsafe.Pointer(pParse)).FnMem {
			/* This is an error condition that can result, for example, when a SELECT
			 ** on the right-hand side of an INSERT contains more result columns than
			 ** there are columns in the table on the left.  The error will be caught
			 ** and reported later.  But we need to make sure enough memory is allocated
			 ** to avoid other spurious errors in the meantime. */
			**(**int32)(__ccgo_up(pParse + 48)) += nResultCol
		}
	}
	(*TSelectDest)(unsafe.Pointer(pDest)).FnSdst = nResultCol
	v1 = (*TSelectDest)(unsafe.Pointer(pDest)).FiSdst
	regResult = v1
	regOrig = v1
	if srcTab >= 0 {
		i = 0
		for {
			if !(i < nResultCol) {
				break
			}
			_sqlite3VdbeAddOp3(tls, v, int32(OP_Column), srcTab, i, regResult+i)
			goto _3
		_3:
			;
			i = i + 1
		}
	} else {
		if eDest != int32(SRT_Exists) {
			if eDest == int32(SRT_Mem) || eDest == int32(SRT_Output) || eDest == int32(SRT_Coroutine) {
				ecelFlags = uint8(SQLITE_ECEL_DUP)
			} else {
				ecelFlags = uint8(0)
			}
			if pSort != 0 && hasDistinct == 0 && eDest != int32(SRT_EphemTab) && eDest != int32(SRT_Table) {
				/* For each expression in p->pEList that is a copy of an expression in
				 ** the ORDER BY clause (pSort->pOrderBy), set the associated
				 ** iOrderByCol value to one more than the index of the ORDER BY
				 ** expression within the sort-key that pushOntoSorter() will generate.
				 ** This allows the p->pEList field to be omitted from the sorted record,
				 ** saving space and CPU cycles.  */
				ecelFlags = libc.Uint8FromInt32(int32(ecelFlags) | (libc.Int32FromInt32(SQLITE_ECEL_OMITREF) | libc.Int32FromInt32(SQLITE_ECEL_REF)))
				i = (*TSortCtx)(unsafe.Pointer(pSort)).FnOBSat
				for {
					if !(i < (*TExprList)(unsafe.Pointer((*TSortCtx)(unsafe.Pointer(pSort)).FpOrderBy)).FnExpr) {
						break
					}
					v1 = libc.Int32FromUint16(*(*Tu16)(unsafe.Pointer((*TSortCtx)(unsafe.Pointer(pSort)).FpOrderBy + 8 + uintptr(i)*20 + 16)))
					j = v1
					if v1 > 0 {
						*(*Tu16)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpEList + 8 + uintptr(j-int32(1))*20 + 16)) = libc.Uint16FromInt32(i + int32(1) - (*TSortCtx)(unsafe.Pointer(pSort)).FnOBSat)
					}
					goto _4
				_4:
					;
					i = i + 1
				}
				/* Adjust nResultCol to account for columns that are omitted
				 ** from the sorter by the optimizations in this branch */
				pEList = (*TSelect)(unsafe.Pointer(p)).FpEList
				i = 0
				for {
					if !(i < (*TExprList)(unsafe.Pointer(pEList)).FnExpr) {
						break
					}
					if libc.Int32FromUint16(*(*Tu16)(unsafe.Pointer(pEList + 8 + uintptr(i)*20 + 16))) > 0 {
						nResultCol = nResultCol - 1
						regOrig = 0
					}
					goto _6
				_6:
					;
					i = i + 1
				}
			}
			(**(**TRowLoadInfo)(__ccgo_up(bp))).FregResult = regResult
			(**(**TRowLoadInfo)(__ccgo_up(bp))).FecelFlags = ecelFlags
			if (*TSelect)(unsafe.Pointer(p)).FiLimit != 0 && libc.Int32FromUint8(ecelFlags)&int32(SQLITE_ECEL_OMITREF) != 0 && nPrefixReg > 0 {
				(*TSortCtx)(unsafe.Pointer(pSort)).FpDeferredRowLoad = bp
				regOrig = 0
			} else {
				_innerLoopLoadRow(tls, pParse, p, bp)
			}
		}
	}
	/* If the DISTINCT keyword was present on the SELECT statement
	 ** and this row has been seen before, then do not make this row
	 ** part of the result.
	 */
	if hasDistinct != 0 {
		eType = libc.Int32FromUint8((*TDistinctCtx)(unsafe.Pointer(pDistinct)).FeTnctType)
		iTab = (*TDistinctCtx)(unsafe.Pointer(pDistinct)).FtabTnct
		iTab = _codeDistinct(tls, pParse, eType, iTab, iContinue, (*TSelect)(unsafe.Pointer(p)).FpEList, regResult)
		_fixDistinctOpenEph(tls, pParse, eType, iTab, (*TDistinctCtx)(unsafe.Pointer(pDistinct)).FaddrTnct)
		if pSort == uintptr(0) {
			_codeOffset(tls, v, (*TSelect)(unsafe.Pointer(p)).FiOffset, iContinue)
		}
	}
	switch eDest {
	/* Store the result as data using a unique key.
	 */
	case int32(SRT_Fifo):
		fallthrough
	case int32(SRT_DistFifo):
		fallthrough
	case int32(SRT_Table):
		fallthrough
	case int32(SRT_EphemTab):
		r1 = _sqlite3GetTempRange(tls, pParse, nPrefixReg+int32(1))
		_sqlite3VdbeAddOp3(tls, v, int32(OP_MakeRecord), regResult, nResultCol, r1+nPrefixReg)
		if eDest == int32(SRT_DistFifo) {
			/* If the destination is DistFifo, then cursor (iParm+1) is open
			 ** on an ephemeral index. If the current row is already present
			 ** in the index, do not write it to the output. If not, add the
			 ** current row to the index and proceed with writing it to the
			 ** output table as well.  */
			addr = _sqlite3VdbeCurrentAddr(tls, v) + int32(4)
			_sqlite3VdbeAddOp4Int(tls, v, int32(OP_Found), iParm+int32(1), addr, r1, 0)
			_sqlite3VdbeAddOp4Int(tls, v, int32(OP_IdxInsert), iParm+int32(1), r1, regResult, nResultCol)
		}
		if pSort != 0 {
			_pushOntoSorter(tls, pParse, pSort, p, r1+nPrefixReg, regOrig, int32(1), nPrefixReg)
		} else {
			r2 = _sqlite3GetTempReg(tls, pParse)
			_sqlite3VdbeAddOp2(tls, v, int32(OP_NewRowid), iParm, r2)
			_sqlite3VdbeAddOp3(tls, v, int32(OP_Insert), iParm, r1, r2)
			_sqlite3VdbeChangeP5(tls, v, uint16(OPFLAG_APPEND))
			_sqlite3ReleaseTempReg(tls, pParse, r2)
		}
		_sqlite3ReleaseTempRange(tls, pParse, r1, nPrefixReg+int32(1))
	case int32(SRT_Upfrom):
		if pSort != 0 {
			_pushOntoSorter(tls, pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg)
		} else {
			i2 = (*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm2
			r11 = _sqlite3GetTempReg(tls, pParse)
			/* If the UPDATE FROM join is an aggregate that matches no rows, it
			 ** might still be trying to return one row, because that is what
			 ** aggregates do.  Don't record that empty row in the output table. */
			_sqlite3VdbeAddOp2(tls, v, int32(OP_IsNull), regResult, iBreak)
			_sqlite3VdbeAddOp3(tls, v, int32(OP_MakeRecord), regResult+libc.BoolInt32(i2 < 0), nResultCol-libc.BoolInt32(i2 < 0), r11)
			if i2 < 0 {
				_sqlite3VdbeAddOp3(tls, v, int32(OP_Insert), iParm, r11, regResult)
			} else {
				_sqlite3VdbeAddOp4Int(tls, v, int32(OP_IdxInsert), iParm, r11, regResult, i2)
			}
		}
		break
		/* If we are creating a set for an "expr IN (SELECT ...)" construct,
		 ** then there should be a single item on the stack.  Write this
		 ** item into the set table with bogus data.
		 */
		fallthrough
	case int32(SRT_Set):
		if pSort != 0 {
			/* At first glance you would think we could optimize out the
			 ** ORDER BY in this case since the order of entries in the set
			 ** does not matter.  But there might be a LIMIT clause, in which
			 ** case the order does matter */
			_pushOntoSorter(tls, pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg)
			(*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm2 = 0 /* Signal that any Bloom filter is unpopulated */
		} else {
			r12 = _sqlite3GetTempReg(tls, pParse)
			_sqlite3VdbeAddOp4(tls, v, int32(OP_MakeRecord), regResult, nResultCol, r12, (*TSelectDest)(unsafe.Pointer(pDest)).FzAffSdst, nResultCol)
			_sqlite3VdbeAddOp4Int(tls, v, int32(OP_IdxInsert), iParm, r12, regResult, nResultCol)
			if (*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm2 != 0 {
				_sqlite3VdbeAddOp4Int(tls, v, int32(OP_FilterAdd), (*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm2, 0, regResult, nResultCol)
				_sqlite3VdbeExplain(tls, pParse, uint8(0), __ccgo_ts+20467, 0)
			}
			_sqlite3ReleaseTempReg(tls, pParse, r12)
		}
		break
		/* If any row exist in the result set, record that fact and abort.
		 */
		fallthrough
	case int32(SRT_Exists):
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), int32(1), iParm)
		/* The LIMIT clause will terminate the loop for us */
		break
		/* If this is a scalar select that is part of an expression, then
		 ** store the results in the appropriate memory cell or array of
		 ** memory cells and break out of the scan loop.
		 */
		fallthrough
	case int32(SRT_Mem):
		if pSort != 0 {
			_pushOntoSorter(tls, pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg)
			(*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm = regResult
		} else {
			if regResult != iParm {
				/* This occurs in cases where the SELECT had both a DISTINCT and
				 ** an OFFSET clause.  */
				_sqlite3VdbeAddOp3(tls, v, int32(OP_Copy), regResult, iParm, nResultCol-int32(1))
			}
			/* The LIMIT clause will jump out of the loop for us */
		}
	case int32(SRT_Coroutine): /* Send data to a co-routine */
		fallthrough
	case int32(SRT_Output): /* Return the results */
		if pSort != 0 {
			_pushOntoSorter(tls, pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg)
		} else {
			if eDest == int32(SRT_Coroutine) {
				_sqlite3VdbeAddOp1(tls, v, int32(OP_Yield), (*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm)
			} else {
				_sqlite3VdbeAddOp2(tls, v, int32(OP_ResultRow), regResult, nResultCol)
			}
		}
		break
		/* Write the results into a priority queue that is order according to
		 ** pDest->pOrderBy (in pSO).  pDest->iSDParm (in iParm) is the cursor for an
		 ** index with pSO->nExpr+2 columns.  Build a key using pSO for the first
		 ** pSO->nExpr columns, then make sure all keys are unique by adding a
		 ** final OP_Sequence column.  The last column is the record as a blob.
		 */
		fallthrough
	case int32(SRT_DistQueue):
		fallthrough
	case int32(SRT_Queue):
		addrTest = 0
		pSO = (*TSelectDest)(unsafe.Pointer(pDest)).FpOrderBy
		nKey = (*TExprList)(unsafe.Pointer(pSO)).FnExpr
		r13 = _sqlite3GetTempReg(tls, pParse)
		r21 = _sqlite3GetTempRange(tls, pParse, nKey+int32(2))
		r3 = r21 + nKey + int32(1)
		if eDest == int32(SRT_DistQueue) {
			/* If the destination is DistQueue, then cursor (iParm+1) is open
			 ** on a second ephemeral index that holds all values every previously
			 ** added to the queue. */
			addrTest = _sqlite3VdbeAddOp4Int(tls, v, int32(OP_Found), iParm+int32(1), 0, regResult, nResultCol)
		}
		_sqlite3VdbeAddOp3(tls, v, int32(OP_MakeRecord), regResult, nResultCol, r3)
		if eDest == int32(SRT_DistQueue) {
			_sqlite3VdbeAddOp2(tls, v, int32(OP_IdxInsert), iParm+int32(1), r3)
			_sqlite3VdbeChangeP5(tls, v, uint16(OPFLAG_USESEEKRESULT))
		}
		i = 0
		for {
			if !(i < nKey) {
				break
			}
			_sqlite3VdbeAddOp2(tls, v, int32(OP_SCopy), regResult+libc.Int32FromUint16(*(*Tu16)(unsafe.Pointer(pSO + 8 + uintptr(i)*20 + 16)))-int32(1), r21+i)
			goto _7
		_7:
			;
			i = i + 1
		}
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Sequence), iParm, r21+nKey)
		_sqlite3VdbeAddOp3(tls, v, int32(OP_MakeRecord), r21, nKey+int32(2), r13)
		_sqlite3VdbeAddOp4Int(tls, v, int32(OP_IdxInsert), iParm, r13, r21, nKey+int32(2))
		if addrTest != 0 {
			_sqlite3VdbeJumpHere(tls, v, addrTest)
		}
		_sqlite3ReleaseTempReg(tls, pParse, r13)
		_sqlite3ReleaseTempRange(tls, pParse, r21, nKey+int32(2))
		break
		/* Discard the results.  This is used for SELECT statements inside
		 ** the body of a TRIGGER.  The purpose of such selects is to call
		 ** user-defined functions that have side effects.  We do not care
		 ** about the actual results of the select.
		 */
		fallthrough
	default:
		break
	}
	/* Jump to the end of the loop if the LIMIT is reached.  Except, if
	 ** there is a sorter, in which case the sorter has already limited
	 ** the output for us.
	 */
	if pSort == uintptr(0) && (*TSelect)(unsafe.Pointer(p)).FiLimit != 0 {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_DecrJumpZero), (*TSelect)(unsafe.Pointer(p)).FiLimit, iBreak)
	}
}

// C documentation
//
//	/*
//	** Return a comma-separated list of the fully-qualified (with both database
//	** and table name) column names from table pTab. e.g.
//	**
//	**    "main"."t1"."a", "main"."t1"."b", "main"."t1"."c"
//	*/
func _sessionAllCols(tls *libc.TLS, zDb uintptr, pTab uintptr) (r uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var ii int32
	var zRet, v2 uintptr
	_, _, _ = ii, zRet, v2
	zRet = uintptr(0)
	ii = 0
	for {
		if !(ii < (*TSessionTable)(unsafe.Pointer(pTab)).FnCol) {
			break
		}
		if zRet != 0 {
			v2 = __ccgo_ts + 16216
		} else {
			v2 = __ccgo_ts + 1702
		}
		zRet = Xsqlite3_mprintf(tls, __ccgo_ts+35529, libc.VaList(bp+8, zRet, v2, zDb, (*TSessionTable)(unsafe.Pointer(pTab)).FzName, **(**uintptr)(__ccgo_up((*TSessionTable)(unsafe.Pointer(pTab)).FazCol + uintptr(ii)*4))))
		if !(zRet != 0) {
			break
		}
		goto _1
	_1:
		;
		ii = ii + 1
	}
	return zRet
}

// C documentation
//
//	/*
//	** Formulate a statement to DELETE a row from database db. Assuming a table
//	** structure like this:
//	**
//	**     CREATE TABLE x(a, b, c, d, PRIMARY KEY(a, c));
//	**
//	** The DELETE statement looks like this:
//	**
//	**     DELETE FROM x WHERE a = :1 AND c = :3 AND (:5 OR b IS :2 AND d IS :4)
//	**
//	** Variable :5 (nCol+1) is a boolean. It should be set to 0 if we require
//	** matching b and d values, or 1 otherwise. The second case comes up if the
//	** conflict handler is invoked with NOTFOUND and returns CHANGESET_REPLACE.
//	**
//	** If successful, SQLITE_OK is returned and SessionApplyCtx.pDelete is left
//	** pointing to the prepared version of the SQL statement.
//	*/
func _sessionDeleteRow(tls *libc.TLS, db uintptr, zTab uintptr, p uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var i, nPk int32
	var zSep uintptr
	var _ /* buf at bp+4 */ TSessionBuffer
	var _ /* rc at bp+0 */ int32
	_, _, _ = i, nPk, zSep
	zSep = __ccgo_ts + 1702
	**(**int32)(__ccgo_up(bp)) = SQLITE_OK
	**(**TSessionBuffer)(__ccgo_up(bp + 4)) = TSessionBuffer{}
	nPk = 0
	_sessionAppendStr(tls, bp+4, __ccgo_ts+36004, bp)
	_sessionAppendIdent(tls, bp+4, zTab, bp)
	_sessionAppendStr(tls, bp+4, __ccgo_ts+35915, bp)
	i = 0
	for {
		if !(i < (*TSessionApplyCtx)(unsafe.Pointer(p)).FnCol) {
			break
		}
		if **(**Tu8)(__ccgo_up((*TSessionApplyCtx)(unsafe.Pointer(p)).FabPK + uintptr(i))) != 0 {
			nPk = nPk + 1
			_sessionAppendStr(tls, bp+4, zSep, bp)
			_sessionAppendIdent(tls, bp+4, **(**uintptr)(__ccgo_up((*TSessionApplyCtx)(unsafe.Pointer(p)).FazCol + uintptr(i)*4)), bp)
			_sessionAppendStr(tls, bp+4, __ccgo_ts+35910, bp)
			_sessionAppendInteger(tls, bp+4, i+int32(1), bp)
			zSep = __ccgo_ts + 23627
		}
		goto _1
	_1:
		;
		i = i + 1
	}
	if nPk < (*TSessionApplyCtx)(unsafe.Pointer(p)).FnCol {
		_sessionAppendStr(tls, bp+4, __ccgo_ts+36022, bp)
		_sessionAppendInteger(tls, bp+4, (*TSessionApplyCtx)(unsafe.Pointer(p)).FnCol+int32(1), bp)
		_sessionAppendStr(tls, bp+4, __ccgo_ts+35434, bp)
		zSep = __ccgo_ts + 1702
		i = 0
		for {
			if !(i < (*TSessionApplyCtx)(unsafe.Pointer(p)).FnCol) {
				break
			}
			if !(**(**Tu8)(__ccgo_up((*TSessionApplyCtx)(unsafe.Pointer(p)).FabPK + uintptr(i))) != 0) {
				_sessionAppendStr(tls, bp+4, zSep, bp)
				_sessionAppendIdent(tls, bp+4, **(**uintptr)(__ccgo_up((*TSessionApplyCtx)(unsafe.Pointer(p)).FazCol + uintptr(i)*4)), bp)
				_sessionAppendStr(tls, bp+4, __ccgo_ts+35998, bp)
				_sessionAppendInteger(tls, bp+4, i+int32(1), bp)
				zSep = __ccgo_ts + 36030
			}
			goto _2
		_2:
			;
			i = i + 1
		}
		_sessionAppendStr(tls, bp+4, __ccgo_ts+5259, bp)
	}
	if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
		**(**int32)(__ccgo_up(bp)) = _sessionPrepare(tls, db, p+4, p+80, (**(**TSessionBuffer)(__ccgo_up(bp + 4))).FaBuf)
	}
	Xsqlite3_free(tls, (**(**TSessionBuffer)(__ccgo_up(bp + 4))).FaBuf)
	return **(**int32)(__ccgo_up(bp))
}

func _sessionExprCompareOther(tls *libc.TLS, nCol int32, zDb1 uintptr, zDb2 uintptr, zTab uintptr, azCol uintptr, abPK uintptr) (r uintptr) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var bHave, i int32
	var zRet, zSep uintptr
	_, _, _, _ = bHave, i, zRet, zSep
	zSep = __ccgo_ts + 1702
	zRet = uintptr(0)
	bHave = 0
	i = 0
	for {
		if !(i < nCol) {
			break
		}
		if libc.Int32FromUint8(**(**Tu8)(__ccgo_up(abPK + uintptr(i)))) == 0 {
			bHave = int32(1)
			zRet = Xsqlite3_mprintf(tls, __ccgo_ts+35393, libc.VaList(bp+8, zRet, zSep, zDb1, zTab, **(**uintptr)(__ccgo_up(azCol + uintptr(i)*4)), zDb2, zTab, **(**uintptr)(__ccgo_up(azCol + uintptr(i)*4))))
			zSep = __ccgo_ts + 35434
			if zRet == uintptr(0) {
				break
			}
		}
		goto _1
	_1:
		;
		i = i + 1
	}
	if bHave == 0 {
		zRet = Xsqlite3_mprintf(tls, __ccgo_ts+1848, 0)
	}
	return zRet
}

func _sessionExprComparePK(tls *libc.TLS, nCol int32, zDb1 uintptr, zDb2 uintptr, zTab uintptr, azCol uintptr, abPK uintptr) (r uintptr) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var i int32
	var zRet, zSep uintptr
	_, _, _ = i, zRet, zSep
	zSep = __ccgo_ts + 1702
	zRet = uintptr(0)
	i = 0
	for {
		if !(i < nCol) {
			break
		}
		if **(**Tu8)(__ccgo_up(abPK + uintptr(i))) != 0 {
			zRet = Xsqlite3_mprintf(tls, __ccgo_ts+35359, libc.VaList(bp+8, zRet, zSep, zDb1, zTab, **(**uintptr)(__ccgo_up(azCol + uintptr(i)*4)), zDb2, zTab, **(**uintptr)(__ccgo_up(azCol + uintptr(i)*4))))
			zSep = __ccgo_ts + 23627
			if zRet == uintptr(0) {
				break
			}
		}
		goto _1
	_1:
		;
		i = i + 1
	}
	return zRet
}

// C documentation
//
//	/*
//	** Generate either a changeset (if argument bPatchset is zero) or a patchset
//	** (if it is non-zero) based on the current contents of the session object
//	** passed as the first argument.
//	**
//	** If no error occurs, SQLITE_OK is returned and the new changeset/patchset
//	** stored in output variables *pnChangeset and *ppChangeset. Or, if an error
//	** occurs, an SQLite error code is returned and both output variables set
//	** to 0.
//	*/
func _sessionGenerateChangeset(tls *libc.TLS, pSession uintptr, bPatchset int32, __ccgo_fp_xOutput uintptr, pOut uintptr, pnChangeset uintptr, ppChangeset uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var db, p, pTab, zName uintptr
	var i, iCol, nNoop, nOldCol, nRewind int32
	var _ /* buf at bp+0 */ TSessionBuffer
	var _ /* pSel at bp+16 */ uintptr
	var _ /* rc at bp+12 */ int32
	_, _, _, _, _, _, _, _, _ = db, i, iCol, nNoop, nOldCol, nRewind, p, pTab, zName
	db = (*Tsqlite3_session)(unsafe.Pointer(pSession)).Fdb /* Used to iterate through attached tables */
	**(**TSessionBuffer)(__ccgo_up(bp)) = TSessionBuffer{} /* Return code */
	/* Zero the output variables in case an error occurs. If this session
	 ** object is already in the error state (sqlite3_session.rc != SQLITE_OK),
	 ** this call will be a no-op.  */
	if __ccgo_fp_xOutput == uintptr(0) {
		**(**int32)(__ccgo_up(pnChangeset)) = 0
		**(**uintptr)(__ccgo_up(ppChangeset)) = uintptr(0)
	}
	if (*Tsqlite3_session)(unsafe.Pointer(pSession)).Frc != 0 {
		return (*Tsqlite3_session)(unsafe.Pointer(pSession)).Frc
	}
	Xsqlite3_mutex_enter(tls, Xsqlite3_db_mutex(tls, db))
	**(**int32)(__ccgo_up(bp + 12)) = Xsqlite3_exec(tls, (*Tsqlite3_session)(unsafe.Pointer(pSession)).Fdb, __ccgo_ts+35853, uintptr(0), uintptr(0), uintptr(0))
	if **(**int32)(__ccgo_up(bp + 12)) != SQLITE_OK {
		Xsqlite3_mutex_leave(tls, Xsqlite3_db_mutex(tls, db))
		return **(**int32)(__ccgo_up(bp + 12))
	}
	pTab = (*Tsqlite3_session)(unsafe.Pointer(pSession)).FpTable
	for {
		if !(**(**int32)(__ccgo_up(bp + 12)) == SQLITE_OK && pTab != 0) {
			break
		}
		if (*TSessionTable)(unsafe.Pointer(pTab)).FnEntry != 0 {
			zName = (*TSessionTable)(unsafe.Pointer(pTab)).FzName /* Used to iterate through hash buckets */
			**(**uintptr)(__ccgo_up(bp + 16)) = uintptr(0)        /* SELECT statement to query table pTab */
			nRewind = (**(**TSessionBuffer)(__ccgo_up(bp))).FnBuf /* Size of buffer after writing tbl header */
			nOldCol = (*TSessionTable)(unsafe.Pointer(pTab)).FnCol
			/* Check the table schema is still Ok. */
			**(**int32)(__ccgo_up(bp + 12)) = _sessionReinitTable(tls, pSession, pTab)
			if **(**int32)(__ccgo_up(bp + 12)) == SQLITE_OK && (*TSessionTable)(unsafe.Pointer(pTab)).FnCol != nOldCol {
				**(**int32)(__ccgo_up(bp + 12)) = _sessionUpdateChanges(tls, pSession, pTab)
			}
			/* Write a table header */
			_sessionAppendTableHdr(tls, bp, bPatchset, pTab, bp+12)
			/* Build and compile a statement to execute: */
			if **(**int32)(__ccgo_up(bp + 12)) == SQLITE_OK {
				**(**int32)(__ccgo_up(bp + 12)) = _sessionSelectStmt(tls, db, 0, (*Tsqlite3_session)(unsafe.Pointer(pSession)).FzDb, zName, (*TSessionTable)(unsafe.Pointer(pTab)).FbRowid, (*TSessionTable)(unsafe.Pointer(pTab)).FnCol, (*TSessionTable)(unsafe.Pointer(pTab)).FazCol, (*TSessionTable)(unsafe.Pointer(pTab)).FabPK, bp+16, uintptr(0))
			}
			nNoop = (**(**TSessionBuffer)(__ccgo_up(bp))).FnBuf
			i = 0
			for {
				if !(i < (*TSessionTable)(unsafe.Pointer(pTab)).FnChange && **(**int32)(__ccgo_up(bp + 12)) == SQLITE_OK) {
					break
				} /* Used to iterate through changes */
				p = **(**uintptr)(__ccgo_up((*TSessionTable)(unsafe.Pointer(pTab)).FapChange + uintptr(i)*4))
				for {
					if !(**(**int32)(__ccgo_up(bp + 12)) == SQLITE_OK && p != 0) {
						break
					}
					**(**int32)(__ccgo_up(bp + 12)) = _sessionSelectBind(tls, **(**uintptr)(__ccgo_up(bp + 16)), (*TSessionTable)(unsafe.Pointer(pTab)).FnCol, (*TSessionTable)(unsafe.Pointer(pTab)).FabPK, p)
					if **(**int32)(__ccgo_up(bp + 12)) != SQLITE_OK {
						goto _3
					}
					if Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp + 16))) == int32(SQLITE_ROW) {
						if libc.Int32FromUint8((*TSessionChange)(unsafe.Pointer(p)).Fop) == int32(SQLITE_INSERT) {
							_sessionAppendByte(tls, bp, uint8(SQLITE_INSERT), bp+12)
							_sessionAppendByte(tls, bp, (*TSessionChange)(unsafe.Pointer(p)).FbIndirect, bp+12)
							iCol = 0
							for {
								if !(iCol < (*TSessionTable)(unsafe.Pointer(pTab)).FnCol) {
									break
								}
								_sessionAppendCol(tls, bp, **(**uintptr)(__ccgo_up(bp + 16)), iCol, bp+12)
								goto _4
							_4:
								;
								iCol = iCol + 1
							}
						} else {
							**(**int32)(__ccgo_up(bp + 12)) = _sessionAppendUpdate(tls, bp, bPatchset, **(**uintptr)(__ccgo_up(bp + 16)), p, (*TSessionTable)(unsafe.Pointer(pTab)).FabPK)
						}
					} else {
						if libc.Int32FromUint8((*TSessionChange)(unsafe.Pointer(p)).Fop) != int32(SQLITE_INSERT) {
							**(**int32)(__ccgo_up(bp + 12)) = _sessionAppendDelete(tls, bp, bPatchset, p, (*TSessionTable)(unsafe.Pointer(pTab)).FnCol, (*TSessionTable)(unsafe.Pointer(pTab)).FabPK)
						}
					}
					if **(**int32)(__ccgo_up(bp + 12)) == SQLITE_OK {
						**(**int32)(__ccgo_up(bp + 12)) = Xsqlite3_reset(tls, **(**uintptr)(__ccgo_up(bp + 16)))
					}
					/* If the buffer is now larger than sessions_strm_chunk_size, pass
					 ** its contents to the xOutput() callback. */
					if __ccgo_fp_xOutput != 0 && **(**int32)(__ccgo_up(bp + 12)) == SQLITE_OK && (**(**TSessionBuffer)(__ccgo_up(bp))).FnBuf > nNoop && (**(**TSessionBuffer)(__ccgo_up(bp))).FnBuf > _sessions_strm_chunk_size {
						**(**int32)(__ccgo_up(bp + 12)) = (*(*func(*libc.TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_xOutput})))(tls, pOut, (**(**TSessionBuffer)(__ccgo_up(bp))).FaBuf, (**(**TSessionBuffer)(__ccgo_up(bp))).FnBuf)
						nNoop = -int32(1)
						(**(**TSessionBuffer)(__ccgo_up(bp))).FnBuf = 0
					}
					goto _3
				_3:
					;
					p = (*TSessionChange)(unsafe.Pointer(p)).FpNext
				}
				goto _2
			_2:
				;
				i = i + 1
			}
			Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp + 16)))
			if (**(**TSessionBuffer)(__ccgo_up(bp))).FnBuf == nNoop {
				(**(**TSessionBuffer)(__ccgo_up(bp))).FnBuf = nRewind
			}
		}
		goto _1
	_1:
		;
		pTab = (*TSessionTable)(unsafe.Pointer(pTab)).FpNext
	}
	if **(**int32)(__ccgo_up(bp + 12)) == SQLITE_OK {
		if __ccgo_fp_xOutput == uintptr(0) {
			**(**int32)(__ccgo_up(pnChangeset)) = (**(**TSessionBuffer)(__ccgo_up(bp))).FnBuf
			**(**uintptr)(__ccgo_up(ppChangeset)) = (**(**TSessionBuffer)(__ccgo_up(bp))).FaBuf
			(**(**TSessionBuffer)(__ccgo_up(bp))).FaBuf = uintptr(0)
		} else {
			if (**(**TSessionBuffer)(__ccgo_up(bp))).FnBuf > 0 {
				**(**int32)(__ccgo_up(bp + 12)) = (*(*func(*libc.TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_xOutput})))(tls, pOut, (**(**TSessionBuffer)(__ccgo_up(bp))).FaBuf, (**(**TSessionBuffer)(__ccgo_up(bp))).FnBuf)
			}
		}
	}
	Xsqlite3_free(tls, (**(**TSessionBuffer)(__ccgo_up(bp))).FaBuf)
	Xsqlite3_exec(tls, db, __ccgo_ts+35873, uintptr(0), uintptr(0), uintptr(0))
	Xsqlite3_mutex_leave(tls, Xsqlite3_db_mutex(tls, db))
	return **(**int32)(__ccgo_up(bp + 12))
}

// C documentation
//
//	/*
//	** This function is called to initialize the SessionTable.nCol, azCol[]
//	** abPK[] and azDflt[] members of SessionTable object pTab. If these
//	** fields are already initialized, this function is a no-op.
//	**
//	** If an error occurs, an error code is stored in sqlite3_session.rc and
//	** non-zero returned. Or, if no error occurs but the table has no primary
//	** key, sqlite3_session.rc is left set to SQLITE_OK and non-zero returned to
//	** indicate that updates on this table should be ignored. SessionTable.abPK
//	** is set to NULL in this case.
//	*/
func _sessionInitTable(tls *libc.TLS, pSession uintptr, pTab uintptr, db uintptr, zDb uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var i, rc int32
	var v1 uintptr
	var _ /* abPK at bp+0 */ uintptr
	_, _, _ = i, rc, v1
	rc = SQLITE_OK
	if (*TSessionTable)(unsafe.Pointer(pTab)).FnCol == 0 {
		Xsqlite3_free(tls, (*TSessionTable)(unsafe.Pointer(pTab)).FazCol)
		(*TSessionTable)(unsafe.Pointer(pTab)).FabPK = uintptr(0)
		if pSession == uintptr(0) || (*Tsqlite3_session)(unsafe.Pointer(pSession)).FbImplicitPK != 0 {
			v1 = pTab + 20
		} else {
			v1 = uintptr(0)
		}
		rc = _sessionTableInfo(tls, pSession, db, zDb, (*TSessionTable)(unsafe.Pointer(pTab)).FzName, pTab+8, pTab+12, uintptr(0), pTab+24, pTab+28, pTab+32, bp, v1)
		if rc == SQLITE_OK {
			i = 0
			for {
				if !(i < (*TSessionTable)(unsafe.Pointer(pTab)).FnCol) {
					break
				}
				if **(**Tu8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + uintptr(i))) != 0 {
					(*TSessionTable)(unsafe.Pointer(pTab)).FabPK = **(**uintptr)(__ccgo_up(bp))
					break
				}
				goto _2
			_2:
				;
				i = i + 1
			}
			if 0 == Xsqlite3_stricmp(tls, __ccgo_ts+12835, (*TSessionTable)(unsafe.Pointer(pTab)).FzName) {
				(*TSessionTable)(unsafe.Pointer(pTab)).FbStat1 = int32(1)
			}
			if pSession != 0 && (*Tsqlite3_session)(unsafe.Pointer(pSession)).FbEnableSize != 0 {
				**(**Ti64)(__ccgo_up(pSession + 48)) += libc.Int64FromUint32(libc.Uint32FromInt32(libc.Int32FromInt32(1)+_sessionVarintLen(tls, (*TSessionTable)(unsafe.Pointer(pTab)).FnCol)+(*TSessionTable)(unsafe.Pointer(pTab)).FnCol) + libc.Xstrlen(tls, (*TSessionTable)(unsafe.Pointer(pTab)).FzName) + libc.Uint32FromInt32(1))
			}
		}
	}
	if pSession != 0 {
		(*Tsqlite3_session)(unsafe.Pointer(pSession)).Frc = rc
		return libc.BoolInt32(rc != 0 || (*TSessionTable)(unsafe.Pointer(pTab)).FabPK == uintptr(0))
	}
	return rc
}

// C documentation
//
//	/*
//	** Formulate and prepare an INSERT statement to add a record to table zTab.
//	** For example:
//	**
//	**     INSERT INTO main."zTab" VALUES(?1, ?2, ?3 ...);
//	**
//	** If successful, SQLITE_OK is returned and SessionApplyCtx.pInsert is left
//	** pointing to the prepared version of the SQL statement.
//	*/
func _sessionInsertRow(tls *libc.TLS, db uintptr, zTab uintptr, p uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var i int32
	var _ /* buf at bp+4 */ TSessionBuffer
	var _ /* rc at bp+0 */ int32
	_ = i
	**(**int32)(__ccgo_up(bp)) = SQLITE_OK
	**(**TSessionBuffer)(__ccgo_up(bp + 4)) = TSessionBuffer{}
	_sessionAppendStr(tls, bp+4, __ccgo_ts+36035, bp)
	_sessionAppendIdent(tls, bp+4, zTab, bp)
	_sessionAppendStr(tls, bp+4, __ccgo_ts+23633, bp)
	i = 0
	for {
		if !(i < (*TSessionApplyCtx)(unsafe.Pointer(p)).FnCol) {
			break
		}
		if i != 0 {
			_sessionAppendStr(tls, bp+4, __ccgo_ts+16216, bp)
		}
		_sessionAppendIdent(tls, bp+4, **(**uintptr)(__ccgo_up((*TSessionApplyCtx)(unsafe.Pointer(p)).FazCol + uintptr(i)*4)), bp)
		goto _1
	_1:
		;
		i = i + 1
	}
	_sessionAppendStr(tls, bp+4, __ccgo_ts+36053, bp)
	i = int32(1)
	for {
		if !(i < (*TSessionApplyCtx)(unsafe.Pointer(p)).FnCol) {
			break
		}
		_sessionAppendStr(tls, bp+4, __ccgo_ts+36064, bp)
		goto _2
	_2:
		;
		i = i + 1
	}
	_sessionAppendStr(tls, bp+4, __ccgo_ts+5259, bp)
	if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
		**(**int32)(__ccgo_up(bp)) = _sessionPrepare(tls, db, p+8, p+80, (**(**TSessionBuffer)(__ccgo_up(bp + 4))).FaBuf)
	}
	Xsqlite3_free(tls, (**(**TSessionBuffer)(__ccgo_up(bp + 4))).FaBuf)
	return **(**int32)(__ccgo_up(bp))
}

// C documentation
//
//	/*
//	** Prepare a statement against database handle db that SELECTs a single
//	** row containing the default values for each column in table pTab. For
//	** example, if pTab is declared as:
//	**
//	**   CREATE TABLE pTab(a PRIMARY KEY, b DEFAULT 123, c DEFAULT 'abcd');
//	**
//	** Then this function prepares and returns the SQL statement:
//	**
//	**   SELECT NULL, 123, 'abcd';
//	*/
func _sessionPrepareDfltStmt(tls *libc.TLS, db uintptr, pTab uintptr, ppStmt uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var ii int32
	var zDflt, zSep, v2 uintptr
	var _ /* rc at bp+12 */ int32
	var _ /* sql at bp+0 */ TSessionBuffer
	_, _, _, _ = ii, zDflt, zSep, v2
	**(**TSessionBuffer)(__ccgo_up(bp)) = TSessionBuffer{}
	**(**int32)(__ccgo_up(bp + 12)) = SQLITE_OK
	zSep = __ccgo_ts + 11543
	ii = 0
	**(**uintptr)(__ccgo_up(ppStmt)) = uintptr(0)
	_sessionAppendPrintf(tls, bp, bp+12, __ccgo_ts+35352, 0)
	ii = 0
	for {
		if !(ii < (*TSessionTable)(unsafe.Pointer(pTab)).FnCol) {
			break
		}
		if **(**uintptr)(__ccgo_up((*TSessionTable)(unsafe.Pointer(pTab)).FazDflt + uintptr(ii)*4)) != 0 {
			v2 = **(**uintptr)(__ccgo_up((*TSessionTable)(unsafe.Pointer(pTab)).FazDflt + uintptr(ii)*4))
		} else {
			v2 = __ccgo_ts + 1703
		}
		zDflt = v2
		_sessionAppendPrintf(tls, bp, bp+12, __ccgo_ts+5229, libc.VaList(bp+24, zSep, zDflt))
		zSep = __ccgo_ts + 16216
		goto _1
	_1:
		;
		ii = ii + 1
	}
	if **(**int32)(__ccgo_up(bp + 12)) == SQLITE_OK {
		**(**int32)(__ccgo_up(bp + 12)) = Xsqlite3_prepare_v2(tls, db, (**(**TSessionBuffer)(__ccgo_up(bp))).FaBuf, -int32(1), ppStmt, uintptr(0))
	}
	Xsqlite3_free(tls, (**(**TSessionBuffer)(__ccgo_up(bp))).FaBuf)
	return **(**int32)(__ccgo_up(bp + 12))
}

// C documentation
//
//	/*
//	** This function is only called from with a pre-update-hook reporting a
//	** change on table pTab (attached to session pSession). The type of change
//	** (UPDATE, INSERT, DELETE) is specified by the first argument.
//	**
//	** Unless one is already present or an error occurs, an entry is added
//	** to the changed-rows hash table associated with table pTab.
//	*/
func _sessionPreupdateOneChange(tls *libc.TLS, op int32, iRowid Ti64, pSession uintptr, pTab uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var i, iIdx, iIdx1, nExpect, rc int32
	var p, pC uintptr
	var _ /* bNull at bp+4 */ int32
	var _ /* iHash at bp+0 */ int32
	var _ /* nByte at bp+32 */ Tsqlite3_int64
	var _ /* p at bp+40 */ uintptr
	var _ /* p at bp+44 */ uintptr
	var _ /* stat1 at bp+8 */ TSessionStat1Ctx
	_, _, _, _, _, _, _ = i, iIdx, iIdx1, nExpect, p, pC, rc
	**(**int32)(__ccgo_up(bp + 4)) = 0
	rc = SQLITE_OK
	nExpect = 0
	**(**TSessionStat1Ctx)(__ccgo_up(bp + 8)) = TSessionStat1Ctx{}
	if (*Tsqlite3_session)(unsafe.Pointer(pSession)).Frc != 0 {
		return
	}
	/* Load table details if required */
	if _sessionInitTable(tls, pSession, pTab, (*Tsqlite3_session)(unsafe.Pointer(pSession)).Fdb, (*Tsqlite3_session)(unsafe.Pointer(pSession)).FzDb) != 0 {
		return
	}
	/* Check the number of columns in this xPreUpdate call matches the
	 ** number of columns in the table.  */
	nExpect = (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FxCount})))(tls, (*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FpCtx)
	if (*TSessionTable)(unsafe.Pointer(pTab)).FnTotalCol < nExpect {
		if _sessionReinitTable(tls, pSession, pTab) != 0 {
			return
		}
		if _sessionUpdateChanges(tls, pSession, pTab) != 0 {
			return
		}
	}
	if (*TSessionTable)(unsafe.Pointer(pTab)).FnTotalCol != nExpect {
		(*Tsqlite3_session)(unsafe.Pointer(pSession)).Frc = int32(SQLITE_SCHEMA)
		return
	}
	/* Grow the hash table if required */
	if _sessionGrowHash(tls, pSession, 0, pTab) != 0 {
		(*Tsqlite3_session)(unsafe.Pointer(pSession)).Frc = int32(SQLITE_NOMEM)
		return
	}
	if (*TSessionTable)(unsafe.Pointer(pTab)).FbStat1 != 0 {
		(**(**TSessionStat1Ctx)(__ccgo_up(bp + 8))).Fhook = (*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook
		(**(**TSessionStat1Ctx)(__ccgo_up(bp + 8))).FpSession = pSession
		(*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FpCtx = bp + 8
		(*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FxNew = __ccgo_fp(_sessionStat1New)
		(*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FxOld = __ccgo_fp(_sessionStat1Old)
		(*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FxCount = __ccgo_fp(_sessionStat1Count)
		(*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FxDepth = __ccgo_fp(_sessionStat1Depth)
		if (*Tsqlite3_session)(unsafe.Pointer(pSession)).FpZeroBlob == uintptr(0) {
			p = _sqlite3ValueNew(tls, uintptr(0))
			if p == uintptr(0) {
				rc = int32(SQLITE_NOMEM)
				goto error_out
			}
			_sqlite3ValueSetStr(tls, p, 0, __ccgo_ts+1702, uint8(0), libc.UintptrFromInt32(0))
			(*Tsqlite3_session)(unsafe.Pointer(pSession)).FpZeroBlob = p
		}
	}
	/* Calculate the hash-key for this change. If the primary key of the row
	 ** includes a NULL value, exit early. Such changes are ignored by the
	 ** session module. */
	rc = _sessionPreupdateHash(tls, pSession, iRowid, pTab, libc.BoolInt32(op == int32(SQLITE_INSERT)), bp, bp+4)
	if rc != SQLITE_OK {
		goto error_out
	}
	if **(**int32)(__ccgo_up(bp + 4)) == 0 {
		pC = **(**uintptr)(__ccgo_up((*TSessionTable)(unsafe.Pointer(pTab)).FapChange + uintptr(**(**int32)(__ccgo_up(bp)))*4))
		for {
			if !(pC != 0) {
				break
			}
			if _sessionPreupdateEqual(tls, pSession, iRowid, pTab, pC, op) != 0 {
				break
			}
			goto _1
		_1:
			;
			pC = (*TSessionChange)(unsafe.Pointer(pC)).FpNext
		}
		if pC == uintptr(0) { /* Used to iterate through columns */
			(*TSessionTable)(unsafe.Pointer(pTab)).FnEntry = (*TSessionTable)(unsafe.Pointer(pTab)).FnEntry + 1
			/* Figure out how large an allocation is required */
			**(**Tsqlite3_int64)(__ccgo_up(bp + 32)) = int64(20)
			i = (*TSessionTable)(unsafe.Pointer(pTab)).FbRowid
			for {
				if !(i < (*TSessionTable)(unsafe.Pointer(pTab)).FnCol) {
					break
				}
				iIdx = **(**int32)(__ccgo_up((*TSessionTable)(unsafe.Pointer(pTab)).FaiIdx + uintptr(i)*4))
				**(**uintptr)(__ccgo_up(bp + 40)) = uintptr(0)
				if op != int32(SQLITE_INSERT) {
					/* This may fail if the column has a non-NULL default and was added
					 ** using ALTER TABLE ADD COLUMN after this record was created. */
					rc = (*(*func(*libc.TLS, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FxOld})))(tls, (*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FpCtx, iIdx, bp+40)
				} else {
					if **(**Tu8)(__ccgo_up((*TSessionTable)(unsafe.Pointer(pTab)).FabPK + uintptr(i))) != 0 {
						(*(*func(*libc.TLS, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FxNew})))(tls, (*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FpCtx, iIdx, bp+40)
					}
				}
				if rc == SQLITE_OK {
					/* This may fail if SQLite value p contains a utf-16 string that must
					 ** be converted to utf-8 and an OOM error occurs while doing so. */
					rc = _sessionSerializeValue(tls, uintptr(0), **(**uintptr)(__ccgo_up(bp + 40)), bp+32)
				}
				if rc != SQLITE_OK {
					goto error_out
				}
				goto _2
			_2:
				;
				i = i + 1
			}
			if (*TSessionTable)(unsafe.Pointer(pTab)).FbRowid != 0 {
				**(**Tsqlite3_int64)(__ccgo_up(bp + 32)) = **(**Tsqlite3_int64)(__ccgo_up(bp + 32)) + int64(9) /* Size of rowid field - an integer */
			}
			/* Allocate the change object */
			pC = _sessionMalloc64(tls, pSession, **(**Tsqlite3_int64)(__ccgo_up(bp + 32)))
			if !(pC != 0) {
				rc = int32(SQLITE_NOMEM)
				goto error_out
			} else {
				libc.Xmemset(tls, pC, 0, uint32(20))
				(*TSessionChange)(unsafe.Pointer(pC)).FaRecord = pC + 1*20
			}
			/* Populate the change object. None of the preupdate_old(),
			 ** preupdate_new() or SerializeValue() calls below may fail as all
			 ** required values and encodings have already been cached in memory.
			 ** It is not possible for an OOM to occur in this block. */
			**(**Tsqlite3_int64)(__ccgo_up(bp + 32)) = 0
			if (*TSessionTable)(unsafe.Pointer(pTab)).FbRowid != 0 {
				**(**Tu8)(__ccgo_up((*TSessionChange)(unsafe.Pointer(pC)).FaRecord)) = uint8(SQLITE_INTEGER)
				_sessionPutI64(tls, (*TSessionChange)(unsafe.Pointer(pC)).FaRecord+1, iRowid)
				**(**Tsqlite3_int64)(__ccgo_up(bp + 32)) = int64(9)
			}
			i = (*TSessionTable)(unsafe.Pointer(pTab)).FbRowid
			for {
				if !(i < (*TSessionTable)(unsafe.Pointer(pTab)).FnCol) {
					break
				}
				**(**uintptr)(__ccgo_up(bp + 44)) = uintptr(0)
				iIdx1 = **(**int32)(__ccgo_up((*TSessionTable)(unsafe.Pointer(pTab)).FaiIdx + uintptr(i)*4))
				if op != int32(SQLITE_INSERT) {
					(*(*func(*libc.TLS, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FxOld})))(tls, (*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FpCtx, iIdx1, bp+44)
				} else {
					if **(**Tu8)(__ccgo_up((*TSessionTable)(unsafe.Pointer(pTab)).FabPK + uintptr(i))) != 0 {
						(*(*func(*libc.TLS, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FxNew})))(tls, (*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FpCtx, iIdx1, bp+44)
					}
				}
				_sessionSerializeValue(tls, (*TSessionChange)(unsafe.Pointer(pC)).FaRecord+uintptr(**(**Tsqlite3_int64)(__ccgo_up(bp + 32))), **(**uintptr)(__ccgo_up(bp + 44)), bp+32)
				goto _3
			_3:
				;
				i = i + 1
			}
			/* Add the change to the hash-table */
			if (*Tsqlite3_session)(unsafe.Pointer(pSession)).FbIndirect != 0 || (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FxDepth})))(tls, (*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FpCtx) != 0 {
				(*TSessionChange)(unsafe.Pointer(pC)).FbIndirect = uint8(1)
			}
			(*TSessionChange)(unsafe.Pointer(pC)).FnRecordField = libc.Uint16FromInt32((*TSessionTable)(unsafe.Pointer(pTab)).FnCol)
			(*TSessionChange)(unsafe.Pointer(pC)).FnRecord = int32(**(**Tsqlite3_int64)(__ccgo_up(bp + 32)))
			(*TSessionChange)(unsafe.Pointer(pC)).Fop = libc.Uint8FromInt32(op)
			(*TSessionChange)(unsafe.Pointer(pC)).FpNext = **(**uintptr)(__ccgo_up((*TSessionTable)(unsafe.Pointer(pTab)).FapChange + uintptr(**(**int32)(__ccgo_up(bp)))*4))
			**(**uintptr)(__ccgo_up((*TSessionTable)(unsafe.Pointer(pTab)).FapChange + uintptr(**(**int32)(__ccgo_up(bp)))*4)) = pC
		} else {
			if (*TSessionChange)(unsafe.Pointer(pC)).FbIndirect != 0 {
				/* If the existing change is considered "indirect", but this current
				 ** change is "direct", mark the change object as direct. */
				if (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FxDepth})))(tls, (*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook.FpCtx) == 0 && (*Tsqlite3_session)(unsafe.Pointer(pSession)).FbIndirect == 0 {
					(*TSessionChange)(unsafe.Pointer(pC)).FbIndirect = uint8(0)
				}
			}
		}
		if (*Tsqlite3_session)(unsafe.Pointer(pSession)).FbEnableSize != 0 {
			rc = _sessionUpdateMaxSize(tls, op, pSession, pTab, pC)
		}
	}
	/* If an error has occurred, mark the session object as failed. */
	goto error_out
error_out:
	;
	if (*TSessionTable)(unsafe.Pointer(pTab)).FbStat1 != 0 {
		(*Tsqlite3_session)(unsafe.Pointer(pSession)).Fhook = (**(**TSessionStat1Ctx)(__ccgo_up(bp + 8))).Fhook
	}
	if rc != SQLITE_OK {
		(*Tsqlite3_session)(unsafe.Pointer(pSession)).Frc = rc
	}
}

// C documentation
//
//	/*
//	** Retry the changes accumulated in the pApply->constraints buffer. The
//	** pApply->constraints buffer contains all changes to table zTab that
//	** could not be applied due to SQLITE_CONSTRAINT errors. This function
//	** attempts to apply them as follows:
//	**
//	**   1) It runs through the buffer and attempts to retry each change,
//	**      removing any that are successfully applied from the buffer. This
//	**      is repeated until no further progress can be made.
//	**
//	**   2) For each UPDATE change in the buffer, try the following in a
//	**      savepoint transaction:
//	**
//	**      a) DELETE the affected row,
//	**      b) Attempt step (1) with remaining changes,
//	**      c) Attempt to INSERT a row equivalent to the one that would be
//	**         created by applying this UPDATE change.
//	**
//	**      If the INSERT in (c) succeeds, the savepoint is committed and all
//	**      successfully applied changes are removed from the buffer. Step (2)
//	**      is then repeated.
//	**
//	**   3) Once step (2) has been attempted for each UPDATE in the change,
//	**      a final attempt is made to apply each remaining change. This time,
//	**      if an SQLITE_CONSTRAINT error is encountered, the conflict handler
//	**      is invoked and the user has to decide whether to omit the change
//	**      or rollback the entire _apply() operation.
//	*/
func _sessionRetryConstraints(tls *libc.TLS, db uintptr, bPatchset int32, zTab uintptr, pApply uintptr, __ccgo_fp_xConflict uintptr, pCtx uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var iSkip, iThis, iUpdate, rc int32
	var _ /* app at bp+32 */ TSessionBuffer
	var _ /* cons at bp+0 */ TSessionBuffer
	var _ /* cons at bp+12 */ TSessionBuffer
	var _ /* cons at bp+44 */ TSessionBuffer
	var _ /* pInsert at bp+28 */ uintptr
	var _ /* pUp at bp+24 */ uintptr
	_, _, _, _ = iSkip, iThis, iUpdate, rc
	rc = SQLITE_OK
	iUpdate = 0
	/* Step (1) */
	for (*TSessionApplyCtx)(unsafe.Pointer(pApply)).Fconstraints.FnBuf != 0 {
		**(**TSessionBuffer)(__ccgo_up(bp)) = (*TSessionApplyCtx)(unsafe.Pointer(pApply)).Fconstraints
		libc.Xmemset(tls, pApply+48, 0, uint32(12))
		rc = _sessionApplyRetryBuffer(tls, bp, -int32(1), db, bPatchset, zTab, pApply, __ccgo_fp_xConflict, pCtx)
		Xsqlite3_free(tls, (**(**TSessionBuffer)(__ccgo_up(bp))).FaBuf)
		if rc != SQLITE_OK {
			break
		}
		/* If no progress has been made this round, break out of the loop. */
		if (*TSessionApplyCtx)(unsafe.Pointer(pApply)).Fconstraints.FnBuf >= (**(**TSessionBuffer)(__ccgo_up(bp))).FnBuf {
			break
		}
	}
	/* Step (2) */
	for rc == SQLITE_OK && (*TSessionApplyCtx)(unsafe.Pointer(pApply)).Fconstraints.FnBuf != 0 && !((*TSessionApplyCtx)(unsafe.Pointer(pApply)).FbNoUpdateLoop != 0) {
		**(**TSessionBuffer)(__ccgo_up(bp + 12)) = TSessionBuffer{}
		**(**uintptr)(__ccgo_up(bp + 24)) = uintptr(0)
		**(**uintptr)(__ccgo_up(bp + 28)) = uintptr(0)
		iSkip = 0
		rc = _sessionRetryIterInit(tls, pApply+48, bPatchset, zTab, pApply, bp+24)
		if rc == SQLITE_OK {
			iThis = -int32(1)
			for int32(SQLITE_ROW) == Xsqlite3changeset_next(tls, **(**uintptr)(__ccgo_up(bp + 24))) {
				if (*Tsqlite3_changeset_iter)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 24)))).Fop == int32(SQLITE_UPDATE) {
					iThis = iThis + 1
				}
				if iThis == iUpdate {
					break
				}
				iSkip = iSkip + 1
			}
			if iThis == iUpdate {
				rc = Xsqlite3_exec(tls, db, __ccgo_ts+36455, uintptr(0), uintptr(0), uintptr(0))
				if rc == SQLITE_OK {
					rc = _sessionUpdateToDeleteInsert(tls, db, zTab, pApply, **(**uintptr)(__ccgo_up(bp + 24)), bp+28)
				}
			}
			Xsqlite3changeset_finalize(tls, **(**uintptr)(__ccgo_up(bp + 24)))
			if iThis != iUpdate {
				break
			}
		}
		if rc == SQLITE_OK {
			**(**TSessionBuffer)(__ccgo_up(bp + 12)) = (*TSessionApplyCtx)(unsafe.Pointer(pApply)).Fconstraints
			for rc == SQLITE_OK && (*TSessionApplyCtx)(unsafe.Pointer(pApply)).Fconstraints.FnBuf > 0 {
				**(**TSessionBuffer)(__ccgo_up(bp + 32)) = (*TSessionApplyCtx)(unsafe.Pointer(pApply)).Fconstraints
				libc.Xmemset(tls, pApply+48, 0, uint32(12))
				rc = _sessionApplyRetryBuffer(tls, bp+32, iSkip, db, bPatchset, zTab, pApply, __ccgo_fp_xConflict, pCtx)
				if (**(**TSessionBuffer)(__ccgo_up(bp + 32))).FaBuf != (**(**TSessionBuffer)(__ccgo_up(bp + 12))).FaBuf {
					Xsqlite3_free(tls, (**(**TSessionBuffer)(__ccgo_up(bp + 32))).FaBuf)
				}
				if (*TSessionApplyCtx)(unsafe.Pointer(pApply)).Fconstraints.FnBuf >= (**(**TSessionBuffer)(__ccgo_up(bp + 32))).FnBuf {
					break
				}
				iSkip = -int32(1)
			}
		}
		iUpdate = iUpdate + 1
		if rc == SQLITE_OK {
			Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp + 28)))
			rc = Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp + 28)))
			if rc == int32(SQLITE_CONSTRAINT) {
				rc = Xsqlite3_exec(tls, db, __ccgo_ts+36475, uintptr(0), uintptr(0), uintptr(0))
				Xsqlite3_free(tls, (*TSessionApplyCtx)(unsafe.Pointer(pApply)).Fconstraints.FaBuf)
				(*TSessionApplyCtx)(unsafe.Pointer(pApply)).Fconstraints = **(**TSessionBuffer)(__ccgo_up(bp + 12))
				libc.Xmemset(tls, bp+12, 0, uint32(12))
			} else {
				if rc == SQLITE_OK {
					iUpdate = 0
				}
			}
			if rc == SQLITE_OK {
				rc = Xsqlite3_exec(tls, db, __ccgo_ts+36497, uintptr(0), uintptr(0), uintptr(0))
			}
		} else {
			Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp + 28)))
		}
		Xsqlite3_free(tls, (**(**TSessionBuffer)(__ccgo_up(bp + 12))).FaBuf)
	}
	/* Step (3) */
	if rc == SQLITE_OK && (*TSessionApplyCtx)(unsafe.Pointer(pApply)).Fconstraints.FnBuf != 0 {
		**(**TSessionBuffer)(__ccgo_up(bp + 44)) = (*TSessionApplyCtx)(unsafe.Pointer(pApply)).Fconstraints
		libc.Xmemset(tls, pApply+48, 0, uint32(12))
		(*TSessionApplyCtx)(unsafe.Pointer(pApply)).FbDeferConstraints = 0
		rc = _sessionApplyRetryBuffer(tls, bp+44, -int32(1), db, bPatchset, zTab, pApply, __ccgo_fp_xConflict, pCtx)
		Xsqlite3_free(tls, (**(**TSessionBuffer)(__ccgo_up(bp + 44))).FaBuf)
	}
	return rc
}

// C documentation
//
//	/*
//	** Formulate and prepare an SQL statement to query table zTab by primary
//	** key. Assuming the following table structure:
//	**
//	**     CREATE TABLE x(a, b, c, d, PRIMARY KEY(a, c));
//	**
//	** The SELECT statement looks like this:
//	**
//	**     SELECT * FROM x WHERE a = ?1 AND c = ?3
//	**
//	** If successful, SQLITE_OK is returned and SessionApplyCtx.pSelect is left
//	** pointing to the prepared version of the SQL statement.
//	*/
func _sessionSelectRow(tls *libc.TLS, db uintptr, zTab uintptr, p uintptr) (r int32) {
	/* TODO */
	return _sessionSelectStmt(tls, db, libc.Int32FromUint8((*TSessionApplyCtx)(unsafe.Pointer(p)).FbIgnoreNoop), __ccgo_ts+6818, zTab, (*TSessionApplyCtx)(unsafe.Pointer(p)).FbRowid, (*TSessionApplyCtx)(unsafe.Pointer(p)).FnCol, (*TSessionApplyCtx)(unsafe.Pointer(p)).FazCol, (*TSessionApplyCtx)(unsafe.Pointer(p)).FabPK, p+12, p+80)
}

// C documentation
//
//	/*
//	** Formulate and prepare a SELECT statement to retrieve a row from table
//	** zTab in database zDb based on its primary key. i.e.
//	**
//	**   SELECT *, <noop-test> FROM zDb.zTab WHERE (pk1, pk2,...) IS (?1, ?2,...)
//	**
//	** where <noop-test> is:
//	**
//	**   1 AND (?A OR ?1 IS <column>) AND ...
//	**
//	** for each non-pk <column>.
//	*/
func _sessionSelectStmt(tls *libc.TLS, db uintptr, bIgnoreNoop int32, zDb uintptr, zTab uintptr, bRowid int32, nCol int32, azCol uintptr, abPK uintptr, ppStmt uintptr, pzErrmsg uintptr) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112)
	var i int32
	var zSep, zSql, v2 uintptr
	var _ /* cols at bp+4 */ TSessionBuffer
	var _ /* nooptest at bp+16 */ TSessionBuffer
	var _ /* pkfield at bp+28 */ TSessionBuffer
	var _ /* pkvar at bp+40 */ TSessionBuffer
	var _ /* rc at bp+0 */ int32
	_, _, _, _ = i, zSep, zSql, v2
	**(**int32)(__ccgo_up(bp)) = SQLITE_OK
	zSql = uintptr(0)
	zSep = __ccgo_ts + 1702
	**(**TSessionBuffer)(__ccgo_up(bp + 4)) = TSessionBuffer{}
	**(**TSessionBuffer)(__ccgo_up(bp + 16)) = TSessionBuffer{}
	**(**TSessionBuffer)(__ccgo_up(bp + 28)) = TSessionBuffer{}
	**(**TSessionBuffer)(__ccgo_up(bp + 40)) = TSessionBuffer{}
	_sessionAppendStr(tls, bp+16, __ccgo_ts+35684, bp)
	if 0 == Xsqlite3_stricmp(tls, __ccgo_ts+12835, zTab) {
		_sessionAppendStr(tls, bp+16, __ccgo_ts+35688, bp)
		_sessionAppendStr(tls, bp+28, __ccgo_ts+35712, bp)
		_sessionAppendStr(tls, bp+40, __ccgo_ts+35721, bp)
		_sessionAppendStr(tls, bp+4, __ccgo_ts+35766, bp)
	} else {
		i = 0
		for {
			if !(i < nCol) {
				break
			}
			if (**(**TSessionBuffer)(__ccgo_up(bp + 4))).FnBuf != 0 {
				_sessionAppendStr(tls, bp+4, __ccgo_ts+16216, bp)
			}
			_sessionAppendIdent(tls, bp+4, **(**uintptr)(__ccgo_up(azCol + uintptr(i)*4)), bp)
			if **(**Tu8)(__ccgo_up(abPK + uintptr(i))) != 0 {
				_sessionAppendStr(tls, bp+28, zSep, bp)
				_sessionAppendStr(tls, bp+40, zSep, bp)
				zSep = __ccgo_ts + 16216
				_sessionAppendIdent(tls, bp+28, **(**uintptr)(__ccgo_up(azCol + uintptr(i)*4)), bp)
				_sessionAppendPrintf(tls, bp+40, bp, __ccgo_ts+35780, libc.VaList(bp+64, i+int32(1)))
			} else {
				_sessionAppendPrintf(tls, bp+16, bp, __ccgo_ts+35784, libc.VaList(bp+64, i+int32(1)+nCol, i+int32(1), zTab, **(**uintptr)(__ccgo_up(azCol + uintptr(i)*4))))
			}
			goto _1
		_1:
			;
			i = i + 1
		}
	}
	if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
		if bIgnoreNoop != 0 {
			v2 = (**(**TSessionBuffer)(__ccgo_up(bp + 16))).FaBuf
		} else {
			v2 = __ccgo_ts + 1702
		}
		zSql = Xsqlite3_mprintf(tls, __ccgo_ts+35811, libc.VaList(bp+64, (**(**TSessionBuffer)(__ccgo_up(bp + 4))).FaBuf, v2, zDb, zTab, (**(**TSessionBuffer)(__ccgo_up(bp + 28))).FaBuf, (**(**TSessionBuffer)(__ccgo_up(bp + 40))).FaBuf))
		if zSql == uintptr(0) {
			**(**int32)(__ccgo_up(bp)) = int32(SQLITE_NOMEM)
		}
	}
	if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
		**(**int32)(__ccgo_up(bp)) = _sessionPrepare(tls, db, ppStmt, pzErrmsg, zSql)
	}
	Xsqlite3_free(tls, zSql)
	Xsqlite3_free(tls, (**(**TSessionBuffer)(__ccgo_up(bp + 16))).FaBuf)
	Xsqlite3_free(tls, (**(**TSessionBuffer)(__ccgo_up(bp + 28))).FaBuf)
	Xsqlite3_free(tls, (**(**TSessionBuffer)(__ccgo_up(bp + 40))).FaBuf)
	Xsqlite3_free(tls, (**(**TSessionBuffer)(__ccgo_up(bp + 4))).FaBuf)
	return **(**int32)(__ccgo_up(bp))
}

// C documentation
//
//	/*
//	** Prepare statements for applying changes to the sqlite_stat1 table.
//	** These are similar to those created by sessionSelectRow(),
//	** sessionInsertRow(), sessionUpdateRow() and sessionDeleteRow() for
//	** other tables.
//	*/
func _sessionStat1Sql(tls *libc.TLS, db uintptr, p uintptr) (r int32) {
	var rc int32
	_ = rc
	rc = _sessionSelectRow(tls, db, __ccgo_ts+12835, p)
	if rc == SQLITE_OK {
		rc = _sessionPrepare(tls, db, p+8, uintptr(0), __ccgo_ts+36068)
	}
	if rc == SQLITE_OK {
		rc = _sessionPrepare(tls, db, p+4, uintptr(0), __ccgo_ts+36181)
	}
	return rc
}

// C documentation
//
//	/*
//	** This function queries the database for the names of the columns of table
//	** zThis, in schema zDb.
//	**
//	** Otherwise, if they are not NULL, variable *pnCol is set to the number
//	** of columns in the database table and variable *pzTab is set to point to a
//	** nul-terminated copy of the table name. *pazCol (if not NULL) is set to
//	** point to an array of pointers to column names. And *pabPK (again, if not
//	** NULL) is set to point to an array of booleans - true if the corresponding
//	** column is part of the primary key.
//	**
//	** For example, if the table is declared as:
//	**
//	**     CREATE TABLE tbl1(w, x DEFAULT 'abc', y, z, PRIMARY KEY(w, z));
//	**
//	** Then the five output variables are populated as follows:
//	**
//	**     *pnCol  = 4
//	**     *pzTab  = "tbl1"
//	**     *pazCol = {"w", "x", "y", "z"}
//	**     *pazDflt = {NULL, 'abc', NULL, NULL}
//	**     *pabPK  = {1, 0, 0, 1}
//	**
//	** All returned buffers are part of the same single allocation, which must
//	** be freed using sqlite3_free() by the caller
//	*/
func _sessionTableInfo(tls *libc.TLS, pSession uintptr, db uintptr, zDb uintptr, zThis uintptr, pnCol uintptr, pnTotalCol uintptr, pzTab uintptr, pazCol uintptr, pazDflt uintptr, paiIdx uintptr, pabPK uintptr, pbRowid uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var abPK, aiIdx, azCol, azDflt, pAlloc, zDflt, zName, zPragma uintptr
	var bRowid, i, nDbCol, nDflt, nName1, nThis, rc int32
	var nByte Tsqlite3_int64
	var nName Tsize_t
	var _ /* pStmt at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = abPK, aiIdx, azCol, azDflt, bRowid, i, nByte, nDbCol, nDflt, nName, nName1, nThis, pAlloc, rc, zDflt, zName, zPragma
	nDbCol = 0
	pAlloc = uintptr(0)
	azCol = uintptr(0)
	azDflt = uintptr(0)
	abPK = uintptr(0)
	aiIdx = uintptr(0)
	bRowid = 0 /* Set to true to use rowid as PK */
	**(**uintptr)(__ccgo_up(pazCol)) = uintptr(0)
	**(**uintptr)(__ccgo_up(pabPK)) = uintptr(0)
	**(**int32)(__ccgo_up(pnCol)) = 0
	if pnTotalCol != 0 {
		**(**int32)(__ccgo_up(pnTotalCol)) = 0
	}
	if paiIdx != 0 {
		**(**uintptr)(__ccgo_up(paiIdx)) = uintptr(0)
	}
	if pzTab != 0 {
		**(**uintptr)(__ccgo_up(pzTab)) = uintptr(0)
	}
	if pazDflt != 0 {
		**(**uintptr)(__ccgo_up(pazDflt)) = uintptr(0)
	}
	nThis = _sqlite3Strlen30(tls, zThis)
	if nThis == int32(12) && 0 == Xsqlite3_stricmp(tls, __ccgo_ts+12835, zThis) {
		rc = Xsqlite3_table_column_metadata(tls, db, zDb, zThis, uintptr(0), uintptr(0), uintptr(0), uintptr(0), uintptr(0), uintptr(0))
		if rc == SQLITE_OK {
			/* For sqlite_stat1, pretend that (tbl,idx) is the PRIMARY KEY. */
			zPragma = Xsqlite3_mprintf(tls, __ccgo_ts+35192, 0)
		} else {
			if rc == int32(SQLITE_ERROR) {
				zPragma = Xsqlite3_mprintf(tls, __ccgo_ts+1702, 0)
			} else {
				return rc
			}
		}
	} else {
		zPragma = Xsqlite3_mprintf(tls, __ccgo_ts+35322, libc.VaList(bp+16, zDb, zThis))
	}
	if !(zPragma != 0) {
		return int32(SQLITE_NOMEM)
	}
	rc = Xsqlite3_prepare_v2(tls, db, zPragma, -int32(1), bp, uintptr(0))
	Xsqlite3_free(tls, zPragma)
	if rc != SQLITE_OK {
		return rc
	}
	nByte = int64(nThis + int32(1))
	bRowid = libc.BoolInt32(pbRowid != uintptr(0))
	for int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) {
		nByte = nByte + int64(Xsqlite3_column_bytes(tls, **(**uintptr)(__ccgo_up(bp)), int32(1))) /* name */
		nByte = nByte + int64(Xsqlite3_column_bytes(tls, **(**uintptr)(__ccgo_up(bp)), int32(4))) /* dflt_value */
		if Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), int32(6)) == 0 {                /* !hidden */
			nDbCol = nDbCol + 1
		}
		if Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), int32(5)) != 0 {
			bRowid = 0
		} /* pk */
	}
	if nDbCol == 0 {
		bRowid = 0
	}
	nDbCol = nDbCol + bRowid
	nByte = nByte + libc.Int64FromUint32(libc.Xstrlen(tls, __ccgo_ts+31340))
	rc = Xsqlite3_reset(tls, **(**uintptr)(__ccgo_up(bp)))
	if rc == SQLITE_OK {
		nByte = nByte + libc.Int64FromUint32(libc.Uint32FromInt32(nDbCol)*(libc.Uint32FromInt64(4)*libc.Uint32FromInt32(2)+libc.Uint32FromInt64(4)+libc.Uint32FromInt64(1)+libc.Uint32FromInt32(1)+libc.Uint32FromInt32(1)))
		pAlloc = _sessionMalloc64(tls, pSession, nByte)
		if pAlloc == uintptr(0) {
			rc = int32(SQLITE_NOMEM)
		} else {
			libc.Xmemset(tls, pAlloc, 0, libc.Uint32FromInt64(nByte))
		}
	}
	if rc == SQLITE_OK {
		azCol = pAlloc
		azDflt = azCol + uintptr(nDbCol)*4
		aiIdx = azDflt + uintptr(nDbCol)*4
		abPK = aiIdx + uintptr(nDbCol)*4
		pAlloc = abPK + uintptr(nDbCol)
		if pzTab != 0 {
			libc.Xmemcpy(tls, pAlloc, zThis, libc.Uint32FromInt32(nThis+int32(1)))
			**(**uintptr)(__ccgo_up(pzTab)) = pAlloc
			pAlloc = pAlloc + uintptr(nThis+int32(1))
		}
		i = 0
		if bRowid != 0 {
			nName = libc.Xstrlen(tls, __ccgo_ts+31340)
			libc.Xmemcpy(tls, pAlloc, __ccgo_ts+31340, nName+uint32(1))
			**(**uintptr)(__ccgo_up(azCol + uintptr(i)*4)) = pAlloc
			pAlloc = pAlloc + uintptr(nName+uint32(1))
			**(**Tu8)(__ccgo_up(abPK + uintptr(i))) = uint8(1)
			**(**int32)(__ccgo_up(aiIdx + uintptr(i)*4)) = -int32(1)
			i = i + 1
		}
		for int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) {
			if Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), int32(6)) == 0 { /* !hidden */
				nName1 = Xsqlite3_column_bytes(tls, **(**uintptr)(__ccgo_up(bp)), int32(1))
				nDflt = Xsqlite3_column_bytes(tls, **(**uintptr)(__ccgo_up(bp)), int32(4))
				zName = Xsqlite3_column_text(tls, **(**uintptr)(__ccgo_up(bp)), int32(1))
				zDflt = Xsqlite3_column_text(tls, **(**uintptr)(__ccgo_up(bp)), int32(4))
				if zName == uintptr(0) {
					break
				}
				libc.Xmemcpy(tls, pAlloc, zName, libc.Uint32FromInt32(nName1+int32(1)))
				**(**uintptr)(__ccgo_up(azCol + uintptr(i)*4)) = pAlloc
				pAlloc = pAlloc + uintptr(nName1+int32(1))
				if zDflt != 0 {
					libc.Xmemcpy(tls, pAlloc, zDflt, libc.Uint32FromInt32(nDflt+int32(1)))
					**(**uintptr)(__ccgo_up(azDflt + uintptr(i)*4)) = pAlloc
					pAlloc = pAlloc + uintptr(nDflt+int32(1))
				} else {
					**(**uintptr)(__ccgo_up(azDflt + uintptr(i)*4)) = uintptr(0)
				}
				**(**Tu8)(__ccgo_up(abPK + uintptr(i))) = libc.Uint8FromInt32(Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), int32(5)))
				**(**int32)(__ccgo_up(aiIdx + uintptr(i)*4)) = Xsqlite3_column_int(tls, **(**uintptr)(__ccgo_up(bp)), 0)
				i = i + 1
			}
			if pnTotalCol != 0 {
				**(**int32)(__ccgo_up(pnTotalCol)) = **(**int32)(__ccgo_up(pnTotalCol)) + 1
			}
		}
		rc = Xsqlite3_reset(tls, **(**uintptr)(__ccgo_up(bp)))
	}
	/* If successful, populate the output variables. Otherwise, zero them and
	 ** free any allocation made. An error code will be returned in this case.
	 */
	if rc == SQLITE_OK {
		**(**uintptr)(__ccgo_up(pazCol)) = azCol
		if pazDflt != 0 {
			**(**uintptr)(__ccgo_up(pazDflt)) = azDflt
		}
		**(**uintptr)(__ccgo_up(pabPK)) = abPK
		**(**int32)(__ccgo_up(pnCol)) = nDbCol
		if paiIdx != 0 {
			**(**uintptr)(__ccgo_up(paiIdx)) = aiIdx
		}
	} else {
		_sessionFree(tls, pSession, azCol)
	}
	if pbRowid != 0 {
		**(**int32)(__ccgo_up(pbRowid)) = bRowid
	}
	Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp)))
	return rc
}

// C documentation
//
//	/*
//	** Find a prepared UPDATE statement suitable for the UPDATE step currently
//	** being visited by the iterator. The UPDATE is of the form:
//	**
//	**   UPDATE tbl SET col = ?, col2 = ? WHERE pk1 IS ? AND pk2 IS ?
//	*/
func _sessionUpdateFind(tls *libc.TLS, pIter uintptr, p uintptr, bPatchset int32, ppStmt uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var bStat1, ii, nByte, nCol, nU32, nUp int32
	var pUp, pp, zSep, zSql uintptr
	var _ /* buf at bp+4 */ TSessionBuffer
	var _ /* rc at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _ = bStat1, ii, nByte, nCol, nU32, nUp, pUp, pp, zSep, zSql
	**(**int32)(__ccgo_up(bp)) = SQLITE_OK
	pUp = uintptr(0)
	nCol = (*Tsqlite3_changeset_iter)(unsafe.Pointer(pIter)).FnCol
	nU32 = ((*Tsqlite3_changeset_iter)(unsafe.Pointer(pIter)).FnCol + int32(33)) / int32(32)
	if (*TSessionApplyCtx)(unsafe.Pointer(p)).FaUpdateMask == uintptr(0) {
		(*TSessionApplyCtx)(unsafe.Pointer(p)).FaUpdateMask = Xsqlite3_malloc(tls, libc.Int32FromUint32(libc.Uint32FromInt32(nU32)*uint32(4)))
		if (*TSessionApplyCtx)(unsafe.Pointer(p)).FaUpdateMask == uintptr(0) {
			**(**int32)(__ccgo_up(bp)) = int32(SQLITE_NOMEM)
		}
	}
	if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
		libc.Xmemset(tls, (*TSessionApplyCtx)(unsafe.Pointer(p)).FaUpdateMask, 0, libc.Uint32FromInt32(nU32)*uint32(4))
		**(**int32)(__ccgo_up(bp)) = int32(SQLITE_CORRUPT)
		ii = 0
		for {
			if !(ii < (*Tsqlite3_changeset_iter)(unsafe.Pointer(pIter)).FnCol) {
				break
			}
			if **(**uintptr)(__ccgo_up((*Tsqlite3_changeset_iter)(unsafe.Pointer(pIter)).FapValue + uintptr((*Tsqlite3_changeset_iter)(unsafe.Pointer(pIter)).FnCol+ii)*4)) != 0 {
				**(**Tu32)(__ccgo_up((*TSessionApplyCtx)(unsafe.Pointer(p)).FaUpdateMask + uintptr(ii/int32(32))*4)) |= libc.Uint32FromInt32(libc.Int32FromInt32(1) << (ii % libc.Int32FromInt32(32)))
				**(**int32)(__ccgo_up(bp)) = SQLITE_OK
			}
			goto _1
		_1:
			;
			ii = ii + 1
		}
	}
	if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
		if bPatchset != 0 {
			**(**Tu32)(__ccgo_up((*TSessionApplyCtx)(unsafe.Pointer(p)).FaUpdateMask + uintptr(nCol/int32(32))*4)) |= libc.Uint32FromInt32(libc.Int32FromInt32(1) << (nCol % libc.Int32FromInt32(32)))
		}
		if (*TSessionApplyCtx)(unsafe.Pointer(p)).FpUp != 0 {
			nUp = 0
			pp = p + 32
			for int32(1) != 0 {
				nUp = nUp + 1
				if 0 == libc.Xmemcmp(tls, (*TSessionApplyCtx)(unsafe.Pointer(p)).FaUpdateMask, (*TSessionUpdate)(unsafe.Pointer(**(**uintptr)(__ccgo_up(pp)))).FaMask, libc.Uint32FromInt32(nU32)*uint32(4)) {
					pUp = **(**uintptr)(__ccgo_up(pp))
					**(**uintptr)(__ccgo_up(pp)) = (*TSessionUpdate)(unsafe.Pointer(pUp)).FpNext
					(*TSessionUpdate)(unsafe.Pointer(pUp)).FpNext = (*TSessionApplyCtx)(unsafe.Pointer(p)).FpUp
					(*TSessionApplyCtx)(unsafe.Pointer(p)).FpUp = pUp
					break
				}
				if (*TSessionUpdate)(unsafe.Pointer(**(**uintptr)(__ccgo_up(pp)))).FpNext != 0 {
					pp = **(**uintptr)(__ccgo_up(pp)) + 8
				} else {
					if nUp >= int32(SESSION_UPDATE_CACHE_SZ) {
						Xsqlite3_finalize(tls, (*TSessionUpdate)(unsafe.Pointer(**(**uintptr)(__ccgo_up(pp)))).FpStmt)
						Xsqlite3_free(tls, **(**uintptr)(__ccgo_up(pp)))
						**(**uintptr)(__ccgo_up(pp)) = uintptr(0)
					}
					break
				}
			}
		}
		if pUp == uintptr(0) {
			nByte = libc.Int32FromUint32(uint32(12) * libc.Uint32FromInt32(nU32) * uint32(4))
			bStat1 = libc.BoolInt32(Xsqlite3_stricmp(tls, (*Tsqlite3_changeset_iter)(unsafe.Pointer(pIter)).FzTab, __ccgo_ts+12835) == 0)
			pUp = Xsqlite3_malloc(tls, nByte)
			if pUp == uintptr(0) {
				**(**int32)(__ccgo_up(bp)) = int32(SQLITE_NOMEM)
			} else {
				zSep = __ccgo_ts + 1702
				libc.Xmemset(tls, bp+4, 0, uint32(12))
				(*TSessionUpdate)(unsafe.Pointer(pUp)).FaMask = pUp + 1*12
				libc.Xmemcpy(tls, (*TSessionUpdate)(unsafe.Pointer(pUp)).FaMask, (*TSessionApplyCtx)(unsafe.Pointer(p)).FaUpdateMask, libc.Uint32FromInt32(nU32)*uint32(4))
				_sessionAppendStr(tls, bp+4, __ccgo_ts+35891, bp)
				_sessionAppendIdent(tls, bp+4, (*Tsqlite3_changeset_iter)(unsafe.Pointer(pIter)).FzTab, bp)
				_sessionAppendStr(tls, bp+4, __ccgo_ts+35904, bp)
				/* Create the assignments part of the UPDATE */
				ii = 0
				for {
					if !(ii < (*Tsqlite3_changeset_iter)(unsafe.Pointer(pIter)).FnCol) {
						break
					}
					if libc.Int32FromUint8(**(**Tu8)(__ccgo_up((*TSessionApplyCtx)(unsafe.Pointer(p)).FabPK + uintptr(ii)))) == 0 && **(**uintptr)(__ccgo_up((*Tsqlite3_changeset_iter)(unsafe.Pointer(pIter)).FapValue + uintptr((*Tsqlite3_changeset_iter)(unsafe.Pointer(pIter)).FnCol+ii)*4)) != 0 {
						_sessionAppendStr(tls, bp+4, zSep, bp)
						_sessionAppendIdent(tls, bp+4, **(**uintptr)(__ccgo_up((*TSessionApplyCtx)(unsafe.Pointer(p)).FazCol + uintptr(ii)*4)), bp)
						_sessionAppendStr(tls, bp+4, __ccgo_ts+35910, bp)
						_sessionAppendInteger(tls, bp+4, ii*int32(2)+int32(1), bp)
						zSep = __ccgo_ts + 16216
					}
					goto _2
				_2:
					;
					ii = ii + 1
				}
				/* Create the WHERE clause part of the UPDATE */
				zSep = __ccgo_ts + 1702
				_sessionAppendStr(tls, bp+4, __ccgo_ts+35915, bp)
				ii = 0
				for {
					if !(ii < (*Tsqlite3_changeset_iter)(unsafe.Pointer(pIter)).FnCol) {
						break
					}
					if **(**Tu8)(__ccgo_up((*TSessionApplyCtx)(unsafe.Pointer(p)).FabPK + uintptr(ii))) != 0 || bPatchset == 0 && **(**uintptr)(__ccgo_up((*Tsqlite3_changeset_iter)(unsafe.Pointer(pIter)).FapValue + uintptr(ii)*4)) != 0 {
						_sessionAppendStr(tls, bp+4, zSep, bp)
						if bStat1 != 0 && ii == int32(1) {
							_sessionAppendStr(tls, bp+4, __ccgo_ts+35923, bp)
						} else {
							_sessionAppendIdent(tls, bp+4, **(**uintptr)(__ccgo_up((*TSessionApplyCtx)(unsafe.Pointer(p)).FazCol + uintptr(ii)*4)), bp)
							_sessionAppendStr(tls, bp+4, __ccgo_ts+35998, bp)
							_sessionAppendInteger(tls, bp+4, ii*int32(2)+int32(2), bp)
						}
						zSep = __ccgo_ts + 23627
					}
					goto _3
				_3:
					;
					ii = ii + 1
				}
				if **(**int32)(__ccgo_up(bp)) == SQLITE_OK {
					zSql = (**(**TSessionBuffer)(__ccgo_up(bp + 4))).FaBuf
					**(**int32)(__ccgo_up(bp)) = Xsqlite3_prepare_v2(tls, (*TSessionApplyCtx)(unsafe.Pointer(p)).Fdb, zSql, (**(**TSessionBuffer)(__ccgo_up(bp + 4))).FnBuf, pUp, uintptr(0))
				}
				if **(**int32)(__ccgo_up(bp)) != SQLITE_OK {
					Xsqlite3_free(tls, pUp)
					pUp = uintptr(0)
				} else {
					(*TSessionUpdate)(unsafe.Pointer(pUp)).FpNext = (*TSessionApplyCtx)(unsafe.Pointer(p)).FpUp
					(*TSessionApplyCtx)(unsafe.Pointer(p)).FpUp = pUp
				}
				Xsqlite3_free(tls, (**(**TSessionBuffer)(__ccgo_up(bp + 4))).FaBuf)
			}
		}
	}
	if pUp != 0 {
		**(**uintptr)(__ccgo_up(ppStmt)) = (*TSessionUpdate)(unsafe.Pointer(pUp)).FpStmt
	} else {
		**(**uintptr)(__ccgo_up(ppStmt)) = uintptr(0)
	}
	return **(**int32)(__ccgo_up(bp))
}

// C documentation
//
//	/*
//	** Iterator pUp points to an UPDATE change. This function deletes the
//	** affected row from the database and creates an INSERT statement that
//	** may be used to reinsert the row as it is after the UPDATE change
//	** has been applied.
//	**
//	** If successful, SQLITE_OK is returned and output variable (*ppInsert)
//	** is left pointing to a prepared INSERT statement. It is the responsibility
//	** of the caller to eventually free this statement using sqlite3_finalize().
//	** Or, if an error occurs, an SQLite error code is returned and (*ppInsert)
//	** set to NULL. pApply->zErr may be set to an error message in this case.
//	*/
func _sessionUpdateToDeleteInsert(tls *libc.TLS, db uintptr, zTab uintptr, pApply uintptr, pUp uintptr, ppInsert uintptr) (r int32) {
	bp := tls.Alloc(112)
	defer tls.Free(112)
	var iCol, ii int32
	var pVal, zComma, zComma2, zInsert, zSelect uintptr
	var _ /* bWR at bp+12 */ int32
	var _ /* cols at bp+16 */ TSessionBuffer
	var _ /* insbind at bp+28 */ TSessionBuffer
	var _ /* pRet at bp+0 */ uintptr
	var _ /* pSelect at bp+4 */ uintptr
	var _ /* pkcols at bp+40 */ TSessionBuffer
	var _ /* rc at bp+8 */ int32
	var _ /* selbind at bp+52 */ TSessionBuffer
	_, _, _, _, _, _, _ = iCol, ii, pVal, zComma, zComma2, zInsert, zSelect
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)     /* The INSERT statement */
	**(**uintptr)(__ccgo_up(bp + 4)) = uintptr(0) /* SELECT to read current values of row */
	**(**int32)(__ccgo_up(bp + 8)) = SQLITE_OK
	**(**int32)(__ccgo_up(bp + 12)) = 0
	**(**int32)(__ccgo_up(bp + 8)) = _sessionTableIsWithoutRowid(tls, db, zTab, bp+12)
	if **(**int32)(__ccgo_up(bp + 8)) == SQLITE_OK {
		zSelect = uintptr(0)
		zInsert = uintptr(0)
		**(**TSessionBuffer)(__ccgo_up(bp + 16)) = TSessionBuffer{}
		**(**TSessionBuffer)(__ccgo_up(bp + 28)) = TSessionBuffer{}
		**(**TSessionBuffer)(__ccgo_up(bp + 40)) = TSessionBuffer{}
		**(**TSessionBuffer)(__ccgo_up(bp + 52)) = TSessionBuffer{}
		zComma = __ccgo_ts + 1702
		zComma2 = __ccgo_ts + 1702
		ii = 0
		for {
			if !(ii < (*TSessionApplyCtx)(unsafe.Pointer(pApply)).FnCol) {
				break
			}
			_sessionAppendStr(tls, bp+16, zComma, bp+8)
			_sessionAppendIdent(tls, bp+16, **(**uintptr)(__ccgo_up((*TSessionApplyCtx)(unsafe.Pointer(pApply)).FazCol + uintptr(ii)*4)), bp+8)
			_sessionAppendStr(tls, bp+28, zComma, bp+8)
			_sessionAppendStr(tls, bp+28, __ccgo_ts+5261, bp+8)
			zComma = __ccgo_ts + 16216
			if **(**Tu8)(__ccgo_up((*TSessionApplyCtx)(unsafe.Pointer(pApply)).FabPK + uintptr(ii))) != 0 {
				_sessionAppendStr(tls, bp+40, zComma2, bp+8)
				_sessionAppendIdent(tls, bp+40, **(**uintptr)(__ccgo_up((*TSessionApplyCtx)(unsafe.Pointer(pApply)).FazCol + uintptr(ii)*4)), bp+8)
				_sessionAppendStr(tls, bp+52, zComma2, bp+8)
				_sessionAppendPrintf(tls, bp+52, bp+8, __ccgo_ts+35780, libc.VaList(bp+72, ii+int32(1)))
				zComma2 = __ccgo_ts + 16216
			}
			goto _1
		_1:
			;
			ii = ii + 1
		}
		if **(**int32)(__ccgo_up(bp + 12)) == 0 {
			_sessionAppendStr(tls, bp+16, zComma, bp+8)
			_sessionAppendStr(tls, bp+16, __ccgo_ts+31340, bp+8)
			_sessionAppendStr(tls, bp+28, zComma, bp+8)
			_sessionAppendStr(tls, bp+28, __ccgo_ts+5261, bp+8)
		}
		if **(**int32)(__ccgo_up(bp + 8)) == SQLITE_OK {
			zSelect = Xsqlite3_mprintf(tls, __ccgo_ts+36388, libc.VaList(bp+72, (**(**TSessionBuffer)(__ccgo_up(bp + 16))).FaBuf, zTab, (**(**TSessionBuffer)(__ccgo_up(bp + 40))).FaBuf, (**(**TSessionBuffer)(__ccgo_up(bp + 52))).FaBuf))
			if zSelect == uintptr(0) {
				**(**int32)(__ccgo_up(bp + 8)) = int32(SQLITE_NOMEM)
			}
		}
		if **(**int32)(__ccgo_up(bp + 8)) == SQLITE_OK {
			zInsert = Xsqlite3_mprintf(tls, __ccgo_ts+36425, libc.VaList(bp+72, zTab, (**(**TSessionBuffer)(__ccgo_up(bp + 16))).FaBuf, (**(**TSessionBuffer)(__ccgo_up(bp + 28))).FaBuf))
			if zInsert == uintptr(0) {
				**(**int32)(__ccgo_up(bp + 8)) = int32(SQLITE_NOMEM)
			}
		}
		if **(**int32)(__ccgo_up(bp + 8)) == SQLITE_OK {
			**(**int32)(__ccgo_up(bp + 8)) = _sessionPrepare(tls, db, bp+4, pApply+80, zSelect)
		}
		if **(**int32)(__ccgo_up(bp + 8)) == SQLITE_OK {
			**(**int32)(__ccgo_up(bp + 8)) = _sessionPrepare(tls, db, bp, pApply+80, zInsert)
		}
		Xsqlite3_free(tls, zSelect)
		Xsqlite3_free(tls, zInsert)
		Xsqlite3_free(tls, (**(**TSessionBuffer)(__ccgo_up(bp + 16))).FaBuf)
		Xsqlite3_free(tls, (**(**TSessionBuffer)(__ccgo_up(bp + 28))).FaBuf)
		Xsqlite3_free(tls, (**(**TSessionBuffer)(__ccgo_up(bp + 40))).FaBuf)
		Xsqlite3_free(tls, (**(**TSessionBuffer)(__ccgo_up(bp + 52))).FaBuf)
	}
	if **(**int32)(__ccgo_up(bp + 8)) == SQLITE_OK {
		**(**int32)(__ccgo_up(bp + 8)) = _sessionBindRow(tls, pUp, __ccgo_fp(Xsqlite3changeset_old), (*TSessionApplyCtx)(unsafe.Pointer(pApply)).FnCol, (*TSessionApplyCtx)(unsafe.Pointer(pApply)).FabPK, **(**uintptr)(__ccgo_up(bp + 4)))
	}
	if **(**int32)(__ccgo_up(bp + 8)) == SQLITE_OK && Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp + 4))) == int32(SQLITE_ROW) {
		iCol = 0
		for {
			if !(iCol < (*TSessionApplyCtx)(unsafe.Pointer(pApply)).FnCol) {
				break
			}
			pVal = **(**uintptr)(__ccgo_up((*Tsqlite3_changeset_iter)(unsafe.Pointer(pUp)).FapValue + uintptr(iCol+(*TSessionApplyCtx)(unsafe.Pointer(pApply)).FnCol)*4))
			if pVal == uintptr(0) {
				pVal = Xsqlite3_column_value(tls, **(**uintptr)(__ccgo_up(bp + 4)), iCol)
			}
			**(**int32)(__ccgo_up(bp + 8)) = Xsqlite3_bind_value(tls, **(**uintptr)(__ccgo_up(bp)), iCol+int32(1), pVal)
			goto _2
		_2:
			;
			iCol = iCol + 1
		}
		if **(**int32)(__ccgo_up(bp + 12)) == 0 {
			Xsqlite3_bind_int64(tls, **(**uintptr)(__ccgo_up(bp)), iCol+int32(1), Xsqlite3_column_int64(tls, **(**uintptr)(__ccgo_up(bp + 4)), iCol))
		}
	}
	_sessionFinalizeStmt(tls, **(**uintptr)(__ccgo_up(bp + 4)), bp+8)
	/* Delete the row from the database. */
	if **(**int32)(__ccgo_up(bp + 8)) == SQLITE_OK {
		**(**int32)(__ccgo_up(bp + 8)) = _sessionBindRow(tls, pUp, __ccgo_fp(Xsqlite3changeset_old), (*TSessionApplyCtx)(unsafe.Pointer(pApply)).FnCol, (*TSessionApplyCtx)(unsafe.Pointer(pApply)).FabPK, (*TSessionApplyCtx)(unsafe.Pointer(pApply)).FpDelete)
		Xsqlite3_bind_int(tls, (*TSessionApplyCtx)(unsafe.Pointer(pApply)).FpDelete, (*TSessionApplyCtx)(unsafe.Pointer(pApply)).FnCol+int32(1), int32(1))
	}
	if **(**int32)(__ccgo_up(bp + 8)) == SQLITE_OK {
		Xsqlite3_step(tls, (*TSessionApplyCtx)(unsafe.Pointer(pApply)).FpDelete)
		**(**int32)(__ccgo_up(bp + 8)) = Xsqlite3_reset(tls, (*TSessionApplyCtx)(unsafe.Pointer(pApply)).FpDelete)
	}
	if **(**int32)(__ccgo_up(bp + 8)) != SQLITE_OK {
		Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp)))
		**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	}
	**(**uintptr)(__ccgo_up(ppInsert)) = **(**uintptr)(__ccgo_up(bp))
	return **(**int32)(__ccgo_up(bp + 8))
}

// C documentation
//
//	/*
//	** The expression is the default value for the most recently added column
//	** of the table currently under construction.
//	**
//	** Default value expressions must be constant.  Raise an exception if this
//	** is not the case.
//	**
//	** This routine is called by the parser while in the middle of
//	** parsing a CREATE TABLE statement.
//	*/
func _sqlite3AddDefaultValue(tls *libc.TLS, pParse uintptr, pExpr uintptr, zStart uintptr, zEnd uintptr) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var db, p, pCol, pDfltExpr uintptr
	var isInit int32
	var _ /* x at bp+0 */ TExpr
	_, _, _, _, _ = db, isInit, p, pCol, pDfltExpr
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	p = (*TParse)(unsafe.Pointer(pParse)).FpNewTable
	if p != uintptr(0) {
		isInit = libc.BoolInt32((*Tsqlite3)(unsafe.Pointer(db)).Finit1.Fbusy != 0 && libc.Int32FromUint8((*Tsqlite3)(unsafe.Pointer(db)).Finit1.FiDb) != int32(1))
		pCol = (*TTable)(unsafe.Pointer(p)).FaCol + uintptr(int32((*TTable)(unsafe.Pointer(p)).FnCol)-int32(1))*12
		if !(_sqlite3ExprIsConstantOrFunction(tls, pExpr, libc.Uint8FromInt32(isInit)) != 0) {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+14024, libc.VaList(bp+64, (*TColumn)(unsafe.Pointer(pCol)).FzCnName))
		} else {
			if libc.Int32FromUint16((*TColumn)(unsafe.Pointer(pCol)).FcolFlags)&int32(COLFLAG_GENERATED) != 0 {
				_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+14069, 0)
			} else {
				libc.Xmemset(tls, bp, 0, uint32(52))
				(**(**TExpr)(__ccgo_up(bp))).Fop = uint8(TK_SPAN)
				*(*uintptr)(unsafe.Pointer(bp + 8)) = _sqlite3DbSpanDup(tls, db, zStart, zEnd)
				(**(**TExpr)(__ccgo_up(bp))).FpLeft = pExpr
				(**(**TExpr)(__ccgo_up(bp))).Fflags = uint32(EP_Skip)
				pDfltExpr = _sqlite3ExprDup(tls, db, bp, int32(EXPRDUP_REDUCE))
				_sqlite3DbFree(tls, db, *(*uintptr)(unsafe.Pointer(bp + 8)))
				_sqlite3ColumnSetExpr(tls, pParse, p, pCol, pDfltExpr)
			}
		}
	}
	if libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).FeParseMode) >= int32(PARSE_MODE_RENAME) {
		_sqlite3RenameExprUnmap(tls, pParse, pExpr)
	}
	_sqlite3ExprDelete(tls, db, pExpr)
}

// C documentation
//
//	/* Change the most recently parsed column to be a GENERATED ALWAYS AS
//	** column.
//	*/
func _sqlite3AddGenerated(tls *libc.TLS, pParse uintptr, pExpr uintptr, pType uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var eType Tu8
	var pCol, pTab, v1 uintptr
	_, _, _, _ = eType, pCol, pTab, v1
	eType = uint8(COLFLAG_VIRTUAL)
	pTab = (*TParse)(unsafe.Pointer(pParse)).FpNewTable
	if pTab == uintptr(0) {
		/* generated column in an CREATE TABLE IF NOT EXISTS that already exists */
		goto generated_done
	}
	pCol = (*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(int32((*TTable)(unsafe.Pointer(pTab)).FnCol)-int32(1))*12
	if libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).FeParseMode) == int32(PARSE_MODE_DECLARE_VTAB) {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+14259, 0)
		goto generated_done
	}
	if libc.Int32FromUint16((*TColumn)(unsafe.Pointer(pCol)).FiDflt) > 0 {
		goto generated_error
	}
	if pType != 0 {
		if (*TToken)(unsafe.Pointer(pType)).Fn == uint32(7) && Xsqlite3_strnicmp(tls, __ccgo_ts+14302, (*TToken)(unsafe.Pointer(pType)).Fz, int32(7)) == 0 {
			/* no-op */
		} else {
			if (*TToken)(unsafe.Pointer(pType)).Fn == uint32(6) && Xsqlite3_strnicmp(tls, __ccgo_ts+14310, (*TToken)(unsafe.Pointer(pType)).Fz, int32(6)) == 0 {
				eType = uint8(COLFLAG_STORED)
			} else {
				goto generated_error
			}
		}
	}
	if libc.Int32FromUint8(eType) == int32(COLFLAG_VIRTUAL) {
		(*TTable)(unsafe.Pointer(pTab)).FnNVCol = (*TTable)(unsafe.Pointer(pTab)).FnNVCol - 1
	}
	v1 = pCol + 10
	*(*Tu16)(unsafe.Pointer(v1)) = Tu16(int32(*(*Tu16)(unsafe.Pointer(v1))) | libc.Int32FromUint8(eType))
	**(**Tu32)(__ccgo_up(pTab + 28)) |= uint32(eType)
	if libc.Int32FromUint16((*TColumn)(unsafe.Pointer(pCol)).FcolFlags)&int32(COLFLAG_PRIMKEY) != 0 {
		_makeColumnPartOfPrimaryKey(tls, pParse, pCol) /* For the error message */
	}
	if pExpr != 0 && libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pExpr)).Fop) == int32(TK_ID) {
		/* The value of a generated column needs to be a real expression, not
		 ** just a reference to another column, in order for covering index
		 ** optimizations to work correctly.  So if the value is not an expression,
		 ** turn it into one by adding a unary "+" operator. */
		pExpr = _sqlite3PExpr(tls, pParse, int32(TK_UPLUS), pExpr, uintptr(0))
	}
	if pExpr != 0 && libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pExpr)).Fop) != int32(TK_RAISE) {
		(*TExpr)(unsafe.Pointer(pExpr)).FaffExpr = (*TColumn)(unsafe.Pointer(pCol)).Faffinity
	}
	_sqlite3ColumnSetExpr(tls, pParse, pTab, pCol, pExpr)
	pExpr = uintptr(0)
	goto generated_done
	goto generated_error
generated_error:
	;
	_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+14317, libc.VaList(bp+8, (*TColumn)(unsafe.Pointer(pCol)).FzCnName))
	goto generated_done
generated_done:
	;
	_sqlite3ExprDelete(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, pExpr)
}

// C documentation
//
//	/*
//	** Designate the PRIMARY KEY for the table.  pList is a list of names
//	** of columns that form the primary key.  If pList is NULL, then the
//	** most recently added column of the table is the primary key.
//	**
//	** A table can have at most one primary key.  If the table already has
//	** a primary key (and this is the second primary key) then create an
//	** error.
//	**
//	** If the PRIMARY KEY is on a single column whose datatype is INTEGER,
//	** then we will try to use that column as the rowid.  Set the Table.iPKey
//	** field of the table under construction to be the index of the
//	** INTEGER PRIMARY KEY column.  Table.iPKey is set to -1 if there is
//	** no INTEGER PRIMARY KEY.
//	**
//	** If the key is not an INTEGER PRIMARY KEY, then create a unique
//	** index for the key.  No index is created for INTEGER PRIMARY KEYs.
//	*/
func _sqlite3AddPrimaryKey(tls *libc.TLS, pParse uintptr, pList uintptr, onError int32, autoInc int32, sortOrder int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var i, iCol, nTerm int32
	var pCExpr, pCExpr1, pCol, pTab uintptr
	_, _, _, _, _, _, _ = i, iCol, nTerm, pCExpr, pCExpr1, pCol, pTab
	pTab = (*TParse)(unsafe.Pointer(pParse)).FpNewTable
	pCol = uintptr(0)
	iCol = -int32(1)
	if pTab == uintptr(0) {
		goto primary_key_exit
	}
	if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_HasPrimaryKey) != 0 {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+14162, libc.VaList(bp+8, (*TTable)(unsafe.Pointer(pTab)).FzName))
		goto primary_key_exit
	}
	**(**Tu32)(__ccgo_up(pTab + 28)) |= uint32(TF_HasPrimaryKey)
	if pList == uintptr(0) {
		iCol = int32((*TTable)(unsafe.Pointer(pTab)).FnCol) - int32(1)
		pCol = (*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(iCol)*12
		_makeColumnPartOfPrimaryKey(tls, pParse, pCol)
		nTerm = int32(1)
	} else {
		nTerm = (*TExprList)(unsafe.Pointer(pList)).FnExpr
		i = 0
		for {
			if !(i < nTerm) {
				break
			}
			pCExpr = _sqlite3ExprSkipCollate(tls, (*(*TExprList_item)(unsafe.Pointer(pList + 8 + uintptr(i)*20))).FpExpr)
			_sqlite3StringToId(tls, pCExpr)
			if libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pCExpr)).Fop) == int32(TK_ID) {
				iCol = _sqlite3ColumnIndex(tls, pTab, *(*uintptr)(unsafe.Pointer(pCExpr + 8)))
				if iCol >= 0 {
					pCol = (*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(iCol)*12
					_makeColumnPartOfPrimaryKey(tls, pParse, pCol)
				}
			}
			goto _1
		_1:
			;
			i = i + 1
		}
	}
	if nTerm == int32(1) && pCol != 0 && int32(uint32(*(*uint8)(unsafe.Pointer(pCol + 4))&0xf0>>4)) == int32(COLTYPE_INTEGER) && sortOrder != int32(SQLITE_SO_DESC) {
		if libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).FeParseMode) >= int32(PARSE_MODE_RENAME) && pList != 0 {
			pCExpr1 = _sqlite3ExprSkipCollate(tls, (*(*TExprList_item)(unsafe.Pointer(pList + 8))).FpExpr)
			_sqlite3RenameTokenRemap(tls, pParse, pTab+32, pCExpr1)
		}
		(*TTable)(unsafe.Pointer(pTab)).FiPKey = int16(iCol)
		(*TTable)(unsafe.Pointer(pTab)).FkeyConf = libc.Uint8FromInt32(onError)
		**(**Tu32)(__ccgo_up(pTab + 28)) |= libc.Uint32FromInt32(autoInc * int32(TF_Autoincrement))
		if pList != 0 {
			(*TParse)(unsafe.Pointer(pParse)).FiPkSortOrder = (*(*TExprList_item)(unsafe.Pointer(pList + 8))).Ffg.FsortFlags
		}
		_sqlite3HasExplicitNulls(tls, pParse, pList)
	} else {
		if autoInc != 0 {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+14203, 0)
		} else {
			_sqlite3CreateIndex(tls, pParse, uintptr(0), uintptr(0), uintptr(0), pList, onError, uintptr(0), uintptr(0), sortOrder, 0, uint8(SQLITE_IDXTYPE_PRIMARYKEY))
			pList = uintptr(0)
		}
	}
	goto primary_key_exit
primary_key_exit:
	;
	_sqlite3ExprListDelete(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, pList)
	return
}

// C documentation
//
//	/*
//	** Add the RETURNING clause to the parse currently underway.
//	**
//	** This routine creates a special TEMP trigger that will fire for each row
//	** of the DML statement.  That TEMP trigger contains a single SELECT
//	** statement with a result set that is the argument of the RETURNING clause.
//	** The trigger has the Trigger.bReturning flag and an opcode of
//	** TK_RETURNING instead of TK_SELECT, so that the trigger code generator
//	** knows to handle it specially.  The TEMP trigger is automatically
//	** removed at the end of the parse.
//	**
//	** When this routine is called, we do not yet know if the RETURNING clause
//	** is attached to a DELETE, INSERT, or UPDATE, so construct it as a
//	** RETURNING trigger instead.  It will then be converted into the appropriate
//	** type on the first call to sqlite3TriggersExist().
//	*/
func _sqlite3AddReturning(tls *libc.TLS, pParse uintptr, pList uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var db, pHash, pRet uintptr
	_, _, _ = db, pHash, pRet
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	if (*TParse)(unsafe.Pointer(pParse)).FpNewTrigger != 0 {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+13904, 0)
	} else {
	}
	libc.SetBitFieldPtr16Uint32(pParse+28, libc.Uint32FromInt32(1), 3, 0x8)
	pRet = _sqlite3DbMallocZero(tls, db, uint64(140))
	if pRet == uintptr(0) {
		_sqlite3ExprListDelete(tls, db, pList)
		return
	}
	(*(*struct {
		FpReturning uintptr
	})(unsafe.Pointer(&(*TParse)(unsafe.Pointer(pParse)).Fu1))).FpReturning = pRet
	(*TReturning)(unsafe.Pointer(pRet)).FpParse = pParse
	(*TReturning)(unsafe.Pointer(pRet)).FpReturnEL = pList
	_sqlite3ParserAddCleanup(tls, pParse, __ccgo_fp(_sqlite3DeleteReturning), pRet)
	if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
		return
	}
	Xsqlite3_snprintf(tls, int32(40), pRet+100, __ccgo_ts+13938, libc.VaList(bp+8, pParse))
	(*TReturning)(unsafe.Pointer(pRet)).FretTrig.FzName = pRet + 100
	(*TReturning)(unsafe.Pointer(pRet)).FretTrig.Fop = uint8(TK_RETURNING)
	(*TReturning)(unsafe.Pointer(pRet)).FretTrig.Ftr_tm = uint8(TRIGGER_AFTER)
	(*TReturning)(unsafe.Pointer(pRet)).FretTrig.FbReturning = uint8(1)
	(*TReturning)(unsafe.Pointer(pRet)).FretTrig.FpSchema = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + 1*16))).FpSchema
	(*TReturning)(unsafe.Pointer(pRet)).FretTrig.FpTabSchema = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + 1*16))).FpSchema
	(*TReturning)(unsafe.Pointer(pRet)).FretTrig.Fstep_list = pRet + 44
	(*TReturning)(unsafe.Pointer(pRet)).FretTStep.Fop = uint8(TK_RETURNING)
	(*TReturning)(unsafe.Pointer(pRet)).FretTStep.FpTrig = pRet + 8
	(*TReturning)(unsafe.Pointer(pRet)).FretTStep.FpExprList = pList
	pHash = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + 1*16))).FpSchema + 40
	if _sqlite3HashInsert(tls, pHash, pRet+100, pRet+8) == pRet+8 {
		_sqlite3OomFault(tls, db)
	}
}

// C documentation
//
//	/*
//	** Generate bytecode to implement:
//	**
//	**    ALTER TABLE pSrc ADD [CONSTRAINT pName] CHECK(pExpr)
//	**
//	** Any "ON CONFLICT" text that occurs after the "CHECK(...)", up
//	** until pParse->sLastToken, is included as part of the new constraint.
//	*/
func _sqlite3AlterAddConstraint(tls *libc.TLS, pParse uintptr, pSrc uintptr, pFirst uintptr, pName uintptr, zExpr uintptr, nExpr int32, pExpr uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var nCons, rc int32
	var pCons, pTab, zName uintptr
	var _ /* iDb at bp+0 */ int32
	var _ /* zDb at bp+4 */ uintptr
	_, _, _, _, _ = nCons, pCons, pTab, rc, zName
	pTab = uintptr(0)                             /* Table identified by pSrc */
	**(**int32)(__ccgo_up(bp)) = 0                /* Which schema does pTab live in */
	**(**uintptr)(__ccgo_up(bp + 4)) = uintptr(0) /* Name of the schema in which pTab lives */
	pCons = uintptr(0)                            /* Result from error checking pExpr */
	/* Look up the table being altered. */
	pTab = _alterFindTable(tls, pParse, pSrc, bp, bp+4, int32(1))
	if !(pTab != 0) {
		_sqlite3ExprDelete(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, pExpr)
		return
	}
	/* Verify that the new CHECK constraint does not contain any
	 ** internal-use-only function.  Forum post 2026-05-10T01:11:28Z
	 */
	rc = _sqlite3ResolveSelfReference(tls, pParse, pTab, int32(NC_IsCheck), pExpr, uintptr(0))
	_sqlite3ExprDelete(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, pExpr)
	if rc != 0 {
		return
	}
	/* If this new constraint has a name, check that it is not a duplicate of
	 ** an existing constraint. It is an error if it is.  */
	if pName != 0 {
		zName = _sqlite3NameFromToken(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, pName)
		_sqlite3NestedParse(tls, pParse, __ccgo_ts+12285, libc.VaList(bp+16, zName, int32(SQLITE_ERROR), **(**uintptr)(__ccgo_up(bp + 4)), (*TTable)(unsafe.Pointer(pTab)).FzName, zName))
		_sqlite3DbFree(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, zName)
	}
	/* Search for a constraint violation. Throw an exception if one is found. */
	_sqlite3NestedParse(tls, pParse, __ccgo_ts+12450, libc.VaList(bp+16, int32(SQLITE_CONSTRAINT), **(**uintptr)(__ccgo_up(bp + 4)), (*TTable)(unsafe.Pointer(pTab)).FzName, nExpr, zExpr))
	/* Edit the SQL for the named table. */
	pCons = (*TToken)(unsafe.Pointer(pFirst)).Fz
	nCons = _alterRtrimConstraint(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, pCons, int32((*TParse)(unsafe.Pointer(pParse)).FsLastToken.Fz)-int32(pCons))
	_sqlite3NestedParse(tls, pParse, __ccgo_ts+12530, libc.VaList(bp+16, **(**uintptr)(__ccgo_up(bp + 4)), nCons, pCons, (*TTable)(unsafe.Pointer(pTab)).FzName))
	/* Finally, reload the database schema. */
	_renameReloadSchema(tls, pParse, **(**int32)(__ccgo_up(bp)), uint16(INITFLAG_AlterDropCons))
}

// C documentation
//
//	/*
//	** This function is called by the parser after the table-name in
//	** an "ALTER TABLE <table-name> ADD" statement is parsed. Argument
//	** pSrc is the full-name of the table being altered.
//	**
//	** This routine makes a (partial) copy of the Table structure
//	** for the table being altered and sets Parse.pNewTable to point
//	** to it. Routines called by the parser as the column definition
//	** is parsed (i.e. sqlite3AddColumn()) add the new Column data to
//	** the copy. The copy of the Table structure is deleted by tokenize.c
//	** after parsing is finished.
//	**
//	** Routine sqlite3AlterFinishAddColumn() will be called to complete
//	** coding the "ALTER TABLE ... ADD" statement.
//	*/
func _sqlite3AlterBeginAddColumn(tls *libc.TLS, pParse uintptr, pSrc uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var db, pCol, pNew, pTab uintptr
	var i, iDb, nAlloc int32
	_, _, _, _, _, _, _ = db, i, iDb, nAlloc, pCol, pNew, pTab
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	/* Look up the table being altered. */
	if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
		goto exit_begin_add_column
	}
	pTab = _sqlite3LocateTableItem(tls, pParse, uint32(0), pSrc+8)
	if !(pTab != 0) {
		goto exit_begin_add_column
	}
	if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+11034, 0)
		goto exit_begin_add_column
	}
	/* Make sure this is not an attempt to ALTER a view. */
	if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VIEW) {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+11068, 0)
		goto exit_begin_add_column
	}
	if SQLITE_OK != _isAlterableTable(tls, pParse, pTab) {
		goto exit_begin_add_column
	}
	_sqlite3MayAbort(tls, pParse)
	iDb = _sqlite3SchemaToIndex(tls, db, (*TTable)(unsafe.Pointer(pTab)).FpSchema)
	/* Put a copy of the Table struct in Parse.pNewTable for the
	 ** sqlite3AddColumn() function and friends to modify.  But modify
	 ** the name by adding an "sqlite_altertab_" prefix.  By adding this
	 ** prefix, we insure that the name will not collide with an existing
	 ** table because user table are not allowed to have the "sqlite_"
	 ** prefix on their name.
	 */
	pNew = _sqlite3DbMallocZero(tls, db, uint64(80))
	if !(pNew != 0) {
		goto exit_begin_add_column
	}
	(*TParse)(unsafe.Pointer(pParse)).FpNewTable = pNew
	(*TTable)(unsafe.Pointer(pNew)).FnTabRef = uint32(1)
	(*TTable)(unsafe.Pointer(pNew)).FnCol = (*TTable)(unsafe.Pointer(pTab)).FnCol
	nAlloc = (int32((*TTable)(unsafe.Pointer(pNew)).FnCol)-int32(1))/int32(8)*int32(8) + int32(8)
	(*TTable)(unsafe.Pointer(pNew)).FaCol = _sqlite3DbMallocZero(tls, db, uint64(uint32(12)*libc.Uint32FromInt32(nAlloc)))
	(*TTable)(unsafe.Pointer(pNew)).FzName = _sqlite3MPrintf(tls, db, __ccgo_ts+11098, libc.VaList(bp+8, (*TTable)(unsafe.Pointer(pTab)).FzName))
	if !((*TTable)(unsafe.Pointer(pNew)).FaCol != 0) || !((*TTable)(unsafe.Pointer(pNew)).FzName != 0) {
		goto exit_begin_add_column
	}
	libc.Xmemcpy(tls, (*TTable)(unsafe.Pointer(pNew)).FaCol, (*TTable)(unsafe.Pointer(pTab)).FaCol, uint32(12)*libc.Uint32FromInt16((*TTable)(unsafe.Pointer(pNew)).FnCol))
	i = 0
	for {
		if !(i < int32((*TTable)(unsafe.Pointer(pNew)).FnCol)) {
			break
		}
		pCol = (*TTable)(unsafe.Pointer(pNew)).FaCol + uintptr(i)*12
		(*TColumn)(unsafe.Pointer(pCol)).FzCnName = _sqlite3DbStrDup(tls, db, (*TColumn)(unsafe.Pointer(pCol)).FzCnName)
		(*TColumn)(unsafe.Pointer(pCol)).FhName = _sqlite3StrIHash(tls, (*TColumn)(unsafe.Pointer(pCol)).FzCnName)
		goto _1
	_1:
		;
		i = i + 1
	}
	(*(*struct {
		FaddColOffset int32
		FpFKey        uintptr
		FpDfltList    uintptr
	})(unsafe.Pointer(pNew + 44))).FpDfltList = _sqlite3ExprListDup(tls, db, (*(*struct {
		FaddColOffset int32
		FpFKey        uintptr
		FpDfltList    uintptr
	})(unsafe.Pointer(pTab + 44))).FpDfltList, 0)
	(*TTable)(unsafe.Pointer(pNew)).FpSchema = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FpSchema
	(*(*struct {
		FaddColOffset int32
		FpFKey        uintptr
		FpDfltList    uintptr
	})(unsafe.Pointer(pNew + 44))).FaddColOffset = (*(*struct {
		FaddColOffset int32
		FpFKey        uintptr
		FpDfltList    uintptr
	})(unsafe.Pointer(pTab + 44))).FaddColOffset
	goto exit_begin_add_column
exit_begin_add_column:
	;
	_sqlite3SrcListDelete(tls, db, pSrc)
	return
}

// C documentation
//
//	/*
//	** Generate bytecode for one of:
//	**
//	**  (1)   ALTER TABLE pSrc DROP CONSTRAINT pCons
//	**  (2)   ALTER TABLE pSrc ALTER pCol DROP NOT NULL
//	**
//	** One of pCons and pCol must be NULL and the other non-null.
//	*/
func _sqlite3AlterDropConstraint(tls *libc.TLS, pParse uintptr, pSrc uintptr, pCons uintptr, pCol uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var db, pTab, z, zArg uintptr
	var _ /* iCol at bp+8 */ int32
	var _ /* iDb at bp+0 */ int32
	var _ /* zDb at bp+4 */ uintptr
	_, _, _, _ = db, pTab, z, zArg
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	pTab = uintptr(0)
	**(**int32)(__ccgo_up(bp)) = 0
	**(**uintptr)(__ccgo_up(bp + 4)) = uintptr(0)
	zArg = uintptr(0)
	pTab = _alterFindTable(tls, pParse, pSrc, bp, bp+4, libc.BoolInt32(pCons != uintptr(0)))
	if !(pTab != 0) {
		return
	}
	if pCons != 0 {
		z = _sqlite3NameFromToken(tls, db, pCons)
		zArg = _sqlite3MPrintf(tls, db, __ccgo_ts+11927, libc.VaList(bp+24, z))
		_sqlite3DbFree(tls, db, z)
	} else {
		if _alterFindCol(tls, pParse, pTab, pCol, bp+8) != 0 {
			return
		}
		zArg = _sqlite3MPrintf(tls, db, __ccgo_ts+5291, libc.VaList(bp+24, **(**int32)(__ccgo_up(bp + 8))))
	}
	/* Edit the SQL for the named table. */
	_sqlite3NestedParse(tls, pParse, __ccgo_ts+11930, libc.VaList(bp+24, **(**uintptr)(__ccgo_up(bp + 4)), zArg, (*TTable)(unsafe.Pointer(pTab)).FzName))
	_sqlite3DbFree(tls, db, zArg)
	/* Finally, reload the database schema. */
	_renameReloadSchema(tls, pParse, **(**int32)(__ccgo_up(bp)), uint16(INITFLAG_AlterDropCons))
}

// C documentation
//
//	/*
//	** Generate code to implement the "ALTER TABLE xxx RENAME TO yyy"
//	** command.
//	*/
func _sqlite3AlterRenameTable(tls *libc.TLS, pParse uintptr, pSrc uintptr, pName uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var db, pTab, pVTab, v, zDb, zName, zTabName, v2 uintptr
	var i, iDb, nTabName, v1 int32
	_, _, _, _, _, _, _, _, _, _, _, _ = db, i, iDb, nTabName, pTab, pVTab, v, zDb, zName, zTabName, v1, v2 /* Table being renamed */
	zName = uintptr(0)                                                                                      /* NULL-terminated version of pName */
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	pVTab = uintptr(0) /* Non-zero if this is a v-tab with an xRename() */
	if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
		goto exit_rename_table
	}
	pTab = _sqlite3LocateTableItem(tls, pParse, uint32(0), pSrc+8)
	if !(pTab != 0) {
		goto exit_rename_table
	}
	iDb = _sqlite3SchemaToIndex(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, (*TTable)(unsafe.Pointer(pTab)).FpSchema)
	zDb = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FzDbSName
	/* Get a NULL terminated version of the new table name. */
	zName = _sqlite3NameFromToken(tls, db, pName)
	if !(zName != 0) {
		goto exit_rename_table
	}
	/* Check that a table or index named 'zName' does not already exist
	 ** in database iDb. If so, this is an error.
	 */
	if _sqlite3FindTable(tls, db, zName, zDb) != 0 || _sqlite3FindIndex(tls, db, zName, zDb) != 0 || _sqlite3IsShadowTableOf(tls, db, pTab, zName) != 0 {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+9320, libc.VaList(bp+8, zName))
		goto exit_rename_table
	}
	/* Make sure it is not a system table being altered, or a reserved name
	 ** that the table is being renamed to.
	 */
	if SQLITE_OK != _isAlterableTable(tls, pParse, pTab) {
		goto exit_rename_table
	}
	if SQLITE_OK != _sqlite3CheckObjectName(tls, pParse, zName, __ccgo_ts+9379, zName) {
		goto exit_rename_table
	}
	if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VIEW) {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+9385, libc.VaList(bp+8, (*TTable)(unsafe.Pointer(pTab)).FzName))
		goto exit_rename_table
	}
	/* Invoke the authorization callback. */
	if _sqlite3AuthCheck(tls, pParse, int32(SQLITE_ALTER_TABLE), zDb, (*TTable)(unsafe.Pointer(pTab)).FzName, uintptr(0)) != 0 {
		goto exit_rename_table
	}
	if _sqlite3ViewGetColumnNames(tls, pParse, pTab) != 0 {
		goto exit_rename_table
	}
	if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) {
		pVTab = _sqlite3GetVTable(tls, db, pTab)
		if (*Tsqlite3_module)(unsafe.Pointer((*Tsqlite3_vtab)(unsafe.Pointer((*TVTable)(unsafe.Pointer(pVTab)).FpVtab)).FpModule)).FxRename == uintptr(0) {
			pVTab = uintptr(0)
		}
	}
	/* Begin a transaction for database iDb. Then modify the schema cookie
	 ** (since the ALTER TABLE modifies the schema). Call sqlite3MayAbort(),
	 ** as the scalar functions (e.g. sqlite_rename_table()) invoked by the
	 ** nested SQL may raise an exception.  */
	v = _sqlite3GetVdbe(tls, pParse)
	if v == uintptr(0) {
		goto exit_rename_table
	}
	_sqlite3MayAbort(tls, pParse)
	/* figure out how many UTF-8 characters are in zName */
	zTabName = (*TTable)(unsafe.Pointer(pTab)).FzName
	nTabName = _sqlite3Utf8CharLen(tls, zTabName, -int32(1))
	/* Rewrite all CREATE TABLE, INDEX, TRIGGER or VIEW statements in
	 ** the schema to use the new table name.  */
	_sqlite3NestedParse(tls, pParse, __ccgo_ts+9412, libc.VaList(bp+8, zDb, zDb, zTabName, zName, libc.BoolInt32(iDb == int32(1)), zTabName))
	/* Update the tbl_name and name columns of the sqlite_schema table
	 ** as required.  */
	_sqlite3NestedParse(tls, pParse, __ccgo_ts+9596, libc.VaList(bp+8, zDb, zName, zName, zName, nTabName, zTabName))
	/* If the sqlite_sequence table exists in this database, then update
	 ** it with the new table name.
	 */
	if _sqlite3FindTable(tls, db, __ccgo_ts+9901, zDb) != 0 {
		_sqlite3NestedParse(tls, pParse, __ccgo_ts+9917, libc.VaList(bp+8, zDb, zName, (*TTable)(unsafe.Pointer(pTab)).FzName))
	}
	/* If the table being renamed is not itself part of the temp database,
	 ** edit view and trigger definitions within the temp database
	 ** as required.  */
	if iDb != int32(1) {
		_sqlite3NestedParse(tls, pParse, __ccgo_ts+9975, libc.VaList(bp+8, zDb, zTabName, zName, zTabName, zDb, zName))
	}
	/* If this is a virtual table, invoke the xRename() function if
	 ** one is defined. The xRename() callback will modify the names
	 ** of any resources used by the v-table implementation (including other
	 ** SQLite tables) that are identified by the name of the virtual table.
	 */
	if pVTab != 0 {
		v2 = pParse + 48
		*(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1
		v1 = *(*int32)(unsafe.Pointer(v2))
		i = v1
		_sqlite3VdbeLoadString(tls, v, i, zName)
		_sqlite3VdbeAddOp4(tls, v, int32(OP_VRename), i, 0, 0, pVTab, -int32(12))
	}
	_renameReloadSchema(tls, pParse, iDb, uint16(INITFLAG_AlterRename))
	_renameTestSchema(tls, pParse, zDb, libc.BoolInt32(iDb == int32(1)), __ccgo_ts+10240, 0)
	goto exit_rename_table
exit_rename_table:
	;
	_sqlite3SrcListDelete(tls, db, pSrc)
	_sqlite3DbFree(tls, db, zName)
}

// C documentation
//
//	/*
//	** Prepare a statement of the form:
//	**
//	**   ALTER TABLE pSrc ALTER pCol SET NOT NULL
//	*/
func _sqlite3AlterSetNotNull(tls *libc.TLS, pParse uintptr, pSrc uintptr, pCol uintptr, pFirst uintptr) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var nCons int32
	var pCons, pTab uintptr
	var _ /* iCol at bp+0 */ int32
	var _ /* iDb at bp+4 */ int32
	var _ /* zDb at bp+8 */ uintptr
	_, _, _ = nCons, pCons, pTab
	pTab = uintptr(0)
	**(**int32)(__ccgo_up(bp)) = 0
	**(**int32)(__ccgo_up(bp + 4)) = 0
	**(**uintptr)(__ccgo_up(bp + 8)) = uintptr(0)
	pCons = uintptr(0)
	nCons = 0
	/* Look up the table being altered. */
	pTab = _alterFindTable(tls, pParse, pSrc, bp+4, bp+8, 0)
	if !(pTab != 0) {
		return
	}
	/* Find the column being altered. */
	if _alterFindCol(tls, pParse, pTab, pCol, bp) != 0 {
		return
	}
	/* Find the length in bytes of the constraint definition */
	pCons = (*TToken)(unsafe.Pointer(pFirst)).Fz
	nCons = _alterRtrimConstraint(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, pCons, int32((*TParse)(unsafe.Pointer(pParse)).FsLastToken.Fz)-int32(pCons))
	/* Search for a constraint violation. Throw an exception if one is found. */
	_sqlite3NestedParse(tls, pParse, __ccgo_ts+12053, libc.VaList(bp+24, int32(SQLITE_CONSTRAINT), **(**uintptr)(__ccgo_up(bp + 8)), (*TTable)(unsafe.Pointer(pTab)).FzName, libc.Int32FromUint32((*TToken)(unsafe.Pointer(pCol)).Fn), (*TToken)(unsafe.Pointer(pCol)).Fz))
	/* Edit the SQL for the named table. */
	_sqlite3NestedParse(tls, pParse, __ccgo_ts+12134, libc.VaList(bp+24, **(**uintptr)(__ccgo_up(bp + 8)), **(**int32)(__ccgo_up(bp)), nCons, pCons, **(**int32)(__ccgo_up(bp)), (*TTable)(unsafe.Pointer(pTab)).FzName))
	/* Finally, reload the database schema. */
	_renameReloadSchema(tls, pParse, **(**int32)(__ccgo_up(bp + 4)), uint16(INITFLAG_AlterDropCons))
}

// C documentation
//
//	/*
//	** Load the content of the sqlite_stat1 and sqlite_stat4 tables. The
//	** contents of sqlite_stat1 are used to populate the Index.aiRowEst[]
//	** arrays. The contents of sqlite_stat4 are used to populate the
//	** Index.aSample[] arrays.
//	**
//	** If the sqlite_stat1 table is not present in the database, SQLITE_ERROR
//	** is returned. In this case, even if SQLITE_ENABLE_STAT4 was defined
//	** during compilation and the sqlite_stat4 table is present, no data is
//	** read from it.
//	**
//	** If SQLITE_ENABLE_STAT4 was defined during compilation and the
//	** sqlite_stat4 table is not present in the database, SQLITE_ERROR is
//	** returned. However, in this case, data is read from the sqlite_stat1
//	** table (if it is present) before returning.
//	**
//	** If an OOM error occurs, this function always sets db->mallocFailed.
//	** This means if the caller does not care about other errors, the return
//	** code may be ignored.
//	*/
func _sqlite3AnalysisLoad(tls *libc.TLS, db uintptr, iDb int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var i, pIdx, pIdx1, pIdx2, pSchema, pStat1, pTab, zSql, v3 uintptr
	var rc, v5 int32
	var _ /* sInfo at bp+0 */ TanalysisInfo
	_, _, _, _, _, _, _, _, _, _, _ = i, pIdx, pIdx1, pIdx2, pSchema, pStat1, pTab, rc, zSql, v3, v5
	rc = SQLITE_OK
	pSchema = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FpSchema
	/* Clear any prior statistics */
	i = (*THash)(unsafe.Pointer(pSchema + 8)).Ffirst
	for {
		if !(i != 0) {
			break
		}
		pTab = (*THashElem)(unsafe.Pointer(i)).Fdata
		**(**Tu32)(__ccgo_up(pTab + 28)) &= libc.Uint32FromInt32(^libc.Int32FromInt32(TF_HasStat1))
		goto _1
	_1:
		;
		i = (*THashElem)(unsafe.Pointer(i)).Fnext
	}
	i = (*THash)(unsafe.Pointer(pSchema + 24)).Ffirst
	for {
		if !(i != 0) {
			break
		}
		pIdx = (*THashElem)(unsafe.Pointer(i)).Fdata
		libc.SetBitFieldPtr16Uint32(pIdx+56, libc.Uint32FromInt32(0), 7, 0x80)
		_sqlite3DeleteIndexSamples(tls, db, pIdx)
		(*TIndex)(unsafe.Pointer(pIdx)).FaSample = uintptr(0)
		goto _2
	_2:
		;
		i = (*THashElem)(unsafe.Pointer(i)).Fnext
	}
	/* Load new statistics out of the sqlite_stat1 table */
	(**(**TanalysisInfo)(__ccgo_up(bp))).Fdb = db
	(**(**TanalysisInfo)(__ccgo_up(bp))).FzDatabase = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FzDbSName
	v3 = _sqlite3FindTable(tls, db, __ccgo_ts+12835, (**(**TanalysisInfo)(__ccgo_up(bp))).FzDatabase)
	pStat1 = v3
	if v3 != 0 && libc.Int32FromUint8((*TTable)(unsafe.Pointer(pStat1)).FeTabType) == TABTYP_NORM {
		zSql = _sqlite3MPrintf(tls, db, __ccgo_ts+13208, libc.VaList(bp+16, (**(**TanalysisInfo)(__ccgo_up(bp))).FzDatabase))
		if zSql == uintptr(0) {
			rc = int32(SQLITE_NOMEM)
		} else {
			rc = Xsqlite3_exec(tls, db, zSql, __ccgo_fp(_analysisLoader), bp, uintptr(0))
			_sqlite3DbFree(tls, db, zSql)
		}
	}
	/* Set appropriate defaults on all indexes not in the sqlite_stat1 table */
	i = (*THash)(unsafe.Pointer(pSchema + 24)).Ffirst
	for {
		if !(i != 0) {
			break
		}
		pIdx1 = (*THashElem)(unsafe.Pointer(i)).Fdata
		if !(int32(uint32(*(*uint16)(unsafe.Pointer(pIdx1 + 56))&0x80>>7)) != 0) {
			_sqlite3DefaultRowEst(tls, pIdx1)
		}
		goto _4
	_4:
		;
		i = (*THashElem)(unsafe.Pointer(i)).Fnext
	}
	/* Load the statistics from the sqlite_stat4 table. */
	if rc == SQLITE_OK {
		(*Tsqlite3)(unsafe.Pointer(db)).Flookaside.FbDisable = (*Tsqlite3)(unsafe.Pointer(db)).Flookaside.FbDisable + 1
		(*Tsqlite3)(unsafe.Pointer(db)).Flookaside.Fsz = uint16(0)
		rc = _loadStat4(tls, db, (**(**TanalysisInfo)(__ccgo_up(bp))).FzDatabase)
		(*Tsqlite3)(unsafe.Pointer(db)).Flookaside.FbDisable = (*Tsqlite3)(unsafe.Pointer(db)).Flookaside.FbDisable - 1
		if (*Tsqlite3)(unsafe.Pointer(db)).Flookaside.FbDisable != 0 {
			v5 = 0
		} else {
			v5 = libc.Int32FromUint16((*Tsqlite3)(unsafe.Pointer(db)).Flookaside.FszTrue)
		}
		(*Tsqlite3)(unsafe.Pointer(db)).Flookaside.Fsz = libc.Uint16FromInt32(v5)
	}
	i = (*THash)(unsafe.Pointer(pSchema + 24)).Ffirst
	for {
		if !(i != 0) {
			break
		}
		pIdx2 = (*THashElem)(unsafe.Pointer(i)).Fdata
		Xsqlite3_free(tls, (*TIndex)(unsafe.Pointer(pIdx2)).FaiRowEst)
		(*TIndex)(unsafe.Pointer(pIdx2)).FaiRowEst = uintptr(0)
		goto _6
	_6:
		;
		i = (*THashElem)(unsafe.Pointer(i)).Fnext
	}
	if rc == int32(SQLITE_NOMEM) {
		_sqlite3OomFault(tls, db)
	}
	return rc
}

/************** End of analyze.c *********************************************/
/************** Begin file attach.c ******************************************/
/*
** 2003 April 6
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:
**
**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains code used to implement the ATTACH and DETACH commands.
 */
/* #include "sqliteInt.h" */

// C documentation
//
//	/*
//	** The pExpr should be a TK_COLUMN expression.  The table referred to
//	** is in pTabList or else it is the NEW or OLD table of a trigger.
//	** Check to see if it is OK to read this particular column.
//	**
//	** If the auth function returns SQLITE_IGNORE, change the TK_COLUMN
//	** instruction into a TK_NULL.  If the auth function returns SQLITE_DENY,
//	** then generate an error.
//	*/
func _sqlite3AuthRead(tls *libc.TLS, pParse uintptr, pExpr uintptr, pSchema uintptr, pTabList uintptr) {
	var iCol, iDb, iSrc int32
	var pTab, zCol uintptr
	_, _, _, _, _ = iCol, iDb, iSrc, pTab, zCol
	pTab = uintptr(0) /* Index of column in table */
	iDb = _sqlite3SchemaToIndex(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, pSchema)
	if iDb < 0 {
		/* An attempt to read a column out of a subquery or other
		 ** temporary table. */
		return
	}
	if libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pExpr)).Fop) == int32(TK_TRIGGER) {
		pTab = (*TParse)(unsafe.Pointer(pParse)).FpTriggerTab
	} else {
		iSrc = 0
		for {
			if !(iSrc < (*TSrcList)(unsafe.Pointer(pTabList)).FnSrc) {
				break
			}
			if (*TExpr)(unsafe.Pointer(pExpr)).FiTable == (*(*TSrcItem)(unsafe.Pointer(pTabList + 8 + uintptr(iSrc)*48))).FiCursor {
				pTab = (*(*TSrcItem)(unsafe.Pointer(pTabList + 8 + uintptr(iSrc)*48))).FpSTab
				break
			}
			goto _1
		_1:
			;
			iSrc = iSrc + 1
		}
	}
	iCol = int32((*TExpr)(unsafe.Pointer(pExpr)).FiColumn)
	if pTab == uintptr(0) {
		return
	}
	if iCol >= 0 {
		zCol = (**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(iCol)*12))).FzCnName
	} else {
		if int32((*TTable)(unsafe.Pointer(pTab)).FiPKey) >= 0 {
			zCol = (**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr((*TTable)(unsafe.Pointer(pTab)).FiPKey)*12))).FzCnName
		} else {
			zCol = __ccgo_ts + 8199
		}
	}
	if int32(SQLITE_IGNORE) == _sqlite3AuthReadCol(tls, pParse, (*TTable)(unsafe.Pointer(pTab)).FzName, zCol, iDb) {
		(*TExpr)(unsafe.Pointer(pExpr)).Fop = uint8(TK_NULL)
	}
}

// C documentation
//
//	/*
//	** Invoke the authorization callback for permission to read column zCol from
//	** table zTab in database zDb. This function assumes that an authorization
//	** callback has been registered (i.e. that sqlite3.xAuth is not NULL).
//	**
//	** If SQLITE_IGNORE is returned and pExpr is not NULL, then pExpr is changed
//	** to an SQL NULL expression. Otherwise, if pExpr is NULL, then SQLITE_IGNORE
//	** is treated as SQLITE_DENY. In this case an error is left in pParse.
//	*/
func _sqlite3AuthReadCol(tls *libc.TLS, pParse uintptr, zTab uintptr, zCol uintptr, iDb int32) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var db, z, zDb uintptr
	var rc int32
	_, _, _, _ = db, rc, z, zDb
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb                                                     /* Database handle */
	zDb = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FzDbSName /* Auth callback return code */
	if (*Tsqlite3)(unsafe.Pointer(db)).Finit1.Fbusy != 0 {
		return SQLITE_OK
	}
	rc = (*(*func(*libc.TLS, uintptr, int32, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tsqlite3)(unsafe.Pointer(db)).FxAuth})))(tls, (*Tsqlite3)(unsafe.Pointer(db)).FpAuthArg, int32(SQLITE_READ), zTab, zCol, zDb, (*TParse)(unsafe.Pointer(pParse)).FzAuthContext)
	if rc == int32(SQLITE_DENY) {
		z = Xsqlite3_mprintf(tls, __ccgo_ts+13634, libc.VaList(bp+8, zTab, zCol))
		if (*Tsqlite3)(unsafe.Pointer(db)).FnDb > int32(2) || iDb != 0 {
			z = Xsqlite3_mprintf(tls, __ccgo_ts+13640, libc.VaList(bp+8, zDb, z))
		}
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+13646, libc.VaList(bp+8, z))
		(*TParse)(unsafe.Pointer(pParse)).Frc = int32(SQLITE_AUTH)
	} else {
		if rc != int32(SQLITE_IGNORE) && rc != SQLITE_OK {
			_sqliteAuthBadReturnCode(tls, pParse)
		}
	}
	return rc
}

// C documentation
//
//	/*
//	** Load all automatic extensions.
//	**
//	** If anything goes wrong, set an error in the database connection.
//	*/
func _sqlite3AutoLoadExtensions(tls *libc.TLS, db uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var go1, rc, v2 int32
	var i Tu32
	var mutex, pThunk uintptr
	var xInit Tsqlite3_loadext_entry
	var v3 bool
	var _ /* zErrmsg at bp+0 */ uintptr
	_, _, _, _, _, _, _, _ = go1, i, mutex, pThunk, rc, xInit, v2, v3
	go1 = int32(1)
	if _sqlite3Autoext.FnExt == uint32(0) {
		/* Common case: early out without every having to acquire a mutex */
		return
	}
	i = uint32(0)
	for {
		if !(go1 != 0) {
			break
		}
		mutex = _sqlite3MutexAlloc(tls, int32(SQLITE_MUTEX_STATIC_MAIN))
		pThunk = uintptr(unsafe.Pointer(&_sqlite3Apis))
		Xsqlite3_mutex_enter(tls, mutex)
		if i >= _sqlite3Autoext.FnExt {
			xInit = uintptr(0)
			go1 = 0
		} else {
			xInit = **(**uintptr)(__ccgo_up(_sqlite3Autoext.FaExt + uintptr(i)*4))
		}
		Xsqlite3_mutex_leave(tls, mutex)
		**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
		if v3 = xInit != 0; v3 {
			v2 = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{xInit})))(tls, db, bp, pThunk)
			rc = v2
		}
		if v3 && v2 != 0 {
			_sqlite3ErrorWithMsg(tls, db, rc, __ccgo_ts+17743, libc.VaList(bp+16, **(**uintptr)(__ccgo_up(bp))))
			go1 = 0
		}
		Xsqlite3_free(tls, **(**uintptr)(__ccgo_up(bp)))
		goto _1
	_1:
		;
		i = i + 1
	}
}

/************** End of loadext.c *********************************************/
/************** Begin file pragma.c ******************************************/
/*
** 2003 April 6
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:
**
**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains code used to implement the PRAGMA command.
 */
/* #include "sqliteInt.h" */

/***************************************************************************
** The "pragma.h" include file is an automatically generated file that
** that includes the PragType_XXXX macro definitions and the aPragmaName[]
** object.  This ensures that the aPragmaName[] table is arranged in
** lexicographical order to facility a binary search of the pragma name.
** Do not edit pragma.h directly.  Edit and rerun the script in at
** ../tool/mkpragmatab.tcl. */
/************** Include pragma.h in the middle of pragma.c *******************/
/************** Begin file pragma.h ******************************************/
/* DO NOT EDIT!
** This file is automatically generated by the script at
** ../tool/mkpragmatab.tcl.  To update the set of pragmas, edit
** that script and rerun it.
 */

/* The various pragma types */

/* Property flags associated with various pragma. */

// C documentation
//
//	/*
//	** Generate VDBE code for a BEGIN statement.
//	*/
func _sqlite3BeginTransaction(tls *libc.TLS, pParse uintptr, type1 int32) {
	var db, pBt, v uintptr
	var eTxnType, i int32
	_, _, _, _, _ = db, eTxnType, i, pBt, v
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	if _sqlite3AuthCheck(tls, pParse, int32(SQLITE_TRANSACTION), __ccgo_ts+16105, uintptr(0), uintptr(0)) != 0 {
		return
	}
	v = _sqlite3GetVdbe(tls, pParse)
	if !(v != 0) {
		return
	}
	if type1 != int32(TK_DEFERRED) {
		i = 0
		for {
			if !(i < (*Tsqlite3)(unsafe.Pointer(db)).FnDb) {
				break
			}
			pBt = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(i)*16))).FpBt
			if pBt != 0 && _sqlite3BtreeIsReadonly(tls, pBt) != 0 {
				eTxnType = 0 /* Read txn */
			} else {
				if type1 == int32(TK_EXCLUSIVE) {
					eTxnType = int32(2) /* Exclusive txn */
				} else {
					eTxnType = int32(1) /* Write txn */
				}
			}
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Transaction), i, eTxnType)
			_sqlite3VdbeUsesBtree(tls, v, i)
			goto _1
		_1:
			;
			i = i + 1
		}
	}
	_sqlite3VdbeAddOp0(tls, v, int32(OP_AutoCommit))
}

// C documentation
//
//	/*
//	** Generate code to drop a table.
//	*/
func _sqlite3CodeDropTable(tls *libc.TLS, pParse uintptr, pTab uintptr, iDb int32, isView int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var db, pDb, pTrigger, v uintptr
	_, _, _, _ = db, pDb, pTrigger, v
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	pDb = (*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16
	v = _sqlite3GetVdbe(tls, pParse)
	_sqlite3BeginWriteOperation(tls, pParse, int32(1), iDb)
	if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) {
		_sqlite3VdbeAddOp0(tls, v, int32(OP_VBegin))
	}
	/* Drop all triggers associated with the table being dropped. Code
	 ** is generated to remove entries from sqlite_schema and/or
	 ** sqlite_temp_schema if required.
	 */
	pTrigger = _sqlite3TriggerList(tls, pParse, pTab)
	for pTrigger != 0 {
		_sqlite3DropTriggerPtr(tls, pParse, pTrigger)
		pTrigger = (*TTrigger)(unsafe.Pointer(pTrigger)).FpNext
	}
	/* Remove any entries of the sqlite_sequence table associated with
	 ** the table being dropped. This is done before the table is dropped
	 ** at the btree level, in case the sqlite_sequence table needs to
	 ** move as a result of the drop (can happen in auto-vacuum mode).
	 */
	if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_Autoincrement) != 0 {
		_sqlite3NestedParse(tls, pParse, __ccgo_ts+14967, libc.VaList(bp+8, (*TDb)(unsafe.Pointer(pDb)).FzDbSName, (*TTable)(unsafe.Pointer(pTab)).FzName))
	}
	/* Drop all entries in the schema table that refer to the
	 ** table. The program name loops through the schema table and deletes
	 ** every row that refers to a table of the same name as the one being
	 ** dropped. Triggers are handled separately because a trigger can be
	 ** created in the temp database that refers to a table in another
	 ** database.
	 */
	_sqlite3NestedParse(tls, pParse, __ccgo_ts+15012, libc.VaList(bp+8, (*TDb)(unsafe.Pointer(pDb)).FzDbSName, (*TTable)(unsafe.Pointer(pTab)).FzName))
	if !(isView != 0) && !(libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == libc.Int32FromInt32(TABTYP_VTAB)) {
		_destroyTable(tls, pParse, pTab)
	}
	/* Remove the table entry from SQLite's internal schema and modify
	 ** the schema cookie.
	 */
	if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) {
		_sqlite3VdbeAddOp4(tls, v, int32(OP_VDestroy), iDb, 0, 0, (*TTable)(unsafe.Pointer(pTab)).FzName, 0)
		_sqlite3MayAbort(tls, pParse)
	}
	_sqlite3VdbeAddOp4(tls, v, int32(OP_DropTable), iDb, 0, 0, (*TTable)(unsafe.Pointer(pTab)).FzName, 0)
	_sqlite3ChangeCookie(tls, pParse, iDb)
	_sqliteViewResetAll(tls, db, iDb)
}

// C documentation
//
//	/*
//	** This function is exactly the same as sqlite3_create_function(), except
//	** that it is designed to be called by internal code. The difference is
//	** that if a malloc() fails in sqlite3_create_function(), an error code
//	** is returned and the mallocFailed flag cleared.
//	*/
func _sqlite3CreateFunc(tls *libc.TLS, db uintptr, zFunctionName uintptr, nArg int32, enc int32, pUserData uintptr, __ccgo_fp_xSFunc uintptr, __ccgo_fp_xStep uintptr, __ccgo_fp_xFinal uintptr, __ccgo_fp_xValue uintptr, __ccgo_fp_xInverse uintptr, pDestructor uintptr) (r int32) {
	var extraFlags, rc int32
	var p, v1 uintptr
	_, _, _, _ = extraFlags, p, rc, v1
	if zFunctionName == uintptr(0) || __ccgo_fp_xSFunc != uintptr(0) && __ccgo_fp_xFinal != uintptr(0) || libc.BoolInt32(__ccgo_fp_xFinal == uintptr(0)) != libc.BoolInt32(__ccgo_fp_xStep == uintptr(0)) || libc.BoolInt32(__ccgo_fp_xValue == uintptr(0)) != libc.BoolInt32(__ccgo_fp_xInverse == uintptr(0)) || (nArg < -int32(1) || nArg > int32(SQLITE_MAX_FUNCTION_ARG)) || int32(255) < _sqlite3Strlen30(tls, zFunctionName) {
		return _sqlite3MisuseError(tls, int32(189333))
	}
	extraFlags = enc & (libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_DIRECTONLY) | libc.Int32FromInt32(SQLITE_SUBTYPE) | libc.Int32FromInt32(SQLITE_INNOCUOUS) | libc.Int32FromInt32(SQLITE_RESULT_SUBTYPE) | libc.Int32FromInt32(SQLITE_SELFORDER1))
	enc = enc & (libc.Int32FromInt32(SQLITE_FUNC_ENCMASK) | libc.Int32FromInt32(SQLITE_ANY))
	/* The SQLITE_INNOCUOUS flag is the same bit as SQLITE_FUNC_UNSAFE.  But
	 ** the meaning is inverted.  So flip the bit. */
	extraFlags = extraFlags ^ int32(SQLITE_FUNC_UNSAFE) /* tag-20230109-1 */
	/* If SQLITE_UTF16 is specified as the encoding type, transform this
	 ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
	 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
	 **
	 ** If SQLITE_ANY is specified, add three versions of the function
	 ** to the hash table.
	 */
	switch enc {
	case int32(SQLITE_UTF16):
		enc = int32(SQLITE_UTF16LE)
	case int32(SQLITE_ANY):
		rc = _sqlite3CreateFunc(tls, db, zFunctionName, nArg, int32(SQLITE_UTF8)|extraFlags^int32(SQLITE_FUNC_UNSAFE), pUserData, __ccgo_fp_xSFunc, __ccgo_fp_xStep, __ccgo_fp_xFinal, __ccgo_fp_xValue, __ccgo_fp_xInverse, pDestructor)
		if rc == SQLITE_OK {
			rc = _sqlite3CreateFunc(tls, db, zFunctionName, nArg, int32(SQLITE_UTF16LE)|extraFlags^int32(SQLITE_FUNC_UNSAFE), pUserData, __ccgo_fp_xSFunc, __ccgo_fp_xStep, __ccgo_fp_xFinal, __ccgo_fp_xValue, __ccgo_fp_xInverse, pDestructor)
		}
		if rc != SQLITE_OK {
			return rc
		}
		enc = int32(SQLITE_UTF16BE)
	case int32(SQLITE_UTF8):
		fallthrough
	case int32(SQLITE_UTF16LE):
		fallthrough
	case int32(SQLITE_UTF16BE):
	default:
		enc = int32(SQLITE_UTF8)
		break
	}
	/* Check if an existing function is being overridden or deleted. If so,
	 ** and there are active VMs, then return SQLITE_BUSY. If a function
	 ** is being overridden/deleted but there are no active VMs, allow the
	 ** operation to continue but invalidate all precompiled statements.
	 */
	p = _sqlite3FindFunction(tls, db, zFunctionName, nArg, libc.Uint8FromInt32(enc), uint8(0))
	if p != 0 && (*TFuncDef)(unsafe.Pointer(p)).FfuncFlags&uint32(SQLITE_FUNC_ENCMASK) == libc.Uint32FromInt32(enc) && int32((*TFuncDef)(unsafe.Pointer(p)).FnArg) == nArg {
		if (*Tsqlite3)(unsafe.Pointer(db)).FnVdbeActive != 0 {
			_sqlite3ErrorWithMsg(tls, db, int32(SQLITE_BUSY), __ccgo_ts+25913, 0)
			return int32(SQLITE_BUSY)
		} else {
			_sqlite3ExpirePreparedStatements(tls, db, 0)
		}
	} else {
		if __ccgo_fp_xSFunc == uintptr(0) && __ccgo_fp_xFinal == uintptr(0) {
			/* Trying to delete a function that does not exist.  This is a no-op.
			 ** https://sqlite.org/forum/forumpost/726219164b */
			return SQLITE_OK
		}
	}
	p = _sqlite3FindFunction(tls, db, zFunctionName, nArg, libc.Uint8FromInt32(enc), uint8(1))
	if !(p != 0) {
		return int32(SQLITE_NOMEM)
	}
	/* If an older version of the function with a configured destructor is
	 ** being replaced invoke the destructor function here. */
	_functionDestroy(tls, db, p)
	if pDestructor != 0 {
		(*TFuncDestructor)(unsafe.Pointer(pDestructor)).FnRef = (*TFuncDestructor)(unsafe.Pointer(pDestructor)).FnRef + 1
	}
	*(*uintptr)(unsafe.Pointer(p + 36)) = pDestructor
	(*TFuncDef)(unsafe.Pointer(p)).FfuncFlags = (*TFuncDef)(unsafe.Pointer(p)).FfuncFlags&uint32(SQLITE_FUNC_ENCMASK) | libc.Uint32FromInt32(extraFlags)
	if __ccgo_fp_xSFunc != 0 {
		v1 = __ccgo_fp_xSFunc
	} else {
		v1 = __ccgo_fp_xStep
	}
	(*TFuncDef)(unsafe.Pointer(p)).FxSFunc = v1
	(*TFuncDef)(unsafe.Pointer(p)).FxFinalize = __ccgo_fp_xFinal
	(*TFuncDef)(unsafe.Pointer(p)).FxValue = __ccgo_fp_xValue
	(*TFuncDef)(unsafe.Pointer(p)).FxInverse = __ccgo_fp_xInverse
	(*TFuncDef)(unsafe.Pointer(p)).FpUserData = pUserData
	(*TFuncDef)(unsafe.Pointer(p)).FnArg = libc.Int16FromUint16(libc.Uint16FromInt32(nArg))
	return SQLITE_OK
}

// C documentation
//
//	/*
//	** Return true if zName points to a name that may be used to refer to
//	** database iDb attached to handle db.
//	*/
func _sqlite3DbIsNamed(tls *libc.TLS, db uintptr, iDb int32, zName uintptr) (r int32) {
	return libc.BoolInt32(_sqlite3StrICmp(tls, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FzDbSName, zName) == 0 || iDb == 0 && _sqlite3StrICmp(tls, __ccgo_ts+6818, zName) == 0)
}

// C documentation
//
//	/*
//	** Generate code for a DELETE FROM statement.
//	**
//	**     DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL;
//	**                 \________/       \________________/
//	**                  pTabList              pWhere
//	*/
func _sqlite3DeleteFrom(tls *libc.TLS, pParse uintptr, pTabList uintptr, pWhere uintptr, pOrderBy uintptr, pLimit uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var aToOpen, db, pIdx, pPk, pTab, pTrigger, pVTab, pWInfo, v, v3 uintptr
	var addrBypass, addrEphOpen, addrLoop, bComplex, count, eOnePass, i, iAddrOnce, iDb, iEphCur, iKey, iPk, iRowSet, iTabCur, isView, memCnt, nIdx, rcauth, v1, v2 int32
	var nKey, nPk Ti16
	var wcf Tu16
	var _ /* aiCurOnePass at bp+56 */ [2]int32
	var _ /* iDataCur at bp+0 */ int32
	var _ /* iIdxCur at bp+4 */ int32
	var _ /* sContext at bp+8 */ TAuthContext
	var _ /* sNC at bp+16 */ TNameContext
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = aToOpen, addrBypass, addrEphOpen, addrLoop, bComplex, count, db, eOnePass, i, iAddrOnce, iDb, iEphCur, iKey, iPk, iRowSet, iTabCur, isView, memCnt, nIdx, nKey, nPk, pIdx, pPk, pTab, pTrigger, pVTab, pWInfo, rcauth, v, wcf, v1, v2, v3 /* Cursor number for the table */
	**(**int32)(__ccgo_up(bp)) = 0                                                                                                                                                                                                                                                                                                                /* VDBE cursor for the canonical data source */
	**(**int32)(__ccgo_up(bp + 4)) = 0                                                                                                                                                                                                                                                                                                            /* Database number */
	memCnt = 0                                                                                                                                                                                                                                                                                                                                    /* The write cursors opened by WHERE_ONEPASS */
	aToOpen = uintptr(0)                                                                                                                                                                                                                                                                                                                          /* The PRIMARY KEY index on the table */
	iPk = 0                                                                                                                                                                                                                                                                                                                                       /* First of nPk registers holding PRIMARY KEY value */
	nPk = int16(1)                                                                                                                                                                                                                                                                                                                                /* Number of memory cells in the row key */
	iEphCur = 0                                                                                                                                                                                                                                                                                                                                   /* Ephemeral table holding all primary key values */
	iRowSet = 0                                                                                                                                                                                                                                                                                                                                   /* Register for rowset of rows to delete */
	addrBypass = 0                                                                                                                                                                                                                                                                                                                                /* Address of jump over the delete logic */
	addrLoop = 0                                                                                                                                                                                                                                                                                                                                  /* Top of the delete loop */
	addrEphOpen = 0                                                                                                                                                                                                                                                                                                                               /* List of table triggers, if required */
	libc.Xmemset(tls, bp+8, 0, uint32(8))
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	if (*TParse)(unsafe.Pointer(pParse)).FnErr != 0 {
		goto delete_from_cleanup
	}
	/* Locate the table which we want to delete.  This table has to be
	 ** put in an SrcList structure because some of the subroutines we
	 ** will be calling are designed to work with multiple tables and expect
	 ** an SrcList* parameter instead of just a Table* parameter.
	 */
	pTab = _sqlite3SrcListLookup(tls, pParse, pTabList)
	if pTab == uintptr(0) {
		goto delete_from_cleanup
	}
	/* Figure out if we have any triggers and if the table being
	 ** deleted from is a view
	 */
	pTrigger = _sqlite3TriggersExist(tls, pParse, pTab, int32(TK_DELETE), uintptr(0), uintptr(0))
	isView = libc.BoolInt32(libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VIEW))
	bComplex = libc.BoolInt32(pTrigger != 0 || _sqlite3FkRequired(tls, pParse, pTab, uintptr(0), 0) != 0)
	/* If pTab is really a view, make sure it has been initialized.
	 */
	if _sqlite3ViewGetColumnNames(tls, pParse, pTab) != 0 {
		goto delete_from_cleanup
	}
	if _sqlite3IsReadOnly(tls, pParse, pTab, pTrigger) != 0 {
		goto delete_from_cleanup
	}
	iDb = _sqlite3SchemaToIndex(tls, db, (*TTable)(unsafe.Pointer(pTab)).FpSchema)
	rcauth = _sqlite3AuthCheck(tls, pParse, int32(SQLITE_DELETE), (*TTable)(unsafe.Pointer(pTab)).FzName, uintptr(0), (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FzDbSName)
	if rcauth == int32(SQLITE_DENY) {
		goto delete_from_cleanup
	}
	/* Assign cursor numbers to the table and all its indices.
	 */
	v3 = pParse + 44
	v2 = *(*int32)(unsafe.Pointer(v3))
	*(*int32)(unsafe.Pointer(v3)) = *(*int32)(unsafe.Pointer(v3)) + 1
	v1 = v2
	(*(*TSrcItem)(unsafe.Pointer(pTabList + 8))).FiCursor = v1
	iTabCur = v1
	nIdx = 0
	pIdx = (*TTable)(unsafe.Pointer(pTab)).FpIndex
	for {
		if !(pIdx != 0) {
			break
		}
		(*TParse)(unsafe.Pointer(pParse)).FnTab = (*TParse)(unsafe.Pointer(pParse)).FnTab + 1
		goto _4
	_4:
		;
		pIdx = (*TIndex)(unsafe.Pointer(pIdx)).FpNext
		nIdx = nIdx + 1
	}
	/* Start the view context
	 */
	if isView != 0 {
		_sqlite3AuthContextPush(tls, pParse, bp+8, (*TTable)(unsafe.Pointer(pTab)).FzName)
	}
	/* Begin generating code.
	 */
	v = _sqlite3GetVdbe(tls, pParse)
	if v == uintptr(0) {
		goto delete_from_cleanup
	}
	if libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).Fnested) == 0 {
		_sqlite3VdbeCountChanges(tls, v)
	}
	_sqlite3BeginWriteOperation(tls, pParse, bComplex, iDb)
	/* If we are trying to delete from a view, realize that view into
	 ** an ephemeral table.
	 */
	if isView != 0 {
		_sqlite3MaterializeView(tls, pParse, pTab, pWhere, pOrderBy, pLimit, iTabCur)
		v1 = iTabCur
		**(**int32)(__ccgo_up(bp + 4)) = v1
		**(**int32)(__ccgo_up(bp)) = v1
		pOrderBy = uintptr(0)
		pLimit = uintptr(0)
	}
	/* Resolve the column names in the WHERE clause.
	 */
	libc.Xmemset(tls, bp+16, 0, uint32(36))
	(**(**TNameContext)(__ccgo_up(bp + 16))).FpParse = pParse
	(**(**TNameContext)(__ccgo_up(bp + 16))).FpSrcList = pTabList
	if _sqlite3ResolveExprNames(tls, bp+16, pWhere) != 0 {
		goto delete_from_cleanup
	}
	/* Initialize the counter of the number of rows deleted, if
	 ** we are counting rows.
	 */
	if (*Tsqlite3)(unsafe.Pointer(db)).Fflags&(libc.Uint64FromInt32(libc.Int32FromInt32(0x00001))<<libc.Int32FromInt32(32)) != uint64(0) && !((*TParse)(unsafe.Pointer(pParse)).Fnested != 0) && !((*TParse)(unsafe.Pointer(pParse)).FpTriggerTab != 0) && !(int32(Tbft(*(*uint16)(unsafe.Pointer(pParse + 28))&0x8>>3)) != 0) {
		v3 = pParse + 48
		*(*int32)(unsafe.Pointer(v3)) = *(*int32)(unsafe.Pointer(v3)) + 1
		v1 = *(*int32)(unsafe.Pointer(v3))
		memCnt = v1
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), 0, memCnt)
	}
	/* Special case: A DELETE without a WHERE clause deletes everything.
	 ** It is easier just to erase the whole table. Prior to version 3.6.5,
	 ** this optimization caused the row change count (the value returned by
	 ** API function sqlite3_count_changes) to be set incorrectly.
	 **
	 ** The "rcauth==SQLITE_OK" terms is the
	 ** IMPLEMENTATION-OF: R-17228-37124 If the action code is SQLITE_DELETE and
	 ** the callback returns SQLITE_IGNORE then the DELETE operation proceeds but
	 ** the truncate optimization is disabled and all rows are deleted
	 ** individually.
	 */
	if rcauth == SQLITE_OK && pWhere == uintptr(0) && !(bComplex != 0) && !(libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == libc.Int32FromInt32(TABTYP_VTAB)) && (*Tsqlite3)(unsafe.Pointer(db)).FxPreUpdateCallback == uintptr(0) {
		_sqlite3TableLock(tls, pParse, iDb, (*TTable)(unsafe.Pointer(pTab)).Ftnum, uint8(1), (*TTable)(unsafe.Pointer(pTab)).FzName)
		if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_WithoutRowid) == uint32(0) {
			if memCnt != 0 {
				v1 = memCnt
			} else {
				v1 = -int32(1)
			}
			_sqlite3VdbeAddOp4(tls, v, int32(OP_Clear), libc.Int32FromUint32((*TTable)(unsafe.Pointer(pTab)).Ftnum), iDb, v1, (*TTable)(unsafe.Pointer(pTab)).FzName, -int32(1))
		}
		pIdx = (*TTable)(unsafe.Pointer(pTab)).FpIndex
		for {
			if !(pIdx != 0) {
				break
			}
			if int32(uint32(*(*uint16)(unsafe.Pointer(pIdx + 56))&0x3>>0)) == int32(SQLITE_IDXTYPE_PRIMARYKEY) && !((*TTable)(unsafe.Pointer(pTab)).FtabFlags&libc.Uint32FromInt32(TF_WithoutRowid) == libc.Uint32FromInt32(0)) {
				if memCnt != 0 {
					v1 = memCnt
				} else {
					v1 = -int32(1)
				}
				_sqlite3VdbeAddOp3(tls, v, int32(OP_Clear), libc.Int32FromUint32((*TIndex)(unsafe.Pointer(pIdx)).Ftnum), iDb, v1)
			} else {
				_sqlite3VdbeAddOp2(tls, v, int32(OP_Clear), libc.Int32FromUint32((*TIndex)(unsafe.Pointer(pIdx)).Ftnum), iDb)
			}
			goto _9
		_9:
			;
			pIdx = (*TIndex)(unsafe.Pointer(pIdx)).FpNext
		}
	} else {
		wcf = libc.Uint16FromInt32(libc.Int32FromInt32(WHERE_ONEPASS_DESIRED) | libc.Int32FromInt32(WHERE_DUPLICATES_OK))
		if (**(**TNameContext)(__ccgo_up(bp + 16))).FncFlags&int32(NC_Subquery) != 0 {
			bComplex = int32(1)
		}
		if bComplex != 0 {
			v1 = 0
		} else {
			v1 = int32(WHERE_ONEPASS_MULTIROW)
		}
		wcf = libc.Uint16FromInt32(int32(wcf) | v1)
		if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_WithoutRowid) == uint32(0) {
			/* For a rowid table, initialize the RowSet to an empty set */
			pPk = uintptr(0)
			v3 = pParse + 48
			*(*int32)(unsafe.Pointer(v3)) = *(*int32)(unsafe.Pointer(v3)) + 1
			v1 = *(*int32)(unsafe.Pointer(v3))
			iRowSet = v1
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Null), 0, iRowSet)
		} else {
			/* For a WITHOUT ROWID table, create an ephemeral table used to
			 ** hold all primary keys for rows to be deleted. */
			pPk = _sqlite3PrimaryKeyIndex(tls, pTab)
			nPk = libc.Int16FromUint16((*TIndex)(unsafe.Pointer(pPk)).FnKeyCol)
			iPk = (*TParse)(unsafe.Pointer(pParse)).FnMem + int32(1)
			**(**int32)(__ccgo_up(pParse + 48)) += int32(nPk)
			v3 = pParse + 44
			v1 = *(*int32)(unsafe.Pointer(v3))
			*(*int32)(unsafe.Pointer(v3)) = *(*int32)(unsafe.Pointer(v3)) + 1
			iEphCur = v1
			addrEphOpen = _sqlite3VdbeAddOp2(tls, v, int32(OP_OpenEphemeral), iEphCur, int32(nPk))
			_sqlite3VdbeSetP4KeyInfo(tls, pParse, pPk)
		}
		/* Construct a query to find the rowid or primary key for every row
		 ** to be deleted, based on the WHERE clause. Set variable eOnePass
		 ** to indicate the strategy used to implement this delete:
		 **
		 **  ONEPASS_OFF:    Two-pass approach - use a FIFO for rowids/PK values.
		 **  ONEPASS_SINGLE: One-pass approach - at most one row deleted.
		 **  ONEPASS_MULTI:  One-pass approach - any number of rows may be deleted.
		 */
		pWInfo = _sqlite3WhereBegin(tls, pParse, pTabList, pWhere, uintptr(0), uintptr(0), uintptr(0), wcf, iTabCur+int32(1))
		if pWInfo == uintptr(0) {
			goto delete_from_cleanup
		}
		eOnePass = _sqlite3WhereOkOnePass(tls, pWInfo, bp+56)
		if eOnePass != int32(ONEPASS_SINGLE) {
			_sqlite3MultiWrite(tls, pParse)
		}
		if _sqlite3WhereUsesDeferredSeek(tls, pWInfo) != 0 {
			_sqlite3VdbeAddOp1(tls, v, int32(OP_FinishSeek), iTabCur)
		}
		/* Keep track of the number of rows to be deleted */
		if memCnt != 0 {
			_sqlite3VdbeAddOp2(tls, v, int32(OP_AddImm), memCnt, int32(1))
		}
		/* Extract the rowid or primary key for the current row */
		if pPk != 0 {
			i = 0
			for {
				if !(i < int32(nPk)) {
					break
				}
				_sqlite3ExprCodeGetColumnOfTable(tls, v, pTab, iTabCur, int32(**(**Ti16)(__ccgo_up((*TIndex)(unsafe.Pointer(pPk)).FaiColumn + uintptr(i)*2))), iPk+i)
				goto _16
			_16:
				;
				i = i + 1
			}
			iKey = iPk
		} else {
			v3 = pParse + 48
			*(*int32)(unsafe.Pointer(v3)) = *(*int32)(unsafe.Pointer(v3)) + 1
			v1 = *(*int32)(unsafe.Pointer(v3))
			iKey = v1
			_sqlite3ExprCodeGetColumnOfTable(tls, v, pTab, iTabCur, -int32(1), iKey)
		}
		if eOnePass != ONEPASS_OFF {
			/* For ONEPASS, no need to store the rowid/primary-key. There is only
			 ** one, so just keep it in its register(s) and fall through to the
			 ** delete code.  */
			nKey = nPk /* OP_Found will use an unpacked key */
			aToOpen = _sqlite3DbMallocRawNN(tls, db, libc.Uint64FromInt32(nIdx+int32(2)))
			if aToOpen == uintptr(0) {
				_sqlite3WhereEnd(tls, pWInfo)
				goto delete_from_cleanup
			}
			libc.Xmemset(tls, aToOpen, int32(1), libc.Uint32FromInt32(nIdx+int32(1)))
			**(**Tu8)(__ccgo_up(aToOpen + uintptr(nIdx+int32(1)))) = uint8(0)
			if (**(**[2]int32)(__ccgo_up(bp + 56)))[0] >= 0 {
				**(**Tu8)(__ccgo_up(aToOpen + uintptr((**(**[2]int32)(__ccgo_up(bp + 56)))[0]-iTabCur))) = uint8(0)
			}
			if (**(**[2]int32)(__ccgo_up(bp + 56)))[int32(1)] >= 0 {
				**(**Tu8)(__ccgo_up(aToOpen + uintptr((**(**[2]int32)(__ccgo_up(bp + 56)))[int32(1)]-iTabCur))) = uint8(0)
			}
			if addrEphOpen != 0 {
				_sqlite3VdbeChangeToNoop(tls, v, addrEphOpen)
			}
			addrBypass = _sqlite3VdbeMakeLabel(tls, pParse)
		} else {
			if pPk != 0 {
				/* Add the PK key for this row to the temporary table */
				v3 = pParse + 48
				*(*int32)(unsafe.Pointer(v3)) = *(*int32)(unsafe.Pointer(v3)) + 1
				v1 = *(*int32)(unsafe.Pointer(v3))
				iKey = v1
				nKey = 0 /* Zero tells OP_Found to use a composite key */
				_sqlite3VdbeAddOp4(tls, v, int32(OP_MakeRecord), iPk, int32(nPk), iKey, _sqlite3IndexAffinityStr(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, pPk), int32(nPk))
				_sqlite3VdbeAddOp4Int(tls, v, int32(OP_IdxInsert), iEphCur, iKey, iPk, int32(nPk))
			} else {
				/* Add the rowid of the row to be deleted to the RowSet */
				nKey = int16(1) /* OP_DeferredSeek always uses a single rowid */
				_sqlite3VdbeAddOp2(tls, v, int32(OP_RowSetAdd), iRowSet, iKey)
			}
			_sqlite3WhereEnd(tls, pWInfo)
		}
		/* Unless this is a view, open cursors for the table we are
		 ** deleting from and all its indices. If this is a view, then the
		 ** only effect this statement has is to fire the INSTEAD OF
		 ** triggers.
		 */
		if !(isView != 0) {
			iAddrOnce = 0
			if eOnePass == int32(ONEPASS_MULTI) {
				iAddrOnce = _sqlite3VdbeAddOp0(tls, v, int32(OP_Once))
			}
			_sqlite3OpenTableAndIndices(tls, pParse, pTab, int32(OP_OpenWrite), uint8(OPFLAG_FORDELETE), iTabCur, aToOpen, bp, bp+4)
			if eOnePass == int32(ONEPASS_MULTI) {
				_sqlite3VdbeJumpHereOrPopInst(tls, v, iAddrOnce)
			}
		}
		/* Set up a loop over the rowids/primary-keys that were found in the
		 ** where-clause loop above.
		 */
		if eOnePass != ONEPASS_OFF {
			/* OP_Found will use an unpacked key */
			if !(libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == libc.Int32FromInt32(TABTYP_VTAB)) && **(**Tu8)(__ccgo_up(aToOpen + uintptr(**(**int32)(__ccgo_up(bp))-iTabCur))) != 0 {
				_sqlite3VdbeAddOp4Int(tls, v, int32(OP_NotFound), **(**int32)(__ccgo_up(bp)), addrBypass, iKey, int32(nKey))
			}
		} else {
			if pPk != 0 {
				addrLoop = _sqlite3VdbeAddOp1(tls, v, int32(OP_Rewind), iEphCur)
				if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) {
					_sqlite3VdbeAddOp3(tls, v, int32(OP_Column), iEphCur, 0, iKey)
				} else {
					_sqlite3VdbeAddOp2(tls, v, int32(OP_RowData), iEphCur, iKey)
				}
				/* OP_Found will use a composite key */
			} else {
				addrLoop = _sqlite3VdbeAddOp3(tls, v, int32(OP_RowSetRead), iRowSet, 0, iKey)
			}
		}
		/* Delete the row */
		if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) {
			pVTab = _sqlite3GetVTable(tls, db, pTab)
			_sqlite3VtabMakeWritable(tls, pParse, pTab)
			_sqlite3MayAbort(tls, pParse)
			if eOnePass == int32(ONEPASS_SINGLE) {
				_sqlite3VdbeAddOp1(tls, v, int32(OP_Close), iTabCur)
				if (*TParse)(unsafe.Pointer(pParse)).FpToplevel == uintptr(0) {
					(*TParse)(unsafe.Pointer(pParse)).FisMultiWrite = uint8(0)
				}
			}
			_sqlite3VdbeAddOp4(tls, v, int32(OP_VUpdate), 0, int32(1), iKey, pVTab, -int32(12))
			_sqlite3VdbeChangeP5(tls, v, uint16(OE_Abort))
		} else {
			count = libc.BoolInt32(libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).Fnested) == 0) /* True to count changes */
			_sqlite3GenerateRowDelete(tls, pParse, pTab, pTrigger, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), iKey, nKey, libc.Uint8FromInt32(count), uint8(OE_Default), libc.Uint8FromInt32(eOnePass), (**(**[2]int32)(__ccgo_up(bp + 56)))[int32(1)])
		}
		/* End of the loop over all rowids/primary-keys. */
		if eOnePass != ONEPASS_OFF {
			_sqlite3VdbeResolveLabel(tls, v, addrBypass)
			_sqlite3WhereEnd(tls, pWInfo)
		} else {
			if pPk != 0 {
				_sqlite3VdbeAddOp2(tls, v, int32(OP_Next), iEphCur, addrLoop+int32(1))
				_sqlite3VdbeJumpHere(tls, v, addrLoop)
			} else {
				_sqlite3VdbeGoto(tls, v, addrLoop)
				_sqlite3VdbeJumpHere(tls, v, addrLoop)
			}
		}
	} /* End non-truncate path */
	/* Update the sqlite_sequence table by storing the content of the
	 ** maximum rowid counter values recorded while inserting into
	 ** autoincrement tables.
	 */
	if libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).Fnested) == 0 && (*TParse)(unsafe.Pointer(pParse)).FpTriggerTab == uintptr(0) {
		_sqlite3AutoincrementEnd(tls, pParse)
	}
	/* Return the number of rows that were deleted. If this routine is
	 ** generating code because of a call to sqlite3NestedParse(), do not
	 ** invoke the callback function.
	 */
	if memCnt != 0 {
		_sqlite3CodeChangeCount(tls, v, memCnt, __ccgo_ts+16447)
	}
	goto delete_from_cleanup
delete_from_cleanup:
	;
	_sqlite3AuthContextPop(tls, bp+8)
	_sqlite3SrcListDelete(tls, db, pTabList)
	_sqlite3ExprDelete(tls, db, pWhere)
	if aToOpen != 0 {
		_sqlite3DbNNFreeNN(tls, db, aToOpen)
	}
	return
}

/* Make sure "isView" and other macros defined above are undefined. Otherwise
** they may interfere with compilation of other functions in this file
** (or in another file, if this file becomes part of the amalgamation).  */

// C documentation
//
//	/*
//	** This routine will drop an existing named index.  This routine
//	** implements the DROP INDEX statement.
//	*/
func _sqlite3DropIndex(tls *libc.TLS, pParse uintptr, pName uintptr, ifExists int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var code, iDb int32
	var db, pIndex, pTab, v, zDb, zTab, v1 uintptr
	_, _, _, _, _, _, _, _, _ = code, db, iDb, pIndex, pTab, v, zDb, zTab, v1
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
		goto exit_drop_index
	}
	/* Never called with prior non-OOM errors */
	if SQLITE_OK != _sqlite3ReadSchema(tls, pParse) {
		goto exit_drop_index
	}
	pIndex = _sqlite3FindIndex(tls, db, (*(*TSrcItem)(unsafe.Pointer(pName + 8))).FzName, *(*uintptr)(unsafe.Pointer(pName + 8 + 44)))
	if pIndex == uintptr(0) {
		if !(ifExists != 0) {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+15873, libc.VaList(bp+8, pName+8))
		} else {
			_sqlite3CodeVerifyNamedSchema(tls, pParse, *(*uintptr)(unsafe.Pointer(pName + 8 + 44)))
			_sqlite3ForceNotReadOnly(tls, pParse)
		}
		libc.SetBitFieldPtr16Uint32(pParse+28, libc.Uint32FromInt32(1), 8, 0x100)
		goto exit_drop_index
	}
	if int32(uint32(*(*uint16)(unsafe.Pointer(pIndex + 56))&0x3>>0)) != SQLITE_IDXTYPE_APPDEF {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+15891, libc.VaList(bp+8, 0))
		goto exit_drop_index
	}
	iDb = _sqlite3SchemaToIndex(tls, db, (*TIndex)(unsafe.Pointer(pIndex)).FpSchema)
	code = int32(SQLITE_DROP_INDEX)
	pTab = (*TIndex)(unsafe.Pointer(pIndex)).FpTable
	zDb = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FzDbSName
	if libc.Bool(!(libc.Int32FromInt32(OMIT_TEMPDB) != 0)) && iDb == int32(1) {
		v1 = __ccgo_ts + 6766
	} else {
		v1 = __ccgo_ts + 6286
	}
	zTab = v1
	if _sqlite3AuthCheck(tls, pParse, int32(SQLITE_DELETE), zTab, uintptr(0), zDb) != 0 {
		goto exit_drop_index
	}
	if libc.Bool(!(libc.Int32FromInt32(OMIT_TEMPDB) != 0)) && iDb == int32(1) {
		code = int32(SQLITE_DROP_TEMP_INDEX)
	}
	if _sqlite3AuthCheck(tls, pParse, code, (*TIndex)(unsafe.Pointer(pIndex)).FzName, (*TTable)(unsafe.Pointer(pTab)).FzName, zDb) != 0 {
		goto exit_drop_index
	}
	/* Generate code to remove the index and from the schema table */
	v = _sqlite3GetVdbe(tls, pParse)
	if v != 0 {
		_sqlite3BeginWriteOperation(tls, pParse, int32(1), iDb)
		_sqlite3NestedParse(tls, pParse, __ccgo_ts+15964, libc.VaList(bp+8, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FzDbSName, (*TIndex)(unsafe.Pointer(pIndex)).FzName))
		_sqlite3ClearStatTables(tls, pParse, iDb, __ccgo_ts+13046, (*TIndex)(unsafe.Pointer(pIndex)).FzName)
		_sqlite3ChangeCookie(tls, pParse, iDb)
		_destroyRootPage(tls, pParse, libc.Int32FromUint32((*TIndex)(unsafe.Pointer(pIndex)).Ftnum), iDb)
		_sqlite3VdbeAddOp4(tls, v, int32(OP_DropIndex), iDb, 0, 0, (*TIndex)(unsafe.Pointer(pIndex)).FzName, 0)
	}
	goto exit_drop_index
exit_drop_index:
	;
	_sqlite3SrcListDelete(tls, db, pName)
}

// C documentation
//
//	/*
//	** This routine is called to do the work of a DROP TABLE statement.
//	** pName is the name of the table to be dropped.
//	*/
func _sqlite3DropTable(tls *libc.TLS, pParse uintptr, pName uintptr, isView int32, noErr int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var code, iDb int32
	var db, pTab, v, zArg2, zDb, zTab, v1 uintptr
	_, _, _, _, _, _, _, _, _ = code, db, iDb, pTab, v, zArg2, zDb, zTab, v1
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
		goto exit_drop_table
	}
	if _sqlite3ReadSchema(tls, pParse) != 0 {
		goto exit_drop_table
	}
	if noErr != 0 {
		(*Tsqlite3)(unsafe.Pointer(db)).FsuppressErr = (*Tsqlite3)(unsafe.Pointer(db)).FsuppressErr + 1
	}
	pTab = _sqlite3LocateTableItem(tls, pParse, libc.Uint32FromInt32(isView), pName+8)
	if noErr != 0 {
		(*Tsqlite3)(unsafe.Pointer(db)).FsuppressErr = (*Tsqlite3)(unsafe.Pointer(db)).FsuppressErr - 1
	}
	if pTab == uintptr(0) {
		if noErr != 0 {
			_sqlite3CodeVerifyNamedSchema(tls, pParse, *(*uintptr)(unsafe.Pointer(pName + 8 + 44)))
			_sqlite3ForceNotReadOnly(tls, pParse)
		}
		goto exit_drop_table
	}
	iDb = _sqlite3SchemaToIndex(tls, db, (*TTable)(unsafe.Pointer(pTab)).FpSchema)
	/* If pTab is a virtual table, call ViewGetColumnNames() to ensure
	 ** it is initialized.
	 */
	if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) && _sqlite3ViewGetColumnNames(tls, pParse, pTab) != 0 {
		goto exit_drop_table
	}
	if libc.Bool(!(libc.Int32FromInt32(OMIT_TEMPDB) != 0)) && iDb == int32(1) {
		v1 = __ccgo_ts + 6766
	} else {
		v1 = __ccgo_ts + 6286
	}
	zTab = v1
	zDb = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FzDbSName
	zArg2 = uintptr(0)
	if _sqlite3AuthCheck(tls, pParse, int32(SQLITE_DELETE), zTab, uintptr(0), zDb) != 0 {
		goto exit_drop_table
	}
	if isView != 0 {
		if libc.Bool(!(libc.Int32FromInt32(OMIT_TEMPDB) != 0)) && iDb == int32(1) {
			code = int32(SQLITE_DROP_TEMP_VIEW)
		} else {
			code = int32(SQLITE_DROP_VIEW)
		}
	} else {
		if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) {
			code = int32(SQLITE_DROP_VTABLE)
			zArg2 = (*TModule)(unsafe.Pointer((*TVTable)(unsafe.Pointer(_sqlite3GetVTable(tls, db, pTab))).FpMod)).FzName
		} else {
			if libc.Bool(!(libc.Int32FromInt32(OMIT_TEMPDB) != 0)) && iDb == int32(1) {
				code = int32(SQLITE_DROP_TEMP_TABLE)
			} else {
				code = int32(SQLITE_DROP_TABLE)
			}
		}
	}
	if _sqlite3AuthCheck(tls, pParse, code, (*TTable)(unsafe.Pointer(pTab)).FzName, zArg2, zDb) != 0 {
		goto exit_drop_table
	}
	if _sqlite3AuthCheck(tls, pParse, int32(SQLITE_DELETE), (*TTable)(unsafe.Pointer(pTab)).FzName, uintptr(0), zDb) != 0 {
		goto exit_drop_table
	}
	if _tableMayNotBeDropped(tls, db, pTab) != 0 {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+15079, libc.VaList(bp+8, (*TTable)(unsafe.Pointer(pTab)).FzName))
		goto exit_drop_table
	}
	/* Ensure DROP TABLE is not used on a view, and DROP VIEW is not used
	 ** on a table.
	 */
	if isView != 0 && !(libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == libc.Int32FromInt32(TABTYP_VIEW)) {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+15107, libc.VaList(bp+8, (*TTable)(unsafe.Pointer(pTab)).FzName))
		goto exit_drop_table
	}
	if !(isView != 0) && libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VIEW) {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+15141, libc.VaList(bp+8, (*TTable)(unsafe.Pointer(pTab)).FzName))
		goto exit_drop_table
	}
	/* Generate code to remove the table from the schema table
	 ** on disk.
	 */
	v = _sqlite3GetVdbe(tls, pParse)
	if v != 0 {
		_sqlite3BeginWriteOperation(tls, pParse, int32(1), iDb)
		if !(isView != 0) {
			_sqlite3ClearStatTables(tls, pParse, iDb, __ccgo_ts+13050, (*TTable)(unsafe.Pointer(pTab)).FzName)
			_sqlite3FkDropTable(tls, pParse, pName, pTab)
		}
		_sqlite3CodeDropTable(tls, pParse, pTab, iDb, isView)
	}
	goto exit_drop_table
exit_drop_table:
	;
	_sqlite3SrcListDelete(tls, db, pName)
}

// C documentation
//
//	/*
//	** This function is called to drop a trigger from the database schema.
//	**
//	** This may be called directly from the parser and therefore identifies
//	** the trigger by name.  The sqlite3DropTriggerPtr() routine does the
//	** same job as this routine except it takes a pointer to the trigger
//	** instead of the trigger name.
//	**/
func _sqlite3DropTrigger(tls *libc.TLS, pParse uintptr, pName uintptr, noErr int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var db, pTrigger, zDb, zName uintptr
	var i, j, v2 int32
	_, _, _, _, _, _, _ = db, i, j, pTrigger, zDb, zName, v2
	pTrigger = uintptr(0)
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
		goto drop_trigger_cleanup
	}
	if SQLITE_OK != _sqlite3ReadSchema(tls, pParse) {
		goto drop_trigger_cleanup
	}
	zDb = *(*uintptr)(unsafe.Pointer(pName + 8 + 44))
	zName = (*(*TSrcItem)(unsafe.Pointer(pName + 8))).FzName
	i = OMIT_TEMPDB
	for {
		if !(i < (*Tsqlite3)(unsafe.Pointer(db)).FnDb) {
			break
		}
		if i < int32(2) {
			v2 = i ^ int32(1)
		} else {
			v2 = i
		}
		j = v2 /* Search TEMP before MAIN */
		if zDb != 0 && _sqlite3DbIsNamed(tls, db, j, zDb) == 0 {
			goto _1
		}
		pTrigger = _sqlite3HashFind(tls, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(j)*16))).FpSchema+40, zName)
		if pTrigger != 0 {
			break
		}
		goto _1
	_1:
		;
		i = i + 1
	}
	if !(pTrigger != 0) {
		if !(noErr != 0) {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+22380, libc.VaList(bp+8, pName+8))
		} else {
			_sqlite3CodeVerifyNamedSchema(tls, pParse, zDb)
		}
		libc.SetBitFieldPtr16Uint32(pParse+28, libc.Uint32FromInt32(1), 8, 0x100)
		goto drop_trigger_cleanup
	}
	_sqlite3DropTriggerPtr(tls, pParse, pTrigger)
	goto drop_trigger_cleanup
drop_trigger_cleanup:
	;
	_sqlite3SrcListDelete(tls, db, pName)
}

// C documentation
//
//	/*
//	** Drop a trigger given a pointer to that trigger.
//	*/
func _sqlite3DropTriggerPtr(tls *libc.TLS, pParse uintptr, pTrigger uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var code, iDb int32
	var db, pTable, v, zDb, zTab, v1 uintptr
	_, _, _, _, _, _, _, _ = code, db, iDb, pTable, v, zDb, zTab, v1
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	iDb = _sqlite3SchemaToIndex(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, (*TTrigger)(unsafe.Pointer(pTrigger)).FpSchema)
	pTable = _tableOfTrigger(tls, pTrigger)
	if pTable != 0 {
		code = int32(SQLITE_DROP_TRIGGER)
		zDb = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FzDbSName
		if libc.Bool(!(libc.Int32FromInt32(OMIT_TEMPDB) != 0)) && iDb == int32(1) {
			v1 = __ccgo_ts + 6766
		} else {
			v1 = __ccgo_ts + 6286
		}
		zTab = v1
		if iDb == int32(1) {
			code = int32(SQLITE_DROP_TEMP_TRIGGER)
		}
		if _sqlite3AuthCheck(tls, pParse, code, (*TTrigger)(unsafe.Pointer(pTrigger)).FzName, (*TTable)(unsafe.Pointer(pTable)).FzName, zDb) != 0 || _sqlite3AuthCheck(tls, pParse, int32(SQLITE_DELETE), zTab, uintptr(0), zDb) != 0 {
			return
		}
	}
	/* Generate code to destroy the database record of the trigger.
	 */
	v1 = _sqlite3GetVdbe(tls, pParse)
	v = v1
	if v1 != uintptr(0) {
		_sqlite3NestedParse(tls, pParse, __ccgo_ts+22400, libc.VaList(bp+8, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FzDbSName, (*TTrigger)(unsafe.Pointer(pTrigger)).FzName))
		_sqlite3ChangeCookie(tls, pParse, iDb)
		_sqlite3VdbeAddOp4(tls, v, int32(OP_DropTrigger), iDb, 0, 0, (*TTrigger)(unsafe.Pointer(pTrigger)).FzName, 0)
	}
}

// C documentation
//
//	/*
//	** Return a static string that describes the kind of error specified in the
//	** argument.
//	*/
func _sqlite3ErrStr(tls *libc.TLS, rc int32) (r uintptr) {
	var zErr uintptr
	_ = zErr
	zErr = __ccgo_ts + 25832
	switch rc {
	case libc.Int32FromInt32(SQLITE_ABORT) | libc.Int32FromInt32(2)<<libc.Int32FromInt32(8):
		zErr = __ccgo_ts + 25846
	case int32(SQLITE_ROW):
		zErr = __ccgo_ts + 25868
	case int32(SQLITE_DONE):
		zErr = __ccgo_ts + 25890
	default:
		rc = rc & int32(0xff)
		if rc >= 0 && rc < libc.Int32FromUint32(libc.Uint32FromInt64(116)/libc.Uint32FromInt64(4)) && _aMsg[rc] != uintptr(0) {
			zErr = _aMsg[rc]
		}
		break
	}
	return zErr
}

// C documentation
//
//	/*
//	** The SrcItem structure passed as the second argument represents a
//	** sub-query in the FROM clause of a SELECT statement. This function
//	** allocates and populates the SrcItem.pTab object. If successful,
//	** SQLITE_OK is returned. Otherwise, if an OOM error is encountered,
//	** SQLITE_NOMEM.
//	*/
func _sqlite3ExpandSubquery(tls *libc.TLS, pParse uintptr, pFrom uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var pSel, pTab, v1 uintptr
	var v2 int32
	_, _, _, _ = pSel, pTab, v1, v2
	pSel = (*TSubquery)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pFrom + 44)))).FpSelect
	v1 = _sqlite3DbMallocZero(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, uint64(80))
	pTab = v1
	(*TSrcItem)(unsafe.Pointer(pFrom)).FpSTab = v1
	if pTab == uintptr(0) {
		return int32(SQLITE_NOMEM)
	}
	(*TTable)(unsafe.Pointer(pTab)).FnTabRef = uint32(1)
	if (*TSrcItem)(unsafe.Pointer(pFrom)).FzAlias != 0 {
		(*TTable)(unsafe.Pointer(pTab)).FzName = _sqlite3DbStrDup(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, (*TSrcItem)(unsafe.Pointer(pFrom)).FzAlias)
	} else {
		(*TTable)(unsafe.Pointer(pTab)).FzName = _sqlite3MPrintf(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, __ccgo_ts+21253, libc.VaList(bp+8, pFrom))
	}
	for (*TSelect)(unsafe.Pointer(pSel)).FpPrior != 0 {
		pSel = (*TSelect)(unsafe.Pointer(pSel)).FpPrior
	}
	_sqlite3ColumnsFromExprList(tls, pParse, (*TSelect)(unsafe.Pointer(pSel)).FpEList, pTab+34, pTab+4)
	(*TTable)(unsafe.Pointer(pTab)).FiPKey = int16(-int32(1))
	(*TTable)(unsafe.Pointer(pTab)).FeTabType = uint8(TABTYP_VIEW)
	(*TTable)(unsafe.Pointer(pTab)).FnRowLogEst = int16(200)
	/* The usual case - do not allow ROWID on a subquery */
	**(**Tu32)(__ccgo_up(pTab + 28)) |= libc.Uint32FromInt32(libc.Int32FromInt32(TF_Ephemeral) | libc.Int32FromInt32(TF_NoVisibleRowid))
	if (*TParse)(unsafe.Pointer(pParse)).FnErr != 0 {
		v2 = int32(SQLITE_ERROR)
	} else {
		v2 = SQLITE_OK
	}
	return v2
}

// C documentation
//
//	/*
//	** Generate code to extract the value of the iCol-th column of a table.
//	*/
func _sqlite3ExprCodeGetColumnOfTable(tls *libc.TLS, v uintptr, pTab uintptr, iTabCur int32, iCol int32, regOut int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var op, savedSelfTab, x int32
	var pCol, pParse, v1 uintptr
	_, _, _, _, _, _ = op, pCol, pParse, savedSelfTab, x, v1
	if iCol < 0 || iCol == int32((*TTable)(unsafe.Pointer(pTab)).FiPKey) {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Rowid), iTabCur, regOut)
	} else {
		if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) {
			op = int32(OP_VColumn)
			x = iCol
		} else {
			v1 = (*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(iCol)*12
			pCol = v1
			if libc.Int32FromUint16((*TColumn)(unsafe.Pointer(v1)).FcolFlags)&int32(COLFLAG_VIRTUAL) != 0 {
				pParse = _sqlite3VdbeParser(tls, v)
				if libc.Int32FromUint16((*TColumn)(unsafe.Pointer(pCol)).FcolFlags)&int32(COLFLAG_BUSY) != 0 {
					_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+8454, libc.VaList(bp+8, (*TColumn)(unsafe.Pointer(pCol)).FzCnName))
				} else {
					savedSelfTab = (*TParse)(unsafe.Pointer(pParse)).FiSelfTab
					v1 = pCol + 10
					*(*Tu16)(unsafe.Pointer(v1)) = Tu16(int32(*(*Tu16)(unsafe.Pointer(v1))) | libc.Int32FromInt32(COLFLAG_BUSY))
					(*TParse)(unsafe.Pointer(pParse)).FiSelfTab = iTabCur + int32(1)
					_sqlite3ExprCodeGeneratedColumn(tls, pParse, pTab, pCol, regOut)
					(*TParse)(unsafe.Pointer(pParse)).FiSelfTab = savedSelfTab
					v1 = pCol + 10
					*(*Tu16)(unsafe.Pointer(v1)) = Tu16(int32(*(*Tu16)(unsafe.Pointer(v1))) & ^libc.Int32FromInt32(COLFLAG_BUSY))
				}
				return
			} else {
				if !((*TTable)(unsafe.Pointer(pTab)).FtabFlags&libc.Uint32FromInt32(TF_WithoutRowid) == libc.Uint32FromInt32(0)) {
					x = _sqlite3TableColumnToIndex(tls, _sqlite3PrimaryKeyIndex(tls, pTab), iCol)
					op = int32(OP_Column)
				} else {
					x = int32(_sqlite3TableColumnToStorage(tls, pTab, int16(iCol)))
					op = int32(OP_Column)
				}
			}
		}
		_sqlite3VdbeAddOp3(tls, v, op, iTabCur, x, regOut)
		_sqlite3ColumnDefault(tls, v, pTab, iCol, regOut)
	}
}

// C documentation
//
//	/*
//	** pColumns and pExpr form a vector assignment which is part of the SET
//	** clause of an UPDATE statement.  Like this:
//	**
//	**        (a,b,c) = (expr1,expr2,expr3)
//	** Or:    (a,b,c) = (SELECT x,y,z FROM ....)
//	**
//	** For each term of the vector assignment, append new entries to the
//	** expression list pList.  In the case of a subquery on the RHS, append
//	** TK_SELECT_COLUMN expressions.
//	*/
func _sqlite3ExprListAppendVector(tls *libc.TLS, pParse uintptr, pList uintptr, pColumns uintptr, pExpr uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var db, pFirst, pSubExpr uintptr
	var i, iFirst, n, v1 int32
	var v3 bool
	_, _, _, _, _, _, _, _ = db, i, iFirst, n, pFirst, pSubExpr, v1, v3
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	if pList != 0 {
		v1 = (*TExprList)(unsafe.Pointer(pList)).FnExpr
	} else {
		v1 = 0
	}
	iFirst = v1
	/* pColumns can only be NULL due to an OOM but an OOM will cause an
	 ** exit prior to this routine being invoked */
	if pColumns == uintptr(0) {
		goto vector_append_error
	}
	if pExpr == uintptr(0) {
		goto vector_append_error
	}
	/* If the RHS is a vector, then we can immediately check to see that
	 ** the size of the RHS and LHS match.  But if the RHS is a SELECT,
	 ** wildcards ("*") in the result set of the SELECT must be expanded before
	 ** we can do the size check, so defer the size check until code generation.
	 */
	if v3 = libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pExpr)).Fop) != int32(TK_SELECT); v3 {
		v1 = _sqlite3ExprVectorSize(tls, pExpr)
		n = v1
	}
	if v3 && (*TIdList)(unsafe.Pointer(pColumns)).FnId != v1 {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+8127, libc.VaList(bp+8, (*TIdList)(unsafe.Pointer(pColumns)).FnId, n))
		goto vector_append_error
	}
	i = 0
	for {
		if !(i < (*TIdList)(unsafe.Pointer(pColumns)).FnId) {
			break
		}
		pSubExpr = _sqlite3ExprForVectorField(tls, pParse, pExpr, i, (*TIdList)(unsafe.Pointer(pColumns)).FnId)
		if pSubExpr == uintptr(0) {
			goto _4
		}
		pList = _sqlite3ExprListAppend(tls, pParse, pList, pSubExpr)
		if pList != 0 {
			(*(*TExprList_item)(unsafe.Pointer(pList + 8 + uintptr((*TExprList)(unsafe.Pointer(pList)).FnExpr-int32(1))*20))).FzEName = (*(*TIdList_item)(unsafe.Pointer(pColumns + 4 + uintptr(i)*4))).FzName
			(*(*TIdList_item)(unsafe.Pointer(pColumns + 4 + uintptr(i)*4))).FzName = uintptr(0)
		}
		goto _4
	_4:
		;
		i = i + 1
	}
	if !((*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0) && libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pExpr)).Fop) == int32(TK_SELECT) && pList != uintptr(0) {
		pFirst = (*(*TExprList_item)(unsafe.Pointer(pList + 8 + uintptr(iFirst)*20))).FpExpr
		/* Store the SELECT statement in pRight so it will be deleted when
		 ** sqlite3ExprListDelete() is called */
		(*TExpr)(unsafe.Pointer(pFirst)).FpRight = pExpr
		pExpr = uintptr(0)
		/* Remember the size of the LHS in iTable so that we can check that
		 ** the RHS and LHS sizes match during code generation. */
		(*TExpr)(unsafe.Pointer(pFirst)).FiTable = (*TIdList)(unsafe.Pointer(pColumns)).FnId
	}
	goto vector_append_error
vector_append_error:
	;
	_sqlite3ExprUnmapAndDelete(tls, pParse, pExpr)
	_sqlite3IdListDelete(tls, db, pColumns)
	return pList
}

// C documentation
//
//	/*
//	** Expression list pEList is a list of vector values. This function
//	** converts the contents of pEList to a VALUES(...) Select statement
//	** returning 1 row for each element of the list. For example, the
//	** expression list:
//	**
//	**   ( (1,2), (3,4) (5,6) )
//	**
//	** is translated to the equivalent of:
//	**
//	**   VALUES(1,2), (3,4), (5,6)
//	**
//	** Each of the vector values in pEList must contain exactly nElem terms.
//	** If a list element that is not a vector or does not contain nElem terms,
//	** an error message is left in pParse.
//	**
//	** This is used as part of processing IN(...) expressions with a list
//	** of vectors on the RHS. e.g. "... IN ((1,2), (3,4), (5,6))".
//	*/
func _sqlite3ExprListToValues(tls *libc.TLS, pParse uintptr, nElem int32, pEList uintptr) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var ii, nExprElem int32
	var pExpr, pRet, pSel, v2 uintptr
	_, _, _, _, _, _ = ii, nExprElem, pExpr, pRet, pSel, v2
	pRet = uintptr(0)
	ii = 0
	for {
		if !(ii < (*TExprList)(unsafe.Pointer(pEList)).FnExpr) {
			break
		}
		pExpr = (*(*TExprList_item)(unsafe.Pointer(pEList + 8 + uintptr(ii)*20))).FpExpr
		if libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pExpr)).Fop) == int32(TK_VECTOR) {
			nExprElem = (*TExprList)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pExpr + 20)))).FnExpr
		} else {
			nExprElem = int32(1)
		}
		if nExprElem != nElem {
			if nExprElem > int32(1) {
				v2 = __ccgo_ts + 7911
			} else {
				v2 = __ccgo_ts + 1702
			}
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+7913, libc.VaList(bp+8, nExprElem, v2, nElem))
			break
		}
		pSel = _sqlite3SelectNew(tls, pParse, *(*uintptr)(unsafe.Pointer(pExpr + 20)), uintptr(0), uintptr(0), uintptr(0), uintptr(0), uintptr(0), uint32(SF_Values), uintptr(0))
		*(*uintptr)(unsafe.Pointer(pExpr + 20)) = uintptr(0)
		if pSel != 0 {
			if pRet != 0 {
				(*TSelect)(unsafe.Pointer(pSel)).Fop = uint8(TK_ALL)
				(*TSelect)(unsafe.Pointer(pSel)).FpPrior = pRet
			}
			pRet = pSel
		}
		goto _1
	_1:
		;
		ii = ii + 1
	}
	if pRet != 0 && (*TSelect)(unsafe.Pointer(pRet)).FpPrior != 0 {
		**(**Tu32)(__ccgo_up(pRet + 4)) |= uint32(SF_MultiValue)
	}
	_sqlite3ExprListDelete(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, pEList)
	return pRet
}

// C documentation
//
//	/*
//	** Parameter zName points to a nul-terminated buffer containing the name
//	** of a database ("main", "temp" or the name of an attached db). This
//	** function returns the index of the named database in db->aDb[], or
//	** -1 if the named db cannot be found.
//	*/
func _sqlite3FindDbName(tls *libc.TLS, db uintptr, zName uintptr) (r int32) {
	var i int32
	var pDb uintptr
	_, _ = i, pDb
	i = -int32(1) /* Database number */
	if zName != 0 {
		i = (*Tsqlite3)(unsafe.Pointer(db)).FnDb - int32(1)
		pDb = (*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(i)*16
		for {
			if !(i >= 0) {
				break
			}
			if 0 == Xsqlite3_stricmp(tls, (*TDb)(unsafe.Pointer(pDb)).FzDbSName, zName) {
				break
			}
			/* "main" is always an acceptable alias for the primary database
			 ** even if it has been renamed using SQLITE_DBCONFIG_MAINDBNAME. */
			if i == 0 && 0 == Xsqlite3_stricmp(tls, __ccgo_ts+6818, zName) {
				break
			}
			goto _1
		_1:
			;
			i = i - 1
			pDb -= 16
		}
	}
	return i
}

// C documentation
//
//	/*
//	** Locate the in-memory structure that describes a particular database
//	** table given the name of that table and (optionally) the name of the
//	** database containing the table.  Return NULL if not found.
//	**
//	** If zDatabase is 0, all databases are searched for the table and the
//	** first matching table is returned.  (No checking for duplicate table
//	** names is done.)  The search order is TEMP first, then MAIN, then any
//	** auxiliary databases added using the ATTACH command.
//	**
//	** See also sqlite3LocateTable().
//	*/
func _sqlite3FindTable(tls *libc.TLS, db uintptr, zName uintptr, zDatabase uintptr) (r uintptr) {
	var i int32
	var p uintptr
	_, _ = i, p
	p = uintptr(0)
	/* All mutexes are required for schema access.  Make sure we hold them. */
	if zDatabase != 0 {
		i = 0
		for {
			if !(i < (*Tsqlite3)(unsafe.Pointer(db)).FnDb) {
				break
			}
			if _sqlite3StrICmp(tls, zDatabase, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(i)*16))).FzDbSName) == 0 {
				break
			}
			goto _1
		_1:
			;
			i = i + 1
		}
		if i >= (*Tsqlite3)(unsafe.Pointer(db)).FnDb {
			/* No match against the official names.  But always match "main"
			 ** to schema 0 as a legacy fallback. */
			if _sqlite3StrICmp(tls, zDatabase, __ccgo_ts+6818) == 0 {
				i = 0
			} else {
				return uintptr(0)
			}
		}
		p = _sqlite3HashFind(tls, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(i)*16))).FpSchema+8, zName)
		if p == uintptr(0) && Xsqlite3_strnicmp(tls, zName, __ccgo_ts+6758, int32(7)) == 0 {
			if i == int32(1) {
				if _sqlite3StrICmp(tls, zName+uintptr(7), __ccgo_ts+6785+7) == 0 || _sqlite3StrICmp(tls, zName+uintptr(7), __ccgo_ts+6804+7) == 0 || _sqlite3StrICmp(tls, zName+uintptr(7), __ccgo_ts+6286+7) == 0 {
					p = _sqlite3HashFind(tls, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + 1*16))).FpSchema+8, __ccgo_ts+6766)
				}
			} else {
				if _sqlite3StrICmp(tls, zName+uintptr(7), __ccgo_ts+6804+7) == 0 {
					p = _sqlite3HashFind(tls, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(i)*16))).FpSchema+8, __ccgo_ts+6286)
				}
			}
		}
	} else {
		/* Match against TEMP first */
		p = _sqlite3HashFind(tls, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + 1*16))).FpSchema+8, zName)
		if p != 0 {
			return p
		}
		/* The main database is second */
		p = _sqlite3HashFind(tls, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb))).FpSchema+8, zName)
		if p != 0 {
			return p
		}
		/* Attached databases are in order of attachment */
		i = int32(2)
		for {
			if !(i < (*Tsqlite3)(unsafe.Pointer(db)).FnDb) {
				break
			}
			p = _sqlite3HashFind(tls, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(i)*16))).FpSchema+8, zName)
			if p != 0 {
				break
			}
			goto _2
		_2:
			;
			i = i + 1
		}
		if p == uintptr(0) && Xsqlite3_strnicmp(tls, zName, __ccgo_ts+6758, int32(7)) == 0 {
			if _sqlite3StrICmp(tls, zName+uintptr(7), __ccgo_ts+6804+7) == 0 {
				p = _sqlite3HashFind(tls, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb))).FpSchema+8, __ccgo_ts+6286)
			} else {
				if _sqlite3StrICmp(tls, zName+uintptr(7), __ccgo_ts+6785+7) == 0 {
					p = _sqlite3HashFind(tls, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + 1*16))).FpSchema+8, __ccgo_ts+6766)
				}
			}
		}
	}
	return p
}

// C documentation
//
//	/*
//	** This routine is called after all of the trigger actions have been parsed
//	** in order to complete the process of building the trigger.
//	*/
func _sqlite3FinishTrigger(tls *libc.TLS, pParse uintptr, pStepList uintptr, pAll uintptr) {
	bp := tls.Alloc(112)
	defer tls.Free(112)
	var db, pHash, pLink, pStep, pTab, pTrig, v, z, zName uintptr
	var iDb int32
	var _ /* nameToken at bp+56 */ TToken
	var _ /* sFix at bp+0 */ TDbFixer
	_, _, _, _, _, _, _, _, _, _ = db, iDb, pHash, pLink, pStep, pTab, pTrig, v, z, zName
	pTrig = (*TParse)(unsafe.Pointer(pParse)).FpNewTrigger /* Name of trigger */
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb             /* Trigger name for error reporting */
	(*TParse)(unsafe.Pointer(pParse)).FpNewTrigger = uintptr(0)
	if (*TParse)(unsafe.Pointer(pParse)).FnErr != 0 || !(pTrig != 0) {
		goto triggerfinish_cleanup
	}
	zName = (*TTrigger)(unsafe.Pointer(pTrig)).FzName
	iDb = _sqlite3SchemaToIndex(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, (*TTrigger)(unsafe.Pointer(pTrig)).FpSchema)
	(*TTrigger)(unsafe.Pointer(pTrig)).Fstep_list = pStepList
	for pStepList != 0 {
		(*TTriggerStep)(unsafe.Pointer(pStepList)).FpTrig = pTrig
		pStepList = (*TTriggerStep)(unsafe.Pointer(pStepList)).FpNext
	}
	_sqlite3TokenInit(tls, bp+56, (*TTrigger)(unsafe.Pointer(pTrig)).FzName)
	_sqlite3FixInit(tls, bp, pParse, iDb, __ccgo_ts+21884, bp+56)
	if _sqlite3FixTriggerStep(tls, bp, (*TTrigger)(unsafe.Pointer(pTrig)).Fstep_list) != 0 || _sqlite3FixExpr(tls, bp, (*TTrigger)(unsafe.Pointer(pTrig)).FpWhen) != 0 {
		goto triggerfinish_cleanup
	}
	if libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).FeParseMode) >= int32(PARSE_MODE_RENAME) {
		(*TParse)(unsafe.Pointer(pParse)).FpNewTrigger = pTrig
		pTrig = uintptr(0)
	} else {
		/* if we are not initializing,
		 ** build the sqlite_schema entry
		 */
		if !((*Tsqlite3)(unsafe.Pointer(db)).Finit1.Fbusy != 0) {
			/* If this is a new CREATE TABLE statement, and if shadow tables
			 ** are read-only, and the trigger makes a change to a shadow table,
			 ** then raise an error - do not allow the trigger to be created. */
			if _sqlite3ReadOnlyShadowTables(tls, db) != 0 {
				pStep = (*TTrigger)(unsafe.Pointer(pTrig)).Fstep_list
				for {
					if !(pStep != 0) {
						break
					}
					if (*TTriggerStep)(unsafe.Pointer(pStep)).FpSrc != uintptr(0) && _sqlite3ShadowTableName(tls, db, (*(*TSrcItem)(unsafe.Pointer((*TTriggerStep)(unsafe.Pointer(pStep)).FpSrc + 8))).FzName) != 0 {
						_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+22133, libc.VaList(bp+72, (*TTrigger)(unsafe.Pointer(pTrig)).FzName, (*(*TSrcItem)(unsafe.Pointer((*TTriggerStep)(unsafe.Pointer(pStep)).FpSrc + 8))).FzName))
						goto triggerfinish_cleanup
					}
					goto _1
				_1:
					;
					pStep = (*TTriggerStep)(unsafe.Pointer(pStep)).FpNext
				}
			}
			/* Make an entry in the sqlite_schema table */
			v = _sqlite3GetVdbe(tls, pParse)
			if v == uintptr(0) {
				goto triggerfinish_cleanup
			}
			_sqlite3BeginWriteOperation(tls, pParse, 0, iDb)
			z = _sqlite3DbStrNDup(tls, db, (*TToken)(unsafe.Pointer(pAll)).Fz, uint64((*TToken)(unsafe.Pointer(pAll)).Fn))
			_sqlite3NestedParse(tls, pParse, __ccgo_ts+22181, libc.VaList(bp+72, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FzDbSName, zName, (*TTrigger)(unsafe.Pointer(pTrig)).Ftable, z))
			_sqlite3DbFree(tls, db, z)
			_sqlite3ChangeCookie(tls, pParse, iDb)
			_sqlite3VdbeAddParseSchemaOp(tls, v, iDb, _sqlite3MPrintf(tls, db, __ccgo_ts+22256, libc.VaList(bp+72, zName)), uint16(0))
		}
	}
	if (*Tsqlite3)(unsafe.Pointer(db)).Finit1.Fbusy != 0 {
		pLink = pTrig
		pHash = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FpSchema + 40
		pTrig = _sqlite3HashInsert(tls, pHash, zName, pTrig)
		if pTrig != 0 {
			_sqlite3OomFault(tls, db)
		} else {
			if (*TTrigger)(unsafe.Pointer(pLink)).FpSchema == (*TTrigger)(unsafe.Pointer(pLink)).FpTabSchema {
				pTab = _sqlite3HashFind(tls, (*TTrigger)(unsafe.Pointer(pLink)).FpTabSchema+8, (*TTrigger)(unsafe.Pointer(pLink)).Ftable)
				(*TTrigger)(unsafe.Pointer(pLink)).FpNext = (*TTable)(unsafe.Pointer(pTab)).FpTrigger
				(*TTable)(unsafe.Pointer(pTab)).FpTrigger = pLink
			}
		}
	}
	goto triggerfinish_cleanup
triggerfinish_cleanup:
	;
	_sqlite3DeleteTrigger(tls, db, pTrig)
	_sqlite3DeleteTriggerStep(tls, db, pStepList)
}

// C documentation
//
//	/*
//	** A foreign key constraint requires that the key columns in the parent
//	** table are collectively subject to a UNIQUE or PRIMARY KEY constraint.
//	** Given that pParent is the parent table for foreign key constraint pFKey,
//	** search the schema for a unique index on the parent key columns.
//	**
//	** If successful, zero is returned. If the parent key is an INTEGER PRIMARY
//	** KEY column, then output variable *ppIdx is set to NULL. Otherwise, *ppIdx
//	** is set to point to the unique index.
//	**
//	** If the parent key consists of a single column (the foreign key constraint
//	** is not a composite foreign key), output variable *paiCol is set to NULL.
//	** Otherwise, it is set to point to an allocated array of size N, where
//	** N is the number of columns in the parent key. The first element of the
//	** array is the index of the child table column that is mapped by the FK
//	** constraint to the parent table column stored in the left-most column
//	** of index *ppIdx. The second element of the array is the index of the
//	** child table column that corresponds to the second left-most column of
//	** *ppIdx, and so on.
//	**
//	** If the required index cannot be found, either because:
//	**
//	**   1) The named parent key columns do not exist, or
//	**
//	**   2) The named parent key columns do exist, but are not subject to a
//	**      UNIQUE or PRIMARY KEY constraint, or
//	**
//	**   3) No parent key columns were provided explicitly as part of the
//	**      foreign key definition, and the parent table does not have a
//	**      PRIMARY KEY, or
//	**
//	**   4) No parent key columns were provided explicitly as part of the
//	**      foreign key definition, and the PRIMARY KEY of the parent table
//	**      consists of a different number of columns to the child key in
//	**      the child table.
//	**
//	** then non-zero is returned, and a "foreign key mismatch" error loaded
//	** into pParse. If an OOM error occurs, non-zero is returned and the
//	** pParse->db->mallocFailed flag is set.
//	*/
func _sqlite3FkLocateIndex(tls *libc.TLS, pParse uintptr, pParent uintptr, pFKey uintptr, ppIdx uintptr, paiCol uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var aiCol, pIdx, zDfltColl, zIdxCol, zKey uintptr
	var i, i1, j, nCol int32
	var iCol Ti16
	_, _, _, _, _, _, _, _, _, _ = aiCol, i, i1, iCol, j, nCol, pIdx, zDfltColl, zIdxCol, zKey
	pIdx = uintptr(0)                                       /* Value to return via *ppIdx */
	aiCol = uintptr(0)                                      /* Value to return via *paiCol */
	nCol = (*TFKey)(unsafe.Pointer(pFKey)).FnCol            /* Number of columns in parent key */
	zKey = (*(*TsColMap)(unsafe.Pointer(pFKey + 36))).FzCol /* Name of left-most parent key column */
	/* The caller is responsible for zeroing output parameters. */
	/* If this is a non-composite (single column) foreign key, check if it
	 ** maps to the INTEGER PRIMARY KEY of table pParent. If so, leave *ppIdx
	 ** and *paiCol set to zero and return early.
	 **
	 ** Otherwise, for a composite foreign key (more than one column), allocate
	 ** space for the aiCol array (returned via output parameter *paiCol).
	 ** Non-composite foreign keys do not require the aiCol array.
	 */
	if nCol == int32(1) {
		/* The FK maps to the IPK if any of the following are true:
		 **
		 **   1) There is an INTEGER PRIMARY KEY column and the FK is implicitly
		 **      mapped to the primary key of table pParent, or
		 **   2) The FK is explicitly mapped to a column declared as INTEGER
		 **      PRIMARY KEY.
		 */
		if int32((*TTable)(unsafe.Pointer(pParent)).FiPKey) >= 0 {
			if !(zKey != 0) {
				return 0
			}
			if !(_sqlite3StrICmp(tls, (**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pParent)).FaCol + uintptr((*TTable)(unsafe.Pointer(pParent)).FiPKey)*12))).FzCnName, zKey) != 0) {
				return 0
			}
		}
	} else {
		if paiCol != 0 {
			aiCol = _sqlite3DbMallocRawNN(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, uint64(libc.Uint32FromInt32(nCol)*uint32(4)))
			if !(aiCol != 0) {
				return int32(1)
			}
			**(**uintptr)(__ccgo_up(paiCol)) = aiCol
		}
	}
	pIdx = (*TTable)(unsafe.Pointer(pParent)).FpIndex
	for {
		if !(pIdx != 0) {
			break
		}
		if libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pIdx)).FnKeyCol) == nCol && libc.Int32FromUint8((*TIndex)(unsafe.Pointer(pIdx)).FonError) != OE_None && (*TIndex)(unsafe.Pointer(pIdx)).FpPartIdxWhere == uintptr(0) {
			/* pIdx is a UNIQUE index (or a PRIMARY KEY) and has the right number
			 ** of columns. If each indexed column corresponds to a foreign key
			 ** column of pFKey, then this index is a winner.  */
			if zKey == uintptr(0) {
				/* If zKey is NULL, then this foreign key is implicitly mapped to
				 ** the PRIMARY KEY of table pParent. The PRIMARY KEY index may be
				 ** identified by the test.  */
				if int32(uint32(*(*uint16)(unsafe.Pointer(pIdx + 56))&0x3>>0)) == int32(SQLITE_IDXTYPE_PRIMARYKEY) {
					if aiCol != 0 {
						i = 0
						for {
							if !(i < nCol) {
								break
							}
							**(**int32)(__ccgo_up(aiCol + uintptr(i)*4)) = (*(*TsColMap)(unsafe.Pointer(pFKey + 36 + uintptr(i)*8))).FiFrom
							goto _2
						_2:
							;
							i = i + 1
						}
					}
					break
				}
			} else {
				i1 = 0
				for {
					if !(i1 < nCol) {
						break
					}
					iCol = **(**Ti16)(__ccgo_up((*TIndex)(unsafe.Pointer(pIdx)).FaiColumn + uintptr(i1)*2)) /* Name of indexed column */
					if int32(iCol) < 0 {
						break
					} /* No foreign keys against expression indexes */
					/* If the index uses a collation sequence that is different from
					 ** the default collation sequence for the column, this index is
					 ** unusable. Bail out early in this case.  */
					zDfltColl = _sqlite3ColumnColl(tls, (*TTable)(unsafe.Pointer(pParent)).FaCol+uintptr(iCol)*12)
					if !(zDfltColl != 0) {
						zDfltColl = uintptr(unsafe.Pointer(&_sqlite3StrBINARY))
					}
					if _sqlite3StrICmp(tls, **(**uintptr)(__ccgo_up((*TIndex)(unsafe.Pointer(pIdx)).FazColl + uintptr(i1)*4)), zDfltColl) != 0 {
						break
					}
					zIdxCol = (**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pParent)).FaCol + uintptr(iCol)*12))).FzCnName
					j = 0
					for {
						if !(j < nCol) {
							break
						}
						if _sqlite3StrICmp(tls, (*(*TsColMap)(unsafe.Pointer(pFKey + 36 + uintptr(j)*8))).FzCol, zIdxCol) == 0 {
							if aiCol != 0 {
								**(**int32)(__ccgo_up(aiCol + uintptr(i1)*4)) = (*(*TsColMap)(unsafe.Pointer(pFKey + 36 + uintptr(j)*8))).FiFrom
							}
							break
						}
						goto _4
					_4:
						;
						j = j + 1
					}
					if j == nCol {
						break
					}
					goto _3
				_3:
					;
					i1 = i1 + 1
				}
				if i1 == nCol {
					break
				} /* pIdx is usable */
			}
		}
		goto _1
	_1:
		;
		pIdx = (*TIndex)(unsafe.Pointer(pIdx)).FpNext
	}
	if !(pIdx != 0) {
		if !(int32(Tbft(*(*uint16)(unsafe.Pointer(pParse + 28))&0x1>>0)) != 0) {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+17302, libc.VaList(bp+8, (*TTable)(unsafe.Pointer((*TFKey)(unsafe.Pointer(pFKey)).FpFrom)).FzName, (*TFKey)(unsafe.Pointer(pFKey)).FzTo))
		}
		_sqlite3DbFree(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, aiCol)
		return int32(1)
	}
	**(**uintptr)(__ccgo_up(ppIdx)) = pIdx
	return 0
}

func _sqlite3Fts5AuxInit(tls *libc.TLS, pApi uintptr) (r int32) {
	var aBuiltin [4]struct {
		FzFunc     uintptr
		FpUserData uintptr
		FxFunc     Tfts5_extension_function
		FxDestroy  uintptr
	}
	var i, rc int32
	_, _, _ = aBuiltin, i, rc
	aBuiltin = [4]struct {
		FzFunc     uintptr
		FpUserData uintptr
		FxFunc     Tfts5_extension_function
		FxDestroy  uintptr
	}{
		0: {
			FzFunc: __ccgo_ts + 37366,
			FxFunc: __ccgo_fp(_fts5SnippetFunction),
		},
		1: {
			FzFunc: __ccgo_ts + 37374,
			FxFunc: __ccgo_fp(_fts5HighlightFunction),
		},
		2: {
			FzFunc: __ccgo_ts + 37384,
			FxFunc: __ccgo_fp(_fts5Bm25Function),
		},
		3: {
			FzFunc: __ccgo_ts + 37389,
			FxFunc: __ccgo_fp(_fts5GetLocaleFunction),
		},
	}
	rc = SQLITE_OK /* To iterate through builtin functions */
	i = 0
	for {
		if !(rc == SQLITE_OK && i < libc.Int32FromUint32(libc.Uint32FromInt64(64)/libc.Uint32FromInt64(16))) {
			break
		}
		rc = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, Tfts5_extension_function, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tfts5_api)(unsafe.Pointer(pApi)).FxCreateFunction})))(tls, pApi, aBuiltin[i].FzFunc, aBuiltin[i].FpUserData, aBuiltin[i].FxFunc, aBuiltin[i].FxDestroy)
		goto _1
	_1:
		;
		i = i + 1
	}
	return rc
}

/*
** 2014 May 31
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:
**
**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
******************************************************************************
 */

/* #include "fts5Int.h" */

// C documentation
//
//	/*
//	** Call sqlite3_declare_vtab() based on the contents of the configuration
//	** object passed as the only argument. Return SQLITE_OK if successful, or
//	** an SQLite error code if an error occurs.
//	*/
func _sqlite3Fts5ConfigDeclareVtab(tls *libc.TLS, pConfig uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var i int32
	var zSep, zSql, v2 uintptr
	var _ /* rc at bp+0 */ int32
	_, _, _, _ = i, zSep, zSql, v2
	**(**int32)(__ccgo_up(bp)) = SQLITE_OK
	zSql = _sqlite3Fts5Mprintf(tls, bp, __ccgo_ts+38303, 0)
	i = 0
	for {
		if !(zSql != 0 && i < (*TFts5Config)(unsafe.Pointer(pConfig)).FnCol) {
			break
		}
		if i == 0 {
			v2 = __ccgo_ts + 1702
		} else {
			v2 = __ccgo_ts + 16216
		}
		zSep = v2
		zSql = _sqlite3Fts5Mprintf(tls, bp, __ccgo_ts+38319, libc.VaList(bp+16, zSql, zSep, **(**uintptr)(__ccgo_up((*TFts5Config)(unsafe.Pointer(pConfig)).FazCol + uintptr(i)*4))))
		goto _1
	_1:
		;
		i = i + 1
	}
	zSql = _sqlite3Fts5Mprintf(tls, bp, __ccgo_ts+38326, libc.VaList(bp+16, zSql, (*TFts5Config)(unsafe.Pointer(pConfig)).FzName, __ccgo_ts+37966))
	if zSql != 0 {
		**(**int32)(__ccgo_up(bp)) = Xsqlite3_declare_vtab(tls, (*TFts5Config)(unsafe.Pointer(pConfig)).Fdb, zSql)
		Xsqlite3_free(tls, zSql)
	}
	return **(**int32)(__ccgo_up(bp))
}

// C documentation
//
//	/*
//	** Load the contents of the %_config table into memory.
//	*/
func _sqlite3Fts5ConfigLoad(tls *libc.TLS, pConfig uintptr, iCookie int32) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var iVersion int32
	var pVal, zK, zSelect, zSql uintptr
	var _ /* bDummy at bp+8 */ int32
	var _ /* p at bp+0 */ uintptr
	var _ /* rc at bp+4 */ int32
	_, _, _, _, _ = iVersion, pVal, zK, zSelect, zSql
	zSelect = __ccgo_ts + 38434
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	**(**int32)(__ccgo_up(bp + 4)) = SQLITE_OK
	iVersion = 0
	/* Set default values */
	(*TFts5Config)(unsafe.Pointer(pConfig)).Fpgsz = int32(FTS5_DEFAULT_PAGE_SIZE)
	(*TFts5Config)(unsafe.Pointer(pConfig)).FnAutomerge = int32(FTS5_DEFAULT_AUTOMERGE)
	(*TFts5Config)(unsafe.Pointer(pConfig)).FnUsermerge = int32(FTS5_DEFAULT_USERMERGE)
	(*TFts5Config)(unsafe.Pointer(pConfig)).FnCrisisMerge = int32(FTS5_DEFAULT_CRISISMERGE)
	(*TFts5Config)(unsafe.Pointer(pConfig)).FnHashSize = libc.Int32FromInt32(1024) * libc.Int32FromInt32(1024)
	(*TFts5Config)(unsafe.Pointer(pConfig)).FnDeleteMerge = int32(FTS5_DEFAULT_DELETE_AUTOMERGE)
	zSql = _sqlite3Fts5Mprintf(tls, bp+4, zSelect, libc.VaList(bp+24, (*TFts5Config)(unsafe.Pointer(pConfig)).FzDb, (*TFts5Config)(unsafe.Pointer(pConfig)).FzName))
	if zSql != 0 {
		**(**int32)(__ccgo_up(bp + 4)) = Xsqlite3_prepare_v2(tls, (*TFts5Config)(unsafe.Pointer(pConfig)).Fdb, zSql, -int32(1), bp, uintptr(0))
		Xsqlite3_free(tls, zSql)
	}
	if **(**int32)(__ccgo_up(bp + 4)) == SQLITE_OK {
		for int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp))) {
			zK = Xsqlite3_column_text(tls, **(**uintptr)(__ccgo_up(bp)), 0)
			pVal = Xsqlite3_column_value(tls, **(**uintptr)(__ccgo_up(bp)), int32(1))
			if 0 == Xsqlite3_stricmp(tls, zK, __ccgo_ts+38466) {
				iVersion = Xsqlite3_value_int(tls, pVal)
			} else {
				**(**int32)(__ccgo_up(bp + 8)) = 0
				_sqlite3Fts5ConfigSetValue(tls, pConfig, zK, pVal, bp+8)
			}
		}
		**(**int32)(__ccgo_up(bp + 4)) = Xsqlite3_finalize(tls, **(**uintptr)(__ccgo_up(bp)))
	}
	if **(**int32)(__ccgo_up(bp + 4)) == SQLITE_OK && iVersion != int32(FTS5_CURRENT_VERSION) && iVersion != int32(FTS5_CURRENT_VERSION_SECUREDELETE) {
		**(**int32)(__ccgo_up(bp + 4)) = int32(SQLITE_ERROR)
		_sqlite3Fts5ConfigErrmsg(tls, pConfig, __ccgo_ts+38474, libc.VaList(bp+24, iVersion, int32(FTS5_CURRENT_VERSION), int32(FTS5_CURRENT_VERSION_SECUREDELETE)))
	} else {
		(*TFts5Config)(unsafe.Pointer(pConfig)).FiVersion = iVersion
	}
	if **(**int32)(__ccgo_up(bp + 4)) == SQLITE_OK {
		(*TFts5Config)(unsafe.Pointer(pConfig)).FiCookie = iCookie
	}
	return **(**int32)(__ccgo_up(bp + 4))
}

func _sqlite3Fts5ConfigSetValue(tls *libc.TLS, pConfig uintptr, zKey uintptr, pVal uintptr, pbBadkey uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var bVal, bVal1, nAutomerge, nCrisisMerge, nHashSize, nUsermerge, nVal, pgsz, rc, v1 int32
	var zIn uintptr
	var _ /* zRank at bp+0 */ uintptr
	var _ /* zRankArgs at bp+4 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _ = bVal, bVal1, nAutomerge, nCrisisMerge, nHashSize, nUsermerge, nVal, pgsz, rc, zIn, v1
	rc = SQLITE_OK
	if 0 == Xsqlite3_stricmp(tls, zKey, __ccgo_ts+38352) {
		pgsz = 0
		if int32(SQLITE_INTEGER) == Xsqlite3_value_numeric_type(tls, pVal) {
			pgsz = Xsqlite3_value_int(tls, pVal)
		}
		if pgsz < int32(32) || pgsz > libc.Int32FromInt32(64)*libc.Int32FromInt32(1024) {
			**(**int32)(__ccgo_up(pbBadkey)) = int32(1)
		} else {
			(*TFts5Config)(unsafe.Pointer(pConfig)).Fpgsz = pgsz
		}
	} else {
		if 0 == Xsqlite3_stricmp(tls, zKey, __ccgo_ts+38357) {
			nHashSize = -int32(1)
			if int32(SQLITE_INTEGER) == Xsqlite3_value_numeric_type(tls, pVal) {
				nHashSize = Xsqlite3_value_int(tls, pVal)
			}
			if nHashSize <= 0 {
				**(**int32)(__ccgo_up(pbBadkey)) = int32(1)
			} else {
				(*TFts5Config)(unsafe.Pointer(pConfig)).FnHashSize = nHashSize
			}
		} else {
			if 0 == Xsqlite3_stricmp(tls, zKey, __ccgo_ts+38366) {
				nAutomerge = -int32(1)
				if int32(SQLITE_INTEGER) == Xsqlite3_value_numeric_type(tls, pVal) {
					nAutomerge = Xsqlite3_value_int(tls, pVal)
				}
				if nAutomerge < 0 || nAutomerge > int32(64) {
					**(**int32)(__ccgo_up(pbBadkey)) = int32(1)
				} else {
					if nAutomerge == int32(1) {
						nAutomerge = int32(FTS5_DEFAULT_AUTOMERGE)
					}
					(*TFts5Config)(unsafe.Pointer(pConfig)).FnAutomerge = nAutomerge
				}
			} else {
				if 0 == Xsqlite3_stricmp(tls, zKey, __ccgo_ts+38376) {
					nUsermerge = -int32(1)
					if int32(SQLITE_INTEGER) == Xsqlite3_value_numeric_type(tls, pVal) {
						nUsermerge = Xsqlite3_value_int(tls, pVal)
					}
					if nUsermerge < int32(2) || nUsermerge > int32(16) {
						**(**int32)(__ccgo_up(pbBadkey)) = int32(1)
					} else {
						(*TFts5Config)(unsafe.Pointer(pConfig)).FnUsermerge = nUsermerge
					}
				} else {
					if 0 == Xsqlite3_stricmp(tls, zKey, __ccgo_ts+38386) {
						nCrisisMerge = -int32(1)
						if int32(SQLITE_INTEGER) == Xsqlite3_value_numeric_type(tls, pVal) {
							nCrisisMerge = Xsqlite3_value_int(tls, pVal)
						}
						if nCrisisMerge < 0 {
							**(**int32)(__ccgo_up(pbBadkey)) = int32(1)
						} else {
							if nCrisisMerge <= int32(1) {
								nCrisisMerge = int32(FTS5_DEFAULT_CRISISMERGE)
							}
							if nCrisisMerge >= int32(FTS5_MAX_SEGMENT) {
								nCrisisMerge = libc.Int32FromInt32(FTS5_MAX_SEGMENT) - libc.Int32FromInt32(1)
							}
							(*TFts5Config)(unsafe.Pointer(pConfig)).FnCrisisMerge = nCrisisMerge
						}
					} else {
						if 0 == Xsqlite3_stricmp(tls, zKey, __ccgo_ts+38398) {
							nVal = -int32(1)
							if int32(SQLITE_INTEGER) == Xsqlite3_value_numeric_type(tls, pVal) {
								nVal = Xsqlite3_value_int(tls, pVal)
							} else {
								**(**int32)(__ccgo_up(pbBadkey)) = int32(1)
							}
							if nVal < 0 {
								nVal = int32(FTS5_DEFAULT_DELETE_AUTOMERGE)
							}
							if nVal > int32(100) {
								nVal = 0
							}
							(*TFts5Config)(unsafe.Pointer(pConfig)).FnDeleteMerge = nVal
						} else {
							if 0 == Xsqlite3_stricmp(tls, zKey, __ccgo_ts+37966) {
								zIn = Xsqlite3_value_text(tls, pVal)
								rc = _sqlite3Fts5ConfigParseRank(tls, zIn, bp, bp+4)
								if rc == SQLITE_OK {
									Xsqlite3_free(tls, (*TFts5Config)(unsafe.Pointer(pConfig)).FzRank)
									Xsqlite3_free(tls, (*TFts5Config)(unsafe.Pointer(pConfig)).FzRankArgs)
									(*TFts5Config)(unsafe.Pointer(pConfig)).FzRank = **(**uintptr)(__ccgo_up(bp))
									(*TFts5Config)(unsafe.Pointer(pConfig)).FzRankArgs = **(**uintptr)(__ccgo_up(bp + 4))
								} else {
									if rc == int32(SQLITE_ERROR) {
										rc = SQLITE_OK
										**(**int32)(__ccgo_up(pbBadkey)) = int32(1)
									}
								}
							} else {
								if 0 == Xsqlite3_stricmp(tls, zKey, __ccgo_ts+38410) {
									bVal = -int32(1)
									if int32(SQLITE_INTEGER) == Xsqlite3_value_numeric_type(tls, pVal) {
										bVal = Xsqlite3_value_int(tls, pVal)
									}
									if bVal < 0 {
										**(**int32)(__ccgo_up(pbBadkey)) = int32(1)
									} else {
										if bVal != 0 {
											v1 = int32(1)
										} else {
											v1 = 0
										}
										(*TFts5Config)(unsafe.Pointer(pConfig)).FbSecureDelete = v1
									}
								} else {
									if 0 == Xsqlite3_stricmp(tls, zKey, __ccgo_ts+38424) {
										bVal1 = -int32(1)
										if int32(SQLITE_INTEGER) == Xsqlite3_value_numeric_type(tls, pVal) {
											bVal1 = Xsqlite3_value_int(tls, pVal)
										}
										if bVal1 < 0 {
											**(**int32)(__ccgo_up(pbBadkey)) = int32(1)
										} else {
											if bVal1 != 0 {
												v1 = int32(1)
											} else {
												v1 = 0
											}
											(*TFts5Config)(unsafe.Pointer(pConfig)).FbPrefixInsttoken = v1
										}
									} else {
										**(**int32)(__ccgo_up(pbBadkey)) = int32(1)
									}
								}
							}
						}
					}
				}
			}
		}
	}
	return rc
}

// C documentation
//
//	/*
//	** Set the 32-bit cookie value stored at the start of all structure
//	** records to the value passed as the second argument.
//	**
//	** Return SQLITE_OK if successful, or an SQLite error code if an error
//	** occurs.
//	*/
func _sqlite3Fts5IndexSetCookie(tls *libc.TLS, p uintptr, iNew int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var pConfig uintptr
	var rc int32
	var _ /* aCookie at bp+0 */ [4]Tu8
	var _ /* pBlob at bp+4 */ uintptr
	_, _ = pConfig, rc                                  /* Return code */
	pConfig = (*TFts5Index)(unsafe.Pointer(p)).FpConfig /* Binary representation of iNew */
	**(**uintptr)(__ccgo_up(bp + 4)) = uintptr(0)
	_sqlite3Fts5Put32(tls, bp, iNew)
	rc = Xsqlite3_blob_open(tls, (*TFts5Config)(unsafe.Pointer(pConfig)).Fdb, (*TFts5Config)(unsafe.Pointer(pConfig)).FzDb, (*TFts5Index)(unsafe.Pointer(p)).FzDataTbl, __ccgo_ts+38940, int64(FTS5_STRUCTURE_ROWID), int32(1), bp+4)
	if rc == SQLITE_OK {
		Xsqlite3_blob_write(tls, **(**uintptr)(__ccgo_up(bp + 4)), bp, int32(4), 0)
		rc = Xsqlite3_blob_close(tls, **(**uintptr)(__ccgo_up(bp + 4)))
	}
	return rc
}

// C documentation
//
//	/*
//	** Attempt to instantiate the tokenizer.
//	*/
func _sqlite3Fts5LoadTokenizer(tls *libc.TLS, pConfig uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var azArg, pMod, xCreate, v1 uintptr
	var nArg, rc, v3 int32
	_, _, _, _, _, _, _ = azArg, nArg, pMod, rc, xCreate, v1, v3
	azArg = (*TFts5Config)(unsafe.Pointer(pConfig)).Ft.FazArg
	nArg = (*TFts5Config)(unsafe.Pointer(pConfig)).Ft.FnArg
	pMod = uintptr(0)
	rc = SQLITE_OK
	if nArg == 0 {
		v1 = uintptr(0)
	} else {
		v1 = **(**uintptr)(__ccgo_up(azArg))
	}
	pMod = _fts5LocateTokenizer(tls, (*TFts5Config)(unsafe.Pointer(pConfig)).FpGlobal, v1)
	if pMod == uintptr(0) {
		rc = int32(SQLITE_ERROR)
		_sqlite3Fts5ConfigErrmsg(tls, pConfig, __ccgo_ts+40441, libc.VaList(bp+8, **(**uintptr)(__ccgo_up(azArg))))
	} else {
		xCreate = uintptr(0)
		if (*TFts5TokenizerModule)(unsafe.Pointer(pMod)).FbV2Native != 0 {
			xCreate = (*TFts5TokenizerModule)(unsafe.Pointer(pMod)).Fx2.FxCreate
			(*TFts5Config)(unsafe.Pointer(pConfig)).Ft.FpApi2 = pMod + 24
		} else {
			(*TFts5Config)(unsafe.Pointer(pConfig)).Ft.FpApi1 = pMod + 12
			xCreate = (*TFts5TokenizerModule)(unsafe.Pointer(pMod)).Fx1.FxCreate
		}
		if azArg != 0 {
			v1 = azArg + 1*4
		} else {
			v1 = uintptr(0)
		}
		if nArg != 0 {
			v3 = nArg - int32(1)
		} else {
			v3 = 0
		}
		rc = (*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{xCreate})))(tls, (*TFts5TokenizerModule)(unsafe.Pointer(pMod)).FpUserData, v1, v3, pConfig+76)
		if rc != SQLITE_OK {
			if rc != int32(SQLITE_NOMEM) {
				_sqlite3Fts5ConfigErrmsg(tls, pConfig, __ccgo_ts+40463, 0)
			}
		} else {
			if (*TFts5TokenizerModule)(unsafe.Pointer(pMod)).FbV2Native == 0 {
				(*TFts5Config)(unsafe.Pointer(pConfig)).Ft.FePattern = _sqlite3Fts5TokenizerPattern(tls, (*TFts5TokenizerModule)(unsafe.Pointer(pMod)).Fx1.FxCreate, (*TFts5Config)(unsafe.Pointer(pConfig)).Ft.FpTok)
			}
		}
	}
	if rc != SQLITE_OK {
		(*TFts5Config)(unsafe.Pointer(pConfig)).Ft.FpApi1 = uintptr(0)
		(*TFts5Config)(unsafe.Pointer(pConfig)).Ft.FpApi2 = uintptr(0)
		(*TFts5Config)(unsafe.Pointer(pConfig)).Ft.FpTok = uintptr(0)
	}
	return rc
}

func _sqlite3Fts5ParseColset(tls *libc.TLS, pParse uintptr, pColset uintptr, p uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var iCol int32
	var pConfig, pRet, z uintptr
	_, _, _, _ = iCol, pConfig, pRet, z
	pRet = uintptr(0) /* Dequoted copy of token p */
	z = _sqlite3Fts5Strndup(tls, pParse+8, (*TFts5Token)(unsafe.Pointer(p)).Fp, (*TFts5Token)(unsafe.Pointer(p)).Fn)
	if (*TFts5Parse)(unsafe.Pointer(pParse)).Frc == SQLITE_OK {
		pConfig = (*TFts5Parse)(unsafe.Pointer(pParse)).FpConfig
		_sqlite3Fts5Dequote(tls, z)
		iCol = 0
		for {
			if !(iCol < (*TFts5Config)(unsafe.Pointer(pConfig)).FnCol) {
				break
			}
			if 0 == Xsqlite3_stricmp(tls, **(**uintptr)(__ccgo_up((*TFts5Config)(unsafe.Pointer(pConfig)).FazCol + uintptr(iCol)*4)), z) {
				break
			}
			goto _1
		_1:
			;
			iCol = iCol + 1
		}
		if iCol == (*TFts5Config)(unsafe.Pointer(pConfig)).FnCol {
			_sqlite3Fts5ParseError(tls, pParse, __ccgo_ts+11908, libc.VaList(bp+8, z))
		} else {
			pRet = _fts5ParseColset(tls, pParse, pColset, iCol)
		}
		Xsqlite3_free(tls, z)
	}
	if pRet == uintptr(0) {
		Xsqlite3_free(tls, pColset)
	}
	return pRet
}

// C documentation
//
//	/*
//	** Token pTok has appeared in a MATCH expression where the NEAR operator
//	** is expected. If token pTok does not contain "NEAR", store an error
//	** in the pParse object.
//	*/
func _sqlite3Fts5ParseNear(tls *libc.TLS, pParse uintptr, pTok uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	if (*TFts5Token)(unsafe.Pointer(pTok)).Fn != int32(4) || libc.Xmemcmp(tls, __ccgo_ts+38603, (*TFts5Token)(unsafe.Pointer(pTok)).Fp, uint32(4)) != 0 {
		_sqlite3Fts5ParseError(tls, pParse, __ccgo_ts+37116, libc.VaList(bp+8, (*TFts5Token)(unsafe.Pointer(pTok)).Fn, (*TFts5Token)(unsafe.Pointer(pTok)).Fp))
	}
}

// C documentation
//
//	/*
//	** Check that the contents of the FTS index match that of the %_content
//	** table. Return SQLITE_OK if they do, or SQLITE_CORRUPT if not. Return
//	** some other SQLite error code if an error occurs while attempting to
//	** determine this.
//	*/
func _sqlite3Fts5StorageIntegrity(tls *libc.TLS, p uintptr, iArg int32) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var aColSize, aTotalSize, pConfig, pVal uintptr
	var bUseCksum, i, i1, iCol, rc, rc2 int32
	var _ /* ctx at bp+0 */ TFts5IntegrityCtx
	var _ /* nLoc at bp+48 */ int32
	var _ /* nRow at bp+56 */ Ti64
	var _ /* nRow at bp+64 */ Ti64
	var _ /* nText at bp+40 */ int32
	var _ /* pLoc at bp+44 */ uintptr
	var _ /* pScan at bp+32 */ uintptr
	var _ /* pText at bp+36 */ uintptr
	_, _, _, _, _, _, _, _, _, _ = aColSize, aTotalSize, bUseCksum, i, i1, iCol, pConfig, pVal, rc, rc2
	pConfig = (*TFts5Storage)(unsafe.Pointer(p)).FpConfig
	rc = SQLITE_OK
	libc.Xmemset(tls, bp, 0, uint32(32))
	(**(**TFts5IntegrityCtx)(__ccgo_up(bp))).FpConfig = (*TFts5Storage)(unsafe.Pointer(p)).FpConfig
	aTotalSize = Xsqlite3_malloc64(tls, uint64(libc.Uint32FromInt32((*TFts5Config)(unsafe.Pointer(pConfig)).FnCol)*(libc.Uint32FromInt64(4)+libc.Uint32FromInt64(8))))
	if !(aTotalSize != 0) {
		return int32(SQLITE_NOMEM)
	}
	aColSize = aTotalSize + uintptr((*TFts5Config)(unsafe.Pointer(pConfig)).FnCol)*8
	libc.Xmemset(tls, aTotalSize, 0, uint32(8)*libc.Uint32FromInt32((*TFts5Config)(unsafe.Pointer(pConfig)).FnCol))
	bUseCksum = libc.BoolInt32((*TFts5Config)(unsafe.Pointer(pConfig)).FeContent == FTS5_CONTENT_NORMAL || (*TFts5Config)(unsafe.Pointer(pConfig)).FeContent == int32(FTS5_CONTENT_EXTERNAL) && iArg != 0)
	if bUseCksum != 0 {
		/* Generate the expected index checksum based on the contents of the
		 ** %_content table. This block stores the checksum in ctx.cksum. */
		rc = _fts5StorageGetStmt(tls, p, int32(FTS5_STMT_SCAN), bp+32, uintptr(0))
		if rc == SQLITE_OK {
			for int32(SQLITE_ROW) == Xsqlite3_step(tls, **(**uintptr)(__ccgo_up(bp + 32))) {
				(**(**TFts5IntegrityCtx)(__ccgo_up(bp))).FiRowid = Xsqlite3_column_int64(tls, **(**uintptr)(__ccgo_up(bp + 32)), 0)
				(**(**TFts5IntegrityCtx)(__ccgo_up(bp))).FszCol = 0
				if (*TFts5Config)(unsafe.Pointer(pConfig)).FbColumnsize != 0 {
					rc = _sqlite3Fts5StorageDocsize(tls, p, (**(**TFts5IntegrityCtx)(__ccgo_up(bp))).FiRowid, aColSize)
				}
				if rc == SQLITE_OK && (*TFts5Config)(unsafe.Pointer(pConfig)).FeDetail == int32(FTS5_DETAIL_NONE) {
					rc = _sqlite3Fts5TermsetNew(tls, bp+24)
				}
				i = 0
				for {
					if !(rc == SQLITE_OK && i < (*TFts5Config)(unsafe.Pointer(pConfig)).FnCol) {
						break
					}
					if libc.Int32FromUint8(**(**Tu8)(__ccgo_up((*TFts5Config)(unsafe.Pointer(pConfig)).FabUnindexed + uintptr(i)))) == 0 {
						**(**uintptr)(__ccgo_up(bp + 36)) = uintptr(0)
						**(**int32)(__ccgo_up(bp + 40)) = 0
						**(**uintptr)(__ccgo_up(bp + 44)) = uintptr(0)
						**(**int32)(__ccgo_up(bp + 48)) = 0
						pVal = Xsqlite3_column_value(tls, **(**uintptr)(__ccgo_up(bp + 32)), i+int32(1))
						if (*TFts5Config)(unsafe.Pointer(pConfig)).FeContent == int32(FTS5_CONTENT_EXTERNAL) && _sqlite3Fts5IsLocaleValue(tls, pConfig, pVal) != 0 {
							rc = _sqlite3Fts5DecodeLocaleValue(tls, pVal, bp+36, bp+40, bp+44, bp+48)
						} else {
							if (*TFts5Config)(unsafe.Pointer(pConfig)).FeContent == FTS5_CONTENT_NORMAL && (*TFts5Config)(unsafe.Pointer(pConfig)).FbLocale != 0 {
								iCol = i + int32(1) + (*TFts5Config)(unsafe.Pointer(pConfig)).FnCol
								**(**uintptr)(__ccgo_up(bp + 44)) = Xsqlite3_column_text(tls, **(**uintptr)(__ccgo_up(bp + 32)), iCol)
								**(**int32)(__ccgo_up(bp + 48)) = Xsqlite3_column_bytes(tls, **(**uintptr)(__ccgo_up(bp + 32)), iCol)
							}
							**(**uintptr)(__ccgo_up(bp + 36)) = Xsqlite3_value_text(tls, pVal)
							**(**int32)(__ccgo_up(bp + 40)) = Xsqlite3_value_bytes(tls, pVal)
						}
						(**(**TFts5IntegrityCtx)(__ccgo_up(bp))).FiCol = i
						(**(**TFts5IntegrityCtx)(__ccgo_up(bp))).FszCol = 0
						if rc == SQLITE_OK && (*TFts5Config)(unsafe.Pointer(pConfig)).FeDetail == int32(FTS5_DETAIL_COLUMNS) {
							rc = _sqlite3Fts5TermsetNew(tls, bp+24)
						}
						if rc == SQLITE_OK {
							_sqlite3Fts5SetLocale(tls, pConfig, **(**uintptr)(__ccgo_up(bp + 44)), **(**int32)(__ccgo_up(bp + 48)))
							rc = _sqlite3Fts5Tokenize(tls, pConfig, int32(FTS5_TOKENIZE_DOCUMENT), **(**uintptr)(__ccgo_up(bp + 36)), **(**int32)(__ccgo_up(bp + 40)), bp, __ccgo_fp(_fts5StorageIntegrityCallback))
							_sqlite3Fts5ClearLocale(tls, pConfig)
						}
						/* If this is not a columnsize=0 database, check that the number
						 ** of tokens in the value matches the aColSize[] value read from
						 ** the %_docsize table.  */
						if rc == SQLITE_OK && (*TFts5Config)(unsafe.Pointer(pConfig)).FbColumnsize != 0 && (**(**TFts5IntegrityCtx)(__ccgo_up(bp))).FszCol != **(**int32)(__ccgo_up(aColSize + uintptr(i)*4)) {
							rc = libc.Int32FromInt32(SQLITE_CORRUPT) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(8)
						}
						**(**Ti64)(__ccgo_up(aTotalSize + uintptr(i)*8)) += int64((**(**TFts5IntegrityCtx)(__ccgo_up(bp))).FszCol)
						if (*TFts5Config)(unsafe.Pointer(pConfig)).FeDetail == int32(FTS5_DETAIL_COLUMNS) {
							_sqlite3Fts5TermsetFree(tls, (**(**TFts5IntegrityCtx)(__ccgo_up(bp))).FpTermset)
							(**(**TFts5IntegrityCtx)(__ccgo_up(bp))).FpTermset = uintptr(0)
						}
					}
					goto _1
				_1:
					;
					i = i + 1
				}
				_sqlite3Fts5TermsetFree(tls, (**(**TFts5IntegrityCtx)(__ccgo_up(bp))).FpTermset)
				(**(**TFts5IntegrityCtx)(__ccgo_up(bp))).FpTermset = uintptr(0)
				if rc != SQLITE_OK {
					break
				}
			}
			rc2 = Xsqlite3_reset(tls, **(**uintptr)(__ccgo_up(bp + 32)))
			if rc == SQLITE_OK {
				rc = rc2
			}
		}
		/* Test that the "totals" (sometimes called "averages") record looks Ok */
		if rc == SQLITE_OK {
			rc = _fts5StorageLoadTotals(tls, p, 0)
			i1 = 0
			for {
				if !(rc == SQLITE_OK && i1 < (*TFts5Config)(unsafe.Pointer(pConfig)).FnCol) {
					break
				}
				if **(**Ti64)(__ccgo_up((*TFts5Storage)(unsafe.Pointer(p)).FaTotalSize + uintptr(i1)*8)) != **(**Ti64)(__ccgo_up(aTotalSize + uintptr(i1)*8)) {
					rc = libc.Int32FromInt32(SQLITE_CORRUPT) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(8)
				}
				goto _2
			_2:
				;
				i1 = i1 + 1
			}
		}
		/* Check that the %_docsize and %_content tables contain the expected
		 ** number of rows.  */
		if rc == SQLITE_OK && (*TFts5Config)(unsafe.Pointer(pConfig)).FeContent == FTS5_CONTENT_NORMAL {
			**(**Ti64)(__ccgo_up(bp + 56)) = 0
			rc = _fts5StorageCount(tls, p, __ccgo_ts+37589, bp+56)
			if rc == SQLITE_OK && **(**Ti64)(__ccgo_up(bp + 56)) != (*TFts5Storage)(unsafe.Pointer(p)).FnTotalRow {
				rc = libc.Int32FromInt32(SQLITE_CORRUPT) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(8)
			}
		}
		if rc == SQLITE_OK && (*TFts5Config)(unsafe.Pointer(pConfig)).FbColumnsize != 0 {
			**(**Ti64)(__ccgo_up(bp + 64)) = 0
			rc = _fts5StorageCount(tls, p, __ccgo_ts+38284, bp+64)
			if rc == SQLITE_OK && **(**Ti64)(__ccgo_up(bp + 64)) != (*TFts5Storage)(unsafe.Pointer(p)).FnTotalRow {
				rc = libc.Int32FromInt32(SQLITE_CORRUPT) | libc.Int32FromInt32(1)<<libc.Int32FromInt32(8)
			}
		}
	}
	/* Pass the expected checksum down to the FTS index module. It will
	 ** verify, amongst other things, that it matches the checksum generated by
	 ** inspecting the index itself.  */
	if rc == SQLITE_OK {
		rc = _sqlite3Fts5IndexIntegrityCheck(tls, (*TFts5Storage)(unsafe.Pointer(p)).FpIndex, (**(**TFts5IntegrityCtx)(__ccgo_up(bp))).Fcksum, bUseCksum)
	}
	Xsqlite3_free(tls, aTotalSize)
	return rc
}

// C documentation
//
//	/*
//	** Register all built-in tokenizers with FTS5.
//	*/
func _sqlite3Fts5TokenizerInit(tls *libc.TLS, pApi uintptr) (r int32) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var i, rc int32
	var _ /* aBuiltin at bp+0 */ [3]struct {
		FzName uintptr
		Fx     Tfts5_tokenizer
	}
	var _ /* sPorter at bp+48 */ Tfts5_tokenizer_v2
	_, _ = i, rc
	**(**[3]struct {
		FzName uintptr
		Fx     Tfts5_tokenizer
	})(__ccgo_up(bp)) = [3]struct {
		FzName uintptr
		Fx     Tfts5_tokenizer
	}{
		0: {
			FzName: __ccgo_ts + 41892,
			Fx: Tfts5_tokenizer{
				FxCreate:   __ccgo_fp(_fts5UnicodeCreate),
				FxDelete:   __ccgo_fp(_fts5UnicodeDelete),
				FxTokenize: __ccgo_fp(_fts5UnicodeTokenize),
			},
		},
		1: {
			FzName: __ccgo_ts + 42211,
			Fx: Tfts5_tokenizer{
				FxCreate:   __ccgo_fp(_fts5AsciiCreate),
				FxDelete:   __ccgo_fp(_fts5AsciiDelete),
				FxTokenize: __ccgo_fp(_fts5AsciiTokenize),
			},
		},
		2: {
			FzName: __ccgo_ts + 42203,
			Fx: Tfts5_tokenizer{
				FxCreate:   __ccgo_fp(_fts5TriCreate),
				FxDelete:   __ccgo_fp(_fts5TriDelete),
				FxTokenize: __ccgo_fp(_fts5TriTokenize),
			},
		},
	}
	rc = SQLITE_OK /* To iterate through builtin functions */
	i = 0
	for {
		if !(rc == SQLITE_OK && i < libc.Int32FromUint32(libc.Uint32FromInt64(48)/libc.Uint32FromInt64(16))) {
			break
		}
		rc = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tfts5_api)(unsafe.Pointer(pApi)).FxCreateTokenizer})))(tls, pApi, (**(**[3]struct {
			FzName uintptr
			Fx     Tfts5_tokenizer
		})(__ccgo_up(bp)))[i].FzName, pApi, bp+uintptr(i)*16+4, uintptr(0))
		goto _1
	_1:
		;
		i = i + 1
	}
	if rc == SQLITE_OK {
		**(**Tfts5_tokenizer_v2)(__ccgo_up(bp + 48)) = Tfts5_tokenizer_v2{
			FiVersion:  int32(2),
			FxCreate:   __ccgo_fp(_fts5PorterCreate),
			FxDelete:   __ccgo_fp(_fts5PorterDelete),
			FxTokenize: __ccgo_fp(_fts5PorterTokenize),
		}
		rc = (*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tfts5_api)(unsafe.Pointer(pApi)).FxCreateTokenizer_v2})))(tls, pApi, __ccgo_ts+41902, pApi, bp+48, uintptr(0))
	}
	return rc
}

/*
** 2012-05-25
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:
**
**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
******************************************************************************
 */

/*
** DO NOT EDIT THIS MACHINE GENERATED FILE.
 */

/* #include <assert.h> */

// C documentation
//
//	/*
//	** Compute the column names for a SELECT statement.
//	**
//	** The only guarantee that SQLite makes about column names is that if the
//	** column has an AS clause assigning it a name, that will be the name used.
//	** That is the only documented guarantee.  However, countless applications
//	** developed over the years have made baseless assumptions about column names
//	** and will break if those assumptions changes.  Hence, use extreme caution
//	** when modifying this routine to avoid breaking legacy.
//	**
//	** See Also: sqlite3ColumnsFromExprList()
//	**
//	** The PRAGMA short_column_names and PRAGMA full_column_names settings are
//	** deprecated.  The default setting is short=ON, full=OFF.  99.9% of all
//	** applications should operate this way.  Nevertheless, we need to support the
//	** other modes for legacy:
//	**
//	**    short=OFF, full=OFF:      Column name is the text of the expression has it
//	**                              originally appears in the SELECT statement.  In
//	**                              other words, the zSpan of the result expression.
//	**
//	**    short=ON, full=OFF:       (This is the default setting).  If the result
//	**                              refers directly to a table column, then the
//	**                              result column name is just the table column
//	**                              name: COLUMN.  Otherwise use zSpan.
//	**
//	**    full=ON, short=ANY:       If the result refers directly to a table column,
//	**                              then the result column name with the table name
//	**                              prefix, ex: TABLE.COLUMN.  Otherwise use zSpan.
//	*/
func _sqlite3GenerateColumnNames(tls *libc.TLS, pParse uintptr, pSelect uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var db, p, pEList, pTab, pTabList, v, z, zCol, zName, zName1, v2 uintptr
	var fullName, i, iCol, srcName int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = db, fullName, i, iCol, p, pEList, pTab, pTabList, srcName, v, z, zCol, zName, zName1, v2
	v = (*TParse)(unsafe.Pointer(pParse)).FpVdbe
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb /* COLUMN or TABLE.COLUMN if no AS clause and is direct */
	if int32(Tbft(*(*uint16)(unsafe.Pointer(pParse + 28))&0x20>>5)) != 0 {
		return
	}
	/* Column names are determined by the left-most term of a compound select */
	for (*TSelect)(unsafe.Pointer(pSelect)).FpPrior != 0 {
		pSelect = (*TSelect)(unsafe.Pointer(pSelect)).FpPrior
	}
	pTabList = (*TSelect)(unsafe.Pointer(pSelect)).FpSrc
	pEList = (*TSelect)(unsafe.Pointer(pSelect)).FpEList
	libc.SetBitFieldPtr16Uint32(pParse+28, libc.Uint32FromInt32(1), 5, 0x20)
	fullName = libc.BoolInt32((*Tsqlite3)(unsafe.Pointer(db)).Fflags&uint64(SQLITE_FullColNames) != uint64(0))
	srcName = libc.BoolInt32((*Tsqlite3)(unsafe.Pointer(db)).Fflags&uint64(SQLITE_ShortColNames) != uint64(0) || fullName != 0)
	_sqlite3VdbeSetNumCols(tls, v, (*TExprList)(unsafe.Pointer(pEList)).FnExpr)
	i = 0
	for {
		if !(i < (*TExprList)(unsafe.Pointer(pEList)).FnExpr) {
			break
		}
		p = (*(*TExprList_item)(unsafe.Pointer(pEList + 8 + uintptr(i)*20))).FpExpr
		/* Agg processing has not run yet */
		/* Covering idx not yet coded */
		if (*(*TExprList_item)(unsafe.Pointer(pEList + 8 + uintptr(i)*20))).FzEName != 0 && int32(uint32(*(*uint16)(unsafe.Pointer(pEList + 8 + uintptr(i)*20 + 8 + 4))&0x3>>0)) == ENAME_NAME {
			/* An AS clause always takes first priority */
			zName = (*(*TExprList_item)(unsafe.Pointer(pEList + 8 + uintptr(i)*20))).FzEName
			_sqlite3VdbeSetColName(tls, v, i, COLNAME_NAME, zName, uintptr(-libc.Int32FromInt32(1)))
		} else {
			if srcName != 0 && libc.Int32FromUint8((*TExpr)(unsafe.Pointer(p)).Fop) == int32(TK_COLUMN) {
				iCol = int32((*TExpr)(unsafe.Pointer(p)).FiColumn)
				pTab = (*TExpr)(unsafe.Pointer(p)).Fy.FpTab
				if iCol < 0 {
					iCol = int32((*TTable)(unsafe.Pointer(pTab)).FiPKey)
				}
				if iCol < 0 {
					zCol = __ccgo_ts + 17965
				} else {
					zCol = (**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(iCol)*12))).FzCnName
				}
				if fullName != 0 {
					zName1 = uintptr(0)
					zName1 = _sqlite3MPrintf(tls, db, __ccgo_ts+13634, libc.VaList(bp+8, (*TTable)(unsafe.Pointer(pTab)).FzName, zCol))
					_sqlite3VdbeSetColName(tls, v, i, COLNAME_NAME, zName1, __ccgo_fp(_sqlite3RowSetClear))
				} else {
					_sqlite3VdbeSetColName(tls, v, i, COLNAME_NAME, zCol, uintptr(-libc.Int32FromInt32(1)))
				}
			} else {
				z = (*(*TExprList_item)(unsafe.Pointer(pEList + 8 + uintptr(i)*20))).FzEName
				if z == uintptr(0) {
					v2 = _sqlite3MPrintf(tls, db, __ccgo_ts+20634, libc.VaList(bp+8, i+int32(1)))
				} else {
					v2 = _sqlite3DbStrDup(tls, db, z)
				}
				z = v2
				_sqlite3VdbeSetColName(tls, v, i, COLNAME_NAME, z, __ccgo_fp(_sqlite3RowSetClear))
			}
		}
		goto _1
	_1:
		;
		i = i + 1
	}
	_generateColumnTypes(tls, pParse, pTabList, pEList)
}

// C documentation
//
//	/*
//	** Generate code to do constraint checks prior to an INSERT or an UPDATE
//	** on table pTab.
//	**
//	** The regNewData parameter is the first register in a range that contains
//	** the data to be inserted or the data after the update.  There will be
//	** pTab->nCol+1 registers in this range.  The first register (the one
//	** that regNewData points to) will contain the new rowid, or NULL in the
//	** case of a WITHOUT ROWID table.  The second register in the range will
//	** contain the content of the first table column.  The third register will
//	** contain the content of the second table column.  And so forth.
//	**
//	** The regOldData parameter is similar to regNewData except that it contains
//	** the data prior to an UPDATE rather than afterwards.  regOldData is zero
//	** for an INSERT.  This routine can distinguish between UPDATE and INSERT by
//	** checking regOldData for zero.
//	**
//	** For an UPDATE, the pkChng boolean is true if the true primary key (the
//	** rowid for a normal table or the PRIMARY KEY for a WITHOUT ROWID table)
//	** might be modified by the UPDATE.  If pkChng is false, then the key of
//	** the iDataCur content table is guaranteed to be unchanged by the UPDATE.
//	**
//	** For an INSERT, the pkChng boolean indicates whether or not the rowid
//	** was explicitly specified as part of the INSERT statement.  If pkChng
//	** is zero, it means that the either rowid is computed automatically or
//	** that the table is a WITHOUT ROWID table and has no rowid.  On an INSERT,
//	** pkChng will only be true if the INSERT statement provides an integer
//	** value for either the rowid column or its INTEGER PRIMARY KEY alias.
//	**
//	** The code generated by this routine will store new index entries into
//	** registers identified by aRegIdx[].  No index entry is created for
//	** indices where aRegIdx[i]==0.  The order of indices in aRegIdx[] is
//	** the same as the order of indices on the linked list of indices
//	** at pTab->pIndex.
//	**
//	** (2019-05-07) The generated code also creates a new record for the
//	** main table, if pTab is a rowid table, and stores that record in the
//	** register identified by aRegIdx[nIdx] - in other words in the first
//	** entry of aRegIdx[] past the last index.  It is important that the
//	** record be generated during constraint checks to avoid affinity changes
//	** to the register content that occur after constraint checks but before
//	** the new record is inserted.
//	**
//	** The caller must have already opened writeable cursors on the main
//	** table and all applicable indices (that is to say, all indices for which
//	** aRegIdx[] is not zero).  iDataCur is the cursor for the main table when
//	** inserting or updating a rowid table, or the cursor for the PRIMARY KEY
//	** index when operating on a WITHOUT ROWID table.  iIdxCur is the cursor
//	** for the first index in the pTab->pIndex list.  Cursors for other indices
//	** are at iIdxCur+N for the N-th element of the pTab->pIndex list.
//	**
//	** This routine also generates code to check constraints.  NOT NULL,
//	** CHECK, and UNIQUE constraints are all checked.  If a constraint fails,
//	** then the appropriate action is performed.  There are five possible
//	** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE.
//	**
//	**  Constraint type  Action       What Happens
//	**  ---------------  ----------   ----------------------------------------
//	**  any              ROLLBACK     The current transaction is rolled back and
//	**                                sqlite3_step() returns immediately with a
//	**                                return code of SQLITE_CONSTRAINT.
//	**
//	**  any              ABORT        Back out changes from the current command
//	**                                only (do not do a complete rollback) then
//	**                                cause sqlite3_step() to return immediately
//	**                                with SQLITE_CONSTRAINT.
//	**
//	**  any              FAIL         Sqlite3_step() returns immediately with a
//	**                                return code of SQLITE_CONSTRAINT.  The
//	**                                transaction is not rolled back and any
//	**                                changes to prior rows are retained.
//	**
//	**  any              IGNORE       The attempt in insert or update the current
//	**                                row is skipped, without throwing an error.
//	**                                Processing continues with the next row.
//	**                                (There is an immediate jump to ignoreDest.)
//	**
//	**  NOT NULL         REPLACE      The NULL value is replace by the default
//	**                                value for that column.  If the default value
//	**                                is NULL, the action is the same as ABORT.
//	**
//	**  UNIQUE           REPLACE      The other row that conflicts with the row
//	**                                being inserted is removed.
//	**
//	**  CHECK            REPLACE      Illegal.  The results in an exception.
//	**
//	** Which action to take is determined by the overrideError parameter.
//	** Or if overrideError==OE_Default, then the pParse->onError parameter
//	** is used.  Or if pParse->onError==OE_Default then the onError value
//	** for the constraint is used.
//	*/
func _sqlite3GenerateConstraintChecks(tls *libc.TLS, pParse uintptr, pTab uintptr, aRegIdx uintptr, iDataCur int32, iIdxCur int32, regNewData int32, regOldData int32, pkChng Tu8, overrideError Tu8, ignoreDest int32, pbMayReplace uintptr, aiChng uintptr, pUpsert uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var addr1, addrBypass, addrConflictCk, addrJump, addrRecheck, addrRowidOk, addrUniqueOk, allOk, b2ndPass, i, iField, iReg, iThisCur, ipkBottom, ipkTop, isGenerated, jj, lblRecheckOk, nCol, nConflictCk, nGenerated, nIdx, nPkField, nReplaceTrig, nSeenReplace, onError, op, p2, regCmp, regIdx, regR, regRec, regTrigCnt, seenReplace, upsertIpkDelay, upsertIpkReturn, x, x1, v2 int32
	var bAffinityDone, isUpdate Tu8
	var bUsed, db, p4, pCheck, pCol, pCopy, pExpr, pIdx, pPk, pTerm, pTrigger, pUpsertClause, v, zMsg, zName, zP4, v8 uintptr
	var nByte Tu64
	var _ /* ix at bp+0 */ int32
	var _ /* sIdxIter at bp+4 */ TIndexIterator
	var _ /* x at bp+20 */ TVdbeOp
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = addr1, addrBypass, addrConflictCk, addrJump, addrRecheck, addrRowidOk, addrUniqueOk, allOk, b2ndPass, bAffinityDone, bUsed, db, i, iField, iReg, iThisCur, ipkBottom, ipkTop, isGenerated, isUpdate, jj, lblRecheckOk, nByte, nCol, nConflictCk, nGenerated, nIdx, nPkField, nReplaceTrig, nSeenReplace, onError, op, p2, p4, pCheck, pCol, pCopy, pExpr, pIdx, pPk, pTerm, pTrigger, pUpsertClause, regCmp, regIdx, regR, regRec, regTrigCnt, seenReplace, upsertIpkDelay, upsertIpkReturn, v, x, x1, zMsg, zName, zP4, v2, v8 /* Pointer to one of the indices */
	pPk = uintptr(0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /* Conflict resolution strategy */
	seenReplace = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   /* Number of fields in PRIMARY KEY. 1 for ROWID tables */
	pUpsertClause = uintptr(0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /* True if this is an UPDATE operation */
	bAffinityDone = uint8(0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /* True if the OP_Affinity operation has been run */
	upsertIpkReturn = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               /* Address of Goto at end of IPK uniqueness check */
	upsertIpkDelay = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                /* Address of Goto to bypass initial IPK check */
	ipkTop = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /* Top of the IPK uniqueness check */
	ipkBottom = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     /* Register used to count replace trigger invocations */
	addrRecheck = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   /* Jump here to recheck all uniqueness constraints */
	lblRecheckOk = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /* List of DELETE triggers on the table pTab */
	nReplaceTrig = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /* Index iterator */
	isUpdate = libc.BoolUint8(regOldData != 0)
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	v = (*TParse)(unsafe.Pointer(pParse)).FpVdbe
	/* This table is not a VIEW */
	nCol = int32((*TTable)(unsafe.Pointer(pTab)).FnCol)
	/* pPk is the PRIMARY KEY index for WITHOUT ROWID tables and NULL for
	 ** normal rowid tables.  nPkField is the number of key fields in the
	 ** pPk index or 1 for a rowid table.  In other words, nPkField is the
	 ** number of fields in the true primary key of the table. */
	if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_WithoutRowid) == uint32(0) {
		pPk = uintptr(0)
		nPkField = int32(1)
	} else {
		pPk = _sqlite3PrimaryKeyIndex(tls, pTab)
		nPkField = libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pPk)).FnKeyCol)
	}
	/* Record that this module has started */
	/* Test all NOT NULL constraints.
	 */
	if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_HasNotNull) != 0 {
		b2ndPass = 0        /* True if currently running 2nd pass */
		nSeenReplace = 0    /* Number of ON CONFLICT REPLACE operations */
		nGenerated = 0      /* Number of generated columns with NOT NULL */
		for int32(1) != 0 { /* Make 2 passes over columns. Exit loop via "break" */
			i = 0
			for {
				if !(i < nCol) {
					break
				} /* Register holding column value */
				pCol = (*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(i)*12 /* non-zero if column is generated */
				onError = int32(uint32(*(*uint8)(unsafe.Pointer(pCol + 4)) & 0xf >> 0))
				if onError == OE_None {
					goto _1
				} /* No NOT NULL on this column */
				if i == int32((*TTable)(unsafe.Pointer(pTab)).FiPKey) {
					goto _1 /* ROWID is never NULL */
				}
				isGenerated = libc.Int32FromUint16((*TColumn)(unsafe.Pointer(pCol)).FcolFlags) & int32(COLFLAG_GENERATED)
				if isGenerated != 0 && !(b2ndPass != 0) {
					nGenerated = nGenerated + 1
					goto _1 /* Generated columns processed on 2nd pass */
				}
				if aiChng != 0 && **(**int32)(__ccgo_up(aiChng + uintptr(i)*4)) < 0 && !(isGenerated != 0) {
					/* Do not check NOT NULL on columns that do not change */
					goto _1
				}
				if libc.Int32FromUint8(overrideError) != int32(OE_Default) {
					onError = libc.Int32FromUint8(overrideError)
				} else {
					if onError == int32(OE_Default) {
						onError = int32(OE_Abort)
					}
				}
				if onError == int32(OE_Replace) {
					if b2ndPass != 0 || libc.Int32FromUint16((*TColumn)(unsafe.Pointer(pCol)).FiDflt) == 0 {
						onError = int32(OE_Abort)
					} else {
					}
				} else {
					if b2ndPass != 0 && !(isGenerated != 0) {
						goto _1
					}
				}
				iReg = int32(_sqlite3TableColumnToStorage(tls, pTab, int16(i))) + regNewData + int32(1)
				switch onError {
				case int32(OE_Replace):
					addr1 = _sqlite3VdbeAddOp1(tls, v, int32(OP_NotNull), iReg)
					nSeenReplace = nSeenReplace + 1
					_sqlite3ExprCodeCopy(tls, pParse, _sqlite3ColumnExpr(tls, pTab, pCol), iReg)
					_sqlite3VdbeJumpHere(tls, v, addr1)
				case int32(OE_Abort):
					_sqlite3MayAbort(tls, pParse)
					fallthrough
				case int32(OE_Rollback):
					fallthrough
				case int32(OE_Fail):
					zMsg = _sqlite3MPrintf(tls, db, __ccgo_ts+13634, libc.VaList(bp+48, (*TTable)(unsafe.Pointer(pTab)).FzName, (*TColumn)(unsafe.Pointer(pCol)).FzCnName))
					_sqlite3VdbeAddOp3(tls, v, int32(OP_HaltIfNull), libc.Int32FromInt32(SQLITE_CONSTRAINT)|libc.Int32FromInt32(5)<<libc.Int32FromInt32(8), onError, iReg)
					_sqlite3VdbeAppendP4(tls, v, zMsg, -int32(7))
					_sqlite3VdbeChangeP5(tls, v, uint16(P5_ConstraintNotNull))
				default:
					_sqlite3VdbeAddOp2(tls, v, int32(OP_IsNull), iReg, ignoreDest)
					break
				} /* end switch(onError) */
				goto _1
			_1:
				;
				i = i + 1
			} /* end loop i over columns */
			if nGenerated == 0 && nSeenReplace == 0 {
				/* If there are no generated columns with NOT NULL constraints
				 ** and no NOT NULL ON CONFLICT REPLACE constraints, then a single
				 ** pass is sufficient */
				break
			}
			if b2ndPass != 0 {
				break
			} /* Never need more than 2 passes */
			b2ndPass = int32(1)
			if nSeenReplace > 0 && (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_HasGenerated) != uint32(0) {
				/* If any NOT NULL ON CONFLICT REPLACE constraints fired on the
				 ** first pass, recomputed values for all generated columns, as
				 ** those values might depend on columns affected by the REPLACE.
				 */
				_sqlite3ComputeGeneratedColumns(tls, pParse, regNewData+int32(1), pTab)
			}
		} /* end of 2-pass loop */
	} /* end if( has-not-null-constraints ) */
	/* Test all CHECK constraints
	 */
	if (*TTable)(unsafe.Pointer(pTab)).FpCheck != 0 && (*Tsqlite3)(unsafe.Pointer(db)).Fflags&uint64(SQLITE_IgnoreChecks) == uint64(0) {
		pCheck = (*TTable)(unsafe.Pointer(pTab)).FpCheck
		(*TParse)(unsafe.Pointer(pParse)).FiSelfTab = -(regNewData + int32(1))
		if libc.Int32FromUint8(overrideError) != int32(OE_Default) {
			v2 = libc.Int32FromUint8(overrideError)
		} else {
			v2 = int32(OE_Abort)
		}
		onError = v2
		i = 0
		for {
			if !(i < (*TExprList)(unsafe.Pointer(pCheck)).FnExpr) {
				break
			}
			pExpr = (*(*TExprList_item)(unsafe.Pointer(pCheck + 8 + uintptr(i)*20))).FpExpr
			if aiChng != 0 && !(_sqlite3ExprReferencesUpdatedColumn(tls, pExpr, aiChng, libc.Int32FromUint8(pkChng)) != 0) {
				/* The check constraints do not reference any of the columns being
				 ** updated so there is no point it verifying the check constraint */
				goto _3
			}
			if libc.Int32FromUint8(bAffinityDone) == 0 {
				_sqlite3TableAffinity(tls, v, pTab, regNewData+int32(1))
				bAffinityDone = uint8(1)
			}
			allOk = _sqlite3VdbeMakeLabel(tls, pParse)
			pCopy = _sqlite3ExprDup(tls, db, pExpr, 0)
			if !((*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0) {
				_sqlite3ExprIfTrue(tls, pParse, pCopy, allOk, int32(SQLITE_JUMPIFNULL))
			}
			_sqlite3ExprDelete(tls, db, pCopy)
			if onError == int32(OE_Ignore) {
				_sqlite3VdbeGoto(tls, v, ignoreDest)
			} else {
				zName = (*(*TExprList_item)(unsafe.Pointer(pCheck + 8 + uintptr(i)*20))).FzEName
				if onError == int32(OE_Replace) {
					onError = int32(OE_Abort)
				} /* IMP: R-26383-51744 */
				_sqlite3HaltConstraint(tls, pParse, libc.Int32FromInt32(SQLITE_CONSTRAINT)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(8), onError, zName, P4_TRANSIENT, uint8(P5_ConstraintCheck))
			}
			_sqlite3VdbeResolveLabel(tls, v, allOk)
			goto _3
		_3:
			;
			i = i + 1
		}
		(*TParse)(unsafe.Pointer(pParse)).FiSelfTab = 0
	}
	/* UNIQUE and PRIMARY KEY constraints should be handled in the following
	 ** order:
	 **
	 **   (1)  OE_Update
	 **   (2)  OE_Abort, OE_Fail, OE_Rollback, OE_Ignore
	 **   (3)  OE_Replace
	 **
	 ** OE_Fail and OE_Ignore must happen before any changes are made.
	 ** OE_Update guarantees that only a single row will change, so it
	 ** must happen before OE_Replace.  Technically, OE_Abort and OE_Rollback
	 ** could happen in any order, but they are grouped up front for
	 ** convenience.
	 **
	 ** 2018-08-14: Ticket https://sqlite.org/src/info/908f001483982c43
	 ** The order of constraints used to have OE_Update as (2) and OE_Abort
	 ** and so forth as (1). But apparently PostgreSQL checks the OE_Update
	 ** constraint before any others, so it had to be moved.
	 **
	 ** Constraint checking code is generated in this order:
	 **   (A)  The rowid constraint
	 **   (B)  Unique index constraints that do not have OE_Replace as their
	 **        default conflict resolution strategy
	 **   (C)  Unique index that do use OE_Replace by default.
	 **
	 ** The ordering of (2) and (3) is accomplished by making sure the linked
	 ** list of indexes attached to a table puts all OE_Replace indexes last
	 ** in the list.  See sqlite3CreateIndex() for where that happens.
	 */
	(**(**TIndexIterator)(__ccgo_up(bp + 4))).FeType = 0
	(**(**TIndexIterator)(__ccgo_up(bp + 4))).Fi = 0
	*(*uintptr)(unsafe.Pointer(bp + 4 + 8 + 4)) = uintptr(0) /* Silence harmless compiler warning */
	*(*uintptr)(unsafe.Pointer(bp + 4 + 8)) = (*TTable)(unsafe.Pointer(pTab)).FpIndex
	if pUpsert != 0 {
		if (*TUpsert)(unsafe.Pointer(pUpsert)).FpUpsertTarget == uintptr(0) {
			/* There is just on ON CONFLICT clause and it has no constraint-target */
			if libc.Int32FromUint8((*TUpsert)(unsafe.Pointer(pUpsert)).FisDoUpdate) == 0 {
				/* A single ON CONFLICT DO NOTHING clause, without a constraint-target.
				 ** Make all unique constraint resolution be OE_Ignore */
				overrideError = uint8(OE_Ignore)
				pUpsert = uintptr(0)
			} else {
				/* A single ON CONFLICT DO UPDATE.  Make all resolutions OE_Update */
				overrideError = uint8(OE_Update)
			}
		} else {
			if (*TTable)(unsafe.Pointer(pTab)).FpIndex != uintptr(0) {
				nIdx = 0
				pIdx = (*TTable)(unsafe.Pointer(pTab)).FpIndex
				for {
					if !(pIdx != 0) {
						break
					}
					goto _4
				_4:
					;
					pIdx = (*TIndex)(unsafe.Pointer(pIdx)).FpNext
					nIdx = nIdx + 1
				}
				(**(**TIndexIterator)(__ccgo_up(bp + 4))).FeType = int32(1)
				*(*int32)(unsafe.Pointer(bp + 4 + 8)) = nIdx
				nByte = uint64((libc.Uint32FromInt64(8)+libc.Uint32FromInt32(1))*libc.Uint32FromInt32(nIdx) + libc.Uint32FromInt32(nIdx))
				*(*uintptr)(unsafe.Pointer(bp + 4 + 8 + 4)) = _sqlite3DbMallocZero(tls, db, nByte)
				if *(*uintptr)(unsafe.Pointer(bp + 4 + 8 + 4)) == uintptr(0) {
					return
				} /* OOM */
				bUsed = *(*uintptr)(unsafe.Pointer(bp + 4 + 8 + 4)) + uintptr(nIdx)*8
				(*TUpsert)(unsafe.Pointer(pUpsert)).FpToFree = *(*uintptr)(unsafe.Pointer(bp + 4 + 8 + 4))
				i = 0
				pTerm = pUpsert
				for {
					if !(pTerm != 0) {
						break
					}
					if (*TUpsert)(unsafe.Pointer(pTerm)).FpUpsertTarget == uintptr(0) {
						break
					}
					if (*TUpsert)(unsafe.Pointer(pTerm)).FpUpsertIdx == uintptr(0) {
						goto _5
					} /* Skip ON CONFLICT for the IPK */
					jj = 0
					pIdx = (*TTable)(unsafe.Pointer(pTab)).FpIndex
					for pIdx != uintptr(0) && pIdx != (*TUpsert)(unsafe.Pointer(pTerm)).FpUpsertIdx {
						pIdx = (*TIndex)(unsafe.Pointer(pIdx)).FpNext
						jj = jj + 1
					}
					if **(**Tu8)(__ccgo_up(bUsed + uintptr(jj))) != 0 {
						goto _5
					} /* Duplicate ON CONFLICT clause ignored */
					**(**Tu8)(__ccgo_up(bUsed + uintptr(jj))) = uint8(1)
					(**(**TIndexListTerm)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 4 + 8 + 4)) + uintptr(i)*8))).Fp = pIdx
					(**(**TIndexListTerm)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 4 + 8 + 4)) + uintptr(i)*8))).Fix = jj
					i = i + 1
					goto _5
				_5:
					;
					pTerm = (*TUpsert)(unsafe.Pointer(pTerm)).FpNextUpsert
				}
				jj = 0
				pIdx = (*TTable)(unsafe.Pointer(pTab)).FpIndex
				for {
					if !(pIdx != 0) {
						break
					}
					if **(**Tu8)(__ccgo_up(bUsed + uintptr(jj))) != 0 {
						goto _6
					}
					(**(**TIndexListTerm)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 4 + 8 + 4)) + uintptr(i)*8))).Fp = pIdx
					(**(**TIndexListTerm)(__ccgo_up(*(*uintptr)(unsafe.Pointer(bp + 4 + 8 + 4)) + uintptr(i)*8))).Fix = jj
					i = i + 1
					goto _6
				_6:
					;
					pIdx = (*TIndex)(unsafe.Pointer(pIdx)).FpNext
					jj = jj + 1
				}
			}
		}
	}
	/* Determine if it is possible that triggers (either explicitly coded
	 ** triggers or FK resolution actions) might run as a result of deletes
	 ** that happen when OE_Replace conflict resolution occurs. (Call these
	 ** "replace triggers".)  If any replace triggers run, we will need to
	 ** recheck all of the uniqueness constraints after they have all run.
	 ** But on the recheck, the resolution is OE_Abort instead of OE_Replace.
	 **
	 ** If replace triggers are a possibility, then
	 **
	 **   (1) Allocate register regTrigCnt and initialize it to zero.
	 **       That register will count the number of replace triggers that
	 **       fire.  Constraint recheck only occurs if the number is positive.
	 **   (2) Initialize pTrigger to the list of all DELETE triggers on pTab.
	 **   (3) Initialize addrRecheck and lblRecheckOk
	 **
	 ** The uniqueness rechecking code will create a series of tests to run
	 ** in a second pass.  The addrRecheck and lblRecheckOk variables are
	 ** used to link together these tests which are separated from each other
	 ** in the generate bytecode.
	 */
	if (*Tsqlite3)(unsafe.Pointer(db)).Fflags&libc.Uint64FromInt32(libc.Int32FromInt32(SQLITE_RecTriggers)|libc.Int32FromInt32(SQLITE_ForeignKeys)) == uint64(0) {
		/* There are not DELETE triggers nor FK constraints.  No constraint
		 ** rechecks are needed. */
		pTrigger = uintptr(0)
		regTrigCnt = 0
	} else {
		if (*Tsqlite3)(unsafe.Pointer(db)).Fflags&uint64(SQLITE_RecTriggers) != 0 {
			pTrigger = _sqlite3TriggersExist(tls, pParse, pTab, int32(TK_DELETE), uintptr(0), uintptr(0))
			regTrigCnt = libc.BoolInt32(pTrigger != uintptr(0) || _sqlite3FkRequired(tls, pParse, pTab, uintptr(0), 0) != 0)
		} else {
			pTrigger = uintptr(0)
			regTrigCnt = _sqlite3FkRequired(tls, pParse, pTab, uintptr(0), 0)
		}
		if regTrigCnt != 0 {
			/* Replace triggers might exist.  Allocate the counter and
			 ** initialize it to zero. */
			v8 = pParse + 48
			*(*int32)(unsafe.Pointer(v8)) = *(*int32)(unsafe.Pointer(v8)) + 1
			v2 = *(*int32)(unsafe.Pointer(v8))
			regTrigCnt = v2
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), 0, regTrigCnt)
			lblRecheckOk = _sqlite3VdbeMakeLabel(tls, pParse)
			addrRecheck = lblRecheckOk
		}
	}
	/* If rowid is changing, make sure the new rowid does not previously
	 ** exist in the table.
	 */
	if pkChng != 0 && pPk == uintptr(0) {
		addrRowidOk = _sqlite3VdbeMakeLabel(tls, pParse)
		/* Figure out what action to take in case of a rowid collision */
		onError = libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FkeyConf)
		if libc.Int32FromUint8(overrideError) != int32(OE_Default) {
			onError = libc.Int32FromUint8(overrideError)
		} else {
			if onError == int32(OE_Default) {
				onError = int32(OE_Abort)
			}
		}
		/* figure out whether or not upsert applies in this case */
		if pUpsert != 0 {
			pUpsertClause = _sqlite3UpsertOfIndex(tls, pUpsert, uintptr(0))
			if pUpsertClause != uintptr(0) {
				if libc.Int32FromUint8((*TUpsert)(unsafe.Pointer(pUpsertClause)).FisDoUpdate) == 0 {
					onError = int32(OE_Ignore) /* DO NOTHING is the same as INSERT OR IGNORE */
				} else {
					onError = int32(OE_Update) /* DO UPDATE */
				}
			}
			if pUpsertClause != pUpsert {
				/* The first ON CONFLICT clause has a conflict target other than
				 ** the IPK.  We have to jump ahead to that first ON CONFLICT clause
				 ** and then come back here and deal with the IPK afterwards */
				upsertIpkDelay = _sqlite3VdbeAddOp0(tls, v, int32(OP_Goto))
			}
		}
		/* If the response to a rowid conflict is REPLACE but the response
		 ** to some other UNIQUE constraint is FAIL or IGNORE, then we need
		 ** to defer the running of the rowid conflict checking until after
		 ** the UNIQUE constraints have run.
		 */
		if onError == int32(OE_Replace) && onError != libc.Int32FromUint8(overrideError) && (*TTable)(unsafe.Pointer(pTab)).FpIndex != 0 && !(upsertIpkDelay != 0) {
			ipkTop = _sqlite3VdbeAddOp0(tls, v, int32(OP_Goto)) + int32(1)
		}
		if isUpdate != 0 {
			/* pkChng!=0 does not mean that the rowid has changed, only that
			 ** it might have changed.  Skip the conflict logic below if the rowid
			 ** is unchanged. */
			_sqlite3VdbeAddOp3(tls, v, int32(OP_Eq), regNewData, addrRowidOk, regOldData)
			_sqlite3VdbeChangeP5(tls, v, uint16(SQLITE_NOTNULL))
		}
		/* Check to see if the new rowid already exists in the table.  Skip
		 ** the following conflict logic if it does not. */
		_sqlite3VdbeAddOp3(tls, v, int32(OP_NotExists), iDataCur, addrRowidOk, regNewData)
		switch onError {
		default:
			onError = int32(OE_Abort)
			fallthrough
		case int32(OE_Rollback):
			fallthrough
		case int32(OE_Abort):
			fallthrough
		case int32(OE_Fail):
			_sqlite3RowidConstraint(tls, pParse, onError, pTab)
		case int32(OE_Replace):
			/* If there are DELETE triggers on this table and the
			 ** recursive-triggers flag is set, call GenerateRowDelete() to
			 ** remove the conflicting row from the table. This will fire
			 ** the triggers and remove both the table and index b-tree entries.
			 **
			 ** Otherwise, if there are no triggers or the recursive-triggers
			 ** flag is not set, but the table has one or more indexes, call
			 ** GenerateRowIndexDelete(). This removes the index b-tree entries
			 ** only. The table b-tree entry will be replaced by the new entry
			 ** when it is inserted.
			 **
			 ** If either GenerateRowDelete() or GenerateRowIndexDelete() is called,
			 ** also invoke MultiWrite() to indicate that this VDBE may require
			 ** statement rollback (if the statement is aborted after the delete
			 ** takes place). Earlier versions called sqlite3MultiWrite() regardless,
			 ** but being more selective here allows statements like:
			 **
			 **   REPLACE INTO t(rowid) VALUES($newrowid)
			 **
			 ** to run without a statement journal if there are no indexes on the
			 ** table.
			 */
			if regTrigCnt != 0 {
				_sqlite3MultiWrite(tls, pParse)
				_sqlite3GenerateRowDelete(tls, pParse, pTab, pTrigger, iDataCur, iIdxCur, regNewData, int16(1), uint8(0), uint8(OE_Replace), uint8(1), -int32(1))
				_sqlite3VdbeAddOp2(tls, v, int32(OP_AddImm), regTrigCnt, int32(1)) /* incr trigger cnt */
				nReplaceTrig = nReplaceTrig + 1
			} else {
				/* This OP_Delete opcode fires the pre-update-hook only. It does
				 ** not modify the b-tree. It is more efficient to let the coming
				 ** OP_Insert replace the existing entry than it is to delete the
				 ** existing entry and then insert a new one. */
				_sqlite3VdbeAddOp2(tls, v, int32(OP_Delete), iDataCur, int32(OPFLAG_ISNOOP))
				_sqlite3VdbeAppendP4(tls, v, pTab, -int32(5))
				if (*TTable)(unsafe.Pointer(pTab)).FpIndex != 0 {
					_sqlite3MultiWrite(tls, pParse)
					_sqlite3GenerateRowIndexDelete(tls, pParse, pTab, iDataCur, iIdxCur, uintptr(0), -int32(1))
				}
			}
			seenReplace = int32(1)
		case int32(OE_Update):
			_sqlite3UpsertDoUpdate(tls, pParse, pUpsert, pTab, uintptr(0), iDataCur)
			fallthrough
		case int32(OE_Ignore):
			_sqlite3VdbeGoto(tls, v, ignoreDest)
			break
		}
		_sqlite3VdbeResolveLabel(tls, v, addrRowidOk)
		if pUpsert != 0 && pUpsertClause != pUpsert {
			upsertIpkReturn = _sqlite3VdbeAddOp0(tls, v, int32(OP_Goto))
		} else {
			if ipkTop != 0 {
				ipkBottom = _sqlite3VdbeAddOp0(tls, v, int32(OP_Goto))
				_sqlite3VdbeJumpHere(tls, v, ipkTop-int32(1))
			}
		}
	}
	/* Test all UNIQUE constraints by creating entries for each UNIQUE
	 ** index and making sure that duplicate entries do not already exist.
	 ** Compute the revised record entries for indices as we go.
	 **
	 ** This loop also handles the case of the PRIMARY KEY index for a
	 ** WITHOUT ROWID table.
	 */
	pIdx = _indexIteratorFirst(tls, bp+4, bp)
	for {
		if !(pIdx != 0) {
			break
		} /* First opcode in the conflict check logic */
		if **(**int32)(__ccgo_up(aRegIdx + uintptr(**(**int32)(__ccgo_up(bp)))*4)) == 0 {
			goto _9
		} /* Skip indices that do not change */
		if pUpsert != 0 {
			pUpsertClause = _sqlite3UpsertOfIndex(tls, pUpsert, pIdx)
			if upsertIpkDelay != 0 && pUpsertClause == pUpsert {
				_sqlite3VdbeJumpHere(tls, v, upsertIpkDelay)
			}
		}
		addrUniqueOk = _sqlite3VdbeMakeLabel(tls, pParse)
		if libc.Int32FromUint8(bAffinityDone) == 0 {
			_sqlite3TableAffinity(tls, v, pTab, regNewData+int32(1))
			bAffinityDone = uint8(1)
		}
		iThisCur = iIdxCur + **(**int32)(__ccgo_up(bp))
		/* Skip partial indices for which the WHERE clause is not true */
		if (*TIndex)(unsafe.Pointer(pIdx)).FpPartIdxWhere != 0 {
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Null), 0, **(**int32)(__ccgo_up(aRegIdx + uintptr(**(**int32)(__ccgo_up(bp)))*4)))
			(*TParse)(unsafe.Pointer(pParse)).FiSelfTab = -(regNewData + int32(1))
			_sqlite3ExprIfFalseDup(tls, pParse, (*TIndex)(unsafe.Pointer(pIdx)).FpPartIdxWhere, addrUniqueOk, int32(SQLITE_JUMPIFNULL))
			(*TParse)(unsafe.Pointer(pParse)).FiSelfTab = 0
		}
		/* Create a record for this index entry as it should appear after
		 ** the insert or update.  Store that record in the aRegIdx[ix] register
		 */
		regIdx = **(**int32)(__ccgo_up(aRegIdx + uintptr(**(**int32)(__ccgo_up(bp)))*4)) + int32(1)
		i = 0
		for {
			if !(i < libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pIdx)).FnColumn)) {
				break
			}
			iField = int32(**(**Ti16)(__ccgo_up((*TIndex)(unsafe.Pointer(pIdx)).FaiColumn + uintptr(i)*2)))
			if iField == -int32(2) {
				(*TParse)(unsafe.Pointer(pParse)).FiSelfTab = -(regNewData + int32(1))
				_sqlite3ExprCodeCopy(tls, pParse, (*(*TExprList_item)(unsafe.Pointer((*TIndex)(unsafe.Pointer(pIdx)).FaColExpr + 8 + uintptr(i)*20))).FpExpr, regIdx+i)
				(*TParse)(unsafe.Pointer(pParse)).FiSelfTab = 0
			} else {
				if iField == -int32(1) || iField == int32((*TTable)(unsafe.Pointer(pTab)).FiPKey) {
					x = regNewData
					_sqlite3VdbeAddOp2(tls, v, int32(OP_IntCopy), x, regIdx+i)
				} else {
					x = int32(_sqlite3TableColumnToStorage(tls, pTab, int16(iField))) + regNewData + int32(1)
					_sqlite3VdbeAddOp2(tls, v, int32(OP_SCopy), x, regIdx+i)
				}
			}
			goto _10
		_10:
			;
			i = i + 1
		}
		_sqlite3VdbeAddOp3(tls, v, int32(OP_MakeRecord), regIdx, libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pIdx)).FnColumn), **(**int32)(__ccgo_up(aRegIdx + uintptr(**(**int32)(__ccgo_up(bp)))*4)))
		/* In an UPDATE operation, if this index is the PRIMARY KEY index
		 ** of a WITHOUT ROWID table and there has been no change the
		 ** primary key, then no collision is possible.  The collision detection
		 ** logic below can all be skipped. */
		if isUpdate != 0 && pPk == pIdx && libc.Int32FromUint8(pkChng) == 0 {
			_sqlite3VdbeResolveLabel(tls, v, addrUniqueOk)
			goto _9
		}
		/* Find out what action to take in case there is a uniqueness conflict */
		onError = libc.Int32FromUint8((*TIndex)(unsafe.Pointer(pIdx)).FonError)
		if onError == OE_None {
			_sqlite3VdbeResolveLabel(tls, v, addrUniqueOk)
			goto _9 /* pIdx is not a UNIQUE index */
		}
		if libc.Int32FromUint8(overrideError) != int32(OE_Default) {
			onError = libc.Int32FromUint8(overrideError)
		} else {
			if onError == int32(OE_Default) {
				onError = int32(OE_Abort)
			}
		}
		/* Figure out if the upsert clause applies to this index */
		if pUpsertClause != 0 {
			if libc.Int32FromUint8((*TUpsert)(unsafe.Pointer(pUpsertClause)).FisDoUpdate) == 0 {
				onError = int32(OE_Ignore) /* DO NOTHING is the same as INSERT OR IGNORE */
			} else {
				onError = int32(OE_Update) /* DO UPDATE */
			}
		}
		/* Collision detection may be omitted if all of the following are true:
		 **   (1) The conflict resolution algorithm is REPLACE
		 **   (2) The table is a WITHOUT ROWID table
		 **   (3) There are no secondary indexes on the table
		 **   (4) No delete triggers need to be fired if there is a conflict
		 **   (5) No FK constraint counters need to be updated if a conflict occurs.
		 **
		 ** This is not possible for ENABLE_PREUPDATE_HOOK builds, as the row
		 ** must be explicitly deleted in order to ensure any pre-update hook
		 ** is invoked.  */
		/* Check to see if the new index entry will be unique */
		addrConflictCk = _sqlite3VdbeAddOp4Int(tls, v, int32(OP_NoConflict), iThisCur, addrUniqueOk, regIdx, libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pIdx)).FnKeyCol))
		/* Generate code to handle collisions */
		if pIdx == pPk {
			v2 = regIdx
		} else {
			v2 = _sqlite3GetTempRange(tls, pParse, nPkField)
		}
		regR = v2
		if isUpdate != 0 || onError == int32(OE_Replace) {
			if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_WithoutRowid) == uint32(0) {
				_sqlite3VdbeAddOp2(tls, v, int32(OP_IdxRowid), iThisCur, regR)
				/* Conflict only if the rowid of the existing index entry
				 ** is different from old-rowid */
				if isUpdate != 0 {
					_sqlite3VdbeAddOp3(tls, v, int32(OP_Eq), regR, addrUniqueOk, regOldData)
					_sqlite3VdbeChangeP5(tls, v, uint16(SQLITE_NOTNULL))
				}
			} else {
				/* Extract the PRIMARY KEY from the end of the index entry and
				 ** store it in registers regR..regR+nPk-1 */
				if pIdx != pPk {
					i = 0
					for {
						if !(i < libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pPk)).FnKeyCol)) {
							break
						}
						x1 = _sqlite3TableColumnToIndex(tls, pIdx, int32(**(**Ti16)(__ccgo_up((*TIndex)(unsafe.Pointer(pPk)).FaiColumn + uintptr(i)*2))))
						_sqlite3VdbeAddOp3(tls, v, int32(OP_Column), iThisCur, x1, regR+i)
						goto _12
					_12:
						;
						i = i + 1
					}
				}
				if isUpdate != 0 {
					/* If currently processing the PRIMARY KEY of a WITHOUT ROWID
					 ** table, only conflict if the new PRIMARY KEY values are actually
					 ** different from the old.  See TH3 withoutrowid04.test.
					 **
					 ** For a UNIQUE index, only conflict if the PRIMARY KEY values
					 ** of the matched index row are different from the original PRIMARY
					 ** KEY values of this row before the update.  */
					addrJump = _sqlite3VdbeCurrentAddr(tls, v) + libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pPk)).FnKeyCol)
					op = int32(OP_Ne)
					if int32(uint32(*(*uint16)(unsafe.Pointer(pIdx + 56))&0x3>>0)) == int32(SQLITE_IDXTYPE_PRIMARYKEY) {
						v2 = regIdx
					} else {
						v2 = regR
					}
					regCmp = v2
					i = 0
					for {
						if !(i < libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pPk)).FnKeyCol)) {
							break
						}
						p4 = _sqlite3LocateCollSeq(tls, pParse, **(**uintptr)(__ccgo_up((*TIndex)(unsafe.Pointer(pPk)).FazColl + uintptr(i)*4)))
						x1 = int32(**(**Ti16)(__ccgo_up((*TIndex)(unsafe.Pointer(pPk)).FaiColumn + uintptr(i)*2)))
						if i == libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pPk)).FnKeyCol)-int32(1) {
							addrJump = addrUniqueOk
							op = int32(OP_Eq)
						}
						x1 = int32(_sqlite3TableColumnToStorage(tls, pTab, int16(x1)))
						_sqlite3VdbeAddOp4(tls, v, op, regOldData+int32(1)+x1, addrJump, regCmp+i, p4, -int32(2))
						_sqlite3VdbeChangeP5(tls, v, uint16(SQLITE_NOTNULL))
						goto _14
					_14:
						;
						i = i + 1
					}
				}
			}
		}
		/* Generate code that executes if the new index entry is not unique */
		switch onError {
		case int32(OE_Rollback):
			fallthrough
		case int32(OE_Abort):
			fallthrough
		case int32(OE_Fail):
			_sqlite3UniqueConstraint(tls, pParse, onError, pIdx)
		case int32(OE_Update):
			_sqlite3UpsertDoUpdate(tls, pParse, pUpsert, pTab, pIdx, iIdxCur+**(**int32)(__ccgo_up(bp)))
			fallthrough
		case int32(OE_Ignore):
			_sqlite3VdbeGoto(tls, v, ignoreDest)
		default: /* Number of opcodes in conflict check logic */
			nConflictCk = _sqlite3VdbeCurrentAddr(tls, v) - addrConflictCk
			if regTrigCnt != 0 {
				_sqlite3MultiWrite(tls, pParse)
				nReplaceTrig = nReplaceTrig + 1
			}
			if pTrigger != 0 && isUpdate != 0 {
				_sqlite3VdbeAddOp1(tls, v, int32(OP_CursorLock), iDataCur)
			}
			if pIdx == pPk {
				v2 = int32(ONEPASS_SINGLE)
			} else {
				v2 = ONEPASS_OFF
			}
			_sqlite3GenerateRowDelete(tls, pParse, pTab, pTrigger, iDataCur, iIdxCur, regR, int16(nPkField), uint8(0), uint8(OE_Replace), libc.Uint8FromInt32(v2), iThisCur)
			if pTrigger != 0 && isUpdate != 0 {
				_sqlite3VdbeAddOp1(tls, v, int32(OP_CursorUnlock), iDataCur)
			}
			if regTrigCnt != 0 { /* Jump destination to bypass recheck logic */
				_sqlite3VdbeAddOp2(tls, v, int32(OP_AddImm), regTrigCnt, int32(1)) /* incr trigger cnt */
				addrBypass = _sqlite3VdbeAddOp0(tls, v, int32(OP_Goto))            /* Bypass recheck */
				/* Here we insert code that will be invoked after all constraint
				 ** checks have run, if and only if one or more replace triggers
				 ** fired. */
				_sqlite3VdbeResolveLabel(tls, v, lblRecheckOk)
				lblRecheckOk = _sqlite3VdbeMakeLabel(tls, pParse)
				if (*TIndex)(unsafe.Pointer(pIdx)).FpPartIdxWhere != 0 {
					/* Bypass the recheck if this partial index is not defined
					 ** for the current row */
					_sqlite3VdbeAddOp2(tls, v, int32(OP_IsNull), regIdx-int32(1), lblRecheckOk)
				}
				/* Copy the constraint check code from above, except change
				 ** the constraint-ok jump destination to be the address of
				 ** the next retest block */
				for nConflictCk > 0 { /* Conflict check opcode to copy */
					/* The sqlite3VdbeAddOp4() call might reallocate the opcode array.
					 ** Hence, make a complete copy of the opcode, rather than using
					 ** a pointer to the opcode. */
					**(**TVdbeOp)(__ccgo_up(bp + 20)) = **(**TVdbeOp)(__ccgo_up(_sqlite3VdbeGetOp(tls, v, addrConflictCk)))
					if libc.Int32FromUint8((**(**TVdbeOp)(__ccgo_up(bp + 20))).Fopcode) != int32(OP_IdxRowid) {
						if libc.Int32FromUint8(_sqlite3OpcodeProperty[(**(**TVdbeOp)(__ccgo_up(bp + 20))).Fopcode])&int32(OPFLG_JUMP) != 0 {
							p2 = lblRecheckOk
						} else {
							p2 = (**(**TVdbeOp)(__ccgo_up(bp + 20))).Fp2
						}
						if int32((**(**TVdbeOp)(__ccgo_up(bp + 20))).Fp4type) == -int32(3) {
							v8 = uintptr(*(*int32)(unsafe.Pointer(bp + 20 + 16)))
						} else {
							v8 = *(*uintptr)(unsafe.Pointer(bp + 20 + 16))
						}
						zP4 = v8
						_sqlite3VdbeAddOp4(tls, v, libc.Int32FromUint8((**(**TVdbeOp)(__ccgo_up(bp + 20))).Fopcode), (**(**TVdbeOp)(__ccgo_up(bp + 20))).Fp1, p2, (**(**TVdbeOp)(__ccgo_up(bp + 20))).Fp3, zP4, int32((**(**TVdbeOp)(__ccgo_up(bp + 20))).Fp4type))
						_sqlite3VdbeChangeP5(tls, v, (**(**TVdbeOp)(__ccgo_up(bp + 20))).Fp5)
					}
					nConflictCk = nConflictCk - 1
					addrConflictCk = addrConflictCk + 1
				}
				/* If the retest fails, issue an abort */
				_sqlite3UniqueConstraint(tls, pParse, int32(OE_Abort), pIdx)
				_sqlite3VdbeJumpHere(tls, v, addrBypass) /* Terminate the recheck bypass */
			}
			seenReplace = int32(1)
			break
		}
		_sqlite3VdbeResolveLabel(tls, v, addrUniqueOk)
		if regR != regIdx {
			_sqlite3ReleaseTempRange(tls, pParse, regR, nPkField)
		}
		if pUpsertClause != 0 && upsertIpkReturn != 0 && _sqlite3UpsertNextIsIPK(tls, pUpsertClause) != 0 {
			_sqlite3VdbeGoto(tls, v, upsertIpkDelay+int32(1))
			_sqlite3VdbeJumpHere(tls, v, upsertIpkReturn)
			upsertIpkReturn = 0
		}
		goto _9
	_9:
		;
		pIdx = _indexIteratorNext(tls, bp+4, bp)
	}
	/* If the IPK constraint is a REPLACE, run it last */
	if ipkTop != 0 {
		_sqlite3VdbeGoto(tls, v, ipkTop)
		_sqlite3VdbeJumpHere(tls, v, ipkBottom)
	}
	/* Recheck all uniqueness constraints after replace triggers have run */
	if nReplaceTrig != 0 {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_IfNot), regTrigCnt, lblRecheckOk)
		if !(pPk != 0) {
			if isUpdate != 0 {
				_sqlite3VdbeAddOp3(tls, v, int32(OP_Eq), regNewData, addrRecheck, regOldData)
				_sqlite3VdbeChangeP5(tls, v, uint16(SQLITE_NOTNULL))
			}
			_sqlite3VdbeAddOp3(tls, v, int32(OP_NotExists), iDataCur, addrRecheck, regNewData)
			_sqlite3RowidConstraint(tls, pParse, int32(OE_Abort), pTab)
		} else {
			_sqlite3VdbeGoto(tls, v, addrRecheck)
		}
		_sqlite3VdbeResolveLabel(tls, v, lblRecheckOk)
	}
	/* Generate the table record */
	if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_WithoutRowid) == uint32(0) {
		regRec = **(**int32)(__ccgo_up(aRegIdx + uintptr(**(**int32)(__ccgo_up(bp)))*4))
		_sqlite3VdbeAddOp3(tls, v, int32(OP_MakeRecord), regNewData+int32(1), int32((*TTable)(unsafe.Pointer(pTab)).FnNVCol), regRec)
		if !(bAffinityDone != 0) {
			_sqlite3TableAffinity(tls, v, pTab, 0)
		}
	}
	**(**int32)(__ccgo_up(pbMayReplace)) = seenReplace
}

// C documentation
//
//	/*
//	** This routine generates VDBE code that causes a single row of a
//	** single table to be deleted.  Both the original table entry and
//	** all indices are removed.
//	**
//	** Preconditions:
//	**
//	**   1.  iDataCur is an open cursor on the btree that is the canonical data
//	**       store for the table.  (This will be either the table itself,
//	**       in the case of a rowid table, or the PRIMARY KEY index in the case
//	**       of a WITHOUT ROWID table.)
//	**
//	**   2.  Read/write cursors for all indices of pTab must be open as
//	**       cursor number iIdxCur+i for the i-th index.
//	**
//	**   3.  The primary key for the row to be deleted must be stored in a
//	**       sequence of nPk memory cells starting at iPk.  If nPk==0 that means
//	**       that a search record formed from OP_MakeRecord is contained in the
//	**       single memory location iPk.
//	**
//	** eMode:
//	**   Parameter eMode may be passed either ONEPASS_OFF (0), ONEPASS_SINGLE, or
//	**   ONEPASS_MULTI.  If eMode is not ONEPASS_OFF, then the cursor
//	**   iDataCur already points to the row to delete. If eMode is ONEPASS_OFF
//	**   then this function must seek iDataCur to the entry identified by iPk
//	**   and nPk before reading from it.
//	**
//	**   If eMode is ONEPASS_MULTI, then this call is being made as part
//	**   of a ONEPASS delete that affects multiple rows. In this case, if
//	**   iIdxNoSeek is a valid cursor number (>=0) and is not the same as
//	**   iDataCur, then its position should be preserved following the delete
//	**   operation. Or, if iIdxNoSeek is not a valid cursor number, the
//	**   position of iDataCur should be preserved instead.
//	**
//	** iIdxNoSeek:
//	**   If iIdxNoSeek is a valid cursor number (>=0) not equal to iDataCur,
//	**   then it identifies an index cursor (from within array of cursors
//	**   starting at iIdxCur) that already points to the index entry to be deleted.
//	**   Except, this optimization is disabled if there are BEFORE triggers since
//	**   the trigger body might have moved the cursor.
//	*/
func _sqlite3GenerateRowDelete(tls *libc.TLS, pParse uintptr, pTab uintptr, pTrigger uintptr, iDataCur int32, iIdxCur int32, iPk int32, nPk Ti16, count Tu8, onconf Tu8, eMode Tu8, iIdxNoSeek int32) {
	var addrStart, iCol, iLabel, iOld, kk, v1 int32
	var mask Tu32
	var opSeek, p5 Tu8
	var v uintptr
	_, _, _, _, _, _, _, _, _, _ = addrStart, iCol, iLabel, iOld, kk, mask, opSeek, p5, v, v1
	v = (*TParse)(unsafe.Pointer(pParse)).FpVdbe /* Vdbe */
	iOld = 0                                     /* Seek opcode */
	/* Vdbe is guaranteed to have been allocated by this stage. */
	/* Seek cursor iCur to the row to delete. If this row no longer exists
	 ** (this can happen if a trigger program has already deleted it), do
	 ** not attempt to delete it or fire any DELETE triggers.  */
	iLabel = _sqlite3VdbeMakeLabel(tls, pParse)
	if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_WithoutRowid) == uint32(0) {
		v1 = int32(OP_NotExists)
	} else {
		v1 = int32(OP_NotFound)
	}
	opSeek = libc.Uint8FromInt32(v1)
	if libc.Int32FromUint8(eMode) == ONEPASS_OFF {
		_sqlite3VdbeAddOp4Int(tls, v, libc.Int32FromUint8(opSeek), iDataCur, iLabel, iPk, int32(nPk))
	}
	/* If there are any triggers to fire, allocate a range of registers to
	 ** use for the old.* references in the triggers.  */
	if _sqlite3FkRequired(tls, pParse, pTab, uintptr(0), 0) != 0 || pTrigger != 0 { /* Start of BEFORE trigger programs */
		/* TODO: Could use temporary registers here. Also could attempt to
		 ** avoid copying the contents of the rowid register.  */
		mask = _sqlite3TriggerColmask(tls, pParse, pTrigger, uintptr(0), 0, libc.Int32FromInt32(TRIGGER_BEFORE)|libc.Int32FromInt32(TRIGGER_AFTER), pTab, libc.Int32FromUint8(onconf))
		mask = mask | _sqlite3FkOldmask(tls, pParse, pTab)
		iOld = (*TParse)(unsafe.Pointer(pParse)).FnMem + int32(1)
		**(**int32)(__ccgo_up(pParse + 48)) += int32(1) + int32((*TTable)(unsafe.Pointer(pTab)).FnCol)
		/* Populate the OLD.* pseudo-table register array. These values will be
		 ** used by any BEFORE and AFTER triggers that exist.  */
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Copy), iPk, iOld)
		iCol = 0
		for {
			if !(iCol < int32((*TTable)(unsafe.Pointer(pTab)).FnCol)) {
				break
			}
			if mask == uint32(0xffffffff) || iCol <= int32(31) && mask&(libc.Uint32FromInt32(1)<<iCol) != uint32(0) {
				kk = int32(_sqlite3TableColumnToStorage(tls, pTab, int16(iCol)))
				_sqlite3ExprCodeGetColumnOfTable(tls, v, pTab, iDataCur, iCol, iOld+kk+int32(1))
			}
			goto _2
		_2:
			;
			iCol = iCol + 1
		}
		/* Invoke BEFORE DELETE trigger programs. */
		addrStart = _sqlite3VdbeCurrentAddr(tls, v)
		_sqlite3CodeRowTrigger(tls, pParse, pTrigger, int32(TK_DELETE), uintptr(0), int32(TRIGGER_BEFORE), pTab, iOld, libc.Int32FromUint8(onconf), iLabel)
		/* If any BEFORE triggers were coded, then seek the cursor to the
		 ** row to be deleted again. It may be that the BEFORE triggers moved
		 ** the cursor or already deleted the row that the cursor was
		 ** pointing to.
		 **
		 ** Also disable the iIdxNoSeek optimization since the BEFORE trigger
		 ** may have moved that cursor.
		 */
		if addrStart < _sqlite3VdbeCurrentAddr(tls, v) {
			_sqlite3VdbeAddOp4Int(tls, v, libc.Int32FromUint8(opSeek), iDataCur, iLabel, iPk, int32(nPk))
			iIdxNoSeek = -int32(1)
		}
		/* Do FK processing. This call checks that any FK constraints that
		 ** refer to this table (i.e. constraints attached to other tables)
		 ** are not violated by deleting this row.  */
		_sqlite3FkCheck(tls, pParse, pTab, iOld, 0, uintptr(0), 0)
	}
	/* Delete the index and table entries. Skip this step if pTab is really
	 ** a view (in which case the only effect of the DELETE statement is to
	 ** fire the INSTEAD OF triggers).
	 **
	 ** If variable 'count' is non-zero, then this OP_Delete instruction should
	 ** invoke the update-hook. The pre-update-hook, on the other hand should
	 ** be invoked unless table pTab is a system table. The difference is that
	 ** the update-hook is not invoked for rows removed by REPLACE, but the
	 ** pre-update-hook is.
	 */
	if !(libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == libc.Int32FromInt32(TABTYP_VIEW)) {
		p5 = uint8(0)
		_sqlite3GenerateRowIndexDelete(tls, pParse, pTab, iDataCur, iIdxCur, uintptr(0), iIdxNoSeek)
		if count != 0 {
			v1 = int32(OPFLAG_NCHANGE)
		} else {
			v1 = 0
		}
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Delete), iDataCur, v1)
		if libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).Fnested) == 0 || 0 == Xsqlite3_stricmp(tls, (*TTable)(unsafe.Pointer(pTab)).FzName, __ccgo_ts+12835) {
			_sqlite3VdbeAppendP4(tls, v, pTab, -int32(5))
		}
		if libc.Int32FromUint8(eMode) != ONEPASS_OFF {
			_sqlite3VdbeChangeP5(tls, v, uint16(OPFLAG_AUXDELETE))
		}
		if iIdxNoSeek >= 0 && iIdxNoSeek != iDataCur {
			_sqlite3VdbeAddOp1(tls, v, int32(OP_Delete), iIdxNoSeek)
		}
		if libc.Int32FromUint8(eMode) == int32(ONEPASS_MULTI) {
			p5 = libc.Uint8FromInt32(int32(p5) | libc.Int32FromInt32(OPFLAG_SAVEPOSITION))
		}
		_sqlite3VdbeChangeP5(tls, v, uint16(p5))
	}
	/* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
	 ** handle rows (possibly in other tables) that refer via a foreign key
	 ** to the row just deleted. */
	_sqlite3FkActions(tls, pParse, pTab, uintptr(0), iOld, uintptr(0), 0)
	/* Invoke AFTER DELETE trigger programs. */
	if pTrigger != 0 {
		_sqlite3CodeRowTrigger(tls, pParse, pTrigger, int32(TK_DELETE), uintptr(0), int32(TRIGGER_AFTER), pTab, iOld, libc.Int32FromUint8(onconf), iLabel)
	}
	/* Jump here if the row had already been deleted before any BEFORE
	 ** trigger programs were invoked. Or if a trigger program throws a
	 ** RAISE(IGNORE) exception.  */
	_sqlite3VdbeResolveLabel(tls, v, iLabel)
}

// C documentation
//
//	/*
//	** If expression list pList contains an expression that was parsed with
//	** an explicit "NULLS FIRST" or "NULLS LAST" clause, leave an error in
//	** pParse and return non-zero. Otherwise, return zero.
//	*/
func _sqlite3HasExplicitNulls(tls *libc.TLS, pParse uintptr, pList uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var i int32
	var sf Tu8
	var v2 uintptr
	_, _, _ = i, sf, v2
	if pList != 0 {
		i = 0
		for {
			if !(i < (*TExprList)(unsafe.Pointer(pList)).FnExpr) {
				break
			}
			if int32(uint32(*(*uint16)(unsafe.Pointer(pList + 8 + uintptr(i)*20 + 8 + 4))&0x20>>5)) != 0 {
				sf = (*(*TExprList_item)(unsafe.Pointer(pList + 8 + uintptr(i)*20))).Ffg.FsortFlags
				if libc.Int32FromUint8(sf) == 0 || libc.Int32FromUint8(sf) == int32(3) {
					v2 = __ccgo_ts + 15376
				} else {
					v2 = __ccgo_ts + 15382
				}
				_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+15387, libc.VaList(bp+8, v2))
				return int32(1)
			}
			goto _1
		_1:
			;
			i = i + 1
		}
	}
	return 0
}

// C documentation
//
//	/*
//	** If the source-list item passed as an argument was augmented with an
//	** INDEXED BY clause, then try to locate the specified index. If there
//	** was such a clause and the named index cannot be found, return
//	** SQLITE_ERROR and leave an error in pParse. Otherwise, populate
//	** pFrom->pIndex and return SQLITE_OK.
//	*/
func _sqlite3IndexedByLookup(tls *libc.TLS, pParse uintptr, pFrom uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var pIdx, pTab, zIndexedBy uintptr
	_, _, _ = pIdx, pTab, zIndexedBy
	pTab = (*TSrcItem)(unsafe.Pointer(pFrom)).FpSTab
	zIndexedBy = *(*uintptr)(unsafe.Pointer(pFrom + 32))
	pIdx = (*TTable)(unsafe.Pointer(pTab)).FpIndex
	for {
		if !(pIdx != 0 && _sqlite3StrICmp(tls, (*TIndex)(unsafe.Pointer(pIdx)).FzName, zIndexedBy) != 0) {
			break
		}
		goto _1
	_1:
		;
		pIdx = (*TIndex)(unsafe.Pointer(pIdx)).FpNext
	}
	if !(pIdx != 0) {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+21016, libc.VaList(bp+8, zIndexedBy, 0))
		libc.SetBitFieldPtr16Uint32(pParse+28, libc.Uint32FromInt32(1), 8, 0x100)
		return int32(SQLITE_ERROR)
	}
	*(*uintptr)(unsafe.Pointer(pFrom + 36)) = pIdx
	return SQLITE_OK
}

// C documentation
//
//	/*
//	** This routine is called to handle SQL of the following forms:
//	**
//	**    insert into TABLE (IDLIST) values(EXPRLIST),(EXPRLIST),...
//	**    insert into TABLE (IDLIST) select
//	**    insert into TABLE (IDLIST) default values
//	**
//	** The IDLIST following the table name is always optional.  If omitted,
//	** then a list of all (non-hidden) columns for the table is substituted.
//	** The IDLIST appears in the pColumn parameter.  pColumn is NULL if IDLIST
//	** is omitted.
//	**
//	** For the pSelect parameter holds the values to be inserted for the
//	** first two forms shown above.  A VALUES clause is really just short-hand
//	** for a SELECT statement that omits the FROM clause and everything else
//	** that follows.  If the pSelect parameter is NULL, that means that the
//	** DEFAULT VALUES form of the INSERT statement is intended.
//	**
//	** The code generated follows one of four templates.  For a simple
//	** insert with data coming from a single-row VALUES clause, the code executes
//	** once straight down through.  Pseudo-code follows (we call this
//	** the "1st template"):
//	**
//	**         open write cursor to <table> and its indices
//	**         put VALUES clause expressions into registers
//	**         write the resulting record into <table>
//	**         cleanup
//	**
//	** The three remaining templates assume the statement is of the form
//	**
//	**   INSERT INTO <table> SELECT ...
//	**
//	** If the SELECT clause is of the restricted form "SELECT * FROM <table2>" -
//	** in other words if the SELECT pulls all columns from a single table
//	** and there is no WHERE or LIMIT or GROUP BY or ORDER BY clauses, and
//	** if <table2> and <table1> are distinct tables but have identical
//	** schemas, including all the same indices, then a special optimization
//	** is invoked that copies raw records from <table2> over to <table1>.
//	** See the xferOptimization() function for the implementation of this
//	** template.  This is the 2nd template.
//	**
//	**         open a write cursor to <table>
//	**         open read cursor on <table2>
//	**         transfer all records in <table2> over to <table>
//	**         close cursors
//	**         foreach index on <table>
//	**           open a write cursor on the <table> index
//	**           open a read cursor on the corresponding <table2> index
//	**           transfer all records from the read to the write cursors
//	**           close cursors
//	**         end foreach
//	**
//	** The 3rd template is for when the second template does not apply
//	** and the SELECT clause does not read from <table> at any time.
//	** The generated code follows this template:
//	**
//	**         X <- A
//	**         goto B
//	**      A: setup for the SELECT
//	**         loop over the rows in the SELECT
//	**           load values into registers R..R+n
//	**           yield X
//	**         end loop
//	**         cleanup after the SELECT
//	**         end-coroutine X
//	**      B: open write cursor to <table> and its indices
//	**      C: yield X, at EOF goto D
//	**         insert the select result into <table> from R..R+n
//	**         goto C
//	**      D: cleanup
//	**
//	** The 4th template is used if the insert statement takes its
//	** values from a SELECT but the data is being inserted into a table
//	** that is also read as part of the SELECT.  In the third form,
//	** we have to use an intermediate table to store the results of
//	** the select.  The template is like this:
//	**
//	**         X <- A
//	**         goto B
//	**      A: setup for the SELECT
//	**         loop over the tables in the SELECT
//	**           load value into register R..R+n
//	**           yield X
//	**         end loop
//	**         cleanup after the SELECT
//	**         end co-routine R
//	**      B: open temp table
//	**      L: yield X, at EOF goto M
//	**         insert row from R..R+n into temp table
//	**         goto L
//	**      M: open write cursor to <table> and its indices
//	**         rewind temp table
//	**      C: loop over rows of intermediate table
//	**           transfer values form intermediate table into <table>
//	**         end loop
//	**      D: cleanup
//	*/
func _sqlite3Insert(tls *libc.TLS, pParse uintptr, pTabList uintptr, pSelect uintptr, pColumn uintptr, onError int32, pUpsert uintptr) {
	bp := tls.Alloc(112)
	defer tls.Free(112)
	var aRegIdx, aTabColMap, db, pIdx, pIpk, pItem, pList, pNx, pSubq, pTab, pTrigger, pVTab, pX, v, v5 uintptr
	var addr1, addr11, addrCont, addrInsTop, addrL, addrTop, bUseSeek, endOfLoop, i, iDb, iRegStore, ipkColumn, isView, j, k, nColumn, nHidden, nIdx, rc, regAutoinc, regCols, regData, regFromSelect, regIns, regRec, regRowCount, regRowid, regTempRowid, regYield, srcTab, y, v1 int32
	var appendFlag, bIdListInOrder, useTempTable, withoutRowid Tu8
	var colFlags, v20 Tu32
	var _ /* dest at bp+8 */ TSelectDest
	var _ /* iDataCur at bp+0 */ int32
	var _ /* iIdxCur at bp+4 */ int32
	var _ /* isReplace at bp+76 */ int32
	var _ /* sNC at bp+40 */ TNameContext
	var _ /* tmask at bp+36 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = aRegIdx, aTabColMap, addr1, addr11, addrCont, addrInsTop, addrL, addrTop, appendFlag, bIdListInOrder, bUseSeek, colFlags, db, endOfLoop, i, iDb, iRegStore, ipkColumn, isView, j, k, nColumn, nHidden, nIdx, pIdx, pIpk, pItem, pList, pNx, pSubq, pTab, pTrigger, pVTab, pX, rc, regAutoinc, regCols, regData, regFromSelect, regIns, regRec, regRowCount, regRowid, regTempRowid, regYield, srcTab, useTempTable, v, withoutRowid, y, v1, v20, v5 /* Number of columns in the data */
	nHidden = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /* Number of hidden columns if TABLE is virtual */
	**(**int32)(__ccgo_up(bp)) = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /* VDBE cursor that is the main data repository */
	**(**int32)(__ccgo_up(bp + 4)) = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /* First index cursor */
	ipkColumn = -int32(1)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               /* Label for the end of the insertion loop */
	srcTab = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /* Data comes from this temporary cursor if >=0 */
	addrInsTop = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /* Jump to label "D" */
	addrCont = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /* Index of database holding TABLE */
	useTempTable = uint8(0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             /* Store SELECT results in intermediate table */
	appendFlag = uint8(0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               /* True if IDLIST is in table order */
	pList = uintptr(0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /* Register in which to store next column */
	/* Register allocations */
	regFromSelect = 0       /* Base register for data coming from SELECT */
	regAutoinc = 0          /* Register holding the AUTOINCREMENT counter */
	regRowCount = 0         /* register holding first column to insert */
	aRegIdx = uintptr(0)    /* One register allocated to each index */
	aTabColMap = uintptr(0) /* Mask of trigger times */
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	if (*TParse)(unsafe.Pointer(pParse)).FnErr != 0 {
		goto insert_cleanup
	}
	(**(**TSelectDest)(__ccgo_up(bp + 8))).FiSDParm = 0 /* Suppress a harmless compiler warning */
	/* If the Select object is really just a simple VALUES() list with a
	 ** single row (the common case) then keep that one row of values
	 ** and discard the other (unused) parts of the pSelect object
	 */
	if pSelect != 0 && (*TSelect)(unsafe.Pointer(pSelect)).FselFlags&uint32(SF_Values) != uint32(0) && (*TSelect)(unsafe.Pointer(pSelect)).FpPrior == uintptr(0) {
		pList = (*TSelect)(unsafe.Pointer(pSelect)).FpEList
		(*TSelect)(unsafe.Pointer(pSelect)).FpEList = uintptr(0)
		_sqlite3SelectDelete(tls, db, pSelect)
		pSelect = uintptr(0)
	}
	/* Locate the table into which we will be inserting new information.
	 */
	pTab = _sqlite3SrcListLookup(tls, pParse, pTabList)
	if pTab == uintptr(0) {
		goto insert_cleanup
	}
	iDb = _sqlite3SchemaToIndex(tls, db, (*TTable)(unsafe.Pointer(pTab)).FpSchema)
	if _sqlite3AuthCheck(tls, pParse, int32(SQLITE_INSERT), (*TTable)(unsafe.Pointer(pTab)).FzName, uintptr(0), (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FzDbSName) != 0 {
		goto insert_cleanup
	}
	withoutRowid = libc.BoolUint8(!((*TTable)(unsafe.Pointer(pTab)).FtabFlags&libc.Uint32FromInt32(TF_WithoutRowid) == libc.Uint32FromInt32(0)))
	/* Figure out if we have any triggers and if the table being
	 ** inserted into is a view
	 */
	pTrigger = _sqlite3TriggersExist(tls, pParse, pTab, int32(TK_INSERT), uintptr(0), bp+36)
	isView = libc.BoolInt32(libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VIEW))
	/* If pTab is really a view, make sure it has been initialized.
	 ** ViewGetColumnNames() is a no-op if pTab is not a view.
	 */
	if _sqlite3ViewGetColumnNames(tls, pParse, pTab) != 0 {
		goto insert_cleanup
	}
	/* Cannot insert into a read-only table.
	 */
	if _sqlite3IsReadOnly(tls, pParse, pTab, pTrigger) != 0 {
		goto insert_cleanup
	}
	/* Allocate a VDBE
	 */
	v = _sqlite3GetVdbe(tls, pParse)
	if v == uintptr(0) {
		goto insert_cleanup
	}
	if libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).Fnested) == 0 {
		_sqlite3VdbeCountChanges(tls, v)
	}
	_sqlite3BeginWriteOperation(tls, pParse, libc.BoolInt32(pSelect != 0 || pTrigger != 0), iDb)
	/* If the statement is of the form
	 **
	 **       INSERT INTO <table1> SELECT * FROM <table2>;
	 **
	 ** Then special optimizations can be applied that make the transfer
	 ** very fast and which reduce fragmentation of indices.
	 **
	 ** This is the 2nd template.
	 */
	if pColumn == uintptr(0) && pSelect != uintptr(0) && pTrigger == uintptr(0) && _xferOptimization(tls, pParse, pTab, pSelect, onError, iDb) != 0 {
		goto insert_end
	}
	/* If this is an AUTOINCREMENT table, look up the sequence number in the
	 ** sqlite_sequence table and store it in memory cell regAutoinc.
	 */
	regAutoinc = _autoIncBegin(tls, pParse, iDb, pTab)
	/* Allocate a block registers to hold the rowid and the values
	 ** for all columns of the new row.
	 */
	v1 = (*TParse)(unsafe.Pointer(pParse)).FnMem + libc.Int32FromInt32(1)
	regIns = v1
	regRowid = v1
	**(**int32)(__ccgo_up(pParse + 48)) += int32((*TTable)(unsafe.Pointer(pTab)).FnCol) + int32(1)
	if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) {
		regRowid = regRowid + 1
		(*TParse)(unsafe.Pointer(pParse)).FnMem = (*TParse)(unsafe.Pointer(pParse)).FnMem + 1
	}
	regData = regRowid + int32(1)
	/* If the INSERT statement included an IDLIST term, then make sure
	 ** all elements of the IDLIST really are columns of the table and
	 ** remember the column indices.
	 **
	 ** If the table has an INTEGER PRIMARY KEY column and that column
	 ** is named in the IDLIST, then record in the ipkColumn variable
	 ** the index into IDLIST of the primary key column.  ipkColumn is
	 ** the index of the primary key as it appears in IDLIST, not as
	 ** is appears in the original table.  (The index of the INTEGER
	 ** PRIMARY KEY in the original table is pTab->iPKey.)  After this
	 ** loop, if ipkColumn==(-1), that means that integer primary key
	 ** is unspecified, and hence the table is either WITHOUT ROWID or
	 ** it will automatically generated an integer primary key.
	 **
	 ** bIdListInOrder is true if the columns in IDLIST are in storage
	 ** order.  This enables an optimization that avoids shuffling the
	 ** columns into storage order.  False negatives are harmless,
	 ** but false positives will cause database corruption.
	 */
	bIdListInOrder = libc.BoolUint8((*TTable)(unsafe.Pointer(pTab)).FtabFlags&libc.Uint32FromInt32(libc.Int32FromInt32(TF_OOOHidden)|libc.Int32FromInt32(TF_HasStored)) == uint32(0))
	if pColumn != 0 {
		aTabColMap = _sqlite3DbMallocZero(tls, db, uint64(libc.Uint32FromInt16((*TTable)(unsafe.Pointer(pTab)).FnCol)*uint32(4)))
		if aTabColMap == uintptr(0) {
			goto insert_cleanup
		}
		i = 0
		for {
			if !(i < (*TIdList)(unsafe.Pointer(pColumn)).FnId) {
				break
			}
			j = _sqlite3ColumnIndex(tls, pTab, (*(*TIdList_item)(unsafe.Pointer(pColumn + 4 + uintptr(i)*4))).FzName)
			if j >= 0 {
				if **(**int32)(__ccgo_up(aTabColMap + uintptr(j)*4)) == 0 {
					**(**int32)(__ccgo_up(aTabColMap + uintptr(j)*4)) = i + int32(1)
				}
				if i != j {
					bIdListInOrder = uint8(0)
				}
				if j == int32((*TTable)(unsafe.Pointer(pTab)).FiPKey) {
					ipkColumn = i
				}
				if libc.Int32FromUint16((**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(j)*12))).FcolFlags)&(libc.Int32FromInt32(COLFLAG_STORED)|libc.Int32FromInt32(COLFLAG_VIRTUAL)) != 0 {
					_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+17347, libc.VaList(bp+88, (**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(j)*12))).FzCnName))
					goto insert_cleanup
				}
			} else {
				if _sqlite3IsRowid(tls, (*(*TIdList_item)(unsafe.Pointer(pColumn + 4 + uintptr(i)*4))).FzName) != 0 && !(withoutRowid != 0) {
					ipkColumn = i
					bIdListInOrder = uint8(0)
				} else {
					_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+17388, libc.VaList(bp+88, pTabList+8, (*(*TIdList_item)(unsafe.Pointer(pColumn + 4 + uintptr(i)*4))).FzName))
					libc.SetBitFieldPtr16Uint32(pParse+28, libc.Uint32FromInt32(1), 8, 0x100)
					goto insert_cleanup
				}
			}
			goto _2
		_2:
			;
			i = i + 1
		}
	}
	/* Figure out how many columns of data are supplied.  If the data
	 ** is coming from a SELECT statement, then generate a co-routine that
	 ** produces a single row of the SELECT on each invocation.  The
	 ** co-routine is the common header to the 3rd and 4th templates.
	 */
	if pSelect != 0 { /* Result code */
		if (*TSrcList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(pSelect)).FpSrc)).FnSrc == int32(1) && int32(*(*uint32)(unsafe.Pointer((*TSelect)(unsafe.Pointer(pSelect)).FpSrc + 8 + 12 + 4))&0x40>>6) != 0 && (*TSelect)(unsafe.Pointer(pSelect)).FpPrior == uintptr(0) {
			pItem = (*TSelect)(unsafe.Pointer(pSelect)).FpSrc + 8
			pSubq = *(*uintptr)(unsafe.Pointer(pItem + 44))
			(**(**TSelectDest)(__ccgo_up(bp + 8))).FiSDParm = (*TSubquery)(unsafe.Pointer(pSubq)).FregReturn
			regFromSelect = (*TSubquery)(unsafe.Pointer(pSubq)).FregResult
			nColumn = (*TExprList)(unsafe.Pointer((*TSelect)(unsafe.Pointer((*TSubquery)(unsafe.Pointer(pSubq)).FpSelect)).FpEList)).FnExpr
			_sqlite3VdbeExplain(tls, pParse, uint8(0), __ccgo_ts+17420, libc.VaList(bp+88, pItem))
			if bIdListInOrder != 0 && nColumn == int32((*TTable)(unsafe.Pointer(pTab)).FnCol) {
				regData = regFromSelect
				regRowid = regData - int32(1)
				if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) {
					v1 = int32(1)
				} else {
					v1 = 0
				}
				regIns = regRowid - v1
			}
		} else {
			v5 = pParse + 48
			*(*int32)(unsafe.Pointer(v5)) = *(*int32)(unsafe.Pointer(v5)) + 1
			v1 = *(*int32)(unsafe.Pointer(v5)) /* Top of the co-routine */
			regYield = v1
			addrTop = _sqlite3VdbeCurrentAddr(tls, v) + int32(1)
			_sqlite3VdbeAddOp3(tls, v, int32(OP_InitCoroutine), regYield, 0, addrTop)
			_sqlite3SelectDestInit(tls, bp+8, int32(SRT_Coroutine), regYield)
			if bIdListInOrder != 0 {
				v1 = regData
			} else {
				v1 = 0
			}
			(**(**TSelectDest)(__ccgo_up(bp + 8))).FiSdst = v1
			(**(**TSelectDest)(__ccgo_up(bp + 8))).FnSdst = int32((*TTable)(unsafe.Pointer(pTab)).FnCol)
			rc = _sqlite3Select(tls, pParse, pSelect, bp+8)
			regFromSelect = (**(**TSelectDest)(__ccgo_up(bp + 8))).FiSdst
			if rc != 0 || (*TParse)(unsafe.Pointer(pParse)).FnErr != 0 {
				goto insert_cleanup
			}
			_sqlite3VdbeEndCoroutine(tls, v, regYield)
			_sqlite3VdbeJumpHere(tls, v, addrTop-int32(1)) /* label B: */
			nColumn = (*TExprList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(pSelect)).FpEList)).FnExpr
		}
		/* Set useTempTable to TRUE if the result of the SELECT statement
		 ** should be written into a temporary table (template 4).  Set to
		 ** FALSE if each output row of the SELECT can be written directly into
		 ** the destination table (template 3).
		 **
		 ** A temp table must be used if the table being updated is also one
		 ** of the tables being read by the SELECT statement.  Also use a
		 ** temp table in the case of row triggers.
		 */
		if pTrigger != 0 || _readsTable(tls, pParse, iDb, pTab) != 0 {
			useTempTable = uint8(1)
		}
		if useTempTable != 0 { /* Label "L" */
			v5 = pParse + 44
			v1 = *(*int32)(unsafe.Pointer(v5))
			*(*int32)(unsafe.Pointer(v5)) = *(*int32)(unsafe.Pointer(v5)) + 1
			srcTab = v1
			regRec = _sqlite3GetTempReg(tls, pParse)
			regTempRowid = _sqlite3GetTempReg(tls, pParse)
			_sqlite3VdbeAddOp2(tls, v, int32(OP_OpenEphemeral), srcTab, nColumn)
			addrL = _sqlite3VdbeAddOp1(tls, v, int32(OP_Yield), (**(**TSelectDest)(__ccgo_up(bp + 8))).FiSDParm)
			_sqlite3VdbeAddOp3(tls, v, int32(OP_MakeRecord), regFromSelect, nColumn, regRec)
			_sqlite3VdbeAddOp2(tls, v, int32(OP_NewRowid), srcTab, regTempRowid)
			_sqlite3VdbeAddOp3(tls, v, int32(OP_Insert), srcTab, regRec, regTempRowid)
			_sqlite3VdbeGoto(tls, v, addrL)
			_sqlite3VdbeJumpHere(tls, v, addrL)
			_sqlite3ReleaseTempReg(tls, pParse, regRec)
			_sqlite3ReleaseTempReg(tls, pParse, regTempRowid)
		}
	} else {
		libc.Xmemset(tls, bp+40, 0, uint32(36))
		(**(**TNameContext)(__ccgo_up(bp + 40))).FpParse = pParse
		srcTab = -int32(1)
		if pList != 0 {
			nColumn = (*TExprList)(unsafe.Pointer(pList)).FnExpr
			if _sqlite3ResolveExprListNames(tls, bp+40, pList) != 0 {
				goto insert_cleanup
			}
		} else {
			nColumn = 0
		}
	}
	/* If there is no IDLIST term but the table has an integer primary
	 ** key, the set the ipkColumn variable to the integer primary key
	 ** column index in the original table definition.
	 */
	if pColumn == uintptr(0) && nColumn > 0 {
		ipkColumn = int32((*TTable)(unsafe.Pointer(pTab)).FiPKey)
		if ipkColumn >= 0 && (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_HasGenerated) != uint32(0) {
			i = ipkColumn - int32(1)
			for {
				if !(i >= 0) {
					break
				}
				if libc.Int32FromUint16((**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(i)*12))).FcolFlags)&int32(COLFLAG_GENERATED) != 0 {
					ipkColumn = ipkColumn - 1
				}
				goto _9
			_9:
				;
				i = i - 1
			}
		}
		/* Make sure the number of columns in the source data matches the number
		 ** of columns to be inserted into the table.
		 */
		if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&libc.Uint32FromInt32(libc.Int32FromInt32(TF_HasGenerated)|libc.Int32FromInt32(TF_HasHidden)) != uint32(0) {
			i = 0
			for {
				if !(i < int32((*TTable)(unsafe.Pointer(pTab)).FnCol)) {
					break
				}
				if libc.Int32FromUint16((**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(i)*12))).FcolFlags)&int32(COLFLAG_NOINSERT) != 0 {
					nHidden = nHidden + 1
				}
				goto _10
			_10:
				;
				i = i + 1
			}
		}
		if nColumn != int32((*TTable)(unsafe.Pointer(pTab)).FnCol)-nHidden {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+17428, libc.VaList(bp+88, pTabList+8, int32((*TTable)(unsafe.Pointer(pTab)).FnCol)-nHidden, nColumn))
			goto insert_cleanup
		}
	}
	if pColumn != uintptr(0) && nColumn != (*TIdList)(unsafe.Pointer(pColumn)).FnId {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+17480, libc.VaList(bp+88, nColumn, (*TIdList)(unsafe.Pointer(pColumn)).FnId))
		goto insert_cleanup
	}
	/* Initialize the count of rows to be inserted
	 */
	if (*Tsqlite3)(unsafe.Pointer(db)).Fflags&(libc.Uint64FromInt32(libc.Int32FromInt32(0x00001))<<libc.Int32FromInt32(32)) != uint64(0) && !((*TParse)(unsafe.Pointer(pParse)).Fnested != 0) && !((*TParse)(unsafe.Pointer(pParse)).FpTriggerTab != 0) && !(int32(Tbft(*(*uint16)(unsafe.Pointer(pParse + 28))&0x8>>3)) != 0) {
		v5 = pParse + 48
		*(*int32)(unsafe.Pointer(v5)) = *(*int32)(unsafe.Pointer(v5)) + 1
		v1 = *(*int32)(unsafe.Pointer(v5))
		regRowCount = v1
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), 0, regRowCount)
	}
	/* If this is not a view, open the table and and all indices */
	if !(isView != 0) {
		nIdx = _sqlite3OpenTableAndIndices(tls, pParse, pTab, int32(OP_OpenWrite), uint8(0), -int32(1), uintptr(0), bp, bp+4)
		aRegIdx = _sqlite3DbMallocRawNN(tls, db, uint64(uint32(4)*libc.Uint32FromInt32(nIdx+libc.Int32FromInt32(2))))
		if aRegIdx == uintptr(0) {
			goto insert_cleanup
		}
		i = 0
		pIdx = (*TTable)(unsafe.Pointer(pTab)).FpIndex
		for {
			if !(i < nIdx) {
				break
			}
			v5 = pParse + 48
			*(*int32)(unsafe.Pointer(v5)) = *(*int32)(unsafe.Pointer(v5)) + 1
			v1 = *(*int32)(unsafe.Pointer(v5))
			**(**int32)(__ccgo_up(aRegIdx + uintptr(i)*4)) = v1
			**(**int32)(__ccgo_up(pParse + 48)) += libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pIdx)).FnColumn)
			goto _13
		_13:
			;
			pIdx = (*TIndex)(unsafe.Pointer(pIdx)).FpNext
			i = i + 1
		}
		v5 = pParse + 48
		*(*int32)(unsafe.Pointer(v5)) = *(*int32)(unsafe.Pointer(v5)) + 1
		v1 = *(*int32)(unsafe.Pointer(v5))
		**(**int32)(__ccgo_up(aRegIdx + uintptr(i)*4)) = v1 /* Register to store the table record */
	}
	if pUpsert != 0 {
		if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+17505, libc.VaList(bp+88, (*TTable)(unsafe.Pointer(pTab)).FzName))
			goto insert_cleanup
		}
		if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VIEW) {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+17551, 0)
			goto insert_cleanup
		}
		if _sqlite3HasExplicitNulls(tls, pParse, (*TUpsert)(unsafe.Pointer(pUpsert)).FpUpsertTarget) != 0 {
			goto insert_cleanup
		}
		(*(*TSrcItem)(unsafe.Pointer(pTabList + 8))).FiCursor = **(**int32)(__ccgo_up(bp))
		pNx = pUpsert
		for cond := true; cond; cond = pNx != uintptr(0) {
			(*TUpsert)(unsafe.Pointer(pNx)).FpUpsertSrc = pTabList
			(*TUpsert)(unsafe.Pointer(pNx)).FregData = regData
			(*TUpsert)(unsafe.Pointer(pNx)).FiDataCur = **(**int32)(__ccgo_up(bp))
			(*TUpsert)(unsafe.Pointer(pNx)).FiIdxCur = **(**int32)(__ccgo_up(bp + 4))
			if (*TUpsert)(unsafe.Pointer(pNx)).FpUpsertTarget != 0 {
				if _sqlite3UpsertAnalyzeTarget(tls, pParse, pTabList, pNx, pUpsert) != 0 {
					goto insert_cleanup
				}
			}
			pNx = (*TUpsert)(unsafe.Pointer(pNx)).FpNextUpsert
		}
	}
	/* This is the top of the main insertion loop */
	if useTempTable != 0 {
		/* This block codes the top of loop only.  The complete loop is the
		 ** following pseudocode (template 4):
		 **
		 **         rewind temp table, if empty goto D
		 **      C: loop over rows of intermediate table
		 **           transfer values form intermediate table into <table>
		 **         end loop
		 **      D: ...
		 */
		addrInsTop = _sqlite3VdbeAddOp1(tls, v, int32(OP_Rewind), srcTab)
		addrCont = _sqlite3VdbeCurrentAddr(tls, v)
	} else {
		if pSelect != 0 {
			/* This block codes the top of loop only.  The complete loop is the
			 ** following pseudocode (template 3):
			 **
			 **      C: yield X, at EOF goto D
			 **         insert the select result into <table> from R..R+n
			 **         goto C
			 **      D: ...
			 */
			v1 = _sqlite3VdbeAddOp1(tls, v, int32(OP_Yield), (**(**TSelectDest)(__ccgo_up(bp + 8))).FiSDParm)
			addrCont = v1
			addrInsTop = v1
			if ipkColumn >= 0 {
				/* tag-20191021-001: If the INTEGER PRIMARY KEY is being generated by the
				 ** SELECT, go ahead and copy the value into the rowid slot now, so that
				 ** the value does not get overwritten by a NULL at tag-20191021-002. */
				_sqlite3VdbeAddOp2(tls, v, int32(OP_Copy), regFromSelect+ipkColumn, regRowid)
			}
		}
	}
	/* Compute data for ordinary columns of the new entry.  Values
	 ** are written in storage order into registers starting with regData.
	 ** Only ordinary columns are computed in this loop. The rowid
	 ** (if there is one) is computed later and generated columns are
	 ** computed after the rowid since they might depend on the value
	 ** of the rowid.
	 */
	nHidden = 0
	iRegStore = regData
	i = 0
	for {
		if !(i < int32((*TTable)(unsafe.Pointer(pTab)).FnCol)) {
			break
		}
		if i == int32((*TTable)(unsafe.Pointer(pTab)).FiPKey) {
			/* tag-20191021-002: References to the INTEGER PRIMARY KEY are filled
			 ** using the rowid. So put a NULL in the IPK slot of the record to avoid
			 ** using excess space.  The file format definition requires this extra
			 ** NULL - we cannot optimize further by skipping the column completely */
			_sqlite3VdbeAddOp1(tls, v, int32(OP_SoftNull), iRegStore)
			goto _19
		}
		v20 = uint32((**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(i)*12))).FcolFlags)
		colFlags = v20
		if v20&uint32(COLFLAG_NOINSERT) != uint32(0) {
			nHidden = nHidden + 1
			if colFlags&uint32(COLFLAG_VIRTUAL) != uint32(0) {
				/* Virtual columns do not participate in OP_MakeRecord.  So back up
				 ** iRegStore by one slot to compensate for the iRegStore++ in the
				 ** outer for() loop */
				iRegStore = iRegStore - 1
				goto _19
			} else {
				if colFlags&uint32(COLFLAG_STORED) != uint32(0) {
					/* Stored columns are computed later.  But if there are BEFORE
					 ** triggers, the slots used for stored columns will be OP_Copy-ed
					 ** to a second block of registers, so the register needs to be
					 ** initialized to NULL to avoid an uninitialized register read */
					if **(**int32)(__ccgo_up(bp + 36))&int32(TRIGGER_BEFORE) != 0 {
						_sqlite3VdbeAddOp1(tls, v, int32(OP_SoftNull), iRegStore)
					}
					goto _19
				} else {
					if pColumn == uintptr(0) {
						/* Hidden columns that are not explicitly named in the INSERT
						 ** get their default value */
						_sqlite3ExprCodeFactorable(tls, pParse, _sqlite3ColumnExpr(tls, pTab, (*TTable)(unsafe.Pointer(pTab)).FaCol+uintptr(i)*12), iRegStore)
						goto _19
					}
				}
			}
		}
		if pColumn != 0 {
			j = **(**int32)(__ccgo_up(aTabColMap + uintptr(i)*4))
			if j == 0 {
				/* A column not named in the insert column list gets its
				 ** default value */
				_sqlite3ExprCodeFactorable(tls, pParse, _sqlite3ColumnExpr(tls, pTab, (*TTable)(unsafe.Pointer(pTab)).FaCol+uintptr(i)*12), iRegStore)
				goto _19
			}
			k = j - int32(1)
		} else {
			if nColumn == 0 {
				/* This is INSERT INTO ... DEFAULT VALUES.  Load the default value. */
				_sqlite3ExprCodeFactorable(tls, pParse, _sqlite3ColumnExpr(tls, pTab, (*TTable)(unsafe.Pointer(pTab)).FaCol+uintptr(i)*12), iRegStore)
				goto _19
			} else {
				k = i - nHidden
			}
		}
		if useTempTable != 0 {
			_sqlite3VdbeAddOp3(tls, v, int32(OP_Column), srcTab, k, iRegStore)
		} else {
			if pSelect != 0 {
				if regFromSelect != regData {
					_sqlite3VdbeAddOp2(tls, v, int32(OP_SCopy), regFromSelect+k, iRegStore)
				}
			} else {
				pX = (*(*TExprList_item)(unsafe.Pointer(pList + 8 + uintptr(k)*20))).FpExpr
				y = _sqlite3ExprCodeTarget(tls, pParse, pX, iRegStore)
				if y != iRegStore {
					if (*TExpr)(unsafe.Pointer(pX)).Fflags&libc.Uint32FromInt32(libc.Int32FromInt32(EP_Subquery)) != uint32(0) {
						v1 = int32(OP_Copy)
					} else {
						v1 = int32(OP_SCopy)
					}
					_sqlite3VdbeAddOp2(tls, v, v1, y, iRegStore)
				}
			}
		}
		goto _19
	_19:
		;
		i = i + 1
		iRegStore = iRegStore + 1
	}
	/* Run the BEFORE and INSTEAD OF triggers, if there are any
	 */
	endOfLoop = _sqlite3VdbeMakeLabel(tls, pParse)
	if **(**int32)(__ccgo_up(bp + 36))&int32(TRIGGER_BEFORE) != 0 {
		regCols = _sqlite3GetTempRange(tls, pParse, int32((*TTable)(unsafe.Pointer(pTab)).FnCol)+int32(1))
		/* build the NEW.* reference row.  Note that if there is an INTEGER
		 ** PRIMARY KEY into which a NULL is being inserted, that NULL will be
		 ** translated into a unique ID for the row.  But on a BEFORE trigger,
		 ** we do not know what the unique ID will be (because the insert has
		 ** not happened yet) so we substitute a rowid of -1
		 */
		if ipkColumn < 0 {
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), -int32(1), regCols)
		} else {
			if useTempTable != 0 {
				_sqlite3VdbeAddOp3(tls, v, int32(OP_Column), srcTab, ipkColumn, regCols)
			} else {
				/* Otherwise useTempTable is true */
				_sqlite3ExprCode(tls, pParse, (*(*TExprList_item)(unsafe.Pointer(pList + 8 + uintptr(ipkColumn)*20))).FpExpr, regCols)
			}
			addr1 = _sqlite3VdbeAddOp1(tls, v, int32(OP_NotNull), regCols)
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), -int32(1), regCols)
			_sqlite3VdbeJumpHere(tls, v, addr1)
			_sqlite3VdbeAddOp1(tls, v, int32(OP_MustBeInt), regCols)
		}
		/* Copy the new data already generated. */
		_sqlite3VdbeAddOp3(tls, v, int32(OP_Copy), regRowid+int32(1), regCols+int32(1), int32((*TTable)(unsafe.Pointer(pTab)).FnNVCol)-int32(1))
		/* Compute the new value for generated columns after all other
		 ** columns have already been computed.  This must be done after
		 ** computing the ROWID in case one of the generated columns
		 ** refers to the ROWID. */
		if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_HasGenerated) != 0 {
			_sqlite3ComputeGeneratedColumns(tls, pParse, regCols+int32(1), pTab)
		}
		/* If this is an INSERT on a view with an INSTEAD OF INSERT trigger,
		 ** do not attempt any conversions before assembling the record.
		 ** If this is a real table, attempt conversions as required by the
		 ** table column affinities.
		 */
		if !(isView != 0) {
			_sqlite3TableAffinity(tls, v, pTab, regCols+int32(1))
		}
		/* Fire BEFORE or INSTEAD OF triggers */
		_sqlite3CodeRowTrigger(tls, pParse, pTrigger, int32(TK_INSERT), uintptr(0), int32(TRIGGER_BEFORE), pTab, regCols-int32((*TTable)(unsafe.Pointer(pTab)).FnCol)-int32(1), onError, endOfLoop)
		_sqlite3ReleaseTempRange(tls, pParse, regCols, int32((*TTable)(unsafe.Pointer(pTab)).FnCol)+int32(1))
	}
	if !(isView != 0) {
		if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) {
			/* The row that the VUpdate opcode will delete: none */
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Null), 0, regIns)
		}
		if ipkColumn >= 0 {
			/* Compute the new rowid */
			if useTempTable != 0 {
				_sqlite3VdbeAddOp3(tls, v, int32(OP_Column), srcTab, ipkColumn, regRowid)
			} else {
				if pSelect != 0 {
					/* Rowid already initialized at tag-20191021-001 */
				} else {
					pIpk = (*(*TExprList_item)(unsafe.Pointer(pList + 8 + uintptr(ipkColumn)*20))).FpExpr
					if libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pIpk)).Fop) == int32(TK_NULL) && !(libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == libc.Int32FromInt32(TABTYP_VTAB)) {
						_sqlite3VdbeAddOp3(tls, v, int32(OP_NewRowid), **(**int32)(__ccgo_up(bp)), regRowid, regAutoinc)
						appendFlag = uint8(1)
					} else {
						_sqlite3ExprCode(tls, pParse, (*(*TExprList_item)(unsafe.Pointer(pList + 8 + uintptr(ipkColumn)*20))).FpExpr, regRowid)
					}
				}
			}
			/* If the PRIMARY KEY expression is NULL, then use OP_NewRowid
			 ** to generate a unique primary key value.
			 */
			if !(appendFlag != 0) {
				if !(libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == libc.Int32FromInt32(TABTYP_VTAB)) {
					addr11 = _sqlite3VdbeAddOp1(tls, v, int32(OP_NotNull), regRowid)
					_sqlite3VdbeAddOp3(tls, v, int32(OP_NewRowid), **(**int32)(__ccgo_up(bp)), regRowid, regAutoinc)
					_sqlite3VdbeJumpHere(tls, v, addr11)
				} else {
					addr11 = _sqlite3VdbeCurrentAddr(tls, v)
					_sqlite3VdbeAddOp2(tls, v, int32(OP_IsNull), regRowid, addr11+int32(2))
				}
				_sqlite3VdbeAddOp1(tls, v, int32(OP_MustBeInt), regRowid)
			}
		} else {
			if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) || withoutRowid != 0 {
				_sqlite3VdbeAddOp2(tls, v, int32(OP_Null), 0, regRowid)
			} else {
				_sqlite3VdbeAddOp3(tls, v, int32(OP_NewRowid), **(**int32)(__ccgo_up(bp)), regRowid, regAutoinc)
				appendFlag = uint8(1)
			}
		}
		_autoIncStep(tls, pParse, regAutoinc, regRowid)
		/* Compute the new value for generated columns after all other
		 ** columns have already been computed.  This must be done after
		 ** computing the ROWID in case one of the generated columns
		 ** is derived from the INTEGER PRIMARY KEY. */
		if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_HasGenerated) != 0 {
			_sqlite3ComputeGeneratedColumns(tls, pParse, regRowid+int32(1), pTab)
		}
		/* Generate code to check constraints and generate index keys and
		 ** do the insertion.
		 */
		if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) {
			pVTab = _sqlite3GetVTable(tls, db, pTab)
			_sqlite3VtabMakeWritable(tls, pParse, pTab)
			_sqlite3VdbeAddOp4(tls, v, int32(OP_VUpdate), int32(1), int32((*TTable)(unsafe.Pointer(pTab)).FnCol)+int32(2), regIns, pVTab, -int32(12))
			if onError == int32(OE_Default) {
				v1 = int32(OE_Abort)
			} else {
				v1 = onError
			}
			_sqlite3VdbeChangeP5(tls, v, libc.Uint16FromInt32(v1))
			_sqlite3MayAbort(tls, pParse)
		} else {
			**(**int32)(__ccgo_up(bp + 76)) = 0 /* True to use OPFLAG_SEEKRESULT */
			_sqlite3GenerateConstraintChecks(tls, pParse, pTab, aRegIdx, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), regIns, 0, libc.BoolUint8(ipkColumn >= 0), libc.Uint8FromInt32(onError), endOfLoop, bp+76, uintptr(0), pUpsert)
			if (*Tsqlite3)(unsafe.Pointer(db)).Fflags&uint64(SQLITE_ForeignKeys) != 0 {
				_sqlite3FkCheck(tls, pParse, pTab, 0, regIns, uintptr(0), 0)
			}
			/* Set the OPFLAG_USESEEKRESULT flag if either (a) there are no REPLACE
			 ** constraints or (b) there are no triggers and this table is not a
			 ** parent table in a foreign key constraint. It is safe to set the
			 ** flag in the second case as if any REPLACE constraint is hit, an
			 ** OP_Delete or OP_IdxDelete instruction will be executed on each
			 ** cursor that is disturbed. And these instructions both clear the
			 ** VdbeCursor.seekResult variable, disabling the OPFLAG_USESEEKRESULT
			 ** functionality.  */
			bUseSeek = libc.BoolInt32(**(**int32)(__ccgo_up(bp + 76)) == 0 || !(_sqlite3VdbeHasSubProgram(tls, v) != 0))
			_sqlite3CompleteInsertion(tls, pParse, pTab, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), regIns, aRegIdx, 0, libc.Int32FromUint8(appendFlag), bUseSeek)
		}
	}
	/* Update the count of rows that are inserted
	 */
	if regRowCount != 0 {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_AddImm), regRowCount, int32(1))
	}
	if pTrigger != 0 {
		/* Code AFTER triggers */
		_sqlite3CodeRowTrigger(tls, pParse, pTrigger, int32(TK_INSERT), uintptr(0), int32(TRIGGER_AFTER), pTab, regData-int32(2)-int32((*TTable)(unsafe.Pointer(pTab)).FnCol), onError, endOfLoop)
	}
	/* The bottom of the main insertion loop, if the data source
	 ** is a SELECT statement.
	 */
	_sqlite3VdbeResolveLabel(tls, v, endOfLoop)
	if useTempTable != 0 {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Next), srcTab, addrCont)
		_sqlite3VdbeJumpHere(tls, v, addrInsTop)
		_sqlite3VdbeAddOp1(tls, v, int32(OP_Close), srcTab)
	} else {
		if pSelect != 0 {
			_sqlite3VdbeGoto(tls, v, addrCont)
			_sqlite3VdbeJumpHere(tls, v, addrInsTop)
		}
	}
	goto insert_end
insert_end:
	;
	/* Update the sqlite_sequence table by storing the content of the
	 ** maximum rowid counter values recorded while inserting into
	 ** autoincrement tables.
	 */
	if libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).Fnested) == 0 && (*TParse)(unsafe.Pointer(pParse)).FpTriggerTab == uintptr(0) {
		_sqlite3AutoincrementEnd(tls, pParse)
	}
	/*
	 ** Return the number of rows inserted. If this routine is
	 ** generating code because of a call to sqlite3NestedParse(), do not
	 ** invoke the callback function.
	 */
	if regRowCount != 0 {
		_sqlite3CodeChangeCount(tls, v, regRowCount, __ccgo_ts+17572)
	}
	goto insert_cleanup
insert_cleanup:
	;
	_sqlite3SrcListDelete(tls, db, pTabList)
	_sqlite3ExprListDelete(tls, db, pList)
	_sqlite3UpsertDelete(tls, db, pUpsert)
	_sqlite3SelectDelete(tls, db, pSelect)
	if pColumn != 0 {
		_sqlite3IdListDelete(tls, db, pColumn)
		_sqlite3DbFree(tls, db, aTabColMap)
	}
	if aRegIdx != 0 {
		_sqlite3DbNNFreeNN(tls, db, aRegIdx)
	}
}

/* Make sure "isView" and other macros defined above are undefined. Otherwise
** they may interfere with compilation of other functions in this file
** (or in another file, if this file becomes part of the amalgamation).  */

/*
** Meanings of bits in of pWalker->eCode for
** sqlite3ExprReferencesUpdatedColumn()
 */

// C documentation
//
//	/*
//	** Given 1 to 3 identifiers preceding the JOIN keyword, determine the
//	** type of join.  Return an integer constant that expresses that type
//	** in terms of the following bit values:
//	**
//	**     JT_INNER
//	**     JT_CROSS
//	**     JT_OUTER
//	**     JT_NATURAL
//	**     JT_LEFT
//	**     JT_RIGHT
//	**
//	** A full outer join is the combination of JT_LEFT and JT_RIGHT.
//	**
//	** If an illegal or unsupported join type is seen, then still return
//	** a join type, but put an error in the pParse structure.
//	**
//	** These are the valid join types:
//	**
//	**
//	**      pA       pB       pC               Return Value
//	**     -------  -----    -----             ------------
//	**     CROSS      -        -                 JT_CROSS
//	**     INNER      -        -                 JT_INNER
//	**     LEFT       -        -                 JT_LEFT|JT_OUTER
//	**     LEFT     OUTER      -                 JT_LEFT|JT_OUTER
//	**     RIGHT      -        -                 JT_RIGHT|JT_OUTER
//	**     RIGHT    OUTER      -                 JT_RIGHT|JT_OUTER
//	**     FULL       -        -                 JT_LEFT|JT_RIGHT|JT_OUTER
//	**     FULL     OUTER      -                 JT_LEFT|JT_RIGHT|JT_OUTER
//	**     NATURAL  INNER      -                 JT_NATURAL|JT_INNER
//	**     NATURAL  LEFT       -                 JT_NATURAL|JT_LEFT|JT_OUTER
//	**     NATURAL  LEFT     OUTER               JT_NATURAL|JT_LEFT|JT_OUTER
//	**     NATURAL  RIGHT      -                 JT_NATURAL|JT_RIGHT|JT_OUTER
//	**     NATURAL  RIGHT    OUTER               JT_NATURAL|JT_RIGHT|JT_OUTER
//	**     NATURAL  FULL       -                 JT_NATURAL|JT_LEFT|JT_RIGHT
//	**     NATURAL  FULL     OUTER               JT_NATRUAL|JT_LEFT|JT_RIGHT
//	**
//	** To preserve historical compatibly, SQLite also accepts a variety
//	** of other non-standard and in many cases nonsensical join types.
//	** This routine makes as much sense at it can from the nonsense join
//	** type and returns a result.  Examples of accepted nonsense join types
//	** include but are not limited to:
//	**
//	**          INNER CROSS JOIN        ->   same as JOIN
//	**          NATURAL CROSS JOIN      ->   same as NATURAL JOIN
//	**          OUTER LEFT JOIN         ->   same as LEFT JOIN
//	**          LEFT NATURAL JOIN       ->   same as NATURAL LEFT JOIN
//	**          LEFT RIGHT JOIN         ->   same as FULL JOIN
//	**          RIGHT OUTER FULL JOIN   ->   same as FULL JOIN
//	**          CROSS CROSS CROSS JOIN  ->   same as JOIN
//	**
//	** The only restrictions on the join type name are:
//	**
//	**    *   "INNER" cannot appear together with "OUTER", "LEFT", "RIGHT",
//	**        or "FULL".
//	**
//	**    *   "CROSS" cannot appear together with "OUTER", "LEFT", "RIGHT,
//	**        or "FULL".
//	**
//	**    *   If "OUTER" is present then there must also be one of
//	**        "LEFT", "RIGHT", or "FULL"
//	*/
func _sqlite3JoinType(tls *libc.TLS, pParse uintptr, pA uintptr, pB uintptr, pC uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var apAll [3]uintptr
	var i, j, jointype int32
	var p, zSp1, zSp2 uintptr
	_, _, _, _, _, _, _ = apAll, i, j, jointype, p, zSp1, zSp2
	jointype = 0
	apAll[0] = pA
	apAll[int32(1)] = pB
	apAll[int32(2)] = pC
	i = 0
	for {
		if !(i < int32(3) && apAll[i] != 0) {
			break
		}
		p = apAll[i]
		j = 0
		for {
			if !(j < libc.Int32FromUint32(libc.Uint32FromInt64(21)/libc.Uint32FromInt64(3))) {
				break
			}
			if (*TToken)(unsafe.Pointer(p)).Fn == uint32(_aKeyword[j].FnChar) && Xsqlite3_strnicmp(tls, (*TToken)(unsafe.Pointer(p)).Fz, uintptr(unsafe.Pointer(&_zKeyText))+uintptr(_aKeyword[j].Fi), libc.Int32FromUint32((*TToken)(unsafe.Pointer(p)).Fn)) == 0 {
				jointype = jointype | libc.Int32FromUint8(_aKeyword[j].Fcode)
				break
			}
			goto _2
		_2:
			;
			j = j + 1
		}
		if j >= libc.Int32FromUint32(libc.Uint32FromInt64(21)/libc.Uint32FromInt64(3)) {
			jointype = jointype | int32(JT_ERROR)
			break
		}
		goto _1
	_1:
		;
		i = i + 1
	}
	if jointype&(libc.Int32FromInt32(JT_INNER)|libc.Int32FromInt32(JT_OUTER)) == libc.Int32FromInt32(JT_INNER)|libc.Int32FromInt32(JT_OUTER) || jointype&int32(JT_ERROR) != 0 || jointype&(libc.Int32FromInt32(JT_OUTER)|libc.Int32FromInt32(JT_LEFT)|libc.Int32FromInt32(JT_RIGHT)) == int32(JT_OUTER) {
		zSp1 = __ccgo_ts + 11543
		zSp2 = __ccgo_ts + 11543
		if pB == uintptr(0) {
			zSp1 = zSp1 + 1
		}
		if pC == uintptr(0) {
			zSp2 = zSp2 + 1
		}
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+20286, libc.VaList(bp+8, pA, zSp1, pB, zSp2, pC))
		jointype = int32(JT_INNER)
	}
	return jointype
}

// C documentation
//
//	/*
//	** Like malloc(), but remember the size of the allocation
//	** so that we can find it later using sqlite3MemSize().
//	**
//	** For this low-level routine, we are guaranteed that nByte>0 because
//	** cases of nByte<=0 will be intercepted and dealt with by higher level
//	** routines.
//	*/
func _sqlite3MemMalloc(tls *libc.TLS, nByte int32) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var p uintptr
	_ = p
	p = libc.Xmalloc(tls, libc.Uint32FromInt32(nByte+int32(8)))
	if p != 0 {
		**(**Tsqlite3_int64)(__ccgo_up(p)) = int64(nByte)
		p += 8
	} else {
		Xsqlite3_log(tls, int32(SQLITE_NOMEM), __ccgo_ts+1598, libc.VaList(bp+8, nByte))
	}
	return p
}

// C documentation
//
//	/*
//	** Like realloc().  Resize an allocation previously obtained from
//	** sqlite3MemMalloc().
//	**
//	** For this low-level interface, we know that pPrior!=0.  Cases where
//	** pPrior==0 while have been intercepted by higher-level routine and
//	** redirected to xMalloc.  Similarly, we know that nByte>0 because
//	** cases where nByte<=0 will have been intercepted by higher-level
//	** routines and redirected to xFree.
//	*/
func _sqlite3MemRealloc(tls *libc.TLS, pPrior uintptr, nByte int32) (r uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var p uintptr
	_ = p
	p = pPrior
	/* EV: R-46199-30249 */
	p -= 8
	p = libc.Xrealloc(tls, p, libc.Uint32FromInt32(nByte+libc.Int32FromInt32(8)))
	if p != 0 {
		**(**Tsqlite3_int64)(__ccgo_up(p)) = int64(nByte)
		p += 8
	} else {
		Xsqlite3_log(tls, int32(SQLITE_NOMEM), __ccgo_ts+1636, libc.VaList(bp+8, _sqlite3MemSize(tls, pPrior), nByte))
	}
	return p
}

// C documentation
//
//	/*
//	** Cause a function to throw an error if it was call from OP_PureFunc
//	** rather than OP_Function.
//	**
//	** OP_PureFunc means that the function must be deterministic, and should
//	** throw an error if it is given inputs that would make it non-deterministic.
//	** This routine is invoked by date/time functions that use non-deterministic
//	** features such as 'now'.
//	*/
func _sqlite3NotPureFunc(tls *libc.TLS, pCtx uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var pOp, zContext, zMsg uintptr
	_, _, _ = pOp, zContext, zMsg
	if (*Tsqlite3_context)(unsafe.Pointer(pCtx)).FpVdbe == uintptr(0) {
		return int32(1)
	}
	pOp = (*TVdbe)(unsafe.Pointer((*Tsqlite3_context)(unsafe.Pointer(pCtx)).FpVdbe)).FaOp + uintptr((*Tsqlite3_context)(unsafe.Pointer(pCtx)).FiOp)*20
	if libc.Int32FromUint8((*TVdbeOp)(unsafe.Pointer(pOp)).Fopcode) == int32(OP_PureFunc) {
		if libc.Int32FromUint16((*TVdbeOp)(unsafe.Pointer(pOp)).Fp5)&int32(NC_IsCheck) != 0 {
			zContext = __ccgo_ts + 5424
		} else {
			if libc.Int32FromUint16((*TVdbeOp)(unsafe.Pointer(pOp)).Fp5)&int32(NC_GenCol) != 0 {
				zContext = __ccgo_ts + 5443
			} else {
				zContext = __ccgo_ts + 5462
			}
		}
		zMsg = Xsqlite3_mprintf(tls, __ccgo_ts+5471, libc.VaList(bp+8, (*TFuncDef)(unsafe.Pointer((*Tsqlite3_context)(unsafe.Pointer(pCtx)).FpFunc)).FzName, zContext))
		Xsqlite3_result_error(tls, pCtx, zMsg, -int32(1))
		Xsqlite3_free(tls, zMsg)
		return 0
	}
	return int32(1)
}

// C documentation
//
//	/*
//	** Make sure the TEMP database is open and available for use.  Return
//	** the number of errors.  Leave any error messages in the pParse structure.
//	*/
func _sqlite3OpenTempDatabase(tls *libc.TLS, pParse uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var db uintptr
	var rc int32
	var _ /* pBt at bp+0 */ uintptr
	_, _ = db, rc
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	if (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + 1*16))).FpBt == uintptr(0) && !((*TParse)(unsafe.Pointer(pParse)).Fexplain != 0) {
		rc = _sqlite3BtreeOpen(tls, (*Tsqlite3)(unsafe.Pointer(db)).FpVfs, uintptr(0), db, bp, 0, _flags)
		if rc != SQLITE_OK {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+16135, 0)
			(*TParse)(unsafe.Pointer(pParse)).Frc = rc
			return int32(1)
		}
		(**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + 1*16))).FpBt = **(**uintptr)(__ccgo_up(bp))
		if int32(SQLITE_NOMEM) == _sqlite3BtreeSetPageSize(tls, **(**uintptr)(__ccgo_up(bp)), (*Tsqlite3)(unsafe.Pointer(db)).FnextPagesize, 0, 0) {
			_sqlite3OomFault(tls, db)
			return int32(1)
		}
	}
	return 0
}

// C documentation
//
//	/*
//	** Turn bulk memory into a valid Parse object and link that Parse object
//	** into database connection db.
//	**
//	** Call sqlite3ParseObjectReset() to undo this operation.
//	**
//	** Caution:  Do not confuse this routine with sqlite3ParseObjectInit() which
//	** is generated by Lemon.
//	*/
func _sqlite3ParseObjectInit(tls *libc.TLS, pParse uintptr, db uintptr) {
	libc.Xmemset(tls, pParse+uintptr(uint32(libc.UintptrFromInt32(0)+4)), 0, uint32(libc.UintptrFromInt32(0)+136)-uint32(libc.UintptrFromInt32(0)+4))
	libc.Xmemset(tls, pParse+uintptr(uint32(libc.UintptrFromInt32(0)+208)), 0, libc.Uint32FromInt64(284)-uint32(libc.UintptrFromInt32(0)+208))
	(*TParse)(unsafe.Pointer(pParse)).FpOuterParse = (*Tsqlite3)(unsafe.Pointer(db)).FpParse
	(*Tsqlite3)(unsafe.Pointer(db)).FpParse = pParse
	(*TParse)(unsafe.Pointer(pParse)).Fdb = db
	if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+1672, 0)
	}
}

/*
** Maximum number of times that we will try again to prepare a statement
** that returns SQLITE_ERROR_RETRY.
 */

// C documentation
//
//	/*
//	** Generate code for the REINDEX command.
//	**
//	**        REINDEX                            -- 1
//	**        REINDEX  <collation>               -- 2
//	**        REINDEX  ?<database>.?<indexname>  -- 3
//	**        REINDEX  ?<database>.?<tablename>  -- 4
//	**        REINDEX  EXPRESSIONS               -- 5
//	**
//	** Form 1 causes all indexes in all attached databases to be rebuilt.
//	** Form 2 rebuilds all indexes in all databases that use the named
//	** collating function.  Forms 3 and 4 rebuild the named index or all
//	** indexes associated with the named table, respectively.  Form 5
//	** rebuilds all expression indexes in addition to all collations,
//	** indexes, or tables named "EXPRESSIONS".
//	**
//	** If the name is ambiguous such that it matches two or more of
//	** forms 2 through 5, then rebuild the union of all matching indexes,
//	** taken care to avoid rebuilding the same index more than once.
//	*/
func _sqlite3Reindex(tls *libc.TLS, pParse uintptr, pName1 uintptr, pName2 uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var bAll, bMatch, iDb, iReDb, isExprIdx int32
	var db, k, pDb, pIdx, pReIndex, pReTab, pTab, z, zColl, zDb, v1 uintptr
	var v2 bool
	var _ /* pObjName at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bAll, bMatch, db, iDb, iReDb, isExprIdx, k, pDb, pIdx, pReIndex, pReTab, pTab, z, zColl, zDb, v1, v2
	z = uintptr(0)                             /* Name of a table or index or collation */
	zDb = uintptr(0)                           /* Name of the database */
	iReDb = -int32(1)                          /* The database index number */
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb /* Name of the table or index to be reindexed */
	bMatch = 0                                 /* At least one name match */
	zColl = uintptr(0)                         /* Rebuild indexes using this collation */
	pReTab = uintptr(0)                        /* Rebuild all indexes of this table */
	pReIndex = uintptr(0)                      /* Rebuild this index */
	isExprIdx = 0                              /* Rebuild all expression indexes */
	bAll = 0                                   /* Rebuild all indexes */
	/* Read the database schema. If an error occurs, leave an error message
	 ** and code in pParse and return NULL. */
	if SQLITE_OK != _sqlite3ReadSchema(tls, pParse) {
		return
	}
	if pName1 == uintptr(0) {
		/* rebuild all indexes */
		bMatch = int32(1)
		bAll = int32(1)
	} else {
		if pName2 == uintptr(0) || (*TToken)(unsafe.Pointer(pName2)).Fz == uintptr(0) {
			z = _sqlite3NameFromToken(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, pName1)
			if z == uintptr(0) {
				return
			}
		} else {
			iReDb = _sqlite3TwoPartName(tls, pParse, pName1, pName2, bp)
			if iReDb < 0 {
				return
			}
			z = _sqlite3NameFromToken(tls, db, **(**uintptr)(__ccgo_up(bp)))
			if z == uintptr(0) {
				return
			}
			zDb = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iReDb)*16))).FzDbSName
		}
	}
	if !(bAll != 0) {
		if zDb == uintptr(0) && _sqlite3StrICmp(tls, z, __ccgo_ts+16228) == 0 {
			isExprIdx = int32(1)
			bMatch = int32(1)
		}
		if zDb == uintptr(0) && _sqlite3FindCollSeq(tls, db, (*Tsqlite3)(unsafe.Pointer(db)).Fenc, z, 0) != uintptr(0) {
			zColl = z
			bMatch = int32(1)
		}
		if v2 = zColl == uintptr(0); v2 {
			v1 = _sqlite3FindTable(tls, db, z, zDb)
			pReTab = v1
		}
		if v2 && v1 != uintptr(0) {
			bMatch = int32(1)
		}
		if v2 = zColl == uintptr(0); v2 {
			v1 = _sqlite3FindIndex(tls, db, z, zDb)
			pReIndex = v1
		}
		if v2 && v1 != uintptr(0) {
			bMatch = int32(1)
		}
	}
	if bMatch != 0 {
		iDb = 0
		pDb = (*Tsqlite3)(unsafe.Pointer(db)).FaDb
		for {
			if !(iDb < (*Tsqlite3)(unsafe.Pointer(db)).FnDb) {
				break
			}
			if iReDb >= 0 && iReDb != iDb {
				goto _5
			}
			k = (*THash)(unsafe.Pointer((*TDb)(unsafe.Pointer(pDb)).FpSchema + 8)).Ffirst
			for {
				if !(k != 0) {
					break
				}
				pTab = (*THashElem)(unsafe.Pointer(k)).Fdata
				if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) {
					goto _6
				}
				pIdx = (*TTable)(unsafe.Pointer(pTab)).FpIndex
				for {
					if !(pIdx != 0) {
						break
					}
					if bAll != 0 || pTab == pReTab || pIdx == pReIndex || isExprIdx != 0 && int32(uint32(*(*uint16)(unsafe.Pointer(pIdx + 56))&0x800>>11)) != 0 || zColl != uintptr(0) && _collationMatch(tls, zColl, pIdx) != 0 {
						_sqlite3BeginWriteOperation(tls, pParse, 0, iDb)
						_sqlite3RefillIndex(tls, pParse, pIdx, -int32(1))
					}
					goto _7
				_7:
					;
					pIdx = (*TIndex)(unsafe.Pointer(pIdx)).FpNext
				} /* End loop over indexes of pTab */
				goto _6
			_6:
				;
				k = (*THashElem)(unsafe.Pointer(k)).Fnext
			} /* End loop over tables of iDb */
			goto _5
		_5:
			;
			iDb = iDb + 1
			pDb += 16
		} /* End loop over databases */
	} else {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+16240, 0)
	}
	_sqlite3DbFree(tls, db, z)
	return
}

// C documentation
//
//	/*
//	** Return a pointer to a buffer containing a usable rowid alias for table
//	** pTab. An alias is usable if there is not an explicit user-defined column
//	** of the same name.
//	*/
func _sqlite3RowidAlias(tls *libc.TLS, pTab uintptr) (r uintptr) {
	var azOpt [3]uintptr
	var ii int32
	_, _ = azOpt, ii
	azOpt = [3]uintptr{
		0: __ccgo_ts + 8191,
		1: __ccgo_ts + 8199,
		2: __ccgo_ts + 8205,
	}
	ii = 0
	for {
		if !(ii < libc.Int32FromUint32(libc.Uint32FromInt64(12)/libc.Uint32FromInt64(4))) {
			break
		}
		if _sqlite3ColumnIndex(tls, pTab, azOpt[ii]) < 0 {
			return azOpt[ii]
		}
		goto _1
	_1:
		;
		ii = ii + 1
	}
	return uintptr(0)
}

// C documentation
//
//	/*
//	** Code an OP_Halt due to non-unique rowid.
//	*/
func _sqlite3RowidConstraint(tls *libc.TLS, pParse uintptr, onError int32, pTab uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var rc int32
	var zMsg uintptr
	_, _ = rc, zMsg
	if int32((*TTable)(unsafe.Pointer(pTab)).FiPKey) >= 0 {
		zMsg = _sqlite3MPrintf(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, __ccgo_ts+13634, libc.VaList(bp+8, (*TTable)(unsafe.Pointer(pTab)).FzName, (**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr((*TTable)(unsafe.Pointer(pTab)).FiPKey)*12))).FzCnName))
		rc = libc.Int32FromInt32(SQLITE_CONSTRAINT) | libc.Int32FromInt32(6)<<libc.Int32FromInt32(8)
	} else {
		zMsg = _sqlite3MPrintf(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, __ccgo_ts+16219, libc.VaList(bp+8, (*TTable)(unsafe.Pointer(pTab)).FzName))
		rc = libc.Int32FromInt32(SQLITE_CONSTRAINT) | libc.Int32FromInt32(10)<<libc.Int32FromInt32(8)
	}
	_sqlite3HaltConstraint(tls, pParse, rc, onError, zMsg, int8(-libc.Int32FromInt32(7)), uint8(P5_ConstraintUnique))
}

// C documentation
//
//	/*
//	** Generate byte-code for the SELECT statement given in the p argument.
//	**
//	** The results are returned according to the SelectDest structure.
//	** See comments in sqliteInt.h for further information.
//	**
//	** This routine returns the number of errors.  If any errors are
//	** encountered, then an appropriate error message is left in
//	** pParse->zErrMsg.
//	**
//	** This routine does NOT free the Select structure passed in.  The
//	** calling function needs to do that.
//	**
//	** This is a long function.  The following is an outline of the processing
//	** steps, with tags referencing various milestones:
//	**
//	**  *  Resolve names and similar preparation                tag-select-0100
//	**  *  Scan of the FROM clause                              tag-select-0200
//	**      +  OUTER JOIN strength reduction                      tag-select-0220
//	**      +  Sub-query ORDER BY removal                         tag-select-0230
//	**      +  Query flattening                                   tag-select-0240
//	**  *  Separate subroutine for compound-SELECT              tag-select-0300
//	**  *  WHERE-clause constant propagation                    tag-select-0330
//	**  *  Count()-of-VIEW optimization                         tag-select-0350
//	**  *  Scan of the FROM clause again                        tag-select-0400
//	**      +  Authorize unreferenced tables                      tag-select-0410
//	**      +  Predicate push-down optimization                   tag-select-0420
//	**      +  Omit unused subquery columns optimization          tag-select-0440
//	**      +  Generate code to implement subqueries              tag-select-0480
//	**         -  Co-routines                                       tag-select-0482
//	**         -  Reuse previously computed CTE                     tag-select-0484
//	**         -  REuse previously computed VIEW                    tag-select-0486
//	**         -  Materialize a VIEW or CTE                         tag-select-0488
//	**  *  DISTINCT ORDER BY -> GROUP BY optimization           tag-select-0500
//	**  *  Set up for ORDER BY                                  tag-select-0600
//	**  *  Create output table                                  tag-select-0630
//	**  *  Prepare registers for LIMIT                          tag-select-0650
//	**  *  Setup for DISTINCT                                   tag-select-0680
//	**  *  Generate code for non-aggregate and non-GROUP BY     tag-select-0700
//	**  *  Generate code for aggregate and/or GROUP BY          tag-select-0800
//	**      +  GROUP BY queries                                   tag-select-0810
//	**      +  non-GROUP BY queries                               tag-select-0820
//	**         -  Special case of count() w/o GROUP BY              tag-select-0821
//	**         -  General case of non-GROUP BY aggregates           tag-select-0822
//	**  *  Sort results, as needed                              tag-select-0900
//	**  *  Internal self-checks                                 tag-select-1000
//	*/
func _sqlite3Select(tls *libc.TLS, pParse uintptr, p uintptr, pDest uintptr) (r int32) {
	bp := tls.Alloc(160)
	defer tls.Free(160)
	var addr1, addrEnd, addrGosub, addrOutputRow, addrReset, addrSetAbort, addrSortingIdx, addrTop, addrTopOfLoop, eDist, eDist1, groupBySort, i, iAMem, iAbortFlag, iBMem, iBreak, iCont, iCsr, iDb, iDb1, iEnd, iOrderByCol, iUseFlag, ii, isAgg, j, k, nCol, nGroupBy, onceAddr, orderByGrp, rc, regAcc, regBase, regGosub, regOutputRow, regRecord, regReset, sortOut, sortPTab, topAddr, v12, v15 int32
	var db, p0, pAggInfo, pBase, pBest, pCol, pCteUse, pCteUse1, pDistinct, pDistinct1, pEList, pExpr, pF, pF1, pGroupBy, pHaving, pI2, pIdx, pItem, pItem1, pItem2, pKeyInfo, pKeyInfo1, pKeyInfo2, pPrior, pPriorSubq, pSub, pSub1, pSubq, pTab, pTab1, pTabList, pWInfo, pWhere, pWin, pX, v, zDb, zSavedAuthContext, v1, v3 uintptr
	var distFlag, distFlag1, wctrlFlags Tu16
	var iRoot TPgno
	var minMaxFlag Tu8
	var _ /* dest at bp+56 */ TSelectDest
	var _ /* pMinMaxOrderBy at bp+52 */ uintptr
	var _ /* sDistinct at bp+0 */ TDistinctCtx
	var _ /* sNC at bp+84 */ TNameContext
	var _ /* sSort at bp+12 */ TSortCtx
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = addr1, addrEnd, addrGosub, addrOutputRow, addrReset, addrSetAbort, addrSortingIdx, addrTop, addrTopOfLoop, db, distFlag, distFlag1, eDist, eDist1, groupBySort, i, iAMem, iAbortFlag, iBMem, iBreak, iCont, iCsr, iDb, iDb1, iEnd, iOrderByCol, iRoot, iUseFlag, ii, isAgg, j, k, minMaxFlag, nCol, nGroupBy, onceAddr, orderByGrp, p0, pAggInfo, pBase, pBest, pCol, pCteUse, pCteUse1, pDistinct, pDistinct1, pEList, pExpr, pF, pF1, pGroupBy, pHaving, pI2, pIdx, pItem, pItem1, pItem2, pKeyInfo, pKeyInfo1, pKeyInfo2, pPrior, pPriorSubq, pSub, pSub1, pSubq, pTab, pTab1, pTabList, pWInfo, pWhere, pWin, pX, rc, regAcc, regBase, regGosub, regOutputRow, regRecord, regReset, sortOut, sortPTab, topAddr, v, wctrlFlags, zDb, zSavedAuthContext, v1, v12, v15, v3 /* True for select lists like "count(*)" */
	pEList = uintptr(0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        /* The HAVING clause.  May be NULL */
	pAggInfo = uintptr(0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      /* Aggregate information */
	rc = int32(1)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /* The database connection */
	**(**uintptr)(__ccgo_up(bp + 52)) = uintptr(0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             /* Flag for min/max queries */
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	v = _sqlite3GetVdbe(tls, pParse)
	if p == uintptr(0) || (*TParse)(unsafe.Pointer(pParse)).FnErr != 0 {
		return int32(1)
	}
	if _sqlite3AuthCheck(tls, pParse, int32(SQLITE_SELECT), uintptr(0), uintptr(0), uintptr(0)) != 0 {
		return int32(1)
	}
	/* tag-select-0100 */
	if libc.Int32FromUint8((*TSelectDest)(unsafe.Pointer(pDest)).FeDest) <= int32(SRT_DistQueue) {
		/* All of these destinations are also able to ignore the ORDER BY clause */
		if (*TSelect)(unsafe.Pointer(p)).FpOrderBy != 0 {
			_sqlite3ParserAddCleanup(tls, pParse, __ccgo_fp(_sqlite3ExprListDeleteGeneric), (*TSelect)(unsafe.Pointer(p)).FpOrderBy)
			(*TSelect)(unsafe.Pointer(p)).FpOrderBy = uintptr(0)
		}
		**(**Tu32)(__ccgo_up(p + 4)) &= ^libc.Uint32FromInt32(SF_Distinct)
	}
	_sqlite3SelectPrep(tls, pParse, p, uintptr(0))
	if (*TParse)(unsafe.Pointer(pParse)).FnErr != 0 {
		goto select_end
	}
	/* If the SF_UFSrcCheck flag is set, then this function is being called
	 ** as part of populating the temp table for an UPDATE...FROM statement.
	 ** In this case, it is an error if the target object (pSrc->a[0]) name
	 ** or alias is duplicated within FROM clause (pSrc->a[1..n]).
	 **
	 ** Postgres disallows this case too. The reason is that some other
	 ** systems handle this case differently, and not all the same way,
	 ** which is just confusing. To avoid this, we follow PG's lead and
	 ** disallow it altogether.  */
	if (*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_UFSrcCheck) != 0 {
		p0 = (*TSelect)(unsafe.Pointer(p)).FpSrc + 8
		if _sameSrcAlias(tls, p0, (*TSelect)(unsafe.Pointer(p)).FpSrc) != 0 {
			if (*TSrcItem)(unsafe.Pointer(p0)).FzAlias != 0 {
				v1 = (*TSrcItem)(unsafe.Pointer(p0)).FzAlias
			} else {
				v1 = (*TTable)(unsafe.Pointer((*TSrcItem)(unsafe.Pointer(p0)).FpSTab)).FzName
			}
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+21630, libc.VaList(bp+128, v1))
			goto select_end
		}
		/* Clear the SF_UFSrcCheck flag. The check has already been performed,
		 ** and leaving this flag set can cause errors if a compound sub-query
		 ** in p->pSrc is flattened into this query and this function called
		 ** again as part of compound SELECT processing.  */
		**(**Tu32)(__ccgo_up(p + 4)) &= ^libc.Uint32FromInt32(SF_UFSrcCheck)
	}
	if libc.Int32FromUint8((*TSelectDest)(unsafe.Pointer(pDest)).FeDest) == int32(SRT_Output) {
		_sqlite3GenerateColumnNames(tls, pParse, p)
	}
	if _sqlite3WindowRewrite(tls, pParse, p) != 0 {
		goto select_end
	}
	pTabList = (*TSelect)(unsafe.Pointer(p)).FpSrc
	isAgg = libc.BoolInt32((*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_Aggregate) != uint32(0))
	libc.Xmemset(tls, bp+12, 0, uint32(40))
	(**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy = (*TSelect)(unsafe.Pointer(p)).FpOrderBy
	/* Try to do various optimizations (flattening subqueries, and strength
	 ** reduction of join operators) in the FROM clause up into the main query
	 ** tag-select-0200
	 */
	i = 0
	for {
		if !(!((*TSelect)(unsafe.Pointer(p)).FpPrior != 0) && i < (*TSrcList)(unsafe.Pointer(pTabList)).FnSrc) {
			break
		}
		pItem = pTabList + 8 + uintptr(i)*48
		if int32(*(*uint32)(unsafe.Pointer(pItem + 12 + 4))&0x4>>2) != 0 {
			v1 = (*TSubquery)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pItem + 44)))).FpSelect
		} else {
			v1 = uintptr(0)
		}
		pSub = v1
		pTab = (*TSrcItem)(unsafe.Pointer(pItem)).FpSTab
		/* The expander should have already created transient Table objects
		 ** even for FROM clause elements such as subqueries that do not correspond
		 ** to a real table */
		/* Try to simplify joins:
		 **
		 **      LEFT JOIN  ->  JOIN
		 **     RIGHT JOIN  ->  JOIN
		 **      FULL JOIN  ->  RIGHT JOIN
		 **
		 ** If terms of the i-th table are used in the WHERE clause in such a
		 ** way that the i-th table cannot be the NULL row of a join, then
		 ** perform the appropriate simplification. This is called
		 ** "OUTER JOIN strength reduction" in the SQLite documentation.
		 ** tag-select-0220
		 */
		if libc.Int32FromUint8((*TSrcItem)(unsafe.Pointer(pItem)).Ffg.Fjointype)&(libc.Int32FromInt32(JT_LEFT)|libc.Int32FromInt32(JT_LTORJ)) != 0 && _sqlite3ExprImpliesNonNullRow(tls, (*TSelect)(unsafe.Pointer(p)).FpWhere, (*TSrcItem)(unsafe.Pointer(pItem)).FiCursor, libc.Int32FromUint8((*TSrcItem)(unsafe.Pointer(pItem)).Ffg.Fjointype)&int32(JT_LTORJ)) != 0 && (*Tsqlite3)(unsafe.Pointer(db)).FdbOptFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_SimplifyJoin)) == uint32(0) {
			if libc.Int32FromUint8((*TSrcItem)(unsafe.Pointer(pItem)).Ffg.Fjointype)&int32(JT_LEFT) != 0 {
				if libc.Int32FromUint8((*TSrcItem)(unsafe.Pointer(pItem)).Ffg.Fjointype)&int32(JT_RIGHT) != 0 {
					v1 = pItem + 12
					*(*Tu8)(unsafe.Pointer(v1)) = Tu8(int32(*(*Tu8)(unsafe.Pointer(v1))) & ^libc.Int32FromInt32(JT_LEFT))
				} else {
					v1 = pItem + 12
					*(*Tu8)(unsafe.Pointer(v1)) = Tu8(int32(*(*Tu8)(unsafe.Pointer(v1))) & ^(libc.Int32FromInt32(JT_LEFT) | libc.Int32FromInt32(JT_OUTER)))
					_unsetJoinExpr(tls, (*TSelect)(unsafe.Pointer(p)).FpWhere, (*TSrcItem)(unsafe.Pointer(pItem)).FiCursor, 0)
				}
			}
			if libc.Int32FromUint8((*TSrcItem)(unsafe.Pointer(pItem)).Ffg.Fjointype)&int32(JT_LTORJ) != 0 {
				j = i + int32(1)
				for {
					if !(j < (*TSrcList)(unsafe.Pointer(pTabList)).FnSrc) {
						break
					}
					pI2 = pTabList + 8 + uintptr(j)*48
					if libc.Int32FromUint8((*TSrcItem)(unsafe.Pointer(pI2)).Ffg.Fjointype)&int32(JT_RIGHT) != 0 {
						if libc.Int32FromUint8((*TSrcItem)(unsafe.Pointer(pI2)).Ffg.Fjointype)&int32(JT_LEFT) != 0 {
							v1 = pI2 + 12
							*(*Tu8)(unsafe.Pointer(v1)) = Tu8(int32(*(*Tu8)(unsafe.Pointer(v1))) & ^libc.Int32FromInt32(JT_RIGHT))
						} else {
							v1 = pI2 + 12
							*(*Tu8)(unsafe.Pointer(v1)) = Tu8(int32(*(*Tu8)(unsafe.Pointer(v1))) & ^(libc.Int32FromInt32(JT_RIGHT) | libc.Int32FromInt32(JT_OUTER)))
							_unsetJoinExpr(tls, (*TSelect)(unsafe.Pointer(p)).FpWhere, (*TSrcItem)(unsafe.Pointer(pI2)).FiCursor, int32(1))
						}
					}
					goto _6
				_6:
					;
					j = j + 1
				}
				j = (*TSrcList)(unsafe.Pointer(pTabList)).FnSrc - int32(1)
				for {
					if !(j >= 0) {
						break
					}
					v1 = pTabList + 8 + uintptr(j)*48 + 12
					*(*Tu8)(unsafe.Pointer(v1)) = Tu8(int32(*(*Tu8)(unsafe.Pointer(v1))) & ^libc.Int32FromInt32(JT_LTORJ))
					if libc.Int32FromUint8((*(*TSrcItem)(unsafe.Pointer(pTabList + 8 + uintptr(j)*48))).Ffg.Fjointype)&int32(JT_RIGHT) != 0 {
						break
					}
					goto _9
				_9:
					;
					j = j - 1
				}
			}
		}
		/* No further action if this term of the FROM clause is not a subquery */
		if pSub == uintptr(0) {
			goto _2
		}
		/* Catch mismatch in the declared columns of a view and the number of
		 ** columns in the SELECT on the RHS */
		if int32((*TTable)(unsafe.Pointer(pTab)).FnCol) != (*TExprList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(pSub)).FpEList)).FnExpr {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+21684, libc.VaList(bp+128, int32((*TTable)(unsafe.Pointer(pTab)).FnCol), (*TTable)(unsafe.Pointer(pTab)).FzName, (*TExprList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(pSub)).FpEList)).FnExpr))
			goto select_end
		}
		/* Do not attempt the usual optimizations (flattening and ORDER BY
		 ** elimination) on a MATERIALIZED common table expression because
		 ** a MATERIALIZED common table expression is an optimization fence.
		 */
		if int32(*(*uint32)(unsafe.Pointer(pItem + 12 + 4))&0x200>>9) != 0 && libc.Int32FromUint8((*TCteUse)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pItem + 36)))).FeM10d) == M10d_Yes {
			goto _2
		}
		/* Do not try to flatten an aggregate subquery.
		 **
		 ** Flattening an aggregate subquery is only possible if the outer query
		 ** is not a join.  But if the outer query is not a join, then the subquery
		 ** will be implemented as a co-routine and there is no advantage to
		 ** flattening in that case.
		 */
		if (*TSelect)(unsafe.Pointer(pSub)).FselFlags&uint32(SF_Aggregate) != uint32(0) {
			goto _2
		}
		/* tag-select-0230:
		 ** If a FROM-clause subquery has an ORDER BY clause that is not
		 ** really doing anything, then delete it now so that it does not
		 ** interfere with query flattening.  See the discussion at
		 ** https://sqlite.org/forum/forumpost/2d76f2bcf65d256a
		 **
		 ** Beware of these cases where the ORDER BY clause may not be safely
		 ** omitted:
		 **
		 **    (1)   There is also a LIMIT clause
		 **    (2)   The subquery was added to help with window-function
		 **          processing
		 **    (3)   The subquery is in the FROM clause of an UPDATE
		 **    (4)   The outer query uses an aggregate function other than
		 **          the built-in count(), min(), or max().
		 **    (5)   The ORDER BY isn't going to accomplish anything because
		 **          one of:
		 **            (a)  The outer query has a different ORDER BY clause
		 **            (b)  The subquery is part of a join
		 **          See forum post 062d576715d277c8
		 **    (6)   The subquery is not a recursive CTE.  ORDER BY has a different
		 **          meaning for recursive CTEs and this optimization does not
		 **          apply.
		 **
		 ** Also retain the ORDER BY if the OmitOrderBy optimization is disabled.
		 */
		if (*TSelect)(unsafe.Pointer(pSub)).FpOrderBy != uintptr(0) && ((*TSelect)(unsafe.Pointer(p)).FpOrderBy != uintptr(0) || (*TSrcList)(unsafe.Pointer(pTabList)).FnSrc > int32(1)) && (*TSelect)(unsafe.Pointer(pSub)).FpLimit == uintptr(0) && (*TSelect)(unsafe.Pointer(pSub)).FselFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SF_OrderByReqd)|libc.Int32FromInt32(SF_Recursive)) == uint32(0) && (*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_OrderByReqd) == uint32(0) && (*Tsqlite3)(unsafe.Pointer(db)).FdbOptFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_OmitOrderBy)) == uint32(0) {
			_sqlite3ParserAddCleanup(tls, pParse, __ccgo_fp(_sqlite3ExprListDeleteGeneric), (*TSelect)(unsafe.Pointer(pSub)).FpOrderBy)
			(*TSelect)(unsafe.Pointer(pSub)).FpOrderBy = uintptr(0)
		}
		/* If the outer query contains a "complex" result set (that is,
		 ** if the result set of the outer query uses functions or subqueries)
		 ** and if the subquery contains an ORDER BY clause and if
		 ** it will be implemented as a co-routine, then do not flatten.  This
		 ** restriction allows SQL constructs like this:
		 **
		 **  SELECT expensive_function(x)
		 **    FROM (SELECT x FROM tab ORDER BY y LIMIT 10);
		 **
		 ** The expensive_function() is only computed on the 10 rows that
		 ** are output, rather than every row of the table.
		 **
		 ** The requirement that the outer query have a complex result set
		 ** means that flattening does occur on simpler SQL constraints without
		 ** the expensive_function() like:
		 **
		 **  SELECT x FROM (SELECT x FROM tab ORDER BY y LIMIT 10);
		 */
		if (*TSelect)(unsafe.Pointer(pSub)).FpOrderBy != uintptr(0) && i == 0 && (*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_ComplexResult) != uint32(0) && ((*TSrcList)(unsafe.Pointer(pTabList)).FnSrc == int32(1) || libc.Int32FromUint8((*(*TSrcItem)(unsafe.Pointer(pTabList + 8 + 1*48))).Ffg.Fjointype)&(libc.Int32FromInt32(JT_OUTER)|libc.Int32FromInt32(JT_CROSS)) != 0) {
			goto _2
		}
		/* tag-select-0240 */
		if _flattenSubquery(tls, pParse, p, i, isAgg) != 0 {
			if (*TParse)(unsafe.Pointer(pParse)).FnErr != 0 {
				goto select_end
			}
			/* This subquery can be absorbed into its parent. */
			i = -int32(1)
		}
		pTabList = (*TSelect)(unsafe.Pointer(p)).FpSrc
		if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
			goto select_end
		}
		if !(libc.Int32FromUint8((*TSelectDest)(unsafe.Pointer(pDest)).FeDest) <= libc.Int32FromInt32(SRT_Fifo)) {
			(**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy = (*TSelect)(unsafe.Pointer(p)).FpOrderBy
		}
		goto _2
	_2:
		;
		i = i + 1
	}
	/* Handle compound SELECT statements using the separate multiSelect()
	 ** procedure.  tag-select-0300
	 */
	if (*TSelect)(unsafe.Pointer(p)).FpPrior != 0 {
		rc = _multiSelect(tls, pParse, p, pDest)
		if (*TSelect)(unsafe.Pointer(p)).FpNext == uintptr(0) {
			_sqlite3VdbeExplainPop(tls, pParse)
		}
		return rc
	}
	/* If there may be an "EXISTS (SELECT ...)" in the WHERE clause, attempt
	 ** to change it into a join.  */
	if int32(Tbft(*(*uint16)(unsafe.Pointer(pParse + 28))&0x10>>4)) != 0 && (*Tsqlite3)(unsafe.Pointer(db)).FdbOptFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_ExistsToJoin)) == uint32(0) {
		_existsToJoin(tls, pParse, p, (*TSelect)(unsafe.Pointer(p)).FpWhere)
		pTabList = (*TSelect)(unsafe.Pointer(p)).FpSrc
	}
	/* Do the WHERE-clause constant propagation optimization if this is
	 ** a join.  No need to spend time on this operation for non-join queries
	 ** as the equivalent optimization will be handled by query planner in
	 ** sqlite3WhereBegin().  tag-select-0330
	 */
	if (*TSelect)(unsafe.Pointer(p)).FpWhere != uintptr(0) && libc.Int32FromUint8((*TExpr)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpWhere)).Fop) == int32(TK_AND) && (*Tsqlite3)(unsafe.Pointer(db)).FdbOptFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_PropagateConst)) == uint32(0) && _propagateConstants(tls, pParse, p) != 0 {
	} else {
	}
	/* tag-select-0350 */
	if (*Tsqlite3)(unsafe.Pointer(db)).FdbOptFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_QueryFlattener)|libc.Int32FromInt32(SQLITE_CountOfView)) == uint32(0) && _countOfViewOptimization(tls, pParse, p) != 0 {
		if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
			goto select_end
		}
		pTabList = (*TSelect)(unsafe.Pointer(p)).FpSrc
	}
	/* Loop over all terms in the FROM clause and do two things for each term:
	 **
	 **   (1) Authorize unreferenced tables
	 **   (2) Generate code for all sub-queries
	 **
	 ** tag-select-0400
	 */
	i = 0
	for {
		if !(i < (*TSrcList)(unsafe.Pointer(pTabList)).FnSrc) {
			break
		}
		pItem1 = pTabList + 8 + uintptr(i)*48
		/* Authorized unreferenced tables.  tag-select-0410
		 **
		 ** Issue SQLITE_READ authorizations with a fake column name for any
		 ** tables that are referenced but from which no values are extracted.
		 ** Examples of where these kinds of null SQLITE_READ authorizations
		 ** would occur:
		 **
		 **     SELECT count(*) FROM t1;   -- SQLITE_READ t1.""
		 **     SELECT t1.* FROM t1, t2;   -- SQLITE_READ t2.""
		 **
		 ** The fake column name is an empty string.  It is possible for a table to
		 ** have a column named by the empty string, in which case there is no way to
		 ** distinguish between an unreferenced table and an actual reference to the
		 ** "" column. The original design was for the fake column name to be a NULL,
		 ** which would be unambiguous.  But legacy authorization callbacks might
		 ** assume the column name is non-NULL and segfault.  The use of an empty
		 ** string for the fake column name seems safer.
		 */
		if (*TSrcItem)(unsafe.Pointer(pItem1)).FcolUsed == uint64(0) && (*TSrcItem)(unsafe.Pointer(pItem1)).FzName != uintptr(0) {
			if int32(*(*uint32)(unsafe.Pointer(pItem1 + 12 + 4))&0x10000>>16) != 0 {
				iDb = _sqlite3SchemaToIndex(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, *(*uintptr)(unsafe.Pointer(pItem1 + 44)))
				zDb = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FzDbSName
			} else {
				if int32(*(*uint32)(unsafe.Pointer(pItem1 + 12 + 4))&0x4>>2) != 0 {
					zDb = uintptr(0)
				} else {
					zDb = *(*uintptr)(unsafe.Pointer(pItem1 + 44))
				}
			}
			_sqlite3AuthCheck(tls, pParse, int32(SQLITE_READ), (*TSrcItem)(unsafe.Pointer(pItem1)).FzName, __ccgo_ts+1702, zDb)
		}
		/* Generate code for all sub-queries in the FROM clause
		 */
		if int32(*(*uint32)(unsafe.Pointer(pItem1 + 12 + 4))&0x4>>2) == 0 {
			goto _11
		}
		pSubq = *(*uintptr)(unsafe.Pointer(pItem1 + 44))
		pSub1 = (*TSubquery)(unsafe.Pointer(pSubq)).FpSelect
		/* The code for a subquery should only be generated once. */
		if (*TSubquery)(unsafe.Pointer(pSubq)).FaddrFillSub != 0 {
			goto _11
		}
		/* Increment Parse.nHeight by the height of the largest expression
		 ** tree referred to by this, the parent select. The child select
		 ** may contain expression trees of at most
		 ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit
		 ** more conservative than necessary, but much easier than enforcing
		 ** an exact limit.
		 */
		**(**int32)(__ccgo_up(pParse + 228)) += _sqlite3SelectExprHeight(tls, p)
		/* Make copies of constant WHERE-clause terms in the outer query down
		 ** inside the subquery.  This can help the subquery to run more efficiently.
		 ** This is the "predicate push-down optimization".  tag-select-0420
		 */
		if (*Tsqlite3)(unsafe.Pointer(db)).FdbOptFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_PushDown)) == uint32(0) && (int32(*(*uint32)(unsafe.Pointer(pItem1 + 12 + 4))&0x200>>9) == 0 || libc.Int32FromUint8((*TCteUse)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pItem1 + 36)))).FeM10d) != M10d_Yes && (*TCteUse)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pItem1 + 36)))).FnUse < int32(2)) && _pushDownWhereTerms(tls, pParse, pSub1, (*TSelect)(unsafe.Pointer(p)).FpWhere, pTabList, i) != 0 {
		} else {
		}
		/* Convert unused result columns of the subquery into simple NULL
		 ** expressions, to avoid unneeded searching and computation.
		 ** tag-select-0440
		 */
		if (*Tsqlite3)(unsafe.Pointer(db)).FdbOptFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_NullUnusedCols)) == uint32(0) && _disableUnusedSubqueryResultColumns(tls, pItem1) != 0 {
		}
		zSavedAuthContext = (*TParse)(unsafe.Pointer(pParse)).FzAuthContext
		(*TParse)(unsafe.Pointer(pParse)).FzAuthContext = (*TSrcItem)(unsafe.Pointer(pItem1)).FzName
		/* Generate byte-code to implement the subquery  tag-select-0480
		 */
		if _fromClauseTermCanBeCoroutine(tls, pParse, pTabList, i, libc.Int32FromUint32((*TSelect)(unsafe.Pointer(p)).FselFlags)) != 0 {
			/* Implement a co-routine that will return a single row of the result
			 ** set on each invocation.  tag-select-0482
			 */
			addrTop = _sqlite3VdbeCurrentAddr(tls, v) + int32(1)
			v1 = pParse + 48
			*(*int32)(unsafe.Pointer(v1)) = *(*int32)(unsafe.Pointer(v1)) + 1
			v12 = *(*int32)(unsafe.Pointer(v1))
			(*TSubquery)(unsafe.Pointer(pSubq)).FregReturn = v12
			_sqlite3VdbeAddOp3(tls, v, int32(OP_InitCoroutine), (*TSubquery)(unsafe.Pointer(pSubq)).FregReturn, 0, addrTop)
			(*TSubquery)(unsafe.Pointer(pSubq)).FaddrFillSub = addrTop
			_sqlite3SelectDestInit(tls, bp+56, int32(SRT_Coroutine), (*TSubquery)(unsafe.Pointer(pSubq)).FregReturn)
			_sqlite3VdbeExplain(tls, pParse, uint8(1), __ccgo_ts+21724, libc.VaList(bp+128, pItem1))
			_sqlite3Select(tls, pParse, pSub1, bp+56)
			(*TTable)(unsafe.Pointer((*TSrcItem)(unsafe.Pointer(pItem1)).FpSTab)).FnRowLogEst = (*TSelect)(unsafe.Pointer(pSub1)).FnSelectRow
			libc.SetBitFieldPtr32Uint32(pItem1+12+4, libc.Uint32FromInt32(1), 6, 0x40)
			(*TSubquery)(unsafe.Pointer(pSubq)).FregResult = (**(**TSelectDest)(__ccgo_up(bp + 56))).FiSdst
			_sqlite3VdbeEndCoroutine(tls, v, (*TSubquery)(unsafe.Pointer(pSubq)).FregReturn)
			_sqlite3VdbeJumpHere(tls, v, addrTop-int32(1))
			_sqlite3ClearTempRegCache(tls, pParse)
		} else {
			if int32(*(*uint32)(unsafe.Pointer(pItem1 + 12 + 4))&0x200>>9) != 0 && (*TCteUse)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pItem1 + 36)))).FaddrM9e > 0 {
				/* This is a CTE for which materialization code has already been
				 ** generated.  Invoke the subroutine to compute the materialization,
				 ** then make the pItem->iCursor be a copy of the ephemeral table that
				 ** holds the result of the materialization. tag-select-0484 */
				pCteUse = *(*uintptr)(unsafe.Pointer(pItem1 + 36))
				_sqlite3VdbeAddOp2(tls, v, int32(OP_Gosub), (*TCteUse)(unsafe.Pointer(pCteUse)).FregRtn, (*TCteUse)(unsafe.Pointer(pCteUse)).FaddrM9e)
				if (*TSrcItem)(unsafe.Pointer(pItem1)).FiCursor != (*TCteUse)(unsafe.Pointer(pCteUse)).FiCur {
					_sqlite3VdbeAddOp2(tls, v, int32(OP_OpenDup), (*TSrcItem)(unsafe.Pointer(pItem1)).FiCursor, (*TCteUse)(unsafe.Pointer(pCteUse)).FiCur)
				}
				(*TSelect)(unsafe.Pointer(pSub1)).FnSelectRow = (*TCteUse)(unsafe.Pointer(pCteUse)).FnRowEst
			} else {
				v1 = _isSelfJoinView(tls, pTabList, pItem1, 0, i)
				pPrior = v1
				if v1 != uintptr(0) {
					pPriorSubq = *(*uintptr)(unsafe.Pointer(pPrior + 44))
					if (*TSubquery)(unsafe.Pointer(pPriorSubq)).FaddrFillSub != 0 {
						_sqlite3VdbeAddOp2(tls, v, int32(OP_Gosub), (*TSubquery)(unsafe.Pointer(pPriorSubq)).FregReturn, (*TSubquery)(unsafe.Pointer(pPriorSubq)).FaddrFillSub)
					}
					_sqlite3VdbeAddOp2(tls, v, int32(OP_OpenDup), (*TSrcItem)(unsafe.Pointer(pItem1)).FiCursor, (*TSrcItem)(unsafe.Pointer(pPrior)).FiCursor)
					(*TSelect)(unsafe.Pointer(pSub1)).FnSelectRow = (*TSelect)(unsafe.Pointer((*TSubquery)(unsafe.Pointer(pPriorSubq)).FpSelect)).FnSelectRow
				} else {
					onceAddr = 0
					v1 = pParse + 48
					*(*int32)(unsafe.Pointer(v1)) = *(*int32)(unsafe.Pointer(v1)) + 1
					v12 = *(*int32)(unsafe.Pointer(v1))
					(*TSubquery)(unsafe.Pointer(pSubq)).FregReturn = v12
					topAddr = _sqlite3VdbeAddOp0(tls, v, int32(OP_Goto))
					(*TSubquery)(unsafe.Pointer(pSubq)).FaddrFillSub = topAddr + int32(1)
					libc.SetBitFieldPtr32Uint32(pItem1+12+4, libc.Uint32FromInt32(1), 5, 0x20)
					if int32(*(*uint32)(unsafe.Pointer(pItem1 + 12 + 4))&0x10>>4) == 0 {
						/* If the subquery is not correlated and if we are not inside of
						 ** a trigger, then we only need to compute the value of the subquery
						 ** once. */
						onceAddr = _sqlite3VdbeAddOp0(tls, v, int32(OP_Once))
					} else {
					}
					_sqlite3SelectDestInit(tls, bp+56, int32(SRT_EphemTab), (*TSrcItem)(unsafe.Pointer(pItem1)).FiCursor)
					_sqlite3VdbeExplain(tls, pParse, uint8(1), __ccgo_ts+21739, libc.VaList(bp+128, pItem1))
					_sqlite3Select(tls, pParse, pSub1, bp+56)
					(*TTable)(unsafe.Pointer((*TSrcItem)(unsafe.Pointer(pItem1)).FpSTab)).FnRowLogEst = (*TSelect)(unsafe.Pointer(pSub1)).FnSelectRow
					if onceAddr != 0 {
						_sqlite3VdbeJumpHere(tls, v, onceAddr)
					}
					_sqlite3VdbeAddOp2(tls, v, int32(OP_Return), (*TSubquery)(unsafe.Pointer(pSubq)).FregReturn, topAddr+int32(1))
					_sqlite3VdbeJumpHere(tls, v, topAddr)
					_sqlite3ClearTempRegCache(tls, pParse)
					if int32(*(*uint32)(unsafe.Pointer(pItem1 + 12 + 4))&0x200>>9) != 0 && int32(*(*uint32)(unsafe.Pointer(pItem1 + 12 + 4))&0x10>>4) == 0 {
						pCteUse1 = *(*uintptr)(unsafe.Pointer(pItem1 + 36))
						(*TCteUse)(unsafe.Pointer(pCteUse1)).FaddrM9e = (*TSubquery)(unsafe.Pointer(pSubq)).FaddrFillSub
						(*TCteUse)(unsafe.Pointer(pCteUse1)).FregRtn = (*TSubquery)(unsafe.Pointer(pSubq)).FregReturn
						(*TCteUse)(unsafe.Pointer(pCteUse1)).FiCur = (*TSrcItem)(unsafe.Pointer(pItem1)).FiCursor
						(*TCteUse)(unsafe.Pointer(pCteUse1)).FnRowEst = (*TSelect)(unsafe.Pointer(pSub1)).FnSelectRow
					}
				}
			}
		}
		if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
			goto select_end
		}
		**(**int32)(__ccgo_up(pParse + 228)) -= _sqlite3SelectExprHeight(tls, p)
		(*TParse)(unsafe.Pointer(pParse)).FzAuthContext = zSavedAuthContext
		goto _11
	_11:
		;
		i = i + 1
	}
	/* Various elements of the SELECT copied into local variables for
	 ** convenience */
	pEList = (*TSelect)(unsafe.Pointer(p)).FpEList
	pWhere = (*TSelect)(unsafe.Pointer(p)).FpWhere
	pGroupBy = (*TSelect)(unsafe.Pointer(p)).FpGroupBy
	pHaving = (*TSelect)(unsafe.Pointer(p)).FpHaving
	(**(**TDistinctCtx)(__ccgo_up(bp))).FisTnct = libc.BoolUint8((*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_Distinct) != uint32(0))
	/* tag-select-0500
	 **
	 ** If the query is DISTINCT with an ORDER BY but is not an aggregate, and
	 ** if the select-list is the same as the ORDER BY list, then this query
	 ** can be rewritten as a GROUP BY. In other words, this:
	 **
	 **     SELECT DISTINCT xyz FROM ... ORDER BY xyz
	 **
	 ** is transformed to:
	 **
	 **     SELECT xyz FROM ... GROUP BY xyz ORDER BY xyz
	 **
	 ** The second form is preferred as a single index (or temp-table) may be
	 ** used for both the ORDER BY and DISTINCT processing. As originally
	 ** written the query must use a temp-table for at least one of the ORDER
	 ** BY and DISTINCT, and an index or separate temp-table for the other.
	 */
	if (*TSelect)(unsafe.Pointer(p)).FselFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SF_Distinct)|libc.Int32FromInt32(SF_Aggregate)) == uint32(SF_Distinct) && _sqlite3CopySortOrder(tls, pEList, (**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy) != 0 && _sqlite3ExprListCompare(tls, pEList, (**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy, -int32(1)) == 0 && (*Tsqlite3)(unsafe.Pointer(db)).FdbOptFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_GroupByOrder)) == uint32(0) && (*TSelect)(unsafe.Pointer(p)).FpWin == uintptr(0) {
		**(**Tu32)(__ccgo_up(p + 4)) &= ^libc.Uint32FromInt32(SF_Distinct)
		v1 = _sqlite3ExprListDup(tls, db, pEList, 0)
		(*TSelect)(unsafe.Pointer(p)).FpGroupBy = v1
		pGroupBy = v1
		if pGroupBy != 0 {
			i = 0
			for {
				if !(i < (*TExprList)(unsafe.Pointer(pGroupBy)).FnExpr) {
					break
				}
				*(*Tu16)(unsafe.Pointer(pGroupBy + 8 + uintptr(i)*20 + 16)) = libc.Uint16FromInt32(i + int32(1))
				goto _18
			_18:
				;
				i = i + 1
			}
		}
		**(**Tu32)(__ccgo_up(p + 4)) |= uint32(SF_Aggregate)
		/* Notice that even thought SF_Distinct has been cleared from p->selFlags,
		 ** the sDistinct.isTnct is still set.  Hence, isTnct represents the
		 ** original setting of the SF_Distinct flag, not the current setting */
		(**(**TDistinctCtx)(__ccgo_up(bp))).FisTnct = uint8(2)
	}
	/* If there is an ORDER BY clause, then create an ephemeral index to
	 ** do the sorting.  But this sorting ephemeral index might end up
	 ** being unused if the data can be extracted in pre-sorted order.
	 ** If that is the case, then the OP_OpenEphemeral instruction will be
	 ** changed to an OP_Noop once we figure out that the sorting index is
	 ** not needed.  The sSort.addrSortIndex variable is used to facilitate
	 ** that change.  tag-select-0600
	 */
	if (**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy != 0 {
		pKeyInfo = _sqlite3KeyInfoFromExprList(tls, pParse, (**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy, 0, (*TExprList)(unsafe.Pointer(pEList)).FnExpr)
		v1 = pParse + 44
		v12 = *(*int32)(unsafe.Pointer(v1))
		*(*int32)(unsafe.Pointer(v1)) = *(*int32)(unsafe.Pointer(v1)) + 1
		(**(**TSortCtx)(__ccgo_up(bp + 12))).FiECursor = v12
		(**(**TSortCtx)(__ccgo_up(bp + 12))).FaddrSortIndex = _sqlite3VdbeAddOp4(tls, v, int32(OP_OpenEphemeral), (**(**TSortCtx)(__ccgo_up(bp + 12))).FiECursor, (*TExprList)(unsafe.Pointer((**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy)).FnExpr+int32(1)+(*TExprList)(unsafe.Pointer(pEList)).FnExpr, 0, pKeyInfo, -int32(9))
	} else {
		(**(**TSortCtx)(__ccgo_up(bp + 12))).FaddrSortIndex = -int32(1)
	}
	/* If the output is destined for a temporary table, open that table.
	 ** tag-select-0630
	 */
	if libc.Int32FromUint8((*TSelectDest)(unsafe.Pointer(pDest)).FeDest) == int32(SRT_EphemTab) {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_OpenEphemeral), (*TSelectDest)(unsafe.Pointer(pDest)).FiSDParm, (*TExprList)(unsafe.Pointer(pEList)).FnExpr)
		if (*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_NestedFrom) != 0 {
			ii = (*TExprList)(unsafe.Pointer(pEList)).FnExpr - int32(1)
			for {
				if !(ii > 0 && int32(uint32(*(*uint16)(unsafe.Pointer(pEList + 8 + uintptr(ii)*20 + 8 + 4))&0x40>>6)) == 0) {
					break
				}
				_sqlite3ExprDelete(tls, db, (*(*TExprList_item)(unsafe.Pointer(pEList + 8 + uintptr(ii)*20))).FpExpr)
				_sqlite3DbFree(tls, db, (*(*TExprList_item)(unsafe.Pointer(pEList + 8 + uintptr(ii)*20))).FzEName)
				(*TExprList)(unsafe.Pointer(pEList)).FnExpr = (*TExprList)(unsafe.Pointer(pEList)).FnExpr - 1
				goto _21
			_21:
				;
				ii = ii - 1
			}
			ii = 0
			for {
				if !(ii < (*TExprList)(unsafe.Pointer(pEList)).FnExpr) {
					break
				}
				if int32(uint32(*(*uint16)(unsafe.Pointer(pEList + 8 + uintptr(ii)*20 + 8 + 4))&0x40>>6)) == 0 {
					(*TExpr)(unsafe.Pointer((*(*TExprList_item)(unsafe.Pointer(pEList + 8 + uintptr(ii)*20))).FpExpr)).Fop = uint8(TK_NULL)
				}
				goto _22
			_22:
				;
				ii = ii + 1
			}
		}
	}
	/* Set the limiter.  tag-select-0650
	 */
	iEnd = _sqlite3VdbeMakeLabel(tls, pParse)
	if (*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_FixedLimit) == uint32(0) {
		(*TSelect)(unsafe.Pointer(p)).FnSelectRow = int16(320) /* 4 billion rows */
	}
	if (*TSelect)(unsafe.Pointer(p)).FpLimit != 0 {
		_computeLimitRegisters(tls, pParse, p, iEnd)
	}
	if (*TSelect)(unsafe.Pointer(p)).FiLimit == 0 && (**(**TSortCtx)(__ccgo_up(bp + 12))).FaddrSortIndex >= 0 {
		_sqlite3VdbeChangeOpcode(tls, v, (**(**TSortCtx)(__ccgo_up(bp + 12))).FaddrSortIndex, uint8(OP_SorterOpen))
		v1 = bp + 12 + 32
		*(*Tu8)(unsafe.Pointer(v1)) = Tu8(int32(*(*Tu8)(unsafe.Pointer(v1))) | libc.Int32FromInt32(SORTFLAG_UseSorter))
	}
	/* Open an ephemeral index to use for the distinct set. tag-select-0680
	 */
	if (*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_Distinct) != 0 {
		v1 = pParse + 44
		v12 = *(*int32)(unsafe.Pointer(v1))
		*(*int32)(unsafe.Pointer(v1)) = *(*int32)(unsafe.Pointer(v1)) + 1
		(**(**TDistinctCtx)(__ccgo_up(bp))).FtabTnct = v12
		(**(**TDistinctCtx)(__ccgo_up(bp))).FaddrTnct = _sqlite3VdbeAddOp4(tls, v, int32(OP_OpenEphemeral), (**(**TDistinctCtx)(__ccgo_up(bp))).FtabTnct, 0, 0, _sqlite3KeyInfoFromExprList(tls, pParse, (*TSelect)(unsafe.Pointer(p)).FpEList, 0, 0), -int32(9))
		_sqlite3VdbeChangeP5(tls, v, uint16(BTREE_UNORDERED))
		(**(**TDistinctCtx)(__ccgo_up(bp))).FeTnctType = uint8(WHERE_DISTINCT_UNORDERED)
	} else {
		(**(**TDistinctCtx)(__ccgo_up(bp))).FeTnctType = uint8(WHERE_DISTINCT_NOOP)
	}
	if !(isAgg != 0) && pGroupBy == uintptr(0) {
		if (**(**TDistinctCtx)(__ccgo_up(bp))).FisTnct != 0 {
			v12 = int32(WHERE_WANT_DISTINCT)
		} else {
			v12 = 0
		}
		/* No aggregate functions and no GROUP BY clause.  tag-select-0700 */
		wctrlFlags = uint16(libc.Uint32FromInt32(v12) | (*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_FixedLimit))
		pWin = (*TSelect)(unsafe.Pointer(p)).FpWin /* Main window object (or NULL) */
		if pWin != 0 {
			_sqlite3WindowCodeInit(tls, pParse, p)
		}
		/* Begin the database scan. */
		pWInfo = _sqlite3WhereBegin(tls, pParse, pTabList, pWhere, (**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy, (*TSelect)(unsafe.Pointer(p)).FpEList, p, wctrlFlags, int32((*TSelect)(unsafe.Pointer(p)).FnSelectRow))
		if pWInfo == uintptr(0) {
			goto select_end
		}
		if int32(_sqlite3WhereOutputRowCount(tls, pWInfo)) < int32((*TSelect)(unsafe.Pointer(p)).FnSelectRow) {
			(*TSelect)(unsafe.Pointer(p)).FnSelectRow = _sqlite3WhereOutputRowCount(tls, pWInfo)
			if libc.Int32FromUint8((*TSelectDest)(unsafe.Pointer(pDest)).FeDest) <= int32(SRT_DistQueue) && libc.Int32FromUint8((*TSelectDest)(unsafe.Pointer(pDest)).FeDest) >= int32(SRT_DistFifo) {
				/* TUNING: For a UNION CTE, because UNION is implies DISTINCT,
				 ** reduce the estimated output row count by 8 (LogEst 30).
				 ** Search for tag-20250414a to see other cases */
				v1 = p + 2
				*(*TLogEst)(unsafe.Pointer(v1)) = TLogEst(int32(*(*TLogEst)(unsafe.Pointer(v1))) - libc.Int32FromInt32(30))
			}
		}
		if (**(**TDistinctCtx)(__ccgo_up(bp))).FisTnct != 0 && _sqlite3WhereIsDistinct(tls, pWInfo) != 0 {
			(**(**TDistinctCtx)(__ccgo_up(bp))).FeTnctType = libc.Uint8FromInt32(_sqlite3WhereIsDistinct(tls, pWInfo))
		}
		if (**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy != 0 {
			(**(**TSortCtx)(__ccgo_up(bp + 12))).FnOBSat = _sqlite3WhereIsOrdered(tls, pWInfo)
			(**(**TSortCtx)(__ccgo_up(bp + 12))).FlabelOBLopt = _sqlite3WhereOrderByLimitOptLabel(tls, pWInfo)
			if (**(**TSortCtx)(__ccgo_up(bp + 12))).FnOBSat == (*TExprList)(unsafe.Pointer((**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy)).FnExpr {
				(**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy = uintptr(0)
			}
		}
		/* If sorting index that was created by a prior OP_OpenEphemeral
		 ** instruction ended up not being needed, then change the OP_OpenEphemeral
		 ** into an OP_Noop.
		 */
		if (**(**TSortCtx)(__ccgo_up(bp + 12))).FaddrSortIndex >= 0 && (**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy == uintptr(0) {
			_sqlite3VdbeChangeToNoop(tls, v, (**(**TSortCtx)(__ccgo_up(bp + 12))).FaddrSortIndex)
		}
		if pWin != 0 {
			addrGosub = _sqlite3VdbeMakeLabel(tls, pParse)
			iCont = _sqlite3VdbeMakeLabel(tls, pParse)
			iBreak = _sqlite3VdbeMakeLabel(tls, pParse)
			v1 = pParse + 48
			*(*int32)(unsafe.Pointer(v1)) = *(*int32)(unsafe.Pointer(v1)) + 1
			v12 = *(*int32)(unsafe.Pointer(v1))
			regGosub = v12
			_sqlite3WindowCodeStep(tls, pParse, p, pWInfo, regGosub, addrGosub)
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Goto), 0, iBreak)
			_sqlite3VdbeResolveLabel(tls, v, addrGosub)
			(**(**TSortCtx)(__ccgo_up(bp + 12))).FlabelOBLopt = 0
			_selectInnerLoop(tls, pParse, p, -int32(1), bp+12, bp, pDest, iCont, iBreak)
			_sqlite3VdbeResolveLabel(tls, v, iCont)
			_sqlite3VdbeAddOp1(tls, v, int32(OP_Return), regGosub)
			_sqlite3VdbeResolveLabel(tls, v, iBreak)
		} else {
			/* Use the standard inner loop. */
			_selectInnerLoop(tls, pParse, p, -int32(1), bp+12, bp, pDest, _sqlite3WhereContinueLabel(tls, pWInfo), _sqlite3WhereBreakLabel(tls, pWInfo))
			/* End the database scan loop.
			 */
			_sqlite3WhereEnd(tls, pWInfo)
		}
	} else { /* End of processing for this SELECT */
		sortPTab = 0   /* Pseudotable used to decode sorting results */
		sortOut = 0    /* Output register from the sorter */
		orderByGrp = 0 /* True if the GROUP BY and ORDER BY are the same */
		/* Remove any and all aliases between the result set and the
		 ** GROUP BY clause.
		 */
		if pGroupBy != 0 { /* For looping over expression in a list */
			k = (*TExprList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpEList)).FnExpr
			pItem2 = (*TSelect)(unsafe.Pointer(p)).FpEList + 8
			for {
				if !(k > 0) {
					break
				}
				(*(*struct {
					FiOrderByCol Tu16
					FiAlias      Tu16
				})(unsafe.Pointer(pItem2 + 16))).FiAlias = uint16(0)
				goto _30
			_30:
				;
				k = k - 1
				pItem2 += 20
			}
			k = (*TExprList)(unsafe.Pointer(pGroupBy)).FnExpr
			pItem2 = pGroupBy + 8
			for {
				if !(k > 0) {
					break
				}
				(*(*struct {
					FiOrderByCol Tu16
					FiAlias      Tu16
				})(unsafe.Pointer(pItem2 + 16))).FiAlias = uint16(0)
				goto _31
			_31:
				;
				k = k - 1
				pItem2 += 20
			}
			if int32((*TSelect)(unsafe.Pointer(p)).FnSelectRow) > int32(66) {
				(*TSelect)(unsafe.Pointer(p)).FnSelectRow = int16(66)
			}
			/* If there is both a GROUP BY and an ORDER BY clause and they are
			 ** identical, then it may be possible to disable the ORDER BY clause
			 ** on the grounds that the GROUP BY will cause elements to come out
			 ** in the correct order. It also may not - the GROUP BY might use a
			 ** database index that causes rows to be grouped together as required
			 ** but not actually sorted. Either way, record the fact that the
			 ** ORDER BY and GROUP BY clauses are the same by setting the orderByGrp
			 ** variable.  */
			if _sqlite3CopySortOrder(tls, pGroupBy, (**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy) != 0 && _sqlite3ExprListCompare(tls, pGroupBy, (**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy, -int32(1)) == 0 {
				orderByGrp = int32(1)
			}
		} else {
			(*TSelect)(unsafe.Pointer(p)).FnSelectRow = 0
		}
		/* Create a label to jump to when we want to abort the query */
		addrEnd = _sqlite3VdbeMakeLabel(tls, pParse)
		/* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in
		 ** sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the
		 ** SELECT statement.
		 */
		pAggInfo = _sqlite3DbMallocZero(tls, db, uint64(48))
		if pAggInfo != 0 {
			_sqlite3ParserAddCleanup(tls, pParse, __ccgo_fp(_agginfoFree), pAggInfo)
		}
		if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
			goto select_end
		}
		(*TAggInfo)(unsafe.Pointer(pAggInfo)).FselId = (*TSelect)(unsafe.Pointer(p)).FselId
		libc.Xmemset(tls, bp+84, 0, uint32(36))
		(**(**TNameContext)(__ccgo_up(bp + 84))).FpParse = pParse
		(**(**TNameContext)(__ccgo_up(bp + 84))).FpSrcList = pTabList
		*(*uintptr)(unsafe.Pointer(bp + 84 + 8)) = pAggInfo
		if pGroupBy != 0 {
			v12 = (*TExprList)(unsafe.Pointer(pGroupBy)).FnExpr
		} else {
			v12 = 0
		}
		(*TAggInfo)(unsafe.Pointer(pAggInfo)).FnSortingColumn = libc.Uint32FromInt32(v12)
		(*TAggInfo)(unsafe.Pointer(pAggInfo)).FpGroupBy = pGroupBy
		_sqlite3ExprAnalyzeAggList(tls, bp+84, pEList)
		_sqlite3ExprAnalyzeAggList(tls, bp+84, (**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy)
		if pHaving != 0 {
			if pGroupBy != 0 {
				_havingToWhere(tls, pParse, p)
				pWhere = (*TSelect)(unsafe.Pointer(p)).FpWhere
			}
			_sqlite3ExprAnalyzeAggregates(tls, bp+84, pHaving)
		}
		(*TAggInfo)(unsafe.Pointer(pAggInfo)).FnAccumulator = (*TAggInfo)(unsafe.Pointer(pAggInfo)).FnColumn
		if (*TSelect)(unsafe.Pointer(p)).FpGroupBy == uintptr(0) && (*TSelect)(unsafe.Pointer(p)).FpHaving == uintptr(0) && (*TAggInfo)(unsafe.Pointer(pAggInfo)).FnFunc == int32(1) {
			minMaxFlag = _minMaxQuery(tls, db, (**(**TAggInfo_func)(__ccgo_up((*TAggInfo)(unsafe.Pointer(pAggInfo)).FaFunc))).FpFExpr, bp+52)
		} else {
			minMaxFlag = uint8(WHERE_ORDERBY_NORMAL)
		}
		_analyzeAggFuncArgs(tls, pAggInfo, bp+84)
		if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
			goto select_end
		}
		/* Processing for aggregates with GROUP BY is very different and
		 ** much more complex than aggregates without a GROUP BY.  tag-select-0810
		 */
		if pGroupBy != 0 { /* Return address register for reset subroutine */
			pDistinct = uintptr(0)
			distFlag = uint16(0)
			eDist = WHERE_DISTINCT_NOOP
			if (*TAggInfo)(unsafe.Pointer(pAggInfo)).FnFunc == int32(1) && (**(**TAggInfo_func)(__ccgo_up((*TAggInfo)(unsafe.Pointer(pAggInfo)).FaFunc))).FiDistinct >= 0 && (**(**TAggInfo_func)(__ccgo_up((*TAggInfo)(unsafe.Pointer(pAggInfo)).FaFunc))).FpFExpr != uintptr(0) && (*TExpr)(unsafe.Pointer((**(**TAggInfo_func)(__ccgo_up((*TAggInfo)(unsafe.Pointer(pAggInfo)).FaFunc))).FpFExpr)).Fflags&uint32(EP_xIsSelect) == uint32(0) && *(*uintptr)(unsafe.Pointer((**(**TAggInfo_func)(__ccgo_up((*TAggInfo)(unsafe.Pointer(pAggInfo)).FaFunc))).FpFExpr + 20)) != uintptr(0) {
				pExpr = (*(*TExprList_item)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer((**(**TAggInfo_func)(__ccgo_up((*TAggInfo)(unsafe.Pointer(pAggInfo)).FaFunc))).FpFExpr + 20)) + 8))).FpExpr
				pExpr = _sqlite3ExprDup(tls, db, pExpr, 0)
				pDistinct = _sqlite3ExprListDup(tls, db, pGroupBy, 0)
				pDistinct = _sqlite3ExprListAppend(tls, pParse, pDistinct, pExpr)
				if pDistinct != 0 {
					v12 = libc.Int32FromInt32(WHERE_WANT_DISTINCT) | libc.Int32FromInt32(WHERE_AGG_DISTINCT)
				} else {
					v12 = 0
				}
				distFlag = libc.Uint16FromInt32(v12)
			}
			/* If there is a GROUP BY clause we might need a sorting index to
			 ** implement it.  Allocate that sorting index now.  If it turns out
			 ** that we do not need it after all, the OP_SorterOpen instruction
			 ** will be converted into a Noop.
			 */
			v1 = pParse + 44
			v12 = *(*int32)(unsafe.Pointer(v1))
			*(*int32)(unsafe.Pointer(v1)) = *(*int32)(unsafe.Pointer(v1)) + 1
			(*TAggInfo)(unsafe.Pointer(pAggInfo)).FsortingIdx = v12
			pKeyInfo1 = _sqlite3KeyInfoFromExprList(tls, pParse, pGroupBy, 0, (*TAggInfo)(unsafe.Pointer(pAggInfo)).FnColumn)
			addrSortingIdx = _sqlite3VdbeAddOp4(tls, v, int32(OP_SorterOpen), (*TAggInfo)(unsafe.Pointer(pAggInfo)).FsortingIdx, libc.Int32FromUint32((*TAggInfo)(unsafe.Pointer(pAggInfo)).FnSortingColumn), 0, pKeyInfo1, -int32(9))
			/* Initialize memory locations used by GROUP BY aggregate processing
			 */
			v1 = pParse + 48
			*(*int32)(unsafe.Pointer(v1)) = *(*int32)(unsafe.Pointer(v1)) + 1
			v12 = *(*int32)(unsafe.Pointer(v1))
			iUseFlag = v12
			v1 = pParse + 48
			*(*int32)(unsafe.Pointer(v1)) = *(*int32)(unsafe.Pointer(v1)) + 1
			v12 = *(*int32)(unsafe.Pointer(v1))
			iAbortFlag = v12
			v1 = pParse + 48
			*(*int32)(unsafe.Pointer(v1)) = *(*int32)(unsafe.Pointer(v1)) + 1
			v12 = *(*int32)(unsafe.Pointer(v1))
			regOutputRow = v12
			addrOutputRow = _sqlite3VdbeMakeLabel(tls, pParse)
			v1 = pParse + 48
			*(*int32)(unsafe.Pointer(v1)) = *(*int32)(unsafe.Pointer(v1)) + 1
			v12 = *(*int32)(unsafe.Pointer(v1))
			regReset = v12
			addrReset = _sqlite3VdbeMakeLabel(tls, pParse)
			iAMem = (*TParse)(unsafe.Pointer(pParse)).FnMem + int32(1)
			**(**int32)(__ccgo_up(pParse + 48)) += (*TExprList)(unsafe.Pointer(pGroupBy)).FnExpr
			iBMem = (*TParse)(unsafe.Pointer(pParse)).FnMem + int32(1)
			**(**int32)(__ccgo_up(pParse + 48)) += (*TExprList)(unsafe.Pointer(pGroupBy)).FnExpr
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), 0, iAbortFlag)
			_sqlite3VdbeAddOp3(tls, v, int32(OP_Null), 0, iAMem, iAMem+(*TExprList)(unsafe.Pointer(pGroupBy)).FnExpr-int32(1))
			_sqlite3ExprNullRegisterRange(tls, pParse, iAMem, (*TExprList)(unsafe.Pointer(pGroupBy)).FnExpr)
			/* Begin a loop that will extract all source rows in GROUP BY order.
			 ** This might involve two separate loops with an OP_Sort in between, or
			 ** it might be a single loop that uses an index to extract information
			 ** in the right order to begin with.
			 */
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Gosub), regReset, addrReset)
			if libc.Int32FromUint8((**(**TDistinctCtx)(__ccgo_up(bp))).FisTnct) == int32(2) {
				v12 = int32(WHERE_DISTINCTBY)
			} else {
				v12 = int32(WHERE_GROUPBY)
			}
			if orderByGrp != 0 {
				v15 = int32(WHERE_SORTBYGROUP)
			} else {
				v15 = 0
			}
			pWInfo = _sqlite3WhereBegin(tls, pParse, pTabList, pWhere, pGroupBy, pDistinct, p, libc.Uint16FromInt32(v12|v15|libc.Int32FromUint16(distFlag)), 0)
			if pWInfo == uintptr(0) {
				_sqlite3ExprListDelete(tls, db, pDistinct)
				goto select_end
			}
			if (*TParse)(unsafe.Pointer(pParse)).FpIdxEpr != 0 {
				_optimizeAggregateUseOfIndexedExpr(tls, pParse, p, pAggInfo, bp+84)
			}
			_assignAggregateRegisters(tls, pParse, pAggInfo)
			eDist = _sqlite3WhereIsDistinct(tls, pWInfo)
			if _sqlite3WhereIsOrdered(tls, pWInfo) == (*TExprList)(unsafe.Pointer(pGroupBy)).FnExpr {
				/* The optimizer is able to deliver rows in group by order so
				 ** we do not have to sort.  The OP_OpenEphemeral table will be
				 ** cancelled later because we still need to use the pKeyInfo
				 */
				groupBySort = 0
			} else {
				if (**(**TDistinctCtx)(__ccgo_up(bp))).FisTnct != 0 && (*TSelect)(unsafe.Pointer(p)).FselFlags&uint32(SF_Distinct) == uint32(0) {
					v1 = __ccgo_ts + 21755
				} else {
					v1 = __ccgo_ts + 21764
				}
				_sqlite3VdbeExplain(tls, pParse, uint8(0), __ccgo_ts+20520, libc.VaList(bp+128, v1))
				groupBySort = int32(1)
				nGroupBy = (*TExprList)(unsafe.Pointer(pGroupBy)).FnExpr
				nCol = nGroupBy
				j = nGroupBy
				i = 0
				for {
					if !(i < (*TAggInfo)(unsafe.Pointer(pAggInfo)).FnColumn) {
						break
					}
					if (**(**TAggInfo_col)(__ccgo_up((*TAggInfo)(unsafe.Pointer(pAggInfo)).FaCol + uintptr(i)*20))).FiSorterColumn >= j {
						nCol = nCol + 1
						j = j + 1
					}
					goto _47
				_47:
					;
					i = i + 1
				}
				regBase = _sqlite3GetTempRange(tls, pParse, nCol)
				_sqlite3ExprCodeExprList(tls, pParse, pGroupBy, regBase, 0, uint8(0))
				j = nGroupBy
				(*TAggInfo)(unsafe.Pointer(pAggInfo)).FdirectMode = uint8(1)
				i = 0
				for {
					if !(i < (*TAggInfo)(unsafe.Pointer(pAggInfo)).FnColumn) {
						break
					}
					pCol = (*TAggInfo)(unsafe.Pointer(pAggInfo)).FaCol + uintptr(i)*20
					if (*TAggInfo_col)(unsafe.Pointer(pCol)).FiSorterColumn >= j {
						_sqlite3ExprCode(tls, pParse, (*TAggInfo_col)(unsafe.Pointer(pCol)).FpCExpr, j+regBase)
						j = j + 1
					}
					goto _48
				_48:
					;
					i = i + 1
				}
				(*TAggInfo)(unsafe.Pointer(pAggInfo)).FdirectMode = uint8(0)
				regRecord = _sqlite3GetTempReg(tls, pParse)
				_sqlite3VdbeAddOp3(tls, v, int32(OP_MakeRecord), regBase, nCol, regRecord)
				_sqlite3VdbeAddOp2(tls, v, int32(OP_SorterInsert), (*TAggInfo)(unsafe.Pointer(pAggInfo)).FsortingIdx, regRecord)
				_sqlite3ReleaseTempReg(tls, pParse, regRecord)
				_sqlite3ReleaseTempRange(tls, pParse, regBase, nCol)
				_sqlite3WhereEnd(tls, pWInfo)
				v1 = pParse + 44
				v15 = *(*int32)(unsafe.Pointer(v1))
				*(*int32)(unsafe.Pointer(v1)) = *(*int32)(unsafe.Pointer(v1)) + 1
				v12 = v15
				sortPTab = v12
				(*TAggInfo)(unsafe.Pointer(pAggInfo)).FsortingIdxPTab = v12
				sortOut = _sqlite3GetTempReg(tls, pParse)
				_sqlite3VdbeAddOp3(tls, v, int32(OP_OpenPseudo), sortPTab, sortOut, nCol)
				_sqlite3VdbeAddOp2(tls, v, int32(OP_SorterSort), (*TAggInfo)(unsafe.Pointer(pAggInfo)).FsortingIdx, addrEnd)
				(*TAggInfo)(unsafe.Pointer(pAggInfo)).FuseSortingIdx = uint8(1)
			}
			/* If there are entries in pAgggInfo->aFunc[] that contain subexpressions
			 ** that are indexed (and that were previously identified and tagged
			 ** in optimizeAggregateUseOfIndexedExpr()) then those subexpressions
			 ** must now be converted into a TK_AGG_COLUMN node so that the value
			 ** is correctly pulled from the index rather than being recomputed. */
			if (*TParse)(unsafe.Pointer(pParse)).FpIdxEpr != 0 {
				_aggregateConvertIndexedExprRefToColumn(tls, pAggInfo)
			}
			/* If the index or temporary table used by the GROUP BY sort
			 ** will naturally deliver rows in the order required by the ORDER BY
			 ** clause, cancel the ephemeral table open coded earlier.
			 **
			 ** This is an optimization - the correct answer should result regardless.
			 ** Use the SQLITE_GroupByOrder flag with SQLITE_TESTCTRL_OPTIMIZER to
			 ** disable this optimization for testing purposes.  */
			if orderByGrp != 0 && (*Tsqlite3)(unsafe.Pointer(db)).FdbOptFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_GroupByOrder)) == uint32(0) && (groupBySort != 0 || _sqlite3WhereIsSorted(tls, pWInfo) != 0) {
				(**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy = uintptr(0)
				_sqlite3VdbeChangeToNoop(tls, v, (**(**TSortCtx)(__ccgo_up(bp + 12))).FaddrSortIndex)
			}
			/* Evaluate the current GROUP BY terms and store in b0, b1, b2...
			 ** (b0 is memory location iBMem+0, b1 is iBMem+1, and so forth)
			 ** Then compare the current GROUP BY terms against the GROUP BY terms
			 ** from the previous row currently stored in a0, a1, a2...
			 */
			addrTopOfLoop = _sqlite3VdbeCurrentAddr(tls, v)
			if groupBySort != 0 {
				_sqlite3VdbeAddOp3(tls, v, int32(OP_SorterData), (*TAggInfo)(unsafe.Pointer(pAggInfo)).FsortingIdx, sortOut, sortPTab)
			}
			j = 0
			for {
				if !(j < (*TExprList)(unsafe.Pointer(pGroupBy)).FnExpr) {
					break
				}
				iOrderByCol = libc.Int32FromUint16(*(*Tu16)(unsafe.Pointer(pGroupBy + 8 + uintptr(j)*20 + 16)))
				if groupBySort != 0 {
					_sqlite3VdbeAddOp3(tls, v, int32(OP_Column), sortPTab, j, iBMem+j)
				} else {
					(*TAggInfo)(unsafe.Pointer(pAggInfo)).FdirectMode = uint8(1)
					_sqlite3ExprCode(tls, pParse, (*(*TExprList_item)(unsafe.Pointer(pGroupBy + 8 + uintptr(j)*20))).FpExpr, iBMem+j)
				}
				if iOrderByCol != 0 {
					pX = (*(*TExprList_item)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpEList + 8 + uintptr(iOrderByCol-int32(1))*20))).FpExpr
					pBase = _sqlite3ExprSkipCollateAndLikely(tls, pX)
					for pBase != uintptr(0) && libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pBase)).Fop) == int32(TK_IF_NULL_ROW) {
						pX = (*TExpr)(unsafe.Pointer(pBase)).FpLeft
						pBase = _sqlite3ExprSkipCollateAndLikely(tls, pX)
					}
					if pBase != uintptr(0) && libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pBase)).Fop) != int32(TK_AGG_COLUMN) && libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pBase)).Fop) != int32(TK_REGISTER) {
						_sqlite3ExprToRegister(tls, pX, iAMem+j)
					}
				}
				goto _52
			_52:
				;
				j = j + 1
			}
			_sqlite3VdbeAddOp4(tls, v, int32(OP_Compare), iAMem, iBMem, (*TExprList)(unsafe.Pointer(pGroupBy)).FnExpr, _sqlite3KeyInfoRef(tls, pKeyInfo1), -int32(9))
			addr1 = _sqlite3VdbeCurrentAddr(tls, v)
			_sqlite3VdbeAddOp3(tls, v, int32(OP_Jump), addr1+int32(1), 0, addr1+int32(1))
			/* Generate code that runs whenever the GROUP BY changes.
			 ** Changes in the GROUP BY are detected by the previous code
			 ** block.  If there were no changes, this block is skipped.
			 **
			 ** This code copies current group by terms in b0,b1,b2,...
			 ** over to a0,a1,a2.  It then calls the output subroutine
			 ** and resets the aggregate accumulator registers in preparation
			 ** for the next GROUP BY batch.
			 */
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Gosub), regOutputRow, addrOutputRow)
			_sqlite3ExprCodeMove(tls, pParse, iBMem, iAMem, (*TExprList)(unsafe.Pointer(pGroupBy)).FnExpr)
			_sqlite3VdbeAddOp2(tls, v, int32(OP_IfPos), iAbortFlag, addrEnd)
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Gosub), regReset, addrReset)
			/* Update the aggregate accumulators based on the content of
			 ** the current row
			 */
			_sqlite3VdbeJumpHere(tls, v, addr1)
			_updateAccumulator(tls, pParse, iUseFlag, pAggInfo, eDist)
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), int32(1), iUseFlag)
			/* End of the loop
			 */
			if groupBySort != 0 {
				_sqlite3VdbeAddOp2(tls, v, int32(OP_SorterNext), (*TAggInfo)(unsafe.Pointer(pAggInfo)).FsortingIdx, addrTopOfLoop)
			} else {
				_sqlite3WhereEnd(tls, pWInfo)
				_sqlite3VdbeChangeToNoop(tls, v, addrSortingIdx)
			}
			_sqlite3ExprListDelete(tls, db, pDistinct)
			/* Output the final row of result
			 */
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Gosub), regOutputRow, addrOutputRow)
			/* Jump over the subroutines
			 */
			_sqlite3VdbeGoto(tls, v, addrEnd)
			/* Generate a subroutine that outputs a single row of the result
			 ** set.  This subroutine first looks at the iUseFlag.  If iUseFlag
			 ** is less than or equal to zero, the subroutine is a no-op.  If
			 ** the processing calls for the query to abort, this subroutine
			 ** increments the iAbortFlag memory location before returning in
			 ** order to signal the caller to abort.
			 */
			addrSetAbort = _sqlite3VdbeCurrentAddr(tls, v)
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), int32(1), iAbortFlag)
			_sqlite3VdbeAddOp1(tls, v, int32(OP_Return), regOutputRow)
			_sqlite3VdbeResolveLabel(tls, v, addrOutputRow)
			addrOutputRow = _sqlite3VdbeCurrentAddr(tls, v)
			_sqlite3VdbeAddOp2(tls, v, int32(OP_IfPos), iUseFlag, addrOutputRow+int32(2))
			_sqlite3VdbeAddOp1(tls, v, int32(OP_Return), regOutputRow)
			_finalizeAggFunctions(tls, pParse, pAggInfo)
			_sqlite3ExprIfFalse(tls, pParse, pHaving, addrOutputRow+int32(1), int32(SQLITE_JUMPIFNULL))
			_selectInnerLoop(tls, pParse, p, -int32(1), bp+12, bp, pDest, addrOutputRow+int32(1), addrSetAbort)
			_sqlite3VdbeAddOp1(tls, v, int32(OP_Return), regOutputRow)
			/* Generate a subroutine that will reset the group-by accumulator
			 */
			_sqlite3VdbeResolveLabel(tls, v, addrReset)
			_resetAccumulator(tls, pParse, pAggInfo)
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), 0, iUseFlag)
			_sqlite3VdbeAddOp1(tls, v, int32(OP_Return), regReset)
			if libc.Int32FromUint16(distFlag) != 0 && eDist != WHERE_DISTINCT_NOOP {
				pF = (*TAggInfo)(unsafe.Pointer(pAggInfo)).FaFunc
				_fixDistinctOpenEph(tls, pParse, eDist, (*TAggInfo_func)(unsafe.Pointer(pF)).FiDistinct, (*TAggInfo_func)(unsafe.Pointer(pF)).FiDistAddr)
			}
		} else {
			v1 = _isSimpleCount(tls, p, pAggInfo)
			pTab1 = v1
			if v1 != uintptr(0) {
				/* tag-select-0821
				 **
				 ** If isSimpleCount() returns a pointer to a Table structure, then
				 ** the SQL statement is of the form:
				 **
				 **   SELECT count(*) FROM <tbl>
				 **
				 ** where the Table structure returned represents table <tbl>.
				 **
				 ** This statement is so common that it is optimized specially. The
				 ** OP_Count instruction is executed either on the intkey table that
				 ** contains the data for table <tbl> or on one of its indexes. It
				 ** is better to execute the op on an index, as indexes are almost
				 ** always spread across less pages than their corresponding tables.
				 */
				iDb1 = _sqlite3SchemaToIndex(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, (*TTable)(unsafe.Pointer(pTab1)).FpSchema)
				v3 = pParse + 44
				v12 = *(*int32)(unsafe.Pointer(v3))
				*(*int32)(unsafe.Pointer(v3)) = *(*int32)(unsafe.Pointer(v3)) + 1
				iCsr = v12                                     /* Iterator variable */
				pKeyInfo2 = uintptr(0)                         /* Keyinfo for scanned index */
				pBest = uintptr(0)                             /* Best index found so far */
				iRoot = (*TTable)(unsafe.Pointer(pTab1)).Ftnum /* Root page of scanned b-tree */
				_sqlite3CodeVerifySchema(tls, pParse, iDb1)
				_sqlite3TableLock(tls, pParse, iDb1, (*TTable)(unsafe.Pointer(pTab1)).Ftnum, uint8(0), (*TTable)(unsafe.Pointer(pTab1)).FzName)
				/* Search for the index that has the lowest scan cost.
				 **
				 ** (2011-04-15) Do not do a full scan of an unordered index.
				 **
				 ** (2013-10-03) Do not count the entries in a partial index.
				 **
				 ** In practice the KeyInfo structure will not be used. It is only
				 ** passed to keep OP_OpenRead happy.
				 */
				if !((*TTable)(unsafe.Pointer(pTab1)).FtabFlags&libc.Uint32FromInt32(TF_WithoutRowid) == libc.Uint32FromInt32(0)) {
					pBest = _sqlite3PrimaryKeyIndex(tls, pTab1)
				}
				if !(int32(*(*uint32)(unsafe.Pointer((*TSelect)(unsafe.Pointer(p)).FpSrc + 8 + 12 + 4))&0x1>>0) != 0) {
					pIdx = (*TTable)(unsafe.Pointer(pTab1)).FpIndex
					for {
						if !(pIdx != 0) {
							break
						}
						if int32(uint32(*(*uint16)(unsafe.Pointer(pIdx + 56))&0x4>>2)) == 0 && int32((*TIndex)(unsafe.Pointer(pIdx)).FszIdxRow) < int32((*TTable)(unsafe.Pointer(pTab1)).FszTabRow) && (*TIndex)(unsafe.Pointer(pIdx)).FpPartIdxWhere == uintptr(0) && (!(pBest != 0) || int32((*TIndex)(unsafe.Pointer(pIdx)).FszIdxRow) < int32((*TIndex)(unsafe.Pointer(pBest)).FszIdxRow)) {
							pBest = pIdx
						}
						goto _56
					_56:
						;
						pIdx = (*TIndex)(unsafe.Pointer(pIdx)).FpNext
					}
				}
				if pBest != 0 {
					iRoot = (*TIndex)(unsafe.Pointer(pBest)).Ftnum
					pKeyInfo2 = _sqlite3KeyInfoOfIndex(tls, pParse, pBest)
				}
				/* Open a read-only cursor, execute the OP_Count, close the cursor. */
				_sqlite3VdbeAddOp4Int(tls, v, int32(OP_OpenRead), iCsr, libc.Int32FromUint32(iRoot), iDb1, int32(1))
				if pKeyInfo2 != 0 {
					_sqlite3VdbeChangeP4(tls, v, -int32(1), pKeyInfo2, -int32(9))
				}
				_assignAggregateRegisters(tls, pParse, pAggInfo)
				_sqlite3VdbeAddOp2(tls, v, int32(OP_Count), iCsr, (*TAggInfo)(unsafe.Pointer(pAggInfo)).FiFirstReg+(*TAggInfo)(unsafe.Pointer(pAggInfo)).FnColumn+0)
				_sqlite3VdbeAddOp1(tls, v, int32(OP_Close), iCsr)
				_explainSimpleCount(tls, pParse, pTab1, pBest)
			} else {
				/* The general case of an aggregate query without GROUP BY
				 ** tag-select-0822 */
				regAcc = 0 /* "populate accumulators" flag */
				pDistinct1 = uintptr(0)
				distFlag1 = uint16(0)
				/* If there are accumulator registers but no min() or max() functions
				 ** without FILTER clauses, allocate register regAcc. Register regAcc
				 ** will contain 0 the first time the inner loop runs, and 1 thereafter.
				 ** The code generated by updateAccumulator() uses this to ensure
				 ** that the accumulator registers are (a) updated only once if
				 ** there are no min() or max functions or (b) always updated for the
				 ** first row visited by the aggregate, so that they are updated at
				 ** least once even if the FILTER clause means the min() or max()
				 ** function visits zero rows.  */
				if (*TAggInfo)(unsafe.Pointer(pAggInfo)).FnAccumulator != 0 {
					i = 0
					for {
						if !(i < (*TAggInfo)(unsafe.Pointer(pAggInfo)).FnFunc) {
							break
						}
						if (*TExpr)(unsafe.Pointer((**(**TAggInfo_func)(__ccgo_up((*TAggInfo)(unsafe.Pointer(pAggInfo)).FaFunc + uintptr(i)*24))).FpFExpr)).Fflags&libc.Uint32FromInt32(libc.Int32FromInt32(EP_WinFunc)) != uint32(0) {
							goto _57
						}
						if (*TFuncDef)(unsafe.Pointer((**(**TAggInfo_func)(__ccgo_up((*TAggInfo)(unsafe.Pointer(pAggInfo)).FaFunc + uintptr(i)*24))).FpFunc)).FfuncFlags&uint32(SQLITE_FUNC_NEEDCOLL) != 0 {
							break
						}
						goto _57
					_57:
						;
						i = i + 1
					}
					if i == (*TAggInfo)(unsafe.Pointer(pAggInfo)).FnFunc {
						v1 = pParse + 48
						*(*int32)(unsafe.Pointer(v1)) = *(*int32)(unsafe.Pointer(v1)) + 1
						v12 = *(*int32)(unsafe.Pointer(v1))
						regAcc = v12
						_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), 0, regAcc)
					}
				} else {
					if (*TAggInfo)(unsafe.Pointer(pAggInfo)).FnFunc == int32(1) && (**(**TAggInfo_func)(__ccgo_up((*TAggInfo)(unsafe.Pointer(pAggInfo)).FaFunc))).FiDistinct >= 0 {
						pDistinct1 = *(*uintptr)(unsafe.Pointer((**(**TAggInfo_func)(__ccgo_up((*TAggInfo)(unsafe.Pointer(pAggInfo)).FaFunc))).FpFExpr + 20))
						if pDistinct1 != 0 {
							v12 = libc.Int32FromInt32(WHERE_WANT_DISTINCT) | libc.Int32FromInt32(WHERE_AGG_DISTINCT)
						} else {
							v12 = 0
						}
						distFlag1 = libc.Uint16FromInt32(v12)
					}
				}
				_assignAggregateRegisters(tls, pParse, pAggInfo)
				/* This case runs if the aggregate has no GROUP BY clause.  The
				 ** processing is much simpler since there is only a single row
				 ** of output.
				 */
				_resetAccumulator(tls, pParse, pAggInfo)
				/* If this query is a candidate for the min/max optimization, then
				 ** minMaxFlag will have been previously set to either
				 ** WHERE_ORDERBY_MIN or WHERE_ORDERBY_MAX and pMinMaxOrderBy will
				 ** be an appropriate ORDER BY expression for the optimization.
				 */
				pWInfo = _sqlite3WhereBegin(tls, pParse, pTabList, pWhere, **(**uintptr)(__ccgo_up(bp + 52)), pDistinct1, p, libc.Uint16FromInt32(libc.Int32FromUint8(minMaxFlag)|libc.Int32FromUint16(distFlag1)), 0)
				if pWInfo == uintptr(0) {
					goto select_end
				}
				eDist1 = _sqlite3WhereIsDistinct(tls, pWInfo)
				_updateAccumulator(tls, pParse, regAcc, pAggInfo, eDist1)
				if eDist1 != WHERE_DISTINCT_NOOP {
					pF1 = (*TAggInfo)(unsafe.Pointer(pAggInfo)).FaFunc
					if pF1 != 0 {
						_fixDistinctOpenEph(tls, pParse, eDist1, (*TAggInfo_func)(unsafe.Pointer(pF1)).FiDistinct, (*TAggInfo_func)(unsafe.Pointer(pF1)).FiDistAddr)
					}
				}
				if regAcc != 0 {
					_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), int32(1), regAcc)
				}
				if minMaxFlag != 0 {
					_sqlite3WhereMinMaxOptEarlyOut(tls, v, pWInfo)
				}
				_sqlite3WhereEnd(tls, pWInfo)
				_finalizeAggFunctions(tls, pParse, pAggInfo)
			}
			(**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy = uintptr(0)
			_sqlite3ExprIfFalse(tls, pParse, pHaving, addrEnd, int32(SQLITE_JUMPIFNULL))
			_selectInnerLoop(tls, pParse, p, -int32(1), uintptr(0), uintptr(0), pDest, addrEnd, addrEnd)
		}
		_sqlite3VdbeResolveLabel(tls, v, addrEnd)
	} /* endif aggregate query */
	if libc.Int32FromUint8((**(**TDistinctCtx)(__ccgo_up(bp))).FeTnctType) == int32(WHERE_DISTINCT_UNORDERED) {
		_explainTempTable(tls, pParse, __ccgo_ts+21755)
	}
	/* If there is an ORDER BY clause, then we need to sort the results
	 ** and send them to the callback one by one.  tag-select-0900
	 */
	if (**(**TSortCtx)(__ccgo_up(bp + 12))).FpOrderBy != 0 {
		_generateSortTail(tls, pParse, p, bp+12, (*TExprList)(unsafe.Pointer(pEList)).FnExpr, pDest)
	}
	/* Jump here to skip this query
	 */
	_sqlite3VdbeResolveLabel(tls, v, iEnd)
	/* The SELECT has been coded. If there is an error in the Parse structure,
	 ** set the return code to 1. Otherwise 0. */
	rc = libc.BoolInt32((*TParse)(unsafe.Pointer(pParse)).FnErr > 0)
	/* Control jumps to here if an error is encountered above, or upon
	 ** successful coding of the SELECT.
	 */
	goto select_end
select_end:
	;
	_sqlite3ExprListDelete(tls, db, **(**uintptr)(__ccgo_up(bp + 52)))
	_sqlite3VdbeExplainPop(tls, pParse)
	return rc
}

/************** End of select.c **********************************************/
/************** Begin file table.c *******************************************/
/*
** 2001 September 15
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:
**
**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains the sqlite3_get_table() and sqlite3_free_table()
** interface routines.  These are just wrappers around the main
** interface routine of sqlite3_exec().
**
** These routines are in a separate files so that they will not be linked
** if they are not used.
 */
/* #include "sqliteInt.h" */

// C documentation
//
//	/*
//	** This routine is called by the parser to add a new term to the
//	** end of a growing FROM clause.  The "p" parameter is the part of
//	** the FROM clause that has already been constructed.  "p" is NULL
//	** if this is the first term of the FROM clause.  pTable and pDatabase
//	** are the name of the table and database named in the FROM clause term.
//	** pDatabase is NULL if the database name qualifier is missing - the
//	** usual case.  If the term has an alias, then pAlias points to the
//	** alias token.  If the term is a subquery, then pSubquery is the
//	** SELECT statement that the subquery encodes.  The pTable and
//	** pDatabase parameters are NULL for subqueries.  The pOn and pUsing
//	** parameters are the content of the ON and USING clauses.
//	**
//	** Return a new SrcList which encodes is the FROM with the new
//	** term added.
//	*/
func _sqlite3SrcListAppendFromTerm(tls *libc.TLS, pParse uintptr, p uintptr, pTable uintptr, pDatabase uintptr, pAlias uintptr, pSubquery uintptr, pOnUsing uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var db, pItem, pToken, v1 uintptr
	_, _, _, _ = db, pItem, pToken, v1
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	if !(p != 0) && pOnUsing != uintptr(0) && ((*TOnOrUsing)(unsafe.Pointer(pOnUsing)).FpOn != 0 || (*TOnOrUsing)(unsafe.Pointer(pOnUsing)).FpUsing != 0) {
		if (*TOnOrUsing)(unsafe.Pointer(pOnUsing)).FpOn != 0 {
			v1 = __ccgo_ts + 16060
		} else {
			v1 = __ccgo_ts + 16063
		}
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+16069, libc.VaList(bp+8, v1))
		goto append_from_error
	}
	p = _sqlite3SrcListAppend(tls, pParse, p, pTable, pDatabase)
	if p == uintptr(0) {
		goto append_from_error
	}
	pItem = p + 8 + uintptr((*TSrcList)(unsafe.Pointer(p)).FnSrc-int32(1))*48
	if libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).FeParseMode) >= int32(PARSE_MODE_RENAME) && (*TSrcItem)(unsafe.Pointer(pItem)).FzName != 0 {
		if pDatabase != 0 && (*TToken)(unsafe.Pointer(pDatabase)).Fz != 0 {
			v1 = pDatabase
		} else {
			v1 = pTable
		}
		pToken = v1
		_sqlite3RenameTokenMap(tls, pParse, (*TSrcItem)(unsafe.Pointer(pItem)).FzName, pToken)
	}
	if (*TToken)(unsafe.Pointer(pAlias)).Fn != 0 {
		(*TSrcItem)(unsafe.Pointer(pItem)).FzAlias = _sqlite3NameFromToken(tls, db, pAlias)
	}
	if pSubquery != 0 {
		if _sqlite3SrcItemAttachSubquery(tls, pParse, pItem, pSubquery, 0) != 0 {
			if (*TSelect)(unsafe.Pointer(pSubquery)).FselFlags&uint32(SF_NestedFrom) != 0 {
				libc.SetBitFieldPtr32Uint32(pItem+12+4, libc.Uint32FromInt32(1), 14, 0x4000)
			}
		}
	}
	if pOnUsing == uintptr(0) {
		*(*uintptr)(unsafe.Pointer(pItem + 40)) = uintptr(0)
	} else {
		if (*TOnOrUsing)(unsafe.Pointer(pOnUsing)).FpUsing != 0 {
			libc.SetBitFieldPtr32Uint32(pItem+12+4, libc.Uint32FromInt32(1), 11, 0x800)
			*(*uintptr)(unsafe.Pointer(pItem + 40)) = (*TOnOrUsing)(unsafe.Pointer(pOnUsing)).FpUsing
		} else {
			*(*uintptr)(unsafe.Pointer(pItem + 40)) = (*TOnOrUsing)(unsafe.Pointer(pOnUsing)).FpOn
		}
	}
	return p
	goto append_from_error
append_from_error:
	;
	_sqlite3ClearOnOrUsing(tls, db, pOnUsing)
	_sqlite3SelectDelete(tls, db, pSubquery)
	return uintptr(0)
}

// C documentation
//
//	/*
//	** Expand the space allocated for the given SrcList object by
//	** creating nExtra new slots beginning at iStart.  iStart is zero based.
//	** New slots are zeroed.
//	**
//	** For example, suppose a SrcList initially contains two entries: A,B.
//	** To append 3 new entries onto the end, do this:
//	**
//	**    sqlite3SrcListEnlarge(db, pSrclist, 3, 2);
//	**
//	** After the call above it would contain:  A, B, nil, nil, nil.
//	** If the iStart argument had been 1 instead of 2, then the result
//	** would have been:  A, nil, nil, nil, B.  To prepend the new slots,
//	** the iStart value would be 0.  The result then would
//	** be: nil, nil, nil, A, B.
//	**
//	** If a memory allocation fails or the SrcList becomes too large, leave
//	** the original SrcList unchanged, return NULL, and leave an error message
//	** in pParse.
//	*/
func _sqlite3SrcListEnlarge(tls *libc.TLS, pParse uintptr, pSrc uintptr, nExtra int32, iStart int32) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var db, pNew uintptr
	var i int32
	var nAlloc Tsqlite3_int64
	_, _, _, _ = db, i, nAlloc, pNew
	/* Sanity checking on calling parameters */
	/* Allocate additional space if needed */
	if libc.Uint32FromInt32((*TSrcList)(unsafe.Pointer(pSrc)).FnSrc)+libc.Uint32FromInt32(nExtra) > (*TSrcList)(unsafe.Pointer(pSrc)).FnAlloc {
		nAlloc = int64(2)*int64((*TSrcList)(unsafe.Pointer(pSrc)).FnSrc) + int64(nExtra)
		db = (*TParse)(unsafe.Pointer(pParse)).Fdb
		if (*TSrcList)(unsafe.Pointer(pSrc)).FnSrc+nExtra >= int32(SQLITE_MAX_SRCLIST) {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+16024, libc.VaList(bp+8, int32(SQLITE_MAX_SRCLIST)))
			return uintptr(0)
		}
		if nAlloc > int64(SQLITE_MAX_SRCLIST) {
			nAlloc = int64(SQLITE_MAX_SRCLIST)
		}
		pNew = _sqlite3DbRealloc(tls, db, pSrc, libc.Uint64FromInt64(libc.Int64FromUint32(uint32(libc.UintptrFromInt32(0)+8))+nAlloc*libc.Int64FromInt64(48)))
		if pNew == uintptr(0) {
			return uintptr(0)
		}
		pSrc = pNew
		(*TSrcList)(unsafe.Pointer(pSrc)).FnAlloc = libc.Uint32FromInt64(nAlloc)
	}
	/* Move existing slots that come after the newly inserted slots
	 ** out of the way */
	i = (*TSrcList)(unsafe.Pointer(pSrc)).FnSrc - int32(1)
	for {
		if !(i >= iStart) {
			break
		}
		*(*TSrcItem)(unsafe.Pointer(pSrc + 8 + uintptr(i+nExtra)*48)) = *(*TSrcItem)(unsafe.Pointer(pSrc + 8 + uintptr(i)*48))
		goto _1
	_1:
		;
		i = i - 1
	}
	**(**int32)(__ccgo_up(pSrc)) += nExtra
	/* Zero the newly allocated slots */
	libc.Xmemset(tls, pSrc+8+uintptr(iStart)*48, 0, uint32(48)*libc.Uint32FromInt32(nExtra))
	i = iStart
	for {
		if !(i < iStart+nExtra) {
			break
		}
		(*(*TSrcItem)(unsafe.Pointer(pSrc + 8 + uintptr(i)*48))).FiCursor = -int32(1)
		goto _2
	_2:
		;
		i = i + 1
	}
	/* Return a pointer to the enlarged SrcList */
	return pSrc
}

// C documentation
//
//	/* Create a new thread */
func _sqlite3ThreadCreate(tls *libc.TLS, ppThread uintptr, __ccgo_fp_xTask uintptr, pIn uintptr) (r int32) {
	var p uintptr
	_ = p
	**(**uintptr)(__ccgo_up(ppThread)) = uintptr(0)
	p = _sqlite3Malloc(tls, uint64(12))
	if p == uintptr(0) {
		return int32(SQLITE_NOMEM)
	}
	if int32(p)/int32(17)&int32(1) != 0 {
		(*TSQLiteThread)(unsafe.Pointer(p)).FxTask = __ccgo_fp_xTask
		(*TSQLiteThread)(unsafe.Pointer(p)).FpIn = pIn
	} else {
		(*TSQLiteThread)(unsafe.Pointer(p)).FxTask = uintptr(0)
		(*TSQLiteThread)(unsafe.Pointer(p)).FpResult = (*(*func(*libc.TLS, uintptr) uintptr)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_xTask})))(tls, pIn)
	}
	**(**uintptr)(__ccgo_up(ppThread)) = p
	return SQLITE_OK
}

// C documentation
//
//	/*
//	** Process an UPDATE statement.
//	**
//	**   UPDATE OR IGNORE tbl SET a=b, c=d FROM tbl2... WHERE e<5 AND f NOT NULL;
//	**          \_______/ \_/     \______/      \_____/       \________________/
//	**           onError   |      pChanges         |                pWhere
//	**                     \_______________________/
//	**                               pTabList
//	*/
func _sqlite3Update(tls *libc.TLS, pParse uintptr, pTabList uintptr, pChanges uintptr, pWhere uintptr, onError int32, pOrderBy uintptr, pLimit uintptr, pUpsert uintptr) {
	bp := tls.Alloc(96)
	defer tls.Free(96)
	var aRegIdx, aToOpen, aXRef, db, pIdx, pKeyInfo, pPk, pRowidExpr, pTab, pTrigger, pWInfo, v, v4 uintptr
	var addrOnce, addrOpen, addrTop, bFinishSeek, bProgress, eOnePass, flags, hasFK, i, iBaseCur, iCur, iDataCur, iDb, iEph, iIdxCur, iPk, iRowidExpr, isView, j, k, labelBreak, labelContinue, nAllIdx, nChangeFrom, nEphCol, nIdx, nKey, nOff, newmask, rc, reg, regKey, regNew, regNewRowid, regOld, regOldRowid, regRowCount, regRowSet, v1, v2 int32
	var chngKey, chngPk, chngRowid, v8 Tu8
	var colFlags, oldmask Tu32
	var nPk Ti16
	var v12 uint64
	var v42 uint32
	var _ /* aiCurOnePass at bp+48 */ [2]int32
	var _ /* bReplace at bp+56 */ int32
	var _ /* iNotUsed1 at bp+60 */ int32
	var _ /* iNotUsed2 at bp+64 */ int32
	var _ /* sContext at bp+0 */ TAuthContext
	var _ /* sNC at bp+8 */ TNameContext
	var _ /* tmask at bp+44 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = aRegIdx, aToOpen, aXRef, addrOnce, addrOpen, addrTop, bFinishSeek, bProgress, chngKey, chngPk, chngRowid, colFlags, db, eOnePass, flags, hasFK, i, iBaseCur, iCur, iDataCur, iDb, iEph, iIdxCur, iPk, iRowidExpr, isView, j, k, labelBreak, labelContinue, nAllIdx, nChangeFrom, nEphCol, nIdx, nKey, nOff, nPk, newmask, oldmask, pIdx, pKeyInfo, pPk, pRowidExpr, pTab, pTrigger, pWInfo, rc, reg, regKey, regNew, regNewRowid, regOld, regOldRowid, regRowCount, regRowSet, v, v1, v12, v2, v4, v42, v8 /* The table to be updated */
	addrTop = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           /* VDBE instruction address of the start of the loop */
	pWInfo = uintptr(0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   /* The database structure */
	aRegIdx = uintptr(0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  /* Registers for to each index and the main table */
	aXRef = uintptr(0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    /* Either chngPk or chngRowid */
	pRowidExpr = uintptr(0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               /* Expression defining the new record number */
	iRowidExpr = -int32(1)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                /* Mask of NEW.* columns accessed by BEFORE triggers */
	iEph = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /* Ephemeral table holding all primary key values */
	nKey = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              /* The write cursors opened by WHERE_ONEPASS */
	addrOpen = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          /* Address of OP_OpenEphemeral */
	iPk = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               /* First of nPk cells holding PRIMARY KEY value */
	nPk = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               /* Number of components of the PRIMARY KEY */
	**(**int32)(__ccgo_up(bp + 56)) = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   /* True if REPLACE conflict resolution might happen */
	bFinishSeek = int32(1)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                /* The OP_FinishSeek opcode is needed */
	nChangeFrom = 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       /* If there is a FROM, pChanges->nExpr, else 0 */
	/* Register Allocations */
	regRowCount = 0 /* A count of rows changed */
	regOldRowid = 0 /* The old rowid */
	regNewRowid = 0 /* The new rowid */
	regNew = 0      /* Content of the NEW.* table in triggers */
	regOld = 0      /* Content of OLD.* table in triggers */
	regRowSet = 0   /* Rowset of rows to be updated */
	regKey = 0      /* composite PRIMARY KEY value */
	libc.Xmemset(tls, bp, 0, uint32(8))
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	if (*TParse)(unsafe.Pointer(pParse)).FnErr != 0 {
		goto update_cleanup
	}
	/* Locate the table which we want to update.
	 */
	pTab = _sqlite3SrcListLookup(tls, pParse, pTabList)
	if pTab == uintptr(0) {
		goto update_cleanup
	}
	iDb = _sqlite3SchemaToIndex(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, (*TTable)(unsafe.Pointer(pTab)).FpSchema)
	/* Figure out if we have any triggers and if the table being
	 ** updated is a view.
	 */
	pTrigger = _sqlite3TriggersExist(tls, pParse, pTab, int32(TK_UPDATE), pChanges, bp+44)
	isView = libc.BoolInt32(libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VIEW))
	/* If there was a FROM clause, set nChangeFrom to the number of expressions
	 ** in the change-list. Otherwise, set it to 0. There cannot be a FROM
	 ** clause if this function is being called to generate code for part of
	 ** an UPSERT statement.  */
	if (*TSrcList)(unsafe.Pointer(pTabList)).FnSrc > int32(1) {
		v1 = (*TExprList)(unsafe.Pointer(pChanges)).FnExpr
	} else {
		v1 = 0
	}
	nChangeFrom = v1
	if _sqlite3ViewGetColumnNames(tls, pParse, pTab) != 0 {
		goto update_cleanup
	}
	if _sqlite3IsReadOnly(tls, pParse, pTab, pTrigger) != 0 {
		goto update_cleanup
	}
	/* Allocate a cursors for the main database table and for all indices.
	 ** The index cursors might not be used, but if they are used they
	 ** need to occur right after the database cursor.  So go ahead and
	 ** allocate enough space, just in case.
	 */
	v4 = pParse + 44
	v2 = *(*int32)(unsafe.Pointer(v4))
	*(*int32)(unsafe.Pointer(v4)) = *(*int32)(unsafe.Pointer(v4)) + 1
	v1 = v2
	iDataCur = v1
	iBaseCur = v1
	iIdxCur = iDataCur + int32(1)
	if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_WithoutRowid) == uint32(0) {
		v4 = uintptr(0)
	} else {
		v4 = _sqlite3PrimaryKeyIndex(tls, pTab)
	}
	pPk = v4
	nIdx = 0
	pIdx = (*TTable)(unsafe.Pointer(pTab)).FpIndex
	for {
		if !(pIdx != 0) {
			break
		}
		if pPk == pIdx {
			iDataCur = (*TParse)(unsafe.Pointer(pParse)).FnTab
		}
		(*TParse)(unsafe.Pointer(pParse)).FnTab = (*TParse)(unsafe.Pointer(pParse)).FnTab + 1
		goto _6
	_6:
		;
		pIdx = (*TIndex)(unsafe.Pointer(pIdx)).FpNext
		nIdx = nIdx + 1
	}
	if pUpsert != 0 {
		/* On an UPSERT, reuse the same cursors already opened by INSERT */
		iDataCur = (*TUpsert)(unsafe.Pointer(pUpsert)).FiDataCur
		iIdxCur = (*TUpsert)(unsafe.Pointer(pUpsert)).FiIdxCur
		(*TParse)(unsafe.Pointer(pParse)).FnTab = iBaseCur
	}
	(*(*TSrcItem)(unsafe.Pointer(pTabList + 8))).FiCursor = iDataCur
	/* Allocate space for aXRef[], aRegIdx[], and aToOpen[].
	 ** Initialize aXRef[] and aToOpen[] to their default values.
	 */
	aXRef = _sqlite3DbMallocRawNN(tls, db, uint64(uint32(4)*libc.Uint32FromInt32(int32((*TTable)(unsafe.Pointer(pTab)).FnCol)+nIdx+libc.Int32FromInt32(1))+libc.Uint32FromInt32(nIdx)+uint32(2)))
	if aXRef == uintptr(0) {
		goto update_cleanup
	}
	aRegIdx = aXRef + uintptr((*TTable)(unsafe.Pointer(pTab)).FnCol)*4
	aToOpen = aRegIdx + uintptr(nIdx)*4 + libc.UintptrFromInt32(1)*4
	libc.Xmemset(tls, aToOpen, int32(1), libc.Uint32FromInt32(nIdx+int32(1)))
	**(**Tu8)(__ccgo_up(aToOpen + uintptr(nIdx+int32(1)))) = uint8(0)
	i = 0
	for {
		if !(i < int32((*TTable)(unsafe.Pointer(pTab)).FnCol)) {
			break
		}
		**(**int32)(__ccgo_up(aXRef + uintptr(i)*4)) = -int32(1)
		goto _7
	_7:
		;
		i = i + 1
	}
	/* Initialize the name-context */
	libc.Xmemset(tls, bp+8, 0, uint32(36))
	(**(**TNameContext)(__ccgo_up(bp + 8))).FpParse = pParse
	(**(**TNameContext)(__ccgo_up(bp + 8))).FpSrcList = pTabList
	*(*uintptr)(unsafe.Pointer(bp + 8 + 8)) = pUpsert
	(**(**TNameContext)(__ccgo_up(bp + 8))).FncFlags = int32(NC_UUpsert)
	/* Begin generating code. */
	v = _sqlite3GetVdbe(tls, pParse)
	if v == uintptr(0) {
		goto update_cleanup
	}
	/* Resolve the column names in all the expressions of the
	 ** of the UPDATE statement.  Also find the column index
	 ** for each column to be updated in the pChanges array.  For each
	 ** column to be updated, make sure we have authorization to change
	 ** that column.
	 */
	v8 = libc.Uint8FromInt32(0)
	chngPk = v8
	chngRowid = v8
	i = 0
	for {
		if !(i < (*TExprList)(unsafe.Pointer(pChanges)).FnExpr) {
			break
		}
		/* If this is an UPDATE with a FROM clause, do not resolve expressions
		 ** here. The call to sqlite3Select() below will do that. */
		if nChangeFrom == 0 && _sqlite3ResolveExprNames(tls, bp+8, (*(*TExprList_item)(unsafe.Pointer(pChanges + 8 + uintptr(i)*20))).FpExpr) != 0 {
			goto update_cleanup
		}
		j = _sqlite3ColumnIndex(tls, pTab, (*(*TExprList_item)(unsafe.Pointer(pChanges + 8 + uintptr(i)*20))).FzEName)
		if j >= 0 {
			if j == int32((*TTable)(unsafe.Pointer(pTab)).FiPKey) {
				chngRowid = uint8(1)
				pRowidExpr = (*(*TExprList_item)(unsafe.Pointer(pChanges + 8 + uintptr(i)*20))).FpExpr
				iRowidExpr = i
			} else {
				if pPk != 0 && libc.Int32FromUint16((**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(j)*12))).FcolFlags)&int32(COLFLAG_PRIMKEY) != 0 {
					chngPk = uint8(1)
				} else {
					if libc.Int32FromUint16((**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(j)*12))).FcolFlags)&int32(COLFLAG_GENERATED) != 0 {
						_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+22605, libc.VaList(bp+80, (**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(j)*12))).FzCnName))
						goto update_cleanup
					}
				}
			}
			**(**int32)(__ccgo_up(aXRef + uintptr(j)*4)) = i
		} else {
			if pPk == uintptr(0) && _sqlite3IsRowid(tls, (*(*TExprList_item)(unsafe.Pointer(pChanges + 8 + uintptr(i)*20))).FzEName) != 0 {
				j = -int32(1)
				chngRowid = uint8(1)
				pRowidExpr = (*(*TExprList_item)(unsafe.Pointer(pChanges + 8 + uintptr(i)*20))).FpExpr
				iRowidExpr = i
			} else {
				_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+11908, libc.VaList(bp+80, (*(*TExprList_item)(unsafe.Pointer(pChanges + 8 + uintptr(i)*20))).FzEName))
				libc.SetBitFieldPtr16Uint32(pParse+28, libc.Uint32FromInt32(1), 8, 0x100)
				goto update_cleanup
			}
		}
		if j < 0 {
			v4 = __ccgo_ts + 8199
		} else {
			v4 = (**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(j)*12))).FzCnName
		}
		rc = _sqlite3AuthCheck(tls, pParse, int32(SQLITE_UPDATE), (*TTable)(unsafe.Pointer(pTab)).FzName, v4, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FzDbSName)
		if rc == int32(SQLITE_DENY) {
			goto update_cleanup
		} else {
			if rc == int32(SQLITE_IGNORE) {
				**(**int32)(__ccgo_up(aXRef + uintptr(j)*4)) = -int32(1)
			}
		}
		goto _9
	_9:
		;
		i = i + 1
	}
	chngKey = libc.Uint8FromInt32(libc.Int32FromUint8(chngRowid) + libc.Int32FromUint8(chngPk))
	/* Mark generated columns as changing if their generator expressions
	 ** reference any changing column.  The actual aXRef[] value for
	 ** generated expressions is not used, other than to check to see that it
	 ** is non-negative, so the value of aXRef[] for generated columns can be
	 ** set to any non-negative number.  We use 99999 so that the value is
	 ** obvious when looking at aXRef[] in a symbolic debugger.
	 */
	if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_HasGenerated) != 0 {
		for cond := true; cond; cond = bProgress != 0 {
			bProgress = 0
			i = 0
			for {
				if !(i < int32((*TTable)(unsafe.Pointer(pTab)).FnCol)) {
					break
				}
				if **(**int32)(__ccgo_up(aXRef + uintptr(i)*4)) >= 0 {
					goto _11
				}
				if libc.Int32FromUint16((**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(i)*12))).FcolFlags)&int32(COLFLAG_GENERATED) == 0 {
					goto _11
				}
				if _sqlite3ExprReferencesUpdatedColumn(tls, _sqlite3ColumnExpr(tls, pTab, (*TTable)(unsafe.Pointer(pTab)).FaCol+uintptr(i)*12), aXRef, libc.Int32FromUint8(chngRowid)) != 0 {
					**(**int32)(__ccgo_up(aXRef + uintptr(i)*4)) = int32(99999)
					bProgress = int32(1)
				}
				goto _11
			_11:
				;
				i = i + 1
			}
		}
	}
	/* The SET expressions are not actually used inside the WHERE loop.
	 ** So reset the colUsed mask. Unless this is a virtual table. In that
	 ** case, set all bits of the colUsed mask (to ensure that the virtual
	 ** table implementation makes all columns available).
	 */
	if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) {
		v12 = libc.Uint64FromInt32(-libc.Int32FromInt32(1))
	} else {
		v12 = uint64(0)
	}
	(*(*TSrcItem)(unsafe.Pointer(pTabList + 8))).FcolUsed = v12
	hasFK = _sqlite3FkRequired(tls, pParse, pTab, aXRef, libc.Int32FromUint8(chngKey))
	/* There is one entry in the aRegIdx[] array for each index on the table
	 ** being updated.  Fill in aRegIdx[] with a register number that will hold
	 ** the key for accessing each index.
	 */
	if onError == int32(OE_Replace) {
		**(**int32)(__ccgo_up(bp + 56)) = int32(1)
	}
	nAllIdx = 0
	pIdx = (*TTable)(unsafe.Pointer(pTab)).FpIndex
	for {
		if !(pIdx != 0) {
			break
		}
		if chngKey != 0 || hasFK > int32(1) || pIdx == pPk || _indexWhereClauseMightChange(tls, pIdx, aXRef, libc.Int32FromUint8(chngRowid)) != 0 {
			v4 = pParse + 48
			*(*int32)(unsafe.Pointer(v4)) = *(*int32)(unsafe.Pointer(v4)) + 1
			v1 = *(*int32)(unsafe.Pointer(v4))
			reg = v1
			**(**int32)(__ccgo_up(pParse + 48)) += libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pIdx)).FnColumn)
		} else {
			reg = 0
			i = 0
			for {
				if !(i < libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pIdx)).FnKeyCol)) {
					break
				}
				if _indexColumnIsBeingUpdated(tls, pIdx, i, aXRef, libc.Int32FromUint8(chngRowid)) != 0 {
					v4 = pParse + 48
					*(*int32)(unsafe.Pointer(v4)) = *(*int32)(unsafe.Pointer(v4)) + 1
					v1 = *(*int32)(unsafe.Pointer(v4))
					reg = v1
					**(**int32)(__ccgo_up(pParse + 48)) += libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pIdx)).FnColumn)
					if onError == int32(OE_Default) && libc.Int32FromUint8((*TIndex)(unsafe.Pointer(pIdx)).FonError) == int32(OE_Replace) {
						**(**int32)(__ccgo_up(bp + 56)) = int32(1)
					}
					break
				}
				goto _16
			_16:
				;
				i = i + 1
			}
		}
		if reg == 0 {
			**(**Tu8)(__ccgo_up(aToOpen + uintptr(nAllIdx+int32(1)))) = uint8(0)
		}
		**(**int32)(__ccgo_up(aRegIdx + uintptr(nAllIdx)*4)) = reg
		goto _13
	_13:
		;
		pIdx = (*TIndex)(unsafe.Pointer(pIdx)).FpNext
		nAllIdx = nAllIdx + 1
	}
	v4 = pParse + 48
	*(*int32)(unsafe.Pointer(v4)) = *(*int32)(unsafe.Pointer(v4)) + 1
	v1 = *(*int32)(unsafe.Pointer(v4))
	**(**int32)(__ccgo_up(aRegIdx + uintptr(nAllIdx)*4)) = v1 /* Register storing the table record */
	if **(**int32)(__ccgo_up(bp + 56)) != 0 {
		/* If REPLACE conflict resolution might be invoked, open cursors on all
		 ** indexes in case they are needed to delete records.  */
		libc.Xmemset(tls, aToOpen, int32(1), libc.Uint32FromInt32(nIdx+int32(1)))
	}
	if libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).Fnested) == 0 {
		_sqlite3VdbeCountChanges(tls, v)
	}
	_sqlite3BeginWriteOperation(tls, pParse, libc.BoolInt32(pTrigger != 0 || hasFK != 0), iDb)
	/* Allocate required registers. */
	if !(libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == libc.Int32FromInt32(TABTYP_VTAB)) {
		/* For now, regRowSet and aRegIdx[nAllIdx] share the same register.
		 ** If regRowSet turns out to be needed, then aRegIdx[nAllIdx] will be
		 ** reallocated.  aRegIdx[nAllIdx] is the register in which the main
		 ** table record is written.  regRowSet holds the RowSet for the
		 ** two-pass update algorithm. */
		regRowSet = **(**int32)(__ccgo_up(aRegIdx + uintptr(nAllIdx)*4))
		v4 = pParse + 48
		*(*int32)(unsafe.Pointer(v4)) = *(*int32)(unsafe.Pointer(v4)) + 1
		v2 = *(*int32)(unsafe.Pointer(v4))
		v1 = v2
		regNewRowid = v1
		regOldRowid = v1
		if chngPk != 0 || pTrigger != 0 || hasFK != 0 {
			regOld = (*TParse)(unsafe.Pointer(pParse)).FnMem + int32(1)
			**(**int32)(__ccgo_up(pParse + 48)) += int32((*TTable)(unsafe.Pointer(pTab)).FnCol)
		}
		if chngKey != 0 || pTrigger != 0 || hasFK != 0 {
			v4 = pParse + 48
			*(*int32)(unsafe.Pointer(v4)) = *(*int32)(unsafe.Pointer(v4)) + 1
			v1 = *(*int32)(unsafe.Pointer(v4))
			regNewRowid = v1
		}
		regNew = (*TParse)(unsafe.Pointer(pParse)).FnMem + int32(1)
		**(**int32)(__ccgo_up(pParse + 48)) += int32((*TTable)(unsafe.Pointer(pTab)).FnCol)
	}
	/* Start the view context. */
	if isView != 0 {
		_sqlite3AuthContextPush(tls, pParse, bp, (*TTable)(unsafe.Pointer(pTab)).FzName)
	}
	/* If we are trying to update a view, realize that view into
	 ** an ephemeral table.
	 */
	if nChangeFrom == 0 && isView != 0 {
		_sqlite3MaterializeView(tls, pParse, pTab, pWhere, pOrderBy, pLimit, iDataCur)
		pOrderBy = uintptr(0)
		pLimit = uintptr(0)
	}
	/* Resolve the column names in all the expressions in the
	 ** WHERE clause.
	 */
	if nChangeFrom == 0 && _sqlite3ResolveExprNames(tls, bp+8, pWhere) != 0 {
		goto update_cleanup
	}
	/* Virtual tables must be handled separately */
	if libc.Int32FromUint8((*TTable)(unsafe.Pointer(pTab)).FeTabType) == int32(TABTYP_VTAB) {
		_updateVirtualTable(tls, pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef, pWhere, onError)
		goto update_cleanup
	}
	/* Jump to labelBreak to abandon further processing of this UPDATE */
	v1 = _sqlite3VdbeMakeLabel(tls, pParse)
	labelBreak = v1
	labelContinue = v1
	/* Not an UPSERT.  Normal processing.  Begin by
	 ** initialize the count of updated rows */
	if (*Tsqlite3)(unsafe.Pointer(db)).Fflags&(libc.Uint64FromInt32(libc.Int32FromInt32(0x00001))<<libc.Int32FromInt32(32)) != uint64(0) && !((*TParse)(unsafe.Pointer(pParse)).FpTriggerTab != 0) && !((*TParse)(unsafe.Pointer(pParse)).Fnested != 0) && !(int32(Tbft(*(*uint16)(unsafe.Pointer(pParse + 28))&0x8>>3)) != 0) && pUpsert == uintptr(0) {
		v4 = pParse + 48
		*(*int32)(unsafe.Pointer(v4)) = *(*int32)(unsafe.Pointer(v4)) + 1
		v1 = *(*int32)(unsafe.Pointer(v4))
		regRowCount = v1
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Integer), 0, regRowCount)
	}
	if nChangeFrom == 0 && (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_WithoutRowid) == uint32(0) {
		_sqlite3VdbeAddOp3(tls, v, int32(OP_Null), 0, regRowSet, regOldRowid)
		v4 = pParse + 44
		v1 = *(*int32)(unsafe.Pointer(v4))
		*(*int32)(unsafe.Pointer(v4)) = *(*int32)(unsafe.Pointer(v4)) + 1
		iEph = v1
		addrOpen = _sqlite3VdbeAddOp3(tls, v, int32(OP_OpenEphemeral), iEph, 0, regRowSet)
	} else {
		if pPk != 0 {
			v1 = libc.Int32FromUint16((*TIndex)(unsafe.Pointer(pPk)).FnKeyCol)
		} else {
			v1 = 0
		}
		nPk = int16(v1)
		iPk = (*TParse)(unsafe.Pointer(pParse)).FnMem + int32(1)
		**(**int32)(__ccgo_up(pParse + 48)) += int32(nPk)
		**(**int32)(__ccgo_up(pParse + 48)) += nChangeFrom
		v4 = pParse + 48
		*(*int32)(unsafe.Pointer(v4)) = *(*int32)(unsafe.Pointer(v4)) + 1
		v1 = *(*int32)(unsafe.Pointer(v4))
		regKey = v1
		if pUpsert == uintptr(0) {
			if isView != 0 {
				v1 = int32((*TTable)(unsafe.Pointer(pTab)).FnCol)
			} else {
				v1 = 0
			}
			nEphCol = int32(nPk) + nChangeFrom + v1
			v4 = pParse + 44
			v2 = *(*int32)(unsafe.Pointer(v4))
			*(*int32)(unsafe.Pointer(v4)) = *(*int32)(unsafe.Pointer(v4)) + 1
			iEph = v2
			if pPk != 0 {
				_sqlite3VdbeAddOp3(tls, v, int32(OP_Null), 0, iPk, iPk+int32(nPk)-int32(1))
			}
			addrOpen = _sqlite3VdbeAddOp2(tls, v, int32(OP_OpenEphemeral), iEph, nEphCol)
			if pPk != 0 {
				pKeyInfo = _sqlite3KeyInfoOfIndex(tls, pParse, pPk)
				if pKeyInfo != 0 {
					(*TKeyInfo)(unsafe.Pointer(pKeyInfo)).FnAllField = libc.Uint16FromInt32(nEphCol)
					_sqlite3VdbeAppendP4(tls, v, pKeyInfo, -int32(9))
				}
			}
			if nChangeFrom != 0 {
				_updateFromSelect(tls, pParse, iEph, pPk, pChanges, pTabList, pWhere, pOrderBy, pLimit)
				if isView != 0 {
					iDataCur = iEph
				}
			}
		}
	}
	if nChangeFrom != 0 {
		_sqlite3MultiWrite(tls, pParse)
		eOnePass = ONEPASS_OFF
		nKey = int32(nPk)
		regKey = iPk
	} else {
		if pUpsert != 0 {
			/* If this is an UPSERT, then all cursors have already been opened by
			 ** the outer INSERT and the data cursor should be pointing at the row
			 ** that is to be updated.  So bypass the code that searches for the
			 ** row(s) to be updated.
			 */
			pWInfo = uintptr(0)
			eOnePass = int32(ONEPASS_SINGLE)
			_sqlite3ExprIfFalse(tls, pParse, pWhere, labelBreak, int32(SQLITE_JUMPIFNULL))
			bFinishSeek = 0
		} else {
			/* Begin the database scan.
			 **
			 ** Do not consider a single-pass strategy for a multi-row update if
			 ** there is anything that might disrupt the cursor being used to do
			 ** the UPDATE:
			 **   (1) This is a nested UPDATE
			 **   (2) There are triggers
			 **   (3) There are FOREIGN KEY constraints
			 **   (4) There are REPLACE conflict handlers
			 **   (5) There are subqueries in the WHERE clause
			 */
			flags = int32(WHERE_ONEPASS_DESIRED)
			if !((*TParse)(unsafe.Pointer(pParse)).Fnested != 0) && !(pTrigger != 0) && !(hasFK != 0) && !(chngKey != 0) && !(**(**int32)(__ccgo_up(bp + 56)) != 0) && (pWhere == uintptr(0) || !((*TExpr)(unsafe.Pointer(pWhere)).Fflags&libc.Uint32FromInt32(libc.Int32FromInt32(EP_Subquery)) != libc.Uint32FromInt32(0))) {
				flags = flags | int32(WHERE_ONEPASS_MULTIROW)
			}
			pWInfo = _sqlite3WhereBegin(tls, pParse, pTabList, pWhere, uintptr(0), uintptr(0), uintptr(0), libc.Uint16FromInt32(flags), iIdxCur)
			if pWInfo == uintptr(0) {
				goto update_cleanup
			}
			/* A one-pass strategy that might update more than one row may not
			 ** be used if any column of the index used for the scan is being
			 ** updated. Otherwise, if there is an index on "b", statements like
			 ** the following could create an infinite loop:
			 **
			 **   UPDATE t1 SET b=b+1 WHERE b>?
			 **
			 ** Fall back to ONEPASS_OFF if where.c has selected a ONEPASS_MULTI
			 ** strategy that uses an index for which one or more columns are being
			 ** updated.  */
			eOnePass = _sqlite3WhereOkOnePass(tls, pWInfo, bp+48)
			bFinishSeek = _sqlite3WhereUsesDeferredSeek(tls, pWInfo)
			if eOnePass != int32(ONEPASS_SINGLE) {
				_sqlite3MultiWrite(tls, pParse)
				if eOnePass == int32(ONEPASS_MULTI) {
					iCur = (**(**[2]int32)(__ccgo_up(bp + 48)))[int32(1)]
					if iCur >= 0 && iCur != iDataCur && **(**Tu8)(__ccgo_up(aToOpen + uintptr(iCur-iBaseCur))) != 0 {
						eOnePass = ONEPASS_OFF
					}
				}
			}
		}
		if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_WithoutRowid) == uint32(0) {
			/* Read the rowid of the current row of the WHERE scan. In ONEPASS_OFF
			 ** mode, write the rowid into the FIFO. In either of the one-pass modes,
			 ** leave it in register regOldRowid.  */
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Rowid), iDataCur, regOldRowid)
			if eOnePass == ONEPASS_OFF {
				v4 = pParse + 48
				*(*int32)(unsafe.Pointer(v4)) = *(*int32)(unsafe.Pointer(v4)) + 1
				v1 = *(*int32)(unsafe.Pointer(v4))
				**(**int32)(__ccgo_up(aRegIdx + uintptr(nAllIdx)*4)) = v1
				_sqlite3VdbeAddOp3(tls, v, int32(OP_Insert), iEph, regRowSet, regOldRowid)
			} else {
				if addrOpen != 0 {
					_sqlite3VdbeChangeToNoop(tls, v, addrOpen)
				}
			}
		} else {
			/* Read the PK of the current row into an array of registers. In
			 ** ONEPASS_OFF mode, serialize the array into a record and store it in
			 ** the ephemeral table. Or, in ONEPASS_SINGLE or MULTI mode, change
			 ** the OP_OpenEphemeral instruction to a Noop (the ephemeral table
			 ** is not required) and leave the PK fields in the array of registers.  */
			i = 0
			for {
				if !(i < int32(nPk)) {
					break
				}
				_sqlite3ExprCodeGetColumnOfTable(tls, v, pTab, iDataCur, int32(**(**Ti16)(__ccgo_up((*TIndex)(unsafe.Pointer(pPk)).FaiColumn + uintptr(i)*2))), iPk+i)
				goto _39
			_39:
				;
				i = i + 1
			}
			if eOnePass != 0 {
				if addrOpen != 0 {
					_sqlite3VdbeChangeToNoop(tls, v, addrOpen)
				}
				nKey = int32(nPk)
				regKey = iPk
			} else {
				_sqlite3VdbeAddOp4(tls, v, int32(OP_MakeRecord), iPk, int32(nPk), regKey, _sqlite3IndexAffinityStr(tls, db, pPk), int32(nPk))
				_sqlite3VdbeAddOp4Int(tls, v, int32(OP_IdxInsert), iEph, regKey, iPk, int32(nPk))
			}
		}
	}
	if pUpsert == uintptr(0) {
		if nChangeFrom == 0 && eOnePass != int32(ONEPASS_MULTI) {
			_sqlite3WhereEnd(tls, pWInfo)
		}
		if !(isView != 0) {
			addrOnce = 0
			**(**int32)(__ccgo_up(bp + 60)) = 0
			**(**int32)(__ccgo_up(bp + 64)) = 0
			/* Open every index that needs updating. */
			if eOnePass != ONEPASS_OFF {
				if (**(**[2]int32)(__ccgo_up(bp + 48)))[0] >= 0 {
					**(**Tu8)(__ccgo_up(aToOpen + uintptr((**(**[2]int32)(__ccgo_up(bp + 48)))[0]-iBaseCur))) = uint8(0)
				}
				if (**(**[2]int32)(__ccgo_up(bp + 48)))[int32(1)] >= 0 {
					**(**Tu8)(__ccgo_up(aToOpen + uintptr((**(**[2]int32)(__ccgo_up(bp + 48)))[int32(1)]-iBaseCur))) = uint8(0)
				}
			}
			if eOnePass == int32(ONEPASS_MULTI) && nIdx-libc.BoolInt32((**(**[2]int32)(__ccgo_up(bp + 48)))[int32(1)] >= 0) > 0 {
				addrOnce = _sqlite3VdbeAddOp0(tls, v, int32(OP_Once))
			}
			_sqlite3OpenTableAndIndices(tls, pParse, pTab, int32(OP_OpenWrite), uint8(0), iBaseCur, aToOpen, bp+60, bp+64)
			if addrOnce != 0 {
				_sqlite3VdbeJumpHereOrPopInst(tls, v, addrOnce)
			}
		}
		/* Top of the update loop */
		if eOnePass != ONEPASS_OFF {
			if (**(**[2]int32)(__ccgo_up(bp + 48)))[0] != iDataCur && (**(**[2]int32)(__ccgo_up(bp + 48)))[int32(1)] != iDataCur {
				_sqlite3VdbeAddOp4Int(tls, v, int32(OP_NotFound), iDataCur, labelBreak, regKey, nKey)
			}
			if eOnePass != int32(ONEPASS_SINGLE) {
				labelContinue = _sqlite3VdbeMakeLabel(tls, pParse)
			}
			if pPk != 0 {
				v1 = regKey
			} else {
				v1 = regOldRowid
			}
			_sqlite3VdbeAddOp2(tls, v, int32(OP_IsNull), v1, labelBreak)
		} else {
			if pPk != 0 || nChangeFrom != 0 {
				labelContinue = _sqlite3VdbeMakeLabel(tls, pParse)
				_sqlite3VdbeAddOp2(tls, v, int32(OP_Rewind), iEph, labelBreak)
				addrTop = _sqlite3VdbeCurrentAddr(tls, v)
				if nChangeFrom != 0 {
					if !(isView != 0) {
						if pPk != 0 {
							i = 0
							for {
								if !(i < int32(nPk)) {
									break
								}
								_sqlite3VdbeAddOp3(tls, v, int32(OP_Column), iEph, i, iPk+i)
								goto _41
							_41:
								;
								i = i + 1
							}
							_sqlite3VdbeAddOp4Int(tls, v, int32(OP_NotFound), iDataCur, labelContinue, iPk, int32(nPk))
						} else {
							_sqlite3VdbeAddOp2(tls, v, int32(OP_Rowid), iEph, regOldRowid)
							_sqlite3VdbeAddOp3(tls, v, int32(OP_NotExists), iDataCur, labelContinue, regOldRowid)
						}
					}
				} else {
					_sqlite3VdbeAddOp2(tls, v, int32(OP_RowData), iEph, regKey)
					_sqlite3VdbeAddOp4Int(tls, v, int32(OP_NotFound), iDataCur, labelContinue, regKey, 0)
				}
			} else {
				_sqlite3VdbeAddOp2(tls, v, int32(OP_Rewind), iEph, labelBreak)
				labelContinue = _sqlite3VdbeMakeLabel(tls, pParse)
				addrTop = _sqlite3VdbeAddOp2(tls, v, int32(OP_Rowid), iEph, regOldRowid)
				_sqlite3VdbeAddOp3(tls, v, int32(OP_NotExists), iDataCur, labelContinue, regOldRowid)
			}
		}
	}
	/* If the rowid value will change, set register regNewRowid to
	 ** contain the new value. If the rowid is not being modified,
	 ** then regNewRowid is the same register as regOldRowid, which is
	 ** already populated.  */
	if chngRowid != 0 {
		if nChangeFrom == 0 {
			_sqlite3ExprCode(tls, pParse, pRowidExpr, regNewRowid)
		} else {
			_sqlite3VdbeAddOp3(tls, v, int32(OP_Column), iEph, iRowidExpr, regNewRowid)
		}
		_sqlite3VdbeAddOp1(tls, v, int32(OP_MustBeInt), regNewRowid)
	}
	/* Compute the old pre-UPDATE content of the row being changed, if that
	 ** information is needed */
	if chngPk != 0 || hasFK != 0 || pTrigger != 0 {
		if hasFK != 0 {
			v42 = _sqlite3FkOldmask(tls, pParse, pTab)
		} else {
			v42 = uint32(0)
		}
		oldmask = v42
		oldmask = oldmask | _sqlite3TriggerColmask(tls, pParse, pTrigger, pChanges, 0, libc.Int32FromInt32(TRIGGER_BEFORE)|libc.Int32FromInt32(TRIGGER_AFTER), pTab, onError)
		i = 0
		for {
			if !(i < int32((*TTable)(unsafe.Pointer(pTab)).FnCol)) {
				break
			}
			colFlags = uint32((**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(i)*12))).FcolFlags)
			k = int32(_sqlite3TableColumnToStorage(tls, pTab, int16(i))) + regOld
			if oldmask == uint32(0xffffffff) || i < int32(32) && oldmask&(libc.Uint32FromInt32(1)<<i) != uint32(0) || colFlags&uint32(COLFLAG_PRIMKEY) != uint32(0) {
				_sqlite3ExprCodeGetColumnOfTable(tls, v, pTab, iDataCur, i, k)
			} else {
				_sqlite3VdbeAddOp2(tls, v, int32(OP_Null), 0, k)
			}
			goto _43
		_43:
			;
			i = i + 1
		}
		if libc.Int32FromUint8(chngRowid) == 0 && pPk == uintptr(0) {
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Copy), regOldRowid, regNewRowid)
		}
	}
	/* Populate the array of registers beginning at regNew with the new
	 ** row data. This array is used to check constants, create the new
	 ** table and index records, and as the values for any new.* references
	 ** made by triggers.
	 **
	 ** If there are one or more BEFORE triggers, then do not populate the
	 ** registers associated with columns that are (a) not modified by
	 ** this UPDATE statement and (b) not accessed by new.* references. The
	 ** values for registers not modified by the UPDATE must be reloaded from
	 ** the database after the BEFORE triggers are fired anyway (as the trigger
	 ** may have modified them). So not loading those that are not going to
	 ** be used eliminates some redundant opcodes.
	 */
	newmask = libc.Int32FromUint32(_sqlite3TriggerColmask(tls, pParse, pTrigger, pChanges, int32(1), int32(TRIGGER_BEFORE), pTab, onError))
	i = 0
	k = regNew
	for {
		if !(i < int32((*TTable)(unsafe.Pointer(pTab)).FnCol)) {
			break
		}
		if i == int32((*TTable)(unsafe.Pointer(pTab)).FiPKey) {
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Null), 0, k)
		} else {
			if libc.Int32FromUint16((**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(i)*12))).FcolFlags)&int32(COLFLAG_GENERATED) != 0 {
				if libc.Int32FromUint16((**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(i)*12))).FcolFlags)&int32(COLFLAG_VIRTUAL) != 0 {
					k = k - 1
				}
			} else {
				j = **(**int32)(__ccgo_up(aXRef + uintptr(i)*4))
				if j >= 0 {
					if nChangeFrom != 0 {
						if isView != 0 {
							v1 = int32((*TTable)(unsafe.Pointer(pTab)).FnCol)
						} else {
							v1 = int32(nPk)
						}
						nOff = v1
						_sqlite3VdbeAddOp3(tls, v, int32(OP_Column), iEph, nOff+j, k)
					} else {
						_sqlite3ExprCode(tls, pParse, (*(*TExprList_item)(unsafe.Pointer(pChanges + 8 + uintptr(j)*20))).FpExpr, k)
					}
				} else {
					if 0 == **(**int32)(__ccgo_up(bp + 44))&int32(TRIGGER_BEFORE) || i > int32(31) || libc.Uint32FromInt32(newmask)&(libc.Uint32FromInt32(1)<<i) != 0 {
						/* This branch loads the value of a column that will not be changed
						 ** into a register. This is done if there are no BEFORE triggers, or
						 ** if there are one or more BEFORE triggers that use this value via
						 ** a new.* reference in a trigger program.
						 */
						_sqlite3ExprCodeGetColumnOfTable(tls, v, pTab, iDataCur, i, k)
						bFinishSeek = 0
					} else {
						_sqlite3VdbeAddOp2(tls, v, int32(OP_Null), 0, k)
					}
				}
			}
		}
		goto _44
	_44:
		;
		i = i + 1
		k = k + 1
	}
	if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_HasGenerated) != 0 {
		_sqlite3ComputeGeneratedColumns(tls, pParse, regNew, pTab)
	}
	/* Fire any BEFORE UPDATE triggers. This happens before constraints are
	 ** verified. One could argue that this is wrong.
	 */
	if **(**int32)(__ccgo_up(bp + 44))&int32(TRIGGER_BEFORE) != 0 {
		_sqlite3TableAffinity(tls, v, pTab, regNew)
		_sqlite3CodeRowTrigger(tls, pParse, pTrigger, int32(TK_UPDATE), pChanges, int32(TRIGGER_BEFORE), pTab, regOldRowid, onError, labelContinue)
		if !(isView != 0) {
			/* The row-trigger may have deleted the row being updated. In this
			 ** case, jump to the next row. No updates or AFTER triggers are
			 ** required. This behavior - what happens when the row being updated
			 ** is deleted or renamed by a BEFORE trigger - is left undefined in the
			 ** documentation.
			 */
			if pPk != 0 {
				_sqlite3VdbeAddOp4Int(tls, v, int32(OP_NotFound), iDataCur, labelContinue, regKey, nKey)
			} else {
				_sqlite3VdbeAddOp3(tls, v, int32(OP_NotExists), iDataCur, labelContinue, regOldRowid)
			}
			/* After-BEFORE-trigger-reload-loop:
			 ** If it did not delete it, the BEFORE trigger may still have modified
			 ** some of the columns of the row being updated. Load the values for
			 ** all columns not modified by the update statement into their registers
			 ** in case this has happened. Only unmodified columns are reloaded.
			 ** The values computed for modified columns use the values before the
			 ** BEFORE trigger runs.  See test case trigger1-18.0 (added 2018-04-26)
			 ** for an example.
			 */
			i = 0
			k = regNew
			for {
				if !(i < int32((*TTable)(unsafe.Pointer(pTab)).FnCol)) {
					break
				}
				if libc.Int32FromUint16((**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(i)*12))).FcolFlags)&int32(COLFLAG_GENERATED) != 0 {
					if libc.Int32FromUint16((**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(i)*12))).FcolFlags)&int32(COLFLAG_VIRTUAL) != 0 {
						k = k - 1
					}
				} else {
					if **(**int32)(__ccgo_up(aXRef + uintptr(i)*4)) < 0 && i != int32((*TTable)(unsafe.Pointer(pTab)).FiPKey) {
						_sqlite3ExprCodeGetColumnOfTable(tls, v, pTab, iDataCur, i, k)
					}
				}
				goto _46
			_46:
				;
				i = i + 1
				k = k + 1
			}
			if (*TTable)(unsafe.Pointer(pTab)).FtabFlags&uint32(TF_HasGenerated) != 0 {
				_sqlite3ComputeGeneratedColumns(tls, pParse, regNew, pTab)
			}
		}
	}
	if !(isView != 0) {
		/* Do constraint checks. */
		_sqlite3GenerateConstraintChecks(tls, pParse, pTab, aRegIdx, iDataCur, iIdxCur, regNewRowid, regOldRowid, chngKey, libc.Uint8FromInt32(onError), labelContinue, bp+56, aXRef, uintptr(0))
		/* If REPLACE conflict handling may have been used, or if the PK of the
		 ** row is changing, then the GenerateConstraintChecks() above may have
		 ** moved cursor iDataCur. Reseek it. */
		if **(**int32)(__ccgo_up(bp + 56)) != 0 || chngKey != 0 {
			if pPk != 0 {
				_sqlite3VdbeAddOp4Int(tls, v, int32(OP_NotFound), iDataCur, labelContinue, regKey, nKey)
			} else {
				_sqlite3VdbeAddOp3(tls, v, int32(OP_NotExists), iDataCur, labelContinue, regOldRowid)
			}
		}
		/* Do FK constraint checks. */
		if hasFK != 0 {
			_sqlite3FkCheck(tls, pParse, pTab, regOldRowid, 0, aXRef, libc.Int32FromUint8(chngKey))
		}
		/* Delete the index entries associated with the current record.  */
		_sqlite3GenerateRowIndexDelete(tls, pParse, pTab, iDataCur, iIdxCur, aRegIdx, -int32(1))
		/* We must run the OP_FinishSeek opcode to resolve a prior
		 ** OP_DeferredSeek if there is any possibility that there have been
		 ** no OP_Column opcodes since the OP_DeferredSeek was issued.  But
		 ** we want to avoid the OP_FinishSeek if possible, as running it
		 ** costs CPU cycles. */
		if bFinishSeek != 0 {
			_sqlite3VdbeAddOp1(tls, v, int32(OP_FinishSeek), iDataCur)
		}
		/* If changing the rowid value, or if there are foreign key constraints
		 ** to process, delete the old record. Otherwise, add a noop OP_Delete
		 ** to invoke the pre-update hook.
		 **
		 ** That (regNew==regnewRowid+1) is true is also important for the
		 ** pre-update hook. If the caller invokes preupdate_new(), the returned
		 ** value is copied from memory cell (regNewRowid+1+iCol), where iCol
		 ** is the column index supplied by the user.
		 */
		if hasFK > int32(1) || chngKey != 0 {
			v1 = 0
		} else {
			v1 = int32(OPFLAG_ISNOOP)
		}
		_sqlite3VdbeAddOp3(tls, v, int32(OP_Delete), iDataCur, int32(OPFLAG_ISUPDATE)|v1, regNewRowid)
		if eOnePass == int32(ONEPASS_MULTI) {
			_sqlite3VdbeChangeP5(tls, v, uint16(OPFLAG_SAVEPOSITION))
		}
		if !((*TParse)(unsafe.Pointer(pParse)).Fnested != 0) {
			_sqlite3VdbeAppendP4(tls, v, pTab, -int32(5))
		}
		if hasFK != 0 {
			_sqlite3FkCheck(tls, pParse, pTab, 0, regNewRowid, aXRef, libc.Int32FromUint8(chngKey))
		}
		/* Insert the new index entries and the new record. */
		if eOnePass == int32(ONEPASS_MULTI) {
			v1 = int32(OPFLAG_SAVEPOSITION)
		} else {
			v1 = 0
		}
		_sqlite3CompleteInsertion(tls, pParse, pTab, iDataCur, iIdxCur, regNewRowid, aRegIdx, int32(OPFLAG_ISUPDATE)|v1, 0, 0)
		/* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
		 ** handle rows (possibly in other tables) that refer via a foreign key
		 ** to the row just updated. */
		if hasFK != 0 {
			_sqlite3FkActions(tls, pParse, pTab, pChanges, regOldRowid, aXRef, libc.Int32FromUint8(chngKey))
		}
	}
	/* Increment the row counter
	 */
	if regRowCount != 0 {
		_sqlite3VdbeAddOp2(tls, v, int32(OP_AddImm), regRowCount, int32(1))
	}
	if pTrigger != 0 {
		_sqlite3CodeRowTrigger(tls, pParse, pTrigger, int32(TK_UPDATE), pChanges, int32(TRIGGER_AFTER), pTab, regOldRowid, onError, labelContinue)
	}
	/* Repeat the above with the next record to be updated, until
	 ** all record selected by the WHERE clause have been updated.
	 */
	if eOnePass == int32(ONEPASS_SINGLE) {
		/* Nothing to do at end-of-loop for a single-pass */
	} else {
		if eOnePass == int32(ONEPASS_MULTI) {
			_sqlite3VdbeResolveLabel(tls, v, labelContinue)
			_sqlite3WhereEnd(tls, pWInfo)
		} else {
			_sqlite3VdbeResolveLabel(tls, v, labelContinue)
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Next), iEph, addrTop)
		}
	}
	_sqlite3VdbeResolveLabel(tls, v, labelBreak)
	/* Update the sqlite_sequence table by storing the content of the
	 ** maximum rowid counter values recorded while inserting into
	 ** autoincrement tables.
	 */
	if libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).Fnested) == 0 && (*TParse)(unsafe.Pointer(pParse)).FpTriggerTab == uintptr(0) && pUpsert == uintptr(0) {
		_sqlite3AutoincrementEnd(tls, pParse)
	}
	/*
	 ** Return the number of rows that were changed, if we are tracking
	 ** that information.
	 */
	if regRowCount != 0 {
		_sqlite3CodeChangeCount(tls, v, regRowCount, __ccgo_ts+22641)
	}
	goto update_cleanup
update_cleanup:
	;
	_sqlite3AuthContextPop(tls, bp)
	_sqlite3DbFree(tls, db, aXRef) /* Also frees aRegIdx[] and aToOpen[] */
	_sqlite3SrcListDelete(tls, db, pTabList)
	_sqlite3ExprListDelete(tls, db, pChanges)
	_sqlite3ExprDelete(tls, db, pWhere)
	return
}

/* Make sure "isView" and other macros defined above are undefined. Otherwise
** they may interfere with compilation of other functions in this file
** (or in another file, if this file becomes part of the amalgamation).  */

// C documentation
//
//	/*
//	** Compute a string that describes the P4 parameter for an opcode.
//	** Use zTemp for any required temporary buffer space.
//	*/
func _sqlite3VdbeDisplayP4(tls *libc.TLS, db uintptr, pOp uintptr) (r uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var ai, pColl, pColl1, pDef, pDef1, pKeyInfo, pMem, pSig, pVtab, zColl, zP4, v2, v3 uintptr
	var i, n Tu32
	var j, v6 int32
	var _ /* x at bp+0 */ TStrAccum
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ai, i, j, n, pColl, pColl1, pDef, pDef1, pKeyInfo, pMem, pSig, pVtab, zColl, zP4, v2, v3, v6
	zP4 = uintptr(0)
	_sqlite3StrAccumInit(tls, bp, uintptr(0), uintptr(0), 0, int32(SQLITE_MAX_LENGTH))
	switch int32((*TOp)(unsafe.Pointer(pOp)).Fp4type) {
	case -int32(9):
		pKeyInfo = *(*uintptr)(unsafe.Pointer(pOp + 16))
		Xsqlite3_str_appendf(tls, bp, __ccgo_ts+5234, libc.VaList(bp+32, libc.Int32FromUint16((*TKeyInfo)(unsafe.Pointer(pKeyInfo)).FnKeyField)))
		j = 0
		for {
			if !(j < libc.Int32FromUint16((*TKeyInfo)(unsafe.Pointer(pKeyInfo)).FnKeyField)) {
				break
			}
			pColl = *(*uintptr)(unsafe.Pointer(pKeyInfo + 20 + uintptr(j)*4))
			if pColl != 0 {
				v2 = (*TCollSeq)(unsafe.Pointer(pColl)).FzName
			} else {
				v2 = __ccgo_ts + 1702
			}
			zColl = v2
			if libc.Xstrcmp(tls, zColl, __ccgo_ts+5239) == 0 {
				zColl = __ccgo_ts + 5246
			}
			if libc.Int32FromUint8(**(**Tu8)(__ccgo_up((*TKeyInfo)(unsafe.Pointer(pKeyInfo)).FaSortFlags + uintptr(j))))&int32(KEYINFO_ORDER_DESC) != 0 {
				v2 = __ccgo_ts + 5227
			} else {
				v2 = __ccgo_ts + 1702
			}
			if libc.Int32FromUint8(**(**Tu8)(__ccgo_up((*TKeyInfo)(unsafe.Pointer(pKeyInfo)).FaSortFlags + uintptr(j))))&int32(KEYINFO_ORDER_BIGNULL) != 0 {
				v3 = __ccgo_ts + 5248
			} else {
				v3 = __ccgo_ts + 1702
			}
			Xsqlite3_str_appendf(tls, bp, __ccgo_ts+5251, libc.VaList(bp+32, v2, v3, zColl))
			goto _1
		_1:
			;
			j = j + 1
		}
		Xsqlite3_str_append(tls, bp, __ccgo_ts+5259, int32(1))
	case -int32(2):
		pColl1 = *(*uintptr)(unsafe.Pointer(pOp + 16))
		Xsqlite3_str_appendf(tls, bp, __ccgo_ts+5275, libc.VaList(bp+32, (*TCollSeq)(unsafe.Pointer(pColl1)).FzName, _encnames[(*TCollSeq)(unsafe.Pointer(pColl1)).Fenc]))
	case -int32(8):
		pDef = *(*uintptr)(unsafe.Pointer(pOp + 16))
		Xsqlite3_str_appendf(tls, bp, __ccgo_ts+5284, libc.VaList(bp+32, (*TFuncDef)(unsafe.Pointer(pDef)).FzName, int32((*TFuncDef)(unsafe.Pointer(pDef)).FnArg)))
	case -int32(16):
		pDef1 = (*Tsqlite3_context)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pOp + 16)))).FpFunc
		Xsqlite3_str_appendf(tls, bp, __ccgo_ts+5284, libc.VaList(bp+32, (*TFuncDef)(unsafe.Pointer(pDef1)).FzName, int32((*TFuncDef)(unsafe.Pointer(pDef1)).FnArg)))
	case -int32(14):
		Xsqlite3_str_appendf(tls, bp, __ccgo_ts+1463, libc.VaList(bp+32, **(**Ti64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(pOp + 16))))))
	case -int32(3):
		Xsqlite3_str_appendf(tls, bp, __ccgo_ts+5291, libc.VaList(bp+32, *(*int32)(unsafe.Pointer(pOp + 16))))
	case -int32(13):
		Xsqlite3_str_appendf(tls, bp, __ccgo_ts+1430, libc.VaList(bp+32, **(**float64)(__ccgo_up(*(*uintptr)(unsafe.Pointer(pOp + 16))))))
	case -int32(11):
		pMem = *(*uintptr)(unsafe.Pointer(pOp + 16))
		if libc.Int32FromUint16((*TMem)(unsafe.Pointer(pMem)).Fflags)&int32(MEM_Str) != 0 {
			zP4 = (*TMem)(unsafe.Pointer(pMem)).Fz
		} else {
			if libc.Int32FromUint16((*TMem)(unsafe.Pointer(pMem)).Fflags)&(libc.Int32FromInt32(MEM_Int)|libc.Int32FromInt32(MEM_IntReal)) != 0 {
				Xsqlite3_str_appendf(tls, bp, __ccgo_ts+1463, libc.VaList(bp+32, *(*Ti64)(unsafe.Pointer(pMem))))
			} else {
				if libc.Int32FromUint16((*TMem)(unsafe.Pointer(pMem)).Fflags)&int32(MEM_Real) != 0 {
					Xsqlite3_str_appendf(tls, bp, __ccgo_ts+1430, libc.VaList(bp+32, *(*float64)(unsafe.Pointer(pMem))))
				} else {
					if libc.Int32FromUint16((*TMem)(unsafe.Pointer(pMem)).Fflags)&int32(MEM_Null) != 0 {
						zP4 = __ccgo_ts + 1703
					} else {
						zP4 = __ccgo_ts + 5294
					}
				}
			}
		}
	case -int32(12):
		pVtab = (*TVTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pOp + 16)))).FpVtab
		Xsqlite3_str_appendf(tls, bp, __ccgo_ts+5301, libc.VaList(bp+32, pVtab))
	case -int32(15):
		ai = *(*uintptr)(unsafe.Pointer(pOp + 16))
		n = **(**Tu32)(__ccgo_up(ai)) /* The first element of an INTARRAY is always the
		 ** count of the number of elements to follow */
		i = uint32(1)
		for {
			if !(i <= n) {
				break
			}
			if i == uint32(1) {
				v6 = int32('[')
			} else {
				v6 = int32(',')
			}
			Xsqlite3_str_appendf(tls, bp, __ccgo_ts+5309, libc.VaList(bp+32, v6, **(**Tu32)(__ccgo_up(ai + uintptr(i)*4))))
			goto _5
		_5:
			;
			i = i + 1
		}
		Xsqlite3_str_append(tls, bp, __ccgo_ts+5314, int32(1))
	case -int32(4):
		zP4 = __ccgo_ts + 5316
	case -int32(5):
		zP4 = (*TTable)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pOp + 16)))).FzName
	case -int32(6):
		zP4 = (*TIndex)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pOp + 16)))).FzName
	case -int32(18):
		pSig = *(*uintptr)(unsafe.Pointer(pOp + 16))
		Xsqlite3_str_appendf(tls, bp, __ccgo_ts+5324, libc.VaList(bp+32, (*TSubrtnSig)(unsafe.Pointer(pSig)).FselId, (*TSubrtnSig)(unsafe.Pointer(pSig)).FzAff))
	default:
		zP4 = *(*uintptr)(unsafe.Pointer(pOp + 16))
	}
	if zP4 != 0 {
		Xsqlite3_str_appendall(tls, bp, zP4)
	}
	if libc.Int32FromUint8((**(**TStrAccum)(__ccgo_up(bp))).FaccError)&int32(SQLITE_NOMEM) != 0 {
		_sqlite3OomFault(tls, db)
	}
	return _sqlite3StrAccumFinish(tls, bp)
}

// C documentation
//
//	/*
//	** Set the value stored in *pMem should already be a NULL.
//	** Also store a pointer to go with it.
//	*/
func _sqlite3VdbeMemSetPointer(tls *libc.TLS, pMem uintptr, pPtr uintptr, zPType uintptr, __ccgo_fp_xDestructor uintptr) {
	var v1 uintptr
	_ = v1
	_vdbeMemClear(tls, pMem)
	if zPType != 0 {
		v1 = zPType
	} else {
		v1 = __ccgo_ts + 1702
	}
	*(*uintptr)(unsafe.Pointer(&(*TMem)(unsafe.Pointer(pMem)).Fu)) = v1
	(*TMem)(unsafe.Pointer(pMem)).Fz = pPtr
	(*TMem)(unsafe.Pointer(pMem)).Fflags = libc.Uint16FromInt32(libc.Int32FromInt32(MEM_Null) | libc.Int32FromInt32(MEM_Dyn) | libc.Int32FromInt32(MEM_Subtype) | libc.Int32FromInt32(MEM_Term))
	(*TMem)(unsafe.Pointer(pMem)).FeSubtype = uint8('p')
	if __ccgo_fp_xDestructor != 0 {
		v1 = __ccgo_fp_xDestructor
	} else {
		v1 = __ccgo_fp(_sqlite3NoopDestructor)
	}
	(*TMem)(unsafe.Pointer(pMem)).FxDel = v1
}

// C documentation
//
//	/*
//	** Expression pExpr is a vector that has been used in a context where
//	** it is not permitted. If pExpr is a sub-select vector, this routine
//	** loads the Parse object with a message of the form:
//	**
//	**   "sub-select returns N columns - expected 1"
//	**
//	** Or, if it is a regular scalar vector:
//	**
//	**   "row value misused"
//	*/
func _sqlite3VectorErrorMsg(tls *libc.TLS, pParse uintptr, pExpr uintptr) {
	if (*TExpr)(unsafe.Pointer(pExpr)).Fflags&uint32(EP_xIsSelect) != uint32(0) {
		_sqlite3SubselectError(tls, pParse, (*TExprList)(unsafe.Pointer((*TSelect)(unsafe.Pointer(*(*uintptr)(unsafe.Pointer(pExpr + 20)))).FpEList)).FnExpr, int32(1))
	} else {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+6910, 0)
	}
}

// C documentation
//
//	/*
//	** Check to see if virtual table module pMod can be have an eponymous
//	** virtual table instance.  If it can, create one if one does not already
//	** exist. Return non-zero if either the eponymous virtual table instance
//	** exists when this routine returns or if an attempt to create it failed
//	** and an error message was left in pParse.
//	**
//	** An eponymous virtual table instance is one that is named after its
//	** module, and more importantly, does not require a CREATE VIRTUAL TABLE
//	** statement in order to come into existence.  Eponymous virtual table
//	** instances always exist.  They cannot be DROP-ed.
//	**
//	** Any virtual table module for which xConnect and xCreate are the same
//	** method can have an eponymous virtual table instance.
//	*/
func _sqlite3VtabEponymousTableInit(tls *libc.TLS, pParse uintptr, pMod uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var db, pModule, pTab uintptr
	var rc int32
	var _ /* zErr at bp+0 */ uintptr
	_, _, _, _ = db, pModule, pTab, rc
	pModule = (*TModule)(unsafe.Pointer(pMod)).FpModule
	**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	if (*TModule)(unsafe.Pointer(pMod)).FpEpoTab != 0 {
		return int32(1)
	}
	if (*Tsqlite3_module)(unsafe.Pointer(pModule)).FxCreate != uintptr(0) && (*Tsqlite3_module)(unsafe.Pointer(pModule)).FxCreate != (*Tsqlite3_module)(unsafe.Pointer(pModule)).FxConnect {
		return 0
	}
	pTab = _sqlite3DbMallocZero(tls, db, uint64(80))
	if pTab == uintptr(0) {
		return 0
	}
	(*TTable)(unsafe.Pointer(pTab)).FzName = _sqlite3DbStrDup(tls, db, (*TModule)(unsafe.Pointer(pMod)).FzName)
	if (*TTable)(unsafe.Pointer(pTab)).FzName == uintptr(0) {
		_sqlite3DbFree(tls, db, pTab)
		return 0
	}
	(*TModule)(unsafe.Pointer(pMod)).FpEpoTab = pTab
	(*TTable)(unsafe.Pointer(pTab)).FnTabRef = uint32(1)
	(*TTable)(unsafe.Pointer(pTab)).FeTabType = uint8(TABTYP_VTAB)
	(*TTable)(unsafe.Pointer(pTab)).FpSchema = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb))).FpSchema
	(*TTable)(unsafe.Pointer(pTab)).FiPKey = int16(-int32(1))
	**(**Tu32)(__ccgo_up(pTab + 28)) |= uint32(TF_Eponymous)
	_addModuleArgument(tls, pParse, pTab, _sqlite3DbStrDup(tls, db, (*TTable)(unsafe.Pointer(pTab)).FzName))
	_addModuleArgument(tls, pParse, pTab, uintptr(0))
	_addModuleArgument(tls, pParse, pTab, _sqlite3DbStrDup(tls, db, (*TTable)(unsafe.Pointer(pTab)).FzName))
	(*Tsqlite3)(unsafe.Pointer(db)).FnSchemaLock = (*Tsqlite3)(unsafe.Pointer(db)).FnSchemaLock + 1
	rc = _vtabCallConstructor(tls, db, pTab, pMod, (*Tsqlite3_module)(unsafe.Pointer(pModule)).FxConnect, bp)
	(*Tsqlite3)(unsafe.Pointer(db)).FnSchemaLock = (*Tsqlite3)(unsafe.Pointer(db)).FnSchemaLock - 1
	if rc != 0 {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+3942, libc.VaList(bp+16, **(**uintptr)(__ccgo_up(bp))))
		(*TParse)(unsafe.Pointer(pParse)).Frc = rc
		_sqlite3DbFree(tls, db, **(**uintptr)(__ccgo_up(bp)))
		_sqlite3VtabEponymousTableClear(tls, db, pMod)
	}
	return int32(1)
}

// C documentation
//
//	/*
//	** The parser calls this routine after the CREATE VIRTUAL TABLE statement
//	** has been completely parsed.
//	*/
func _sqlite3VtabFinishParse(tls *libc.TLS, pParse uintptr, pEnd uintptr) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var db, pOld, pSchema, pTab, v, zName, zStmt, zWhere, v2 uintptr
	var iDb, iReg, v1 int32
	_, _, _, _, _, _, _, _, _, _, _, _ = db, iDb, iReg, pOld, pSchema, pTab, v, zName, zStmt, zWhere, v1, v2
	pTab = (*TParse)(unsafe.Pointer(pParse)).FpNewTable /* The table being constructed */
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb          /* The database connection */
	if pTab == uintptr(0) {
		return
	}
	_addArgumentToVtab(tls, pParse)
	(*TParse)(unsafe.Pointer(pParse)).FsArg.Fz = uintptr(0)
	if (*(*struct {
		FnArg  int32
		FazArg uintptr
		Fp     uintptr
	})(unsafe.Pointer(pTab + 44))).FnArg < int32(1) {
		return
	}
	/* If the CREATE VIRTUAL TABLE statement is being entered for the
	 ** first time (in other words if the virtual table is actually being
	 ** created now instead of just being read out of sqlite_schema) then
	 ** do additional initialization work and store the statement text
	 ** in the sqlite_schema table.
	 */
	if !((*Tsqlite3)(unsafe.Pointer(db)).Finit1.Fbusy != 0) {
		_sqlite3MayAbort(tls, pParse)
		/* Compute the complete text of the CREATE VIRTUAL TABLE statement */
		if pEnd != 0 {
			(*TParse)(unsafe.Pointer(pParse)).FsNameToken.Fn = libc.Uint32FromInt32(int32((*TToken)(unsafe.Pointer(pEnd)).Fz)-int32((*TParse)(unsafe.Pointer(pParse)).FsNameToken.Fz)) + (*TToken)(unsafe.Pointer(pEnd)).Fn
		}
		zStmt = _sqlite3MPrintf(tls, db, __ccgo_ts+23328, libc.VaList(bp+8, pParse+172))
		/* A slot for the record has already been allocated in the
		 ** schema table.  We just need to update that slot with all
		 ** the information we've collected.
		 **
		 ** The VM register number pParse->u1.cr.regRowid holds the rowid of an
		 ** entry in the sqlite_schema table that was created for this vtab
		 ** by sqlite3StartTable().
		 */
		iDb = _sqlite3SchemaToIndex(tls, db, (*TTable)(unsafe.Pointer(pTab)).FpSchema)
		_sqlite3NestedParse(tls, pParse, __ccgo_ts+23352, libc.VaList(bp+8, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(iDb)*16))).FzDbSName, (*TTable)(unsafe.Pointer(pTab)).FzName, (*TTable)(unsafe.Pointer(pTab)).FzName, zStmt, (*(*struct {
			FaddrCrTab      int32
			FregRowid       int32
			FregRoot        int32
			FconstraintName TToken
		})(unsafe.Pointer(pParse + 188))).FregRowid))
		v = _sqlite3GetVdbe(tls, pParse)
		_sqlite3ChangeCookie(tls, pParse, iDb)
		_sqlite3VdbeAddOp0(tls, v, int32(OP_Expire))
		zWhere = _sqlite3MPrintf(tls, db, __ccgo_ts+23451, libc.VaList(bp+8, (*TTable)(unsafe.Pointer(pTab)).FzName, zStmt))
		_sqlite3VdbeAddParseSchemaOp(tls, v, iDb, zWhere, uint16(0))
		_sqlite3DbFree(tls, db, zStmt)
		v2 = pParse + 48
		*(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1
		v1 = *(*int32)(unsafe.Pointer(v2))
		iReg = v1
		_sqlite3VdbeLoadString(tls, v, iReg, (*TTable)(unsafe.Pointer(pTab)).FzName)
		_sqlite3VdbeAddOp2(tls, v, int32(OP_VCreate), iDb, iReg)
	} else {
		pSchema = (*TTable)(unsafe.Pointer(pTab)).FpSchema
		zName = (*TTable)(unsafe.Pointer(pTab)).FzName
		_sqlite3MarkAllShadowTablesOf(tls, db, pTab)
		pOld = _sqlite3HashInsert(tls, pSchema+8, zName, pTab)
		if pOld != 0 {
			_sqlite3OomFault(tls, db)
			/* Malloc must have failed inside HashInsert() */
			return
		}
		(*TParse)(unsafe.Pointer(pParse)).FpNewTable = uintptr(0)
	}
}

// C documentation
//
//	/*
//	** For table-valued-functions, transform the function arguments into
//	** new WHERE clause terms.
//	**
//	** Each function argument translates into an equality constraint against
//	** a HIDDEN column in the table.
//	*/
func _sqlite3WhereTabFuncArgs(tls *libc.TLS, pParse uintptr, pItem uintptr, pWC uintptr) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var j, k, v2 int32
	var joinType Tu32
	var pArgs, pColRef, pRhs, pTab, pTerm uintptr
	_, _, _, _, _, _, _, _, _ = j, joinType, k, pArgs, pColRef, pRhs, pTab, pTerm, v2
	if int32(*(*uint32)(unsafe.Pointer(pItem + 12 + 4))&0x8>>3) == 0 {
		return
	}
	pTab = (*TSrcItem)(unsafe.Pointer(pItem)).FpSTab
	pArgs = *(*uintptr)(unsafe.Pointer(pItem + 32))
	if pArgs == uintptr(0) {
		return
	}
	v2 = libc.Int32FromInt32(0)
	k = v2
	j = v2
	for {
		if !(j < (*TExprList)(unsafe.Pointer(pArgs)).FnExpr) {
			break
		}
		for k < int32((*TTable)(unsafe.Pointer(pTab)).FnCol) && libc.Int32FromUint16((**(**TColumn)(__ccgo_up((*TTable)(unsafe.Pointer(pTab)).FaCol + uintptr(k)*12))).FcolFlags)&int32(COLFLAG_HIDDEN) == 0 {
			k = k + 1
		}
		if k >= int32((*TTable)(unsafe.Pointer(pTab)).FnCol) {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+23950, libc.VaList(bp+8, (*TTable)(unsafe.Pointer(pTab)).FzName, j))
			return
		}
		pColRef = _sqlite3ExprAlloc(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, int32(TK_COLUMN), uintptr(0), 0)
		if pColRef == uintptr(0) {
			return
		}
		(*TExpr)(unsafe.Pointer(pColRef)).FiTable = (*TSrcItem)(unsafe.Pointer(pItem)).FiCursor
		v2 = k
		k = k + 1
		(*TExpr)(unsafe.Pointer(pColRef)).FiColumn = int16(v2)
		(*TExpr)(unsafe.Pointer(pColRef)).Fy.FpTab = pTab
		**(**TBitmask)(__ccgo_up(pItem + 24)) |= _sqlite3ExprColUsed(tls, pColRef)
		pRhs = _sqlite3PExpr(tls, pParse, int32(TK_UPLUS), _sqlite3ExprDup(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, (*(*TExprList_item)(unsafe.Pointer(pArgs + 8 + uintptr(j)*20))).FpExpr, 0), uintptr(0))
		pTerm = _sqlite3PExpr(tls, pParse, int32(TK_EQ), pColRef, pRhs)
		if libc.Int32FromUint8((*TSrcItem)(unsafe.Pointer(pItem)).Ffg.Fjointype)&(libc.Int32FromInt32(JT_LEFT)|libc.Int32FromInt32(JT_RIGHT)) != 0 {
			/* testtag-20230227a */
			/* testtag-20230227b */
			joinType = uint32(EP_OuterON)
		} else {
			/* testtag-20230227c */
			joinType = uint32(EP_InnerON)
		}
		_sqlite3SetJoinExpr(tls, pTerm, (*TSrcItem)(unsafe.Pointer(pItem)).FiCursor, joinType)
		_whereClauseInsert(tls, pWC, pTerm, uint16(TERM_DYNAMIC))
		goto _1
	_1:
		;
		j = j + 1
	}
}

/************** End of whereexpr.c *******************************************/
/************** Begin file where.c *******************************************/
/*
** 2001 September 15
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:
**
**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This module contains C code that generates VDBE code used to process
** the WHERE clause of SQL statements.  This module is responsible for
** generating the code that loops through a table looking for applicable
** rows.  Indices are selected and used to speed the search when doing
** so is applicable.  Because this module is responsible for selecting
** indices, you might also think of this module as the "query optimizer".
 */
/* #include "sqliteInt.h" */
/* #include "whereInt.h" */

// C documentation
//
//	/*
//	** Allocate and return a new Window object describing a Window Definition.
//	*/
func _sqlite3WindowAlloc(tls *libc.TLS, pParse uintptr, eType int32, eStart int32, pStart uintptr, eEnd int32, pEnd uintptr, eExclude Tu8) (r uintptr) {
	var bImplicitFrame int32
	var pWin uintptr
	_, _ = bImplicitFrame, pWin
	pWin = uintptr(0)
	bImplicitFrame = 0
	/* Parser assures the following: */
	if eType == 0 {
		bImplicitFrame = int32(1)
		eType = int32(TK_RANGE)
	}
	/* Additionally, the
	 ** starting boundary type may not occur earlier in the following list than
	 ** the ending boundary type:
	 **
	 **   UNBOUNDED PRECEDING
	 **   <expr> PRECEDING
	 **   CURRENT ROW
	 **   <expr> FOLLOWING
	 **   UNBOUNDED FOLLOWING
	 **
	 ** The parser ensures that "UNBOUNDED PRECEDING" cannot be used as an ending
	 ** boundary, and than "UNBOUNDED FOLLOWING" cannot be used as a starting
	 ** frame boundary.
	 */
	if eStart == int32(TK_CURRENT) && eEnd == int32(TK_PRECEDING) || eStart == int32(TK_FOLLOWING) && (eEnd == int32(TK_PRECEDING) || eEnd == int32(TK_CURRENT)) {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+24457, 0)
		goto windowAllocErr
	}
	pWin = _sqlite3DbMallocZero(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, uint64(100))
	if pWin == uintptr(0) {
		goto windowAllocErr
	}
	(*TWindow)(unsafe.Pointer(pWin)).FeFrmType = libc.Uint8FromInt32(eType)
	(*TWindow)(unsafe.Pointer(pWin)).FeStart = libc.Uint8FromInt32(eStart)
	(*TWindow)(unsafe.Pointer(pWin)).FeEnd = libc.Uint8FromInt32(eEnd)
	if libc.Int32FromUint8(eExclude) == 0 && (*Tsqlite3)(unsafe.Pointer((*TParse)(unsafe.Pointer(pParse)).Fdb)).FdbOptFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_WindowFunc)) != uint32(0) {
		eExclude = uint8(TK_NO)
	}
	(*TWindow)(unsafe.Pointer(pWin)).FeExclude = eExclude
	(*TWindow)(unsafe.Pointer(pWin)).FbImplicitFrame = libc.Uint8FromInt32(bImplicitFrame)
	(*TWindow)(unsafe.Pointer(pWin)).FpEnd = _sqlite3WindowOffsetExpr(tls, pParse, pEnd)
	(*TWindow)(unsafe.Pointer(pWin)).FpStart = _sqlite3WindowOffsetExpr(tls, pParse, pStart)
	return pWin
	goto windowAllocErr
windowAllocErr:
	;
	_sqlite3ExprDelete(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, pEnd)
	_sqlite3ExprDelete(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, pStart)
	return uintptr(0)
}

// C documentation
//
//	/*
//	** Attach window object pWin to expression p.
//	*/
func _sqlite3WindowAttach(tls *libc.TLS, pParse uintptr, p uintptr, pWin uintptr) {
	if p != 0 {
		*(*uintptr)(unsafe.Pointer(&(*TExpr)(unsafe.Pointer(p)).Fy)) = pWin
		**(**Tu32)(__ccgo_up(p + 4)) |= libc.Uint32FromInt32(libc.Int32FromInt32(EP_WinFunc) | libc.Int32FromInt32(EP_FullSize))
		(*TWindow)(unsafe.Pointer(pWin)).FpOwner = p
		if (*TExpr)(unsafe.Pointer(p)).Fflags&uint32(EP_Distinct) != 0 && libc.Int32FromUint8((*TWindow)(unsafe.Pointer(pWin)).FeFrmType) != int32(TK_FILTER) {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+24575, 0)
		}
	} else {
		_sqlite3WindowDelete(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, pWin)
	}
}

// C documentation
//
//	/*
//	** This function is called immediately after resolving the function name
//	** for a window function within a SELECT statement. Argument pList is a
//	** linked list of WINDOW definitions for the current SELECT statement.
//	** Argument pFunc is the function definition just resolved and pWin
//	** is the Window object representing the associated OVER clause. This
//	** function updates the contents of pWin as follows:
//	**
//	**   * If the OVER clause referred to a named window (as in "max(x) OVER win"),
//	**     search list pList for a matching WINDOW definition, and update pWin
//	**     accordingly. If no such WINDOW clause can be found, leave an error
//	**     in pParse.
//	**
//	**   * If the function is a built-in window function that requires the
//	**     window to be coerced (see "BUILT-IN WINDOW FUNCTIONS" at the top
//	**     of this file), pWin is updated here.
//	*/
func _sqlite3WindowUpdate(tls *libc.TLS, pParse uintptr, pList uintptr, pWin uintptr, pFunc uintptr) {
	var aUp [8]struct {
		FzFunc    uintptr
		FeFrmType int32
		FeStart   int32
		FeEnd     int32
	}
	var db, p, v2 uintptr
	var i int32
	_, _, _, _, _ = aUp, db, i, p, v2
	if (*TWindow)(unsafe.Pointer(pWin)).FzName != 0 && libc.Int32FromUint8((*TWindow)(unsafe.Pointer(pWin)).FeFrmType) == 0 {
		p = _windowFind(tls, pParse, pList, (*TWindow)(unsafe.Pointer(pWin)).FzName)
		if p == uintptr(0) {
			return
		}
		(*TWindow)(unsafe.Pointer(pWin)).FpPartition = _sqlite3ExprListDup(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, (*TWindow)(unsafe.Pointer(p)).FpPartition, 0)
		(*TWindow)(unsafe.Pointer(pWin)).FpOrderBy = _sqlite3ExprListDup(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, (*TWindow)(unsafe.Pointer(p)).FpOrderBy, 0)
		(*TWindow)(unsafe.Pointer(pWin)).FpStart = _sqlite3ExprDup(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, (*TWindow)(unsafe.Pointer(p)).FpStart, 0)
		(*TWindow)(unsafe.Pointer(pWin)).FpEnd = _sqlite3ExprDup(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, (*TWindow)(unsafe.Pointer(p)).FpEnd, 0)
		(*TWindow)(unsafe.Pointer(pWin)).FeStart = (*TWindow)(unsafe.Pointer(p)).FeStart
		(*TWindow)(unsafe.Pointer(pWin)).FeEnd = (*TWindow)(unsafe.Pointer(p)).FeEnd
		(*TWindow)(unsafe.Pointer(pWin)).FeFrmType = (*TWindow)(unsafe.Pointer(p)).FeFrmType
		(*TWindow)(unsafe.Pointer(pWin)).FeExclude = (*TWindow)(unsafe.Pointer(p)).FeExclude
	} else {
		_sqlite3WindowChain(tls, pParse, pWin, pList)
	}
	if libc.Int32FromUint8((*TWindow)(unsafe.Pointer(pWin)).FeFrmType) == int32(TK_RANGE) && ((*TWindow)(unsafe.Pointer(pWin)).FpStart != 0 || (*TWindow)(unsafe.Pointer(pWin)).FpEnd != 0) && ((*TWindow)(unsafe.Pointer(pWin)).FpOrderBy == uintptr(0) || (*TExprList)(unsafe.Pointer((*TWindow)(unsafe.Pointer(pWin)).FpOrderBy)).FnExpr != int32(1)) {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+24297, 0)
	} else {
		if (*TFuncDef)(unsafe.Pointer(pFunc)).FfuncFlags&uint32(SQLITE_FUNC_WINDOW) != 0 {
			db = (*TParse)(unsafe.Pointer(pParse)).Fdb
			if (*TWindow)(unsafe.Pointer(pWin)).FpFilter != 0 {
				_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+24368, 0)
			} else {
				aUp = [8]struct {
					FzFunc    uintptr
					FeFrmType int32
					FeStart   int32
					FeEnd     int32
				}{
					0: {
						FzFunc:    uintptr(unsafe.Pointer(&_row_numberName)),
						FeFrmType: int32(TK_ROWS),
						FeStart:   int32(TK_UNBOUNDED),
						FeEnd:     int32(TK_CURRENT),
					},
					1: {
						FzFunc:    uintptr(unsafe.Pointer(&_dense_rankName)),
						FeFrmType: int32(TK_RANGE),
						FeStart:   int32(TK_UNBOUNDED),
						FeEnd:     int32(TK_CURRENT),
					},
					2: {
						FzFunc:    uintptr(unsafe.Pointer(&_rankName)),
						FeFrmType: int32(TK_RANGE),
						FeStart:   int32(TK_UNBOUNDED),
						FeEnd:     int32(TK_CURRENT),
					},
					3: {
						FzFunc:    uintptr(unsafe.Pointer(&_percent_rankName)),
						FeFrmType: int32(TK_GROUPS),
						FeStart:   int32(TK_CURRENT),
						FeEnd:     int32(TK_UNBOUNDED),
					},
					4: {
						FzFunc:    uintptr(unsafe.Pointer(&_cume_distName)),
						FeFrmType: int32(TK_GROUPS),
						FeStart:   int32(TK_FOLLOWING),
						FeEnd:     int32(TK_UNBOUNDED),
					},
					5: {
						FzFunc:    uintptr(unsafe.Pointer(&_ntileName)),
						FeFrmType: int32(TK_ROWS),
						FeStart:   int32(TK_CURRENT),
						FeEnd:     int32(TK_UNBOUNDED),
					},
					6: {
						FzFunc:    uintptr(unsafe.Pointer(&_leadName)),
						FeFrmType: int32(TK_ROWS),
						FeStart:   int32(TK_UNBOUNDED),
						FeEnd:     int32(TK_UNBOUNDED),
					},
					7: {
						FzFunc:    uintptr(unsafe.Pointer(&_lagName)),
						FeFrmType: int32(TK_ROWS),
						FeStart:   int32(TK_UNBOUNDED),
						FeEnd:     int32(TK_CURRENT),
					},
				}
				i = 0
				for {
					if !(i < libc.Int32FromUint32(libc.Uint32FromInt64(128)/libc.Uint32FromInt64(16))) {
						break
					}
					if (*TFuncDef)(unsafe.Pointer(pFunc)).FzName == aUp[i].FzFunc {
						_sqlite3ExprDelete(tls, db, (*TWindow)(unsafe.Pointer(pWin)).FpStart)
						_sqlite3ExprDelete(tls, db, (*TWindow)(unsafe.Pointer(pWin)).FpEnd)
						v2 = libc.UintptrFromInt32(0)
						(*TWindow)(unsafe.Pointer(pWin)).FpStart = v2
						(*TWindow)(unsafe.Pointer(pWin)).FpEnd = v2
						(*TWindow)(unsafe.Pointer(pWin)).FeFrmType = libc.Uint8FromInt32(aUp[i].FeFrmType)
						(*TWindow)(unsafe.Pointer(pWin)).FeStart = libc.Uint8FromInt32(aUp[i].FeStart)
						(*TWindow)(unsafe.Pointer(pWin)).FeEnd = libc.Uint8FromInt32(aUp[i].FeEnd)
						(*TWindow)(unsafe.Pointer(pWin)).FeExclude = uint8(0)
						if libc.Int32FromUint8((*TWindow)(unsafe.Pointer(pWin)).FeStart) == int32(TK_FOLLOWING) {
							(*TWindow)(unsafe.Pointer(pWin)).FpStart = _sqlite3ExprInt32(tls, db, int32(1))
						}
						break
					}
					goto _1
				_1:
					;
					i = i + 1
				}
			}
		}
	}
	(*TWindow)(unsafe.Pointer(pWin)).FpWFunc = pFunc
}

// C documentation
//
//	/*
//	** This routine is invoked once per CTE by the parser while parsing a
//	** WITH clause.  The CTE described by the third argument is added to
//	** the WITH clause of the second argument.  If the second argument is
//	** NULL, then a new WITH argument is created.
//	*/
func _sqlite3WithAdd(tls *libc.TLS, pParse uintptr, pWith uintptr, pCte uintptr) (r uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var db, pNew, zName, v3 uintptr
	var i, v2 int32
	_, _, _, _, _, _ = db, i, pNew, zName, v2, v3
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	if pCte == uintptr(0) {
		return pWith
	}
	/* Check that the CTE name is unique within this WITH clause. If
	 ** not, store an error in the Parse structure. */
	zName = (*TCte)(unsafe.Pointer(pCte)).FzName
	if zName != 0 && pWith != 0 {
		i = 0
		for {
			if !(i < (*TWith)(unsafe.Pointer(pWith)).FnCte) {
				break
			}
			if _sqlite3StrICmp(tls, zName, (*(*TCte)(unsafe.Pointer(pWith + 12 + uintptr(i)*24))).FzName) == 0 {
				_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+16286, libc.VaList(bp+8, zName))
			}
			goto _1
		_1:
			;
			i = i + 1
		}
	}
	if pWith != 0 {
		pNew = _sqlite3DbRealloc(tls, db, pWith, uint64(uint32(libc.UintptrFromInt32(0)+12)+libc.Uint32FromInt32((*TWith)(unsafe.Pointer(pWith)).FnCte+libc.Int32FromInt32(1))*libc.Uint32FromInt64(24)))
	} else {
		pNew = _sqlite3DbMallocZero(tls, db, uint64(uint32(libc.UintptrFromInt32(0)+12)+libc.Uint32FromInt32(libc.Int32FromInt32(1))*libc.Uint32FromInt64(24)))
	}
	if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
		_sqlite3CteDelete(tls, db, pCte)
		pNew = pWith
	} else {
		v3 = pNew
		v2 = *(*int32)(unsafe.Pointer(v3))
		*(*int32)(unsafe.Pointer(v3)) = *(*int32)(unsafe.Pointer(v3)) + 1
		*(*TCte)(unsafe.Pointer(pNew + 12 + uintptr(v2)*24)) = **(**TCte)(__ccgo_up(pCte))
		_sqlite3DbFree(tls, db, pCte)
	}
	return pNew
}

func _sqlite3_geopoly_init(tls *libc.TLS, db uintptr) (r int32) {
	var enc, rc int32
	var i uint32
	_, _, _ = enc, i, rc
	rc = SQLITE_OK
	i = uint32(0)
	for {
		if !(i < libc.Uint32FromInt64(144)/libc.Uint32FromInt64(12) && rc == SQLITE_OK) {
			break
		}
		if _aFunc[i].FbPure != 0 {
			enc = libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_DETERMINISTIC) | libc.Int32FromInt32(SQLITE_INNOCUOUS)
		} else {
			enc = libc.Int32FromInt32(SQLITE_UTF8) | libc.Int32FromInt32(SQLITE_DIRECTONLY)
		}
		rc = Xsqlite3_create_function(tls, db, _aFunc[i].FzName, int32(_aFunc[i].FnArg), enc, uintptr(0), _aFunc[i].FxFunc, uintptr(0), uintptr(0))
		goto _1
	_1:
		;
		i = i + 1
	}
	i = uint32(0)
	for {
		if !(i < libc.Uint32FromInt64(12)/libc.Uint32FromInt64(12) && rc == SQLITE_OK) {
			break
		}
		rc = Xsqlite3_create_function(tls, db, _aAgg[i].FzName, int32(1), libc.Int32FromInt32(SQLITE_UTF8)|libc.Int32FromInt32(SQLITE_DETERMINISTIC)|libc.Int32FromInt32(SQLITE_INNOCUOUS), uintptr(0), uintptr(0), _aAgg[i].FxStep, _aAgg[i].FxFinal)
		goto _2
	_2:
		;
		i = i + 1
	}
	if rc == SQLITE_OK {
		rc = Xsqlite3_create_module_v2(tls, db, __ccgo_ts+30219, uintptr(unsafe.Pointer(&_geopolyModule)), uintptr(0), uintptr(0))
	}
	return rc
}

// C documentation
//
//	/*
//	** This routine is called once for each row in the result table.  Its job
//	** is to fill in the TabResult structure appropriately, allocating new
//	** memory as necessary.
//	*/
func _sqlite3_get_table_cb(tls *libc.TLS, pArg uintptr, nCol int32, argv uintptr, colv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var azNew, p, z, v3 uintptr
	var i, n, need int32
	var v2 Tu32
	_, _, _, _, _, _, _, _ = azNew, i, n, need, p, z, v2, v3
	p = pArg /* A single column of result */
	/* Make sure there is enough space in p->azResult to hold everything
	 ** we need to remember from this invocation of the callback.
	 */
	if (*TTabResult)(unsafe.Pointer(p)).FnRow == uint32(0) && argv != uintptr(0) {
		need = nCol * int32(2)
	} else {
		need = nCol
	}
	if (*TTabResult)(unsafe.Pointer(p)).FnData+libc.Uint32FromInt32(need) > (*TTabResult)(unsafe.Pointer(p)).FnAlloc {
		(*TTabResult)(unsafe.Pointer(p)).FnAlloc = (*TTabResult)(unsafe.Pointer(p)).FnAlloc*uint32(2) + libc.Uint32FromInt32(need)
		azNew = _sqlite3Realloc(tls, (*TTabResult)(unsafe.Pointer(p)).FazResult, uint64(uint32(4)*(*TTabResult)(unsafe.Pointer(p)).FnAlloc))
		if azNew == uintptr(0) {
			goto malloc_failed
		}
		(*TTabResult)(unsafe.Pointer(p)).FazResult = azNew
	}
	/* If this is the first row, then generate an extra row containing
	 ** the names of all columns.
	 */
	if (*TTabResult)(unsafe.Pointer(p)).FnRow == uint32(0) {
		(*TTabResult)(unsafe.Pointer(p)).FnColumn = libc.Uint32FromInt32(nCol)
		i = 0
		for {
			if !(i < nCol) {
				break
			}
			z = Xsqlite3_mprintf(tls, __ccgo_ts+3942, libc.VaList(bp+8, **(**uintptr)(__ccgo_up(colv + uintptr(i)*4))))
			if z == uintptr(0) {
				goto malloc_failed
			}
			v3 = p + 20
			v2 = *(*Tu32)(unsafe.Pointer(v3))
			*(*Tu32)(unsafe.Pointer(v3)) = *(*Tu32)(unsafe.Pointer(v3)) + 1
			**(**uintptr)(__ccgo_up((*TTabResult)(unsafe.Pointer(p)).FazResult + uintptr(v2)*4)) = z
			goto _1
		_1:
			;
			i = i + 1
		}
	} else {
		if libc.Int32FromUint32((*TTabResult)(unsafe.Pointer(p)).FnColumn) != nCol {
			Xsqlite3_free(tls, (*TTabResult)(unsafe.Pointer(p)).FzErrMsg)
			(*TTabResult)(unsafe.Pointer(p)).FzErrMsg = Xsqlite3_mprintf(tls, __ccgo_ts+21773, 0)
			(*TTabResult)(unsafe.Pointer(p)).Frc = int32(SQLITE_ERROR)
			return int32(1)
		}
	}
	/* Copy over the row data
	 */
	if argv != uintptr(0) {
		i = 0
		for {
			if !(i < nCol) {
				break
			}
			if **(**uintptr)(__ccgo_up(argv + uintptr(i)*4)) == uintptr(0) {
				z = uintptr(0)
			} else {
				n = _sqlite3Strlen30(tls, **(**uintptr)(__ccgo_up(argv + uintptr(i)*4))) + int32(1)
				z = Xsqlite3_malloc64(tls, libc.Uint64FromInt32(n))
				if z == uintptr(0) {
					goto malloc_failed
				}
				libc.Xmemcpy(tls, z, **(**uintptr)(__ccgo_up(argv + uintptr(i)*4)), libc.Uint32FromInt32(n))
			}
			v3 = p + 20
			v2 = *(*Tu32)(unsafe.Pointer(v3))
			*(*Tu32)(unsafe.Pointer(v3)) = *(*Tu32)(unsafe.Pointer(v3)) + 1
			**(**uintptr)(__ccgo_up((*TTabResult)(unsafe.Pointer(p)).FazResult + uintptr(v2)*4)) = z
			goto _4
		_4:
			;
			i = i + 1
		}
		(*TTabResult)(unsafe.Pointer(p)).FnRow = (*TTabResult)(unsafe.Pointer(p)).FnRow + 1
	}
	return 0
	goto malloc_failed
malloc_failed:
	;
	(*TTabResult)(unsafe.Pointer(p)).Frc = int32(SQLITE_NOMEM)
	return int32(1)
}

// C documentation
//
//	/*
//	** Connect to or create a new DBSTAT virtual table.
//	*/
func _statConnect(tls *libc.TLS, db uintptr, pAux uintptr, argc int32, argv uintptr, ppVtab uintptr, pzErr uintptr) (r int32) {
	bp := tls.Alloc(32)
	defer tls.Free(32)
	var iDb, rc int32
	var pTab uintptr
	var _ /* nm at bp+0 */ TToken
	_, _, _ = iDb, pTab, rc
	pTab = uintptr(0)
	rc = SQLITE_OK
	_ = pAux
	if argc >= int32(4) {
		_sqlite3TokenInit(tls, bp, **(**uintptr)(__ccgo_up(argv + 3*4)))
		iDb = _sqlite3FindDb(tls, db, bp)
		if iDb < 0 {
			**(**uintptr)(__ccgo_up(pzErr)) = Xsqlite3_mprintf(tls, __ccgo_ts+13444, libc.VaList(bp+16, **(**uintptr)(__ccgo_up(argv + 3*4))))
			return int32(SQLITE_ERROR)
		}
	} else {
		iDb = 0
	}
	Xsqlite3_vtab_config(tls, db, int32(SQLITE_VTAB_DIRECTONLY), 0)
	rc = Xsqlite3_declare_vtab(tls, db, uintptr(unsafe.Pointer(&_zDbstatSchema)))
	if rc == SQLITE_OK {
		pTab = Xsqlite3_malloc64(tls, uint64(20))
		if pTab == uintptr(0) {
			rc = int32(SQLITE_NOMEM)
		}
	}
	if rc == SQLITE_OK {
		libc.Xmemset(tls, pTab, 0, uint32(20))
		(*TStatTable)(unsafe.Pointer(pTab)).Fdb = db
		(*TStatTable)(unsafe.Pointer(pTab)).FiDb = iDb
	}
	**(**uintptr)(__ccgo_up(ppVtab)) = pTab
	return rc
}

// C documentation
//
//	/* Initialize a cursor according to the query plan idxNum using the
//	** arguments in argv[0].  See statBestIndex() for a description of the
//	** meaning of the bits in idxNum.
//	*/
func _statFilter(tls *libc.TLS, pCursor uintptr, idxNum int32, idxStr uintptr, argc int32, argv uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var iArg, rc, v1 int32
	var pCsr, pSql, pTab, zDbase, zName, zSql uintptr
	_, _, _, _, _, _, _, _, _ = iArg, pCsr, pSql, pTab, rc, zDbase, zName, zSql, v1
	pCsr = pCursor
	pTab = (*Tsqlite3_vtab_cursor)(unsafe.Pointer(pCursor)).FpVtab /* String value of pSql */
	iArg = 0                                                       /* Count of argv[] parameters used so far */
	rc = SQLITE_OK                                                 /* Result of this operation */
	zName = uintptr(0)                                             /* Only provide analysis of this table */
	_ = argc
	_ = idxStr
	_statResetCsr(tls, pCsr)
	Xsqlite3_finalize(tls, (*TStatCursor)(unsafe.Pointer(pCsr)).FpStmt)
	(*TStatCursor)(unsafe.Pointer(pCsr)).FpStmt = uintptr(0)
	if idxNum&int32(0x01) != 0 {
		v1 = iArg
		iArg = iArg + 1
		/* schema=? constraint is present.  Get its value */
		zDbase = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv + uintptr(v1)*4)))
		(*TStatCursor)(unsafe.Pointer(pCsr)).FiDb = _sqlite3FindDbName(tls, (*TStatTable)(unsafe.Pointer(pTab)).Fdb, zDbase)
		if (*TStatCursor)(unsafe.Pointer(pCsr)).FiDb < 0 {
			(*TStatCursor)(unsafe.Pointer(pCsr)).FiDb = 0
			(*TStatCursor)(unsafe.Pointer(pCsr)).FisEof = uint8(1)
			return SQLITE_OK
		}
	} else {
		(*TStatCursor)(unsafe.Pointer(pCsr)).FiDb = (*TStatTable)(unsafe.Pointer(pTab)).FiDb
	}
	if idxNum&int32(0x02) != 0 {
		/* name=? constraint is present */
		v1 = iArg
		iArg = iArg + 1
		zName = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv + uintptr(v1)*4)))
	}
	if idxNum&int32(0x04) != 0 {
		/* aggregate=? constraint is present */
		v1 = iArg
		iArg = iArg + 1
		(*TStatCursor)(unsafe.Pointer(pCsr)).FisAgg = libc.BoolUint8(Xsqlite3_value_double(tls, **(**uintptr)(__ccgo_up(argv + uintptr(v1)*4))) != float64(0))
	} else {
		(*TStatCursor)(unsafe.Pointer(pCsr)).FisAgg = uint8(0)
	}
	pSql = Xsqlite3_str_new(tls, (*TStatTable)(unsafe.Pointer(pTab)).Fdb)
	Xsqlite3_str_appendf(tls, pSql, __ccgo_ts+34809, libc.VaList(bp+8, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer((*TStatTable)(unsafe.Pointer(pTab)).Fdb)).FaDb + uintptr((*TStatCursor)(unsafe.Pointer(pCsr)).FiDb)*16))).FzDbSName))
	if zName != 0 {
		Xsqlite3_str_appendf(tls, pSql, __ccgo_ts+34964, libc.VaList(bp+8, zName))
	}
	if idxNum&int32(0x08) != 0 {
		Xsqlite3_str_appendf(tls, pSql, __ccgo_ts+34978, 0)
	}
	zSql = Xsqlite3_str_finish(tls, pSql)
	if zSql == uintptr(0) {
		return int32(SQLITE_NOMEM)
	} else {
		rc = Xsqlite3_prepare_v2(tls, (*TStatTable)(unsafe.Pointer(pTab)).Fdb, zSql, -int32(1), pCsr+4, uintptr(0))
		Xsqlite3_free(tls, zSql)
	}
	if rc == SQLITE_OK {
		(*TStatCursor)(unsafe.Pointer(pCsr)).FiPage = -int32(1)
		rc = _statNext(tls, pCursor)
	}
	return rc
}

// C documentation
//
//	/*
//	** Move a DBSTAT cursor to the next entry.  Normally, the next
//	** entry will be the next page, but in aggregated mode (pCsr->isAgg!=0),
//	** the next entry is the next btree.
//	*/
func _statNext(tls *libc.TLS, pCursor uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var i, iOvfl, nPayload, nUsable, rc, v3 int32
	var iRoot Tu32
	var p, p1, pBt, pCell, pCsr, pPager, pTab, z, v1 uintptr
	var _ /* nPage at bp+0 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, iOvfl, iRoot, nPayload, nUsable, p, p1, pBt, pCell, pCsr, pPager, pTab, rc, z, v1, v3
	pCsr = pCursor
	pTab = (*Tsqlite3_vtab_cursor)(unsafe.Pointer(pCursor)).FpVtab
	pBt = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer((*TStatTable)(unsafe.Pointer(pTab)).Fdb)).FaDb + uintptr((*TStatCursor)(unsafe.Pointer(pCsr)).FiDb)*16))).FpBt
	pPager = _sqlite3BtreePager(tls, pBt)
	Xsqlite3_free(tls, (*TStatCursor)(unsafe.Pointer(pCsr)).FzPath)
	(*TStatCursor)(unsafe.Pointer(pCsr)).FzPath = uintptr(0)
	goto statNextRestart
statNextRestart:
	;
	if (*TStatCursor)(unsafe.Pointer(pCsr)).FiPage < 0 {
		/* Start measuring space on the next btree */
		_statResetCounts(tls, pCsr)
		rc = Xsqlite3_step(tls, (*TStatCursor)(unsafe.Pointer(pCsr)).FpStmt)
		if rc == int32(SQLITE_ROW) {
			iRoot = libc.Uint32FromInt64(Xsqlite3_column_int64(tls, (*TStatCursor)(unsafe.Pointer(pCsr)).FpStmt, int32(1)))
			_sqlite3PagerPagecount(tls, pPager, bp)
			if **(**int32)(__ccgo_up(bp)) == 0 {
				(*TStatCursor)(unsafe.Pointer(pCsr)).FisEof = uint8(1)
				return Xsqlite3_reset(tls, (*TStatCursor)(unsafe.Pointer(pCsr)).FpStmt)
			}
			rc = _statGetPage(tls, pBt, iRoot, pCsr+16)
			(**(**TStatPage)(__ccgo_up(pCsr + 16))).FiPgno = iRoot
			(**(**TStatPage)(__ccgo_up(pCsr + 16))).FiCell = 0
			if !((*TStatCursor)(unsafe.Pointer(pCsr)).FisAgg != 0) {
				v1 = Xsqlite3_mprintf(tls, __ccgo_ts+34754, 0)
				z = v1
				(**(**TStatPage)(__ccgo_up(pCsr + 16))).FzPath = v1
				if z == uintptr(0) {
					rc = int32(SQLITE_NOMEM)
				}
			}
			(*TStatCursor)(unsafe.Pointer(pCsr)).FiPage = 0
			(*TStatCursor)(unsafe.Pointer(pCsr)).FnPage = int32(1)
		} else {
			(*TStatCursor)(unsafe.Pointer(pCsr)).FisEof = uint8(1)
			return Xsqlite3_reset(tls, (*TStatCursor)(unsafe.Pointer(pCsr)).FpStmt)
		}
	} else {
		/* Continue analyzing the btree previously started */
		p = pCsr + 16 + uintptr((*TStatCursor)(unsafe.Pointer(pCsr)).FiPage)*40
		if !((*TStatCursor)(unsafe.Pointer(pCsr)).FisAgg != 0) {
			_statResetCounts(tls, pCsr)
		}
		for (*TStatPage)(unsafe.Pointer(p)).FiCell < (*TStatPage)(unsafe.Pointer(p)).FnCell {
			pCell = (*TStatPage)(unsafe.Pointer(p)).FaCell + uintptr((*TStatPage)(unsafe.Pointer(p)).FiCell)*24
			for (*TStatCell)(unsafe.Pointer(pCell)).FiOvfl < (*TStatCell)(unsafe.Pointer(pCell)).FnOvfl {
				_sqlite3BtreeEnter(tls, pBt)
				nUsable = _sqlite3BtreeGetPageSize(tls, pBt) - _sqlite3BtreeGetReserveNoMutex(tls, pBt)
				_sqlite3BtreeLeave(tls, pBt)
				(*TStatCursor)(unsafe.Pointer(pCsr)).FnPage = (*TStatCursor)(unsafe.Pointer(pCsr)).FnPage + 1
				_statSizeAndOffset(tls, pCsr)
				if (*TStatCell)(unsafe.Pointer(pCell)).FiOvfl < (*TStatCell)(unsafe.Pointer(pCell)).FnOvfl-int32(1) {
					**(**Ti64)(__ccgo_up(pCsr + 1336)) += int64(nUsable - int32(4))
				} else {
					**(**Ti64)(__ccgo_up(pCsr + 1336)) += int64((*TStatCell)(unsafe.Pointer(pCell)).FnLastOvfl)
					**(**Ti64)(__ccgo_up(pCsr + 1328)) += int64(nUsable - int32(4) - (*TStatCell)(unsafe.Pointer(pCell)).FnLastOvfl)
				}
				iOvfl = (*TStatCell)(unsafe.Pointer(pCell)).FiOvfl
				(*TStatCell)(unsafe.Pointer(pCell)).FiOvfl = (*TStatCell)(unsafe.Pointer(pCell)).FiOvfl + 1
				if !((*TStatCursor)(unsafe.Pointer(pCsr)).FisAgg != 0) {
					(*TStatCursor)(unsafe.Pointer(pCsr)).FzName = Xsqlite3_column_text(tls, (*TStatCursor)(unsafe.Pointer(pCsr)).FpStmt, 0)
					(*TStatCursor)(unsafe.Pointer(pCsr)).FiPageno = **(**Tu32)(__ccgo_up((*TStatCell)(unsafe.Pointer(pCell)).FaOvfl + uintptr(iOvfl)*4))
					(*TStatCursor)(unsafe.Pointer(pCsr)).FzPagetype = __ccgo_ts + 34756
					v1 = Xsqlite3_mprintf(tls, __ccgo_ts+34765, libc.VaList(bp+16, (*TStatPage)(unsafe.Pointer(p)).FzPath, (*TStatPage)(unsafe.Pointer(p)).FiCell, iOvfl))
					z = v1
					(*TStatCursor)(unsafe.Pointer(pCsr)).FzPath = v1
					if z == uintptr(0) {
						v3 = int32(SQLITE_NOMEM)
					} else {
						v3 = SQLITE_OK
					}
					return v3
				}
			}
			if (*TStatPage)(unsafe.Pointer(p)).FiRightChildPg != 0 {
				break
			}
			(*TStatPage)(unsafe.Pointer(p)).FiCell = (*TStatPage)(unsafe.Pointer(p)).FiCell + 1
		}
		if !((*TStatPage)(unsafe.Pointer(p)).FiRightChildPg != 0) || (*TStatPage)(unsafe.Pointer(p)).FiCell > (*TStatPage)(unsafe.Pointer(p)).FnCell {
			_statClearPage(tls, p)
			(*TStatCursor)(unsafe.Pointer(pCsr)).FiPage = (*TStatCursor)(unsafe.Pointer(pCsr)).FiPage - 1
			if (*TStatCursor)(unsafe.Pointer(pCsr)).FisAgg != 0 && (*TStatCursor)(unsafe.Pointer(pCsr)).FiPage < 0 {
				/* label-statNext-done:  When computing aggregate space usage over
				 ** an entire btree, this is the exit point from this function */
				return SQLITE_OK
			}
			goto statNextRestart /* Tail recursion */
		}
		(*TStatCursor)(unsafe.Pointer(pCsr)).FiPage = (*TStatCursor)(unsafe.Pointer(pCsr)).FiPage + 1
		if (*TStatCursor)(unsafe.Pointer(pCsr)).FiPage >= libc.Int32FromUint32(libc.Uint32FromInt64(1280)/libc.Uint32FromInt64(40)) {
			_statResetCsr(tls, pCsr)
			return _sqlite3CorruptError(tls, int32(232421))
		}
		if (*TStatPage)(unsafe.Pointer(p)).FiCell == (*TStatPage)(unsafe.Pointer(p)).FnCell {
			(**(**TStatPage)(__ccgo_up(p + 1*40))).FiPgno = (*TStatPage)(unsafe.Pointer(p)).FiRightChildPg
		} else {
			(**(**TStatPage)(__ccgo_up(p + 1*40))).FiPgno = (**(**TStatCell)(__ccgo_up((*TStatPage)(unsafe.Pointer(p)).FaCell + uintptr((*TStatPage)(unsafe.Pointer(p)).FiCell)*24))).FiChildPg
		}
		rc = _statGetPage(tls, pBt, (**(**TStatPage)(__ccgo_up(p + 1*40))).FiPgno, p+1*40)
		(*TStatCursor)(unsafe.Pointer(pCsr)).FnPage = (*TStatCursor)(unsafe.Pointer(pCsr)).FnPage + 1
		(**(**TStatPage)(__ccgo_up(p + 1*40))).FiCell = 0
		if !((*TStatCursor)(unsafe.Pointer(pCsr)).FisAgg != 0) {
			v1 = Xsqlite3_mprintf(tls, __ccgo_ts+34777, libc.VaList(bp+16, (*TStatPage)(unsafe.Pointer(p)).FzPath, (*TStatPage)(unsafe.Pointer(p)).FiCell))
			z = v1
			(**(**TStatPage)(__ccgo_up(p + 1*40))).FzPath = v1
			if z == uintptr(0) {
				rc = int32(SQLITE_NOMEM)
			}
		}
		(*TStatPage)(unsafe.Pointer(p)).FiCell = (*TStatPage)(unsafe.Pointer(p)).FiCell + 1
	}
	/* Populate the StatCursor fields with the values to be returned
	 ** by the xColumn() and xRowid() methods.
	 */
	if rc == SQLITE_OK {
		p1 = pCsr + 16 + uintptr((*TStatCursor)(unsafe.Pointer(pCsr)).FiPage)*40
		(*TStatCursor)(unsafe.Pointer(pCsr)).FzName = Xsqlite3_column_text(tls, (*TStatCursor)(unsafe.Pointer(pCsr)).FpStmt, 0)
		(*TStatCursor)(unsafe.Pointer(pCsr)).FiPageno = (*TStatPage)(unsafe.Pointer(p1)).FiPgno
		rc = _statDecodePage(tls, pBt, p1)
		if rc == SQLITE_OK {
			_statSizeAndOffset(tls, pCsr)
			switch libc.Int32FromUint8((*TStatPage)(unsafe.Pointer(p1)).Fflags) {
			case int32(0x05): /* table internal */
				fallthrough
			case int32(0x02): /* index internal */
				(*TStatCursor)(unsafe.Pointer(pCsr)).FzPagetype = __ccgo_ts + 34785
			case int32(0x0D): /* table leaf */
				fallthrough
			case int32(0x0A): /* index leaf */
				(*TStatCursor)(unsafe.Pointer(pCsr)).FzPagetype = __ccgo_ts + 34794
			default:
				(*TStatCursor)(unsafe.Pointer(pCsr)).FzPagetype = __ccgo_ts + 34799
				break
			}
			**(**int32)(__ccgo_up(pCsr + 1320)) += (*TStatPage)(unsafe.Pointer(p1)).FnCell
			**(**Ti64)(__ccgo_up(pCsr + 1328)) += int64((*TStatPage)(unsafe.Pointer(p1)).FnUnused)
			if (*TStatPage)(unsafe.Pointer(p1)).FnMxPayload > (*TStatCursor)(unsafe.Pointer(pCsr)).FnMxPayload {
				(*TStatCursor)(unsafe.Pointer(pCsr)).FnMxPayload = (*TStatPage)(unsafe.Pointer(p1)).FnMxPayload
			}
			if !((*TStatCursor)(unsafe.Pointer(pCsr)).FisAgg != 0) {
				v1 = Xsqlite3_mprintf(tls, __ccgo_ts+3942, libc.VaList(bp+16, (*TStatPage)(unsafe.Pointer(p1)).FzPath))
				z = v1
				(*TStatCursor)(unsafe.Pointer(pCsr)).FzPath = v1
				if z == uintptr(0) {
					rc = int32(SQLITE_NOMEM)
				}
			}
			nPayload = 0
			i = 0
			for {
				if !(i < (*TStatPage)(unsafe.Pointer(p1)).FnCell) {
					break
				}
				nPayload = nPayload + (**(**TStatCell)(__ccgo_up((*TStatPage)(unsafe.Pointer(p1)).FaCell + uintptr(i)*24))).FnLocal
				goto _6
			_6:
				;
				i = i + 1
			}
			**(**Ti64)(__ccgo_up(pCsr + 1336)) += int64(nPayload)
			/* If computing aggregate space usage by btree, continue with the
			 ** next page.  The loop will exit via the return at label-statNext-done
			 */
			if (*TStatCursor)(unsafe.Pointer(pCsr)).FisAgg != 0 {
				goto statNextRestart
			}
		}
	}
	return rc
}

// C documentation
//
//	/*
//	** Scan through the expression pExpr.  Replace every reference to
//	** a column in table number iTable with a copy of the iColumn-th
//	** entry in pEList.  (But leave references to the ROWID column
//	** unchanged.)
//	**
//	** This routine is part of the flattening procedure.  A subquery
//	** whose result set is defined by pEList appears as entry in the
//	** FROM clause of a SELECT such that the VDBE cursor assigned to that
//	** FORM clause entry is iTable.  This routine makes the necessary
//	** changes to pExpr so that it refers directly to the source table
//	** of the subquery rather the result set of the subquery.
//	*/
func _substExpr(tls *libc.TLS, pSubst uintptr, pExpr uintptr) (r uintptr) {
	bp := tls.Alloc(64)
	defer tls.Free(64)
	var db, pColl, pCopy, pNat, pNew, pWin, v1 uintptr
	var iColumn int32
	var _ /* ifNullRow at bp+0 */ TExpr
	_, _, _, _, _, _, _, _ = db, iColumn, pColl, pCopy, pNat, pNew, pWin, v1
	if pExpr == uintptr(0) {
		return uintptr(0)
	}
	if (*TExpr)(unsafe.Pointer(pExpr)).Fflags&libc.Uint32FromInt32(libc.Int32FromInt32(EP_OuterON)|libc.Int32FromInt32(EP_InnerON)) != uint32(0) && *(*int32)(unsafe.Pointer(pExpr + 36)) == (*TSubstContext)(unsafe.Pointer(pSubst)).FiTable {
		*(*int32)(unsafe.Pointer(pExpr + 36)) = (*TSubstContext)(unsafe.Pointer(pSubst)).FiNewTable
	}
	if libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pExpr)).Fop) == int32(TK_COLUMN) && (*TExpr)(unsafe.Pointer(pExpr)).FiTable == (*TSubstContext)(unsafe.Pointer(pSubst)).FiTable && !((*TExpr)(unsafe.Pointer(pExpr)).Fflags&libc.Uint32FromInt32(libc.Int32FromInt32(EP_FixedCol)) != libc.Uint32FromInt32(0)) {
		iColumn = int32((*TExpr)(unsafe.Pointer(pExpr)).FiColumn)
		pCopy = (*(*TExprList_item)(unsafe.Pointer((*TSubstContext)(unsafe.Pointer(pSubst)).FpEList + 8 + uintptr(iColumn)*20))).FpExpr
		if _sqlite3ExprIsVector(tls, pCopy) != 0 {
			_sqlite3VectorErrorMsg(tls, (*TSubstContext)(unsafe.Pointer(pSubst)).FpParse, pCopy)
		} else {
			db = (*TParse)(unsafe.Pointer((*TSubstContext)(unsafe.Pointer(pSubst)).FpParse)).Fdb
			if (*TSubstContext)(unsafe.Pointer(pSubst)).FisOuterJoin != 0 && (libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pCopy)).Fop) != int32(TK_COLUMN) || (*TExpr)(unsafe.Pointer(pCopy)).FiTable != (*TSubstContext)(unsafe.Pointer(pSubst)).FiNewTable) {
				libc.Xmemset(tls, bp, 0, uint32(52))
				(**(**TExpr)(__ccgo_up(bp))).Fop = uint8(TK_IF_NULL_ROW)
				(**(**TExpr)(__ccgo_up(bp))).FpLeft = pCopy
				(**(**TExpr)(__ccgo_up(bp))).FiTable = (*TSubstContext)(unsafe.Pointer(pSubst)).FiNewTable
				(**(**TExpr)(__ccgo_up(bp))).FiColumn = int16(-int32(99))
				(**(**TExpr)(__ccgo_up(bp))).Fflags = uint32(EP_IfNullRow)
				pCopy = bp
			}
			pNew = _sqlite3ExprDup(tls, db, pCopy, 0)
			if (*Tsqlite3)(unsafe.Pointer(db)).FmallocFailed != 0 {
				_sqlite3ExprDelete(tls, db, pNew)
				return pExpr
			}
			if (*TSubstContext)(unsafe.Pointer(pSubst)).FisOuterJoin != 0 {
				**(**Tu32)(__ccgo_up(pNew + 4)) |= libc.Uint32FromInt32(libc.Int32FromInt32(EP_CanBeNull))
			}
			if libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pNew)).Fop) == int32(TK_TRUEFALSE) {
				*(*int32)(unsafe.Pointer(pNew + 8)) = _sqlite3ExprTruthValue(tls, pNew)
				(*TExpr)(unsafe.Pointer(pNew)).Fop = uint8(TK_INTEGER)
				**(**Tu32)(__ccgo_up(pNew + 4)) |= libc.Uint32FromInt32(libc.Int32FromInt32(EP_IntValue))
			}
			/* Ensure that the expression now has an implicit collation sequence,
			 ** just as it did when it was a column of a view or sub-query. */
			pNat = _sqlite3ExprCollSeq(tls, (*TSubstContext)(unsafe.Pointer(pSubst)).FpParse, pNew)
			pColl = _sqlite3ExprCollSeq(tls, (*TSubstContext)(unsafe.Pointer(pSubst)).FpParse, (*(*TExprList_item)(unsafe.Pointer((*TSubstContext)(unsafe.Pointer(pSubst)).FpCList + 8 + uintptr(iColumn)*20))).FpExpr)
			if pNat != pColl || libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pNew)).Fop) != int32(TK_COLUMN) && libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pNew)).Fop) != int32(TK_COLLATE) {
				if pColl != 0 {
					v1 = (*TCollSeq)(unsafe.Pointer(pColl)).FzName
				} else {
					v1 = __ccgo_ts + 5239
				}
				pNew = _sqlite3ExprAddCollateString(tls, (*TSubstContext)(unsafe.Pointer(pSubst)).FpParse, pNew, v1)
			}
			**(**Tu32)(__ccgo_up(pNew + 4)) &= ^libc.Uint32FromInt32(libc.Int32FromInt32(EP_Collate))
			if (*TExpr)(unsafe.Pointer(pExpr)).Fflags&libc.Uint32FromInt32(libc.Int32FromInt32(EP_OuterON)|libc.Int32FromInt32(EP_InnerON)) != uint32(0) {
				_sqlite3SetJoinExpr(tls, pNew, *(*int32)(unsafe.Pointer(pExpr + 36)), (*TExpr)(unsafe.Pointer(pExpr)).Fflags&libc.Uint32FromInt32(libc.Int32FromInt32(EP_OuterON)|libc.Int32FromInt32(EP_InnerON)))
			}
			_sqlite3ExprDelete(tls, db, pExpr)
			pExpr = pNew
		}
	} else {
		if libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pExpr)).Fop) == int32(TK_IF_NULL_ROW) && (*TExpr)(unsafe.Pointer(pExpr)).FiTable == (*TSubstContext)(unsafe.Pointer(pSubst)).FiTable {
			(*TExpr)(unsafe.Pointer(pExpr)).FiTable = (*TSubstContext)(unsafe.Pointer(pSubst)).FiNewTable
		}
		if libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pExpr)).Fop) == int32(TK_AGG_FUNCTION) && libc.Int32FromUint8((*TExpr)(unsafe.Pointer(pExpr)).Fop2) >= (*TSubstContext)(unsafe.Pointer(pSubst)).FnSelDepth {
			(*TExpr)(unsafe.Pointer(pExpr)).Fop2 = (*TExpr)(unsafe.Pointer(pExpr)).Fop2 - 1
		}
		(*TExpr)(unsafe.Pointer(pExpr)).FpLeft = _substExpr(tls, pSubst, (*TExpr)(unsafe.Pointer(pExpr)).FpLeft)
		(*TExpr)(unsafe.Pointer(pExpr)).FpRight = _substExpr(tls, pSubst, (*TExpr)(unsafe.Pointer(pExpr)).FpRight)
		if (*TExpr)(unsafe.Pointer(pExpr)).Fflags&uint32(EP_xIsSelect) != uint32(0) {
			_substSelect(tls, pSubst, *(*uintptr)(unsafe.Pointer(pExpr + 20)), int32(1))
		} else {
			_substExprList(tls, pSubst, *(*uintptr)(unsafe.Pointer(pExpr + 20)))
		}
		if (*TExpr)(unsafe.Pointer(pExpr)).Fflags&libc.Uint32FromInt32(libc.Int32FromInt32(EP_WinFunc)) != uint32(0) {
			pWin = *(*uintptr)(unsafe.Pointer(&(*TExpr)(unsafe.Pointer(pExpr)).Fy))
			(*TWindow)(unsafe.Pointer(pWin)).FpFilter = _substExpr(tls, pSubst, (*TWindow)(unsafe.Pointer(pWin)).FpFilter)
			_substExprList(tls, pSubst, (*TWindow)(unsafe.Pointer(pWin)).FpPartition)
			_substExprList(tls, pSubst, (*TWindow)(unsafe.Pointer(pWin)).FpOrderBy)
		}
	}
	return pExpr
}

// C documentation
//
//	/*
//	** Allocate space to hold a new trigger step.  The allocated space
//	** holds both the TriggerStep object and the TriggerStep.target.z string.
//	**
//	** If an OOM error occurs, NULL is returned and db->mallocFailed is set.
//	*/
func _triggerStepAllocate(tls *libc.TLS, pParse uintptr, op Tu8, pTabList uintptr, zStart uintptr, zEnd uintptr) (r uintptr) {
	var db, pNew, pTriggerStep uintptr
	_, _, _ = db, pNew, pTriggerStep
	pNew = (*TParse)(unsafe.Pointer(pParse)).FpNewTrigger
	db = (*TParse)(unsafe.Pointer(pParse)).Fdb
	pTriggerStep = uintptr(0)
	if (*TParse)(unsafe.Pointer(pParse)).FnErr == 0 {
		if pNew != 0 && (*TTrigger)(unsafe.Pointer(pNew)).FpSchema != (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + 1*16))).FpSchema && *(*uintptr)(unsafe.Pointer(pTabList + 8 + 44)) != 0 {
			_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+22285, 0)
		} else {
			pTriggerStep = _sqlite3DbMallocZero(tls, db, uint64(44))
			if pTriggerStep != 0 {
				(*TTriggerStep)(unsafe.Pointer(pTriggerStep)).FpSrc = _sqlite3SrcListDup(tls, db, pTabList, int32(EXPRDUP_REDUCE))
				(*TTriggerStep)(unsafe.Pointer(pTriggerStep)).Fop = op
				(*TTriggerStep)(unsafe.Pointer(pTriggerStep)).FzSpan = _triggerSpanDup(tls, db, zStart, zEnd)
				if (*TTriggerStep)(unsafe.Pointer(pTriggerStep)).FpSrc != 0 && libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).FeParseMode) >= int32(PARSE_MODE_RENAME) {
					_sqlite3RenameTokenRemap(tls, pParse, (*(*TSrcItem)(unsafe.Pointer((*TTriggerStep)(unsafe.Pointer(pTriggerStep)).FpSrc + 8))).FzName, (*(*TSrcItem)(unsafe.Pointer(pTabList + 8))).FzName)
				}
			}
		}
	}
	_sqlite3SrcListDelete(tls, db, pTabList)
	return pTriggerStep
}

// C documentation
//
//	/*
//	** The unhex() function. This function may be invoked with either one or
//	** two arguments. In both cases the first argument is interpreted as text
//	** a text value containing a set of pairs of hexadecimal digits which are
//	** decoded and returned as a blob.
//	**
//	** If there is only a single argument, then it must consist only of an
//	** even number of hexadecimal digits. Otherwise, return NULL.
//	**
//	** Or, if there is a second argument, then any character that appears in
//	** the second argument is also allowed to appear between pairs of hexadecimal
//	** digits in the first argument. If any other character appears in the
//	** first argument, or if one of the allowed characters appears between
//	** two hexadecimal digits that make up a single byte, NULL is returned.
//	**
//	** The following expressions are all true:
//	**
//	**     unhex('ABCD')       IS x'ABCD'
//	**     unhex('AB CD')      IS NULL
//	**     unhex('AB CD', ' ') IS x'ABCD'
//	**     unhex('A BCD', ' ') IS NULL
//	*/
func _unhexFunc(tls *libc.TLS, pCtx uintptr, argc int32, argv uintptr) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var c, d, v2 Tu8
	var ch Tu32
	var nHex, nPass int32
	var p, pBlob, zPass, v1 uintptr
	var v3 uint32
	var _ /* zHex at bp+0 */ uintptr
	_, _, _, _, _, _, _, _, _, _, _ = c, ch, d, nHex, nPass, p, pBlob, zPass, v1, v2, v3
	zPass = __ccgo_ts + 1702
	nPass = 0
	**(**uintptr)(__ccgo_up(bp)) = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv)))
	nHex = Xsqlite3_value_bytes(tls, **(**uintptr)(__ccgo_up(argv)))
	pBlob = uintptr(0)
	p = uintptr(0)
	if argc == int32(2) {
		zPass = Xsqlite3_value_text(tls, **(**uintptr)(__ccgo_up(argv + 1*4)))
		nPass = Xsqlite3_value_bytes(tls, **(**uintptr)(__ccgo_up(argv + 1*4)))
	}
	if !(**(**uintptr)(__ccgo_up(bp)) != 0) || !(zPass != 0) {
		return
	}
	v1 = _contextMalloc(tls, pCtx, int64(nHex/int32(2)+int32(1)))
	pBlob = v1
	p = v1
	if pBlob != 0 { /* Least significant digit of next byte */
		for {
			v2 = **(**Tu8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))
			c = v2
			if !(libc.Int32FromUint8(v2) != 0x00) {
				break
			}
			for !(libc.Int32FromUint8(_sqlite3CtypeMap[c])&libc.Int32FromInt32(0x08) != 0) {
				if libc.Int32FromUint8(**(**Tu8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))) < int32(0x80) {
					v1 = **(**uintptr)(__ccgo_up(bp))
					**(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1
					v3 = uint32(**(**Tu8)(__ccgo_up(v1)))
				} else {
					v3 = _sqlite3Utf8Read(tls, bp)
				}
				ch = v3
				if !(_strContainsChar(tls, zPass, nPass, ch) != 0) {
					goto unhex_null
				}
				c = **(**Tu8)(__ccgo_up(**(**uintptr)(__ccgo_up(bp))))
				if libc.Int32FromUint8(c) == 0x00 {
					goto unhex_done
				}
			}
			**(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1
			v1 = **(**uintptr)(__ccgo_up(bp))
			**(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + 1
			d = **(**Tu8)(__ccgo_up(v1))
			if !(libc.Int32FromUint8(_sqlite3CtypeMap[d])&libc.Int32FromInt32(0x08) != 0) {
				goto unhex_null
			}
			v1 = p
			p = p + 1
			**(**Tu8)(__ccgo_up(v1)) = libc.Uint8FromInt32(libc.Int32FromUint8(_sqlite3HexToInt(tls, libc.Int32FromUint8(c)))<<int32(4) | libc.Int32FromUint8(_sqlite3HexToInt(tls, libc.Int32FromUint8(d))))
		}
	}
	goto unhex_done
unhex_done:
	;
	Xsqlite3_result_blob(tls, pCtx, pBlob, int32(p)-int32(pBlob), __ccgo_fp(Xsqlite3_free))
	return
	goto unhex_null
unhex_null:
	;
	Xsqlite3_free(tls, pBlob)
	return
}

// C documentation
//
//	/*
//	** Information and control of an open file handle.
//	*/
func _unixFileControl(tls *libc.TLS, id uintptr, op int32, pArg uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var newLimit Ti64
	var pFile, zTFile uintptr
	var rc, rc1 int32
	_, _, _, _, _ = newLimit, pFile, rc, rc1, zTFile
	pFile = id
	switch op {
	case int32(SQLITE_FCNTL_NULL_IO):
		(*(*func(*libc.TLS, int32) int32)(unsafe.Pointer(&struct{ uintptr }{_aSyscall[int32(1)].FpCurrent})))(tls, (*TunixFile)(unsafe.Pointer(pFile)).Fh)
		(*TunixFile)(unsafe.Pointer(pFile)).Fh = -int32(1)
		return SQLITE_OK
	case int32(SQLITE_FCNTL_LOCKSTATE):
		**(**int32)(__ccgo_up(pArg)) = libc.Int32FromUint8((*TunixFile)(unsafe.Pointer(pFile)).FeFileLock)
		return SQLITE_OK
	case int32(SQLITE_FCNTL_LAST_ERRNO):
		**(**int32)(__ccgo_up(pArg)) = (*TunixFile)(unsafe.Pointer(pFile)).FlastErrno
		return SQLITE_OK
	case int32(SQLITE_FCNTL_CHUNK_SIZE):
		(*TunixFile)(unsafe.Pointer(pFile)).FszChunk = **(**int32)(__ccgo_up(pArg))
		return SQLITE_OK
	case int32(SQLITE_FCNTL_SIZE_HINT):
		rc = _fcntlSizeHint(tls, pFile, **(**Ti64)(__ccgo_up(pArg)))
		return rc
	case int32(SQLITE_FCNTL_PERSIST_WAL):
		_unixModeBit(tls, pFile, uint8(UNIXFILE_PERSIST_WAL), pArg)
		return SQLITE_OK
	case int32(SQLITE_FCNTL_POWERSAFE_OVERWRITE):
		_unixModeBit(tls, pFile, uint8(UNIXFILE_PSOW), pArg)
		return SQLITE_OK
	case int32(SQLITE_FCNTL_VFSNAME):
		**(**uintptr)(__ccgo_up(pArg)) = Xsqlite3_mprintf(tls, __ccgo_ts+3942, libc.VaList(bp+8, (*Tsqlite3_vfs)(unsafe.Pointer((*TunixFile)(unsafe.Pointer(pFile)).FpVfs)).FzName))
		return SQLITE_OK
	case int32(SQLITE_FCNTL_TEMPFILENAME):
		zTFile = Xsqlite3_malloc64(tls, libc.Uint64FromInt32((*Tsqlite3_vfs)(unsafe.Pointer((*TunixFile)(unsafe.Pointer(pFile)).FpVfs)).FmxPathname))
		if zTFile != 0 {
			_unixGetTempname(tls, (*Tsqlite3_vfs)(unsafe.Pointer((*TunixFile)(unsafe.Pointer(pFile)).FpVfs)).FmxPathname, zTFile)
			**(**uintptr)(__ccgo_up(pArg)) = zTFile
		}
		return SQLITE_OK
	case int32(SQLITE_FCNTL_HAS_MOVED):
		**(**int32)(__ccgo_up(pArg)) = _fileHasMoved(tls, pFile)
		return SQLITE_OK
	case int32(SQLITE_FCNTL_MMAP_SIZE):
		newLimit = **(**Ti64)(__ccgo_up(pArg))
		rc1 = SQLITE_OK
		if newLimit > _sqlite3Config.FmxMmap {
			newLimit = _sqlite3Config.FmxMmap
		}
		/* The value of newLimit may be eventually cast to (size_t) and passed
		 ** to mmap(). Restrict its value to 2GB if (size_t) is not at least a
		 ** 64-bit type. */
		if newLimit > 0 && libc.Bool(uint32(4) < uint32(8)) {
			newLimit = newLimit & libc.Int64FromInt32(0x7FFFFFFF)
		}
		**(**Ti64)(__ccgo_up(pArg)) = (*TunixFile)(unsafe.Pointer(pFile)).FmmapSizeMax
		if newLimit >= 0 && newLimit != (*TunixFile)(unsafe.Pointer(pFile)).FmmapSizeMax && (*TunixFile)(unsafe.Pointer(pFile)).FnFetchOut == 0 {
			(*TunixFile)(unsafe.Pointer(pFile)).FmmapSizeMax = newLimit
			if (*TunixFile)(unsafe.Pointer(pFile)).FmmapSize > 0 {
				_unixUnmapfile(tls, pFile)
				rc1 = _unixMapfile(tls, pFile, int64(-int32(1)))
			}
		}
		return rc1
	case int32(SQLITE_FCNTL_EXTERNAL_READER):
		return _unixFcntlExternalReader(tls, id, pArg)
	}
	return int32(SQLITE_NOTFOUND)
}

// C documentation
//
//	/*
//	** Attempt to set the size of the memory mapping maintained by file
//	** descriptor pFd to nNew bytes. Any existing mapping is discarded.
//	**
//	** If successful, this function sets the following variables:
//	**
//	**       unixFile.pMapRegion
//	**       unixFile.mmapSize
//	**       unixFile.mmapSizeActual
//	**
//	** If unsuccessful, an error message is logged via sqlite3_log() and
//	** the three variables above are zeroed. In this case SQLite should
//	** continue accessing the database using the xRead() and xWrite()
//	** methods.
//	*/
func _unixRemapfile(tls *libc.TLS, pFd uintptr, nNew Ti64) {
	var flags, h, szSyspage int32
	var nOrig, nReuse Ti64
	var pNew, pOrig, pReq, zErr uintptr
	var v1 Tsqlite3_int64
	_, _, _, _, _, _, _, _, _, _ = flags, h, nOrig, nReuse, pNew, pOrig, pReq, szSyspage, zErr, v1
	zErr = __ccgo_ts + 3698
	h = (*TunixFile)(unsafe.Pointer(pFd)).Fh                  /* File descriptor open on db file */
	pOrig = (*TunixFile)(unsafe.Pointer(pFd)).FpMapRegion     /* Pointer to current file mapping */
	nOrig = (*TunixFile)(unsafe.Pointer(pFd)).FmmapSizeActual /* Size of pOrig region in bytes */
	pNew = uintptr(0)                                         /* Location of new mapping */
	flags = int32(PROT_READ)                                  /* Flags to pass to mmap() */
	if pOrig != 0 {
		szSyspage = (*(*func(*libc.TLS) int32)(unsafe.Pointer(&struct{ uintptr }{_aSyscall[int32(25)].FpCurrent})))(tls)
		nReuse = (*TunixFile)(unsafe.Pointer(pFd)).FmmapSize & int64(^(szSyspage - libc.Int32FromInt32(1)))
		pReq = pOrig + uintptr(nReuse)
		/* Unmap any pages of the existing mapping that cannot be reused. */
		if nReuse != nOrig {
			(*(*func(*libc.TLS, uintptr, Tsize_t) int32)(unsafe.Pointer(&struct{ uintptr }{_aSyscall[int32(23)].FpCurrent})))(tls, pReq, libc.Uint32FromInt64(nOrig-nReuse))
		}
		pNew = (*(*func(*libc.TLS, uintptr, Tsize_t, int32, int32, int32, Toff_t) uintptr)(unsafe.Pointer(&struct{ uintptr }{_aSyscall[int32(22)].FpCurrent})))(tls, pReq, libc.Uint32FromInt64(nNew-nReuse), flags, int32(MAP_SHARED), h, nReuse)
		if pNew != uintptr(-libc.Int32FromInt32(1)) {
			if pNew != pReq {
				(*(*func(*libc.TLS, uintptr, Tsize_t) int32)(unsafe.Pointer(&struct{ uintptr }{_aSyscall[int32(23)].FpCurrent})))(tls, pNew, libc.Uint32FromInt64(nNew-nReuse))
				pNew = uintptr(0)
			} else {
				pNew = pOrig
			}
		}
		/* The attempt to extend the existing mapping failed. Free it. */
		if pNew == uintptr(-libc.Int32FromInt32(1)) || pNew == uintptr(0) {
			(*(*func(*libc.TLS, uintptr, Tsize_t) int32)(unsafe.Pointer(&struct{ uintptr }{_aSyscall[int32(23)].FpCurrent})))(tls, pOrig, libc.Uint32FromInt64(nReuse))
		}
	}
	/* If pNew is still NULL, try to create an entirely new mapping. */
	if pNew == uintptr(0) {
		pNew = (*(*func(*libc.TLS, uintptr, Tsize_t, int32, int32, int32, Toff_t) uintptr)(unsafe.Pointer(&struct{ uintptr }{_aSyscall[int32(22)].FpCurrent})))(tls, uintptr(0), libc.Uint32FromInt64(nNew), flags, int32(MAP_SHARED), h, 0)
	}
	if pNew == uintptr(-libc.Int32FromInt32(1)) {
		pNew = uintptr(0)
		nNew = 0
		_unixLogErrorAtLine(tls, SQLITE_OK, zErr, (*TunixFile)(unsafe.Pointer(pFd)).FzPath, int32(45847))
		/* If the mmap() above failed, assume that all subsequent mmap() calls
		 ** will probably fail too. Fall back to using xRead/xWrite exclusively
		 ** in this case.  */
		(*TunixFile)(unsafe.Pointer(pFd)).FmmapSizeMax = 0
	}
	(*TunixFile)(unsafe.Pointer(pFd)).FpMapRegion = pNew
	v1 = nNew
	(*TunixFile)(unsafe.Pointer(pFd)).FmmapSizeActual = v1
	(*TunixFile)(unsafe.Pointer(pFd)).FmmapSize = v1
}

// C documentation
//
//	/*
//	** Change the lock state for a shared-memory segment.
//	**
//	** Note that the relationship between SHARED and EXCLUSIVE locks is a little
//	** different here than in posix.  In xShmLock(), one can go from unlocked
//	** to shared and back or from unlocked to exclusive and back.  But one may
//	** not go from shared to exclusive or from exclusive to shared.
//	*/
func _unixShmLock(tls *libc.TLS, fd uintptr, ofst int32, n int32, flags int32) (r int32) {
	var aLock, p, pDbFd, pShmNode, v1 uintptr
	var bUnlock, ii, rc int32
	var mask Tu16
	_, _, _, _, _, _, _, _, _ = aLock, bUnlock, ii, mask, p, pDbFd, pShmNode, rc, v1
	pDbFd = fd     /* The underlying file iNode */
	rc = SQLITE_OK /* Result code */
	mask = libc.Uint16FromInt32(int32(1)<<(ofst+n) - int32(1)<<ofst)
	p = (*TunixFile)(unsafe.Pointer(pDbFd)).FpShm
	if p == uintptr(0) {
		return libc.Int32FromInt32(SQLITE_IOERR) | libc.Int32FromInt32(20)<<libc.Int32FromInt32(8)
	}
	pShmNode = (*TunixShm)(unsafe.Pointer(p)).FpShmNode
	if pShmNode == uintptr(0) {
		return libc.Int32FromInt32(SQLITE_IOERR) | libc.Int32FromInt32(20)<<libc.Int32FromInt32(8)
	}
	aLock = pShmNode + 36
	/* Check that, if this to be a blocking lock, no locks that occur later
	 ** in the following list than the lock being obtained are already held:
	 **
	 **   1. Recovery lock (ofst==2).
	 **   2. Checkpointer lock (ofst==1).
	 **   3. Write lock (ofst==0).
	 **   4. Read locks (ofst>=3 && ofst<SQLITE_SHM_NLOCK).
	 **
	 ** In other words, if this is a blocking lock, none of the locks that
	 ** occur later in the above list than the lock being obtained may be
	 ** held.
	 */
	/* Check if there is any work to do. There are three cases:
	 **
	 **    a) An unlock operation where there are locks to unlock,
	 **    b) An shared lock where the requested lock is not already held
	 **    c) An exclusive lock where the requested lock is not already held
	 **
	 ** The SQLite core never requests an exclusive lock that it already holds.
	 ** This is assert()ed below.
	 */
	if flags&int32(SQLITE_SHM_UNLOCK) != 0 && (libc.Int32FromUint16((*TunixShm)(unsafe.Pointer(p)).FexclMask)|libc.Int32FromUint16((*TunixShm)(unsafe.Pointer(p)).FsharedMask))&libc.Int32FromUint16(mask) != 0 || flags == libc.Int32FromInt32(SQLITE_SHM_SHARED)|libc.Int32FromInt32(SQLITE_SHM_LOCK) && 0 == libc.Int32FromUint16((*TunixShm)(unsafe.Pointer(p)).FsharedMask)&libc.Int32FromUint16(mask) || flags == libc.Int32FromInt32(SQLITE_SHM_EXCLUSIVE)|libc.Int32FromInt32(SQLITE_SHM_LOCK) {
		/* Take the required mutexes. In SETLK_TIMEOUT mode (blocking locks), if
		 ** this is an attempt on an exclusive lock use sqlite3_mutex_try(). If any
		 ** other thread is holding this mutex, then it is either holding or about
		 ** to hold a lock exclusive to the one being requested, and we may
		 ** therefore return SQLITE_BUSY to the caller.
		 **
		 ** Doing this prevents some deadlock scenarios. For example, thread 1 may
		 ** be a checkpointer blocked waiting on the WRITER lock. And thread 2
		 ** may be a normal SQL client upgrading to a write transaction. In this
		 ** case thread 2 does a non-blocking request for the WRITER lock. But -
		 ** if it were to use sqlite3_mutex_enter() then it would effectively
		 ** become a (doomed) blocking request, as thread 2 would block until thread
		 ** 1 obtained WRITER and released the mutex. Since thread 2 already holds
		 ** a lock on a read-locking slot at this point, this breaks the
		 ** anti-deadlock rules (see above).  */
		Xsqlite3_mutex_enter(tls, (*TunixShmNode)(unsafe.Pointer(pShmNode)).FpShmMutex)
		if rc == SQLITE_OK {
			if flags&int32(SQLITE_SHM_UNLOCK) != 0 {
				/* Case (a) - unlock.  */
				bUnlock = int32(1)
				/* If this is a SHARED lock being unlocked, it is possible that other
				 ** clients within this process are holding the same SHARED lock. In
				 ** this case, set bUnlock to 0 so that the posix lock is not removed
				 ** from the file-descriptor below.  */
				if flags&int32(SQLITE_SHM_SHARED) != 0 {
					if **(**int32)(__ccgo_up(aLock + uintptr(ofst)*4)) > int32(1) {
						bUnlock = 0
						**(**int32)(__ccgo_up(aLock + uintptr(ofst)*4)) = **(**int32)(__ccgo_up(aLock + uintptr(ofst)*4)) - 1
						v1 = p + 10
						*(*Tu16)(unsafe.Pointer(v1)) = Tu16(int32(*(*Tu16)(unsafe.Pointer(v1))) & ^libc.Int32FromUint16(mask))
					}
				}
				if bUnlock != 0 {
					rc = _unixShmSystemLock(tls, pDbFd, int32(F_UNLCK), ofst+(libc.Int32FromInt32(22)+libc.Int32FromInt32(SQLITE_SHM_NLOCK))*libc.Int32FromInt32(4), n)
					if rc == SQLITE_OK {
						libc.Xmemset(tls, aLock+uintptr(ofst)*4, 0, uint32(4)*libc.Uint32FromInt32(n))
						v1 = p + 10
						*(*Tu16)(unsafe.Pointer(v1)) = Tu16(int32(*(*Tu16)(unsafe.Pointer(v1))) & ^libc.Int32FromUint16(mask))
						v1 = p + 12
						*(*Tu16)(unsafe.Pointer(v1)) = Tu16(int32(*(*Tu16)(unsafe.Pointer(v1))) & ^libc.Int32FromUint16(mask))
					}
				}
			} else {
				if flags&int32(SQLITE_SHM_SHARED) != 0 {
					/* Case (b) - a shared lock.  */
					if **(**int32)(__ccgo_up(aLock + uintptr(ofst)*4)) < 0 {
						/* An exclusive lock is held by some other connection. BUSY. */
						rc = int32(SQLITE_BUSY)
					} else {
						if **(**int32)(__ccgo_up(aLock + uintptr(ofst)*4)) == 0 {
							rc = _unixShmSystemLock(tls, pDbFd, int32(F_RDLCK), ofst+(libc.Int32FromInt32(22)+libc.Int32FromInt32(SQLITE_SHM_NLOCK))*libc.Int32FromInt32(4), n)
						}
					}
					/* Get the local shared locks */
					if rc == SQLITE_OK {
						v1 = p + 10
						*(*Tu16)(unsafe.Pointer(v1)) = Tu16(int32(*(*Tu16)(unsafe.Pointer(v1))) | libc.Int32FromUint16(mask))
						**(**int32)(__ccgo_up(aLock + uintptr(ofst)*4)) = **(**int32)(__ccgo_up(aLock + uintptr(ofst)*4)) + 1
					}
				} else {
					/* Make sure no sibling connections hold locks that will block this
					 ** lock.  If any do, return SQLITE_BUSY right away.  */
					ii = ofst
					for {
						if !(ii < ofst+n) {
							break
						}
						if **(**int32)(__ccgo_up(aLock + uintptr(ii)*4)) != 0 {
							rc = int32(SQLITE_BUSY)
							break
						}
						goto _5
					_5:
						;
						ii = ii + 1
					}
					/* Get the exclusive locks at the system level. Then if successful
					 ** also update the in-memory values. */
					if rc == SQLITE_OK {
						rc = _unixShmSystemLock(tls, pDbFd, int32(F_WRLCK), ofst+(libc.Int32FromInt32(22)+libc.Int32FromInt32(SQLITE_SHM_NLOCK))*libc.Int32FromInt32(4), n)
						if rc == SQLITE_OK {
							v1 = p + 12
							*(*Tu16)(unsafe.Pointer(v1)) = Tu16(int32(*(*Tu16)(unsafe.Pointer(v1))) | libc.Int32FromUint16(mask))
							ii = ofst
							for {
								if !(ii < ofst+n) {
									break
								}
								**(**int32)(__ccgo_up(aLock + uintptr(ii)*4)) = -int32(1)
								goto _7
							_7:
								;
								ii = ii + 1
							}
						}
					}
				}
			}
		}
		/* Drop the mutexes acquired above. */
		Xsqlite3_mutex_leave(tls, (*TunixShmNode)(unsafe.Pointer(pShmNode)).FpShmMutex)
	}
	return rc
}

// C documentation
//
//	/*
//	** Make sure all writes to a particular file are committed to disk.
//	**
//	** If dataOnly==0 then both the file itself and its metadata (file
//	** size, access time, etc) are synced.  If dataOnly!=0 then only the
//	** file data is synced.
//	**
//	** Under Unix, also make sure that the directory entry for the file
//	** has been created by fsync-ing the directory that contains the file.
//	** If we do not do this and we encounter a power failure, the directory
//	** entry for the journal might not exist after we reboot.  The next
//	** SQLite to access the file will not know that the journal exists (because
//	** the directory entry for the journal was never created) and the transaction
//	** will not roll back - possibly leading to database corruption.
//	*/
func _unixSync(tls *libc.TLS, id uintptr, flags int32) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var isDataOnly, isFullsync, rc int32
	var pFile, v1 uintptr
	var _ /* dirfd at bp+0 */ int32
	_, _, _, _, _ = isDataOnly, isFullsync, pFile, rc, v1
	pFile = id
	isDataOnly = flags & int32(SQLITE_SYNC_DATAONLY)
	isFullsync = libc.BoolInt32(flags&int32(0x0F) == int32(SQLITE_SYNC_FULL))
	/* Check that one of SQLITE_SYNC_NORMAL or FULL was passed */
	/* Unix cannot, but some systems may return SQLITE_FULL from here. This
	 ** line is to test that doing so does not cause any problems.
	 */
	rc = _full_fsync(tls, (*TunixFile)(unsafe.Pointer(pFile)).Fh, isFullsync, isDataOnly)
	if rc != 0 {
		_storeLastErrno(tls, pFile, **(**int32)(__ccgo_up(libc.X__error(tls))))
		return _unixLogErrorAtLine(tls, libc.Int32FromInt32(SQLITE_IOERR)|libc.Int32FromInt32(4)<<libc.Int32FromInt32(8), __ccgo_ts+3945, (*TunixFile)(unsafe.Pointer(pFile)).FzPath, int32(44131))
	}
	/* Also fsync the directory containing the file if the DIRSYNC flag
	 ** is set.  This is a one-time occurrence.  Many systems (examples: AIX)
	 ** are unable to fsync a directory, so ignore errors on the fsync.
	 */
	if libc.Int32FromUint16((*TunixFile)(unsafe.Pointer(pFile)).FctrlFlags)&int32(UNIXFILE_DIRSYNC) != 0 {
		rc = (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{_aSyscall[int32(17)].FpCurrent})))(tls, (*TunixFile)(unsafe.Pointer(pFile)).FzPath, bp)
		if rc == SQLITE_OK {
			_full_fsync(tls, **(**int32)(__ccgo_up(bp)), 0, 0)
			_robust_close(tls, pFile, **(**int32)(__ccgo_up(bp)), int32(44145))
		} else {
			rc = SQLITE_OK
		}
		v1 = pFile + 18
		*(*uint16)(unsafe.Pointer(v1)) = uint16(int32(*(*uint16)(unsafe.Pointer(v1))) & ^libc.Int32FromInt32(UNIXFILE_DIRSYNC))
	}
	return rc
}

// C documentation
//
//	/*
//	** The expression object indicated by the second argument is guaranteed
//	** to be a scalar SQL function. If
//	**
//	**   * all function arguments are SQL literals,
//	**   * one of the SQLITE_FUNC_CONSTANT or _SLOCHNG function flags is set, and
//	**   * the SQLITE_FUNC_NEEDCOLL function flag is not set,
//	**
//	** then this routine attempts to invoke the SQL function. Assuming no
//	** error occurs, output parameter (*ppVal) is set to point to a value
//	** object containing the result before returning SQLITE_OK.
//	**
//	** Affinity aff is applied to the result of the function before returning.
//	** If the result is a text value, the sqlite3_value object uses encoding
//	** enc.
//	**
//	** If the conditions above are not met, this function returns SQLITE_OK
//	** and sets (*ppVal) to NULL. Or, if an error occurs, (*ppVal) is set to
//	** NULL and an SQLite error code returned.
//	*/
func _valueFromFunction(tls *libc.TLS, db uintptr, p uintptr, enc Tu8, aff Tu8, ppVal uintptr, pCtx uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var apVal, pFunc, pList, pVal uintptr
	var i, nVal, rc int32
	var _ /* ctx at bp+0 */ Tsqlite3_context
	_, _, _, _, _, _, _ = apVal, i, nVal, pFunc, pList, pVal, rc /* Context object for function invocation */
	apVal = uintptr(0)                                           /* Function arguments */
	nVal = 0                                                     /* Number of function arguments */
	pFunc = uintptr(0)                                           /* Function definition */
	pVal = uintptr(0)                                            /* New value */
	rc = SQLITE_OK                                               /* Return code */
	pList = uintptr(0)                                           /* Iterator variable */
	pList = *(*uintptr)(unsafe.Pointer(p + 20))
	if pList != 0 {
		nVal = (*TExprList)(unsafe.Pointer(pList)).FnExpr
	}
	pFunc = _sqlite3FindFunction(tls, db, *(*uintptr)(unsafe.Pointer(p + 8)), nVal, enc, uint8(0))
	if (*TFuncDef)(unsafe.Pointer(pFunc)).FfuncFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_CONSTANT)|libc.Int32FromInt32(SQLITE_FUNC_SLOCHNG)) == uint32(0) || (*TFuncDef)(unsafe.Pointer(pFunc)).FfuncFlags&libc.Uint32FromInt32(libc.Int32FromInt32(SQLITE_FUNC_NEEDCOLL)|libc.Int32FromInt32(SQLITE_FUNC_RUNONLY)) != uint32(0) {
		return SQLITE_OK
	}
	if pList != 0 {
		apVal = _sqlite3DbMallocZero(tls, db, uint64(uint32(4)*libc.Uint32FromInt32(nVal)))
		if apVal == uintptr(0) {
			rc = int32(SQLITE_NOMEM)
			goto value_from_function_out
		}
		i = 0
		for {
			if !(i < nVal) {
				break
			}
			rc = _sqlite3Stat4ValueFromExpr(tls, (*TValueNewStat4Ctx)(unsafe.Pointer(pCtx)).FpParse, (*(*TExprList_item)(unsafe.Pointer(pList + 8 + uintptr(i)*20))).FpExpr, aff, apVal+uintptr(i)*4)
			if **(**uintptr)(__ccgo_up(apVal + uintptr(i)*4)) == uintptr(0) || rc != SQLITE_OK {
				goto value_from_function_out
			}
			goto _1
		_1:
			;
			i = i + 1
		}
	}
	pVal = _valueNew(tls, db, pCtx)
	if pVal == uintptr(0) {
		rc = int32(SQLITE_NOMEM)
		goto value_from_function_out
	}
	libc.Xmemset(tls, bp, 0, uint32(28))
	(**(**Tsqlite3_context)(__ccgo_up(bp))).FpOut = pVal
	(**(**Tsqlite3_context)(__ccgo_up(bp))).FpFunc = pFunc
	(**(**Tsqlite3_context)(__ccgo_up(bp))).Fenc = (*Tsqlite3)(unsafe.Pointer(db)).Fenc
	(*(*func(*libc.TLS, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*TFuncDef)(unsafe.Pointer(pFunc)).FxSFunc})))(tls, bp, nVal, apVal)
	if (**(**Tsqlite3_context)(__ccgo_up(bp))).FisError != 0 {
		rc = (**(**Tsqlite3_context)(__ccgo_up(bp))).FisError
		_sqlite3ErrorMsg(tls, (*TValueNewStat4Ctx)(unsafe.Pointer(pCtx)).FpParse, __ccgo_ts+3942, libc.VaList(bp+40, Xsqlite3_value_text(tls, pVal)))
	} else {
		_sqlite3ValueApplyAffinity(tls, pVal, aff, uint8(SQLITE_UTF8))
		rc = _sqlite3VdbeChangeEncoding(tls, pVal, libc.Int32FromUint8(enc))
		if rc == SQLITE_OK && _sqlite3VdbeMemTooBig(tls, pVal) != 0 {
			rc = int32(SQLITE_TOOBIG)
			(*TParse)(unsafe.Pointer((*TValueNewStat4Ctx)(unsafe.Pointer(pCtx)).FpParse)).FnErr = (*TParse)(unsafe.Pointer((*TValueNewStat4Ctx)(unsafe.Pointer(pCtx)).FpParse)).FnErr + 1
		}
	}
	goto value_from_function_out
value_from_function_out:
	;
	if rc != SQLITE_OK {
		pVal = uintptr(0)
		(*TParse)(unsafe.Pointer((*TValueNewStat4Ctx)(unsafe.Pointer(pCtx)).FpParse)).Frc = rc
	}
	if apVal != 0 {
		i = 0
		for {
			if !(i < nVal) {
				break
			}
			_sqlite3ValueFree(tls, **(**uintptr)(__ccgo_up(apVal + uintptr(i)*4)))
			goto _2
		_2:
			;
			i = i + 1
		}
		_sqlite3DbFreeNN(tls, db, apVal)
	}
	**(**uintptr)(__ccgo_up(ppVal)) = pVal
	return rc
}

// C documentation
//
//	/*
//	** A read or write transaction may or may not be active on database handle
//	** db. If a transaction is active, commit it. If there is a
//	** write-transaction spanning more than one database file, this routine
//	** takes care of the super-journal trickery.
//	*/
func _vdbeCommit(tls *libc.TLS, db uintptr, p uintptr) (r int32) {
	bp := tls.Alloc(48)
	defer tls.Free(48)
	var i, nMainFile, nTrans, needXcommit, rc, retryCount, txn, v5 int32
	var offset Ti64
	var pBt, pBt1, pBt2, pBt3, pBt4, pBt5, pPager, pVfs, zFile, zMainFile, zSuper uintptr
	var v6 bool
	var _ /* iRandom at bp+8 */ Tu32
	var _ /* pSuperJrnl at bp+0 */ uintptr
	var _ /* res at bp+4 */ int32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, nMainFile, nTrans, needXcommit, offset, pBt, pBt1, pBt2, pBt3, pBt4, pBt5, pPager, pVfs, rc, retryCount, txn, zFile, zMainFile, zSuper, v5, v6
	nTrans = 0 /* Number of databases with an active write-transaction
	 ** that are candidates for a two-phase commit using a
	 ** super-journal */
	rc = SQLITE_OK
	needXcommit = 0
	/* Before doing anything else, call the xSync() callback for any
	 ** virtual module tables written in this transaction. This has to
	 ** be done before determining whether a super-journal file is
	 ** required, as an xSync() callback may add an attached database
	 ** to the transaction.
	 */
	rc = _sqlite3VtabSync(tls, db, p)
	/* This loop determines (a) if the commit hook should be invoked and
	 ** (b) how many database files have open write transactions, not
	 ** including the temp database. (b) is important because if more than
	 ** one database file has an open write transaction, a super-journal
	 ** file is required for an atomic commit.
	 */
	i = 0
	for {
		if !(rc == SQLITE_OK && i < (*Tsqlite3)(unsafe.Pointer(db)).FnDb) {
			break
		}
		pBt = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(i)*16))).FpBt
		if _sqlite3BtreeTxnState(tls, pBt) == int32(SQLITE_TXN_WRITE) {
			needXcommit = int32(1)
			_sqlite3BtreeEnter(tls, pBt)
			pPager = _sqlite3BtreePager(tls, pBt)
			if libc.Int32FromUint8((**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(i)*16))).Fsafety_level) != int32(PAGER_SYNCHRONOUS_OFF) && _aMJNeeded[_sqlite3PagerGetJournalMode(tls, pPager)] != 0 && _sqlite3PagerIsMemdb(tls, pPager) == 0 {
				nTrans = nTrans + 1
			}
			rc = _sqlite3PagerExclusiveLock(tls, pPager)
			_sqlite3BtreeLeave(tls, pBt)
		}
		goto _1
	_1:
		;
		i = i + 1
	}
	if rc != SQLITE_OK {
		return rc
	}
	/* If there are any write-transactions at all, invoke the commit hook */
	if needXcommit != 0 && (*Tsqlite3)(unsafe.Pointer(db)).FxCommitCallback != 0 {
		rc = (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tsqlite3)(unsafe.Pointer(db)).FxCommitCallback})))(tls, (*Tsqlite3)(unsafe.Pointer(db)).FpCommitArg)
		if rc != 0 {
			return libc.Int32FromInt32(SQLITE_CONSTRAINT) | libc.Int32FromInt32(2)<<libc.Int32FromInt32(8)
		}
	}
	/* The simple case - no more than one database file (not counting the
	 ** TEMP database) has a transaction active.   There is no need for the
	 ** super-journal.
	 **
	 ** If the return value of sqlite3BtreeGetFilename() is a zero length
	 ** string, it means the main database is :memory: or a temp file.  In
	 ** that case we do not support atomic multi-file commits, so use the
	 ** simple case then too.
	 */
	if 0 == _sqlite3Strlen30(tls, _sqlite3BtreeGetFilename(tls, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb))).FpBt)) || nTrans <= int32(1) {
		if needXcommit != 0 {
			i = 0
			for {
				if !(rc == SQLITE_OK && i < (*Tsqlite3)(unsafe.Pointer(db)).FnDb) {
					break
				}
				pBt1 = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(i)*16))).FpBt
				if _sqlite3BtreeTxnState(tls, pBt1) >= int32(SQLITE_TXN_WRITE) {
					rc = _sqlite3BtreeCommitPhaseOne(tls, pBt1, uintptr(0))
				}
				goto _2
			_2:
				;
				i = i + 1
			}
		}
		/* Do the commit only if all databases successfully complete phase 1.
		 ** If one of the BtreeCommitPhaseOne() calls fails, this indicates an
		 ** IO error while deleting or truncating a journal file. It is unlikely,
		 ** but could happen. In this case abandon processing and return the error.
		 */
		i = 0
		for {
			if !(rc == SQLITE_OK && i < (*Tsqlite3)(unsafe.Pointer(db)).FnDb) {
				break
			}
			pBt2 = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(i)*16))).FpBt
			txn = _sqlite3BtreeTxnState(tls, pBt2)
			if txn != SQLITE_TXN_NONE {
				rc = _sqlite3BtreeCommitPhaseTwo(tls, pBt2, 0)
			}
			goto _3
		_3:
			;
			i = i + 1
		}
		if rc == SQLITE_OK {
			_sqlite3VtabCommit(tls, db)
		}
	} else {
		pVfs = (*Tsqlite3)(unsafe.Pointer(db)).FpVfs
		zSuper = uintptr(0) /* File-name for the super-journal */
		zMainFile = _sqlite3BtreeGetFilename(tls, (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb))).FpBt)
		**(**uintptr)(__ccgo_up(bp)) = uintptr(0)
		offset = 0
		retryCount = 0
		/* Select a super-journal file name */
		nMainFile = _sqlite3Strlen30(tls, zMainFile)
		zSuper = _sqlite3MPrintf(tls, db, __ccgo_ts+5340, libc.VaList(bp+24, 0, zMainFile, 0))
		if zSuper == uintptr(0) {
			return int32(SQLITE_NOMEM)
		}
		zSuper = zSuper + uintptr(4)
		for cond := true; cond; cond = rc == SQLITE_OK && **(**int32)(__ccgo_up(bp + 4)) != 0 {
			if retryCount != 0 {
				if retryCount > int32(100) {
					Xsqlite3_log(tls, int32(SQLITE_FULL), __ccgo_ts+5352, libc.VaList(bp+24, zSuper))
					_sqlite3OsDelete(tls, pVfs, zSuper, 0)
					break
				} else {
					if retryCount == int32(1) {
						Xsqlite3_log(tls, int32(SQLITE_FULL), __ccgo_ts+5366, libc.VaList(bp+24, zSuper))
					}
				}
			}
			retryCount = retryCount + 1
			Xsqlite3_randomness(tls, int32(4), bp+8)
			Xsqlite3_snprintf(tls, int32(13), zSuper+uintptr(nMainFile), __ccgo_ts+5381, libc.VaList(bp+24, **(**Tu32)(__ccgo_up(bp + 8))>>libc.Int32FromInt32(8)&uint32(0xffffff), **(**Tu32)(__ccgo_up(bp + 8))&uint32(0xff)))
			/* The antipenultimate character of the super-journal name must
			 ** be "9" to avoid name collisions when using 8+3 filenames. */
			rc = _sqlite3OsAccess(tls, pVfs, zSuper, SQLITE_ACCESS_EXISTS, bp+4)
		}
		if rc == SQLITE_OK {
			/* Open the super-journal. */
			rc = _sqlite3OsOpenMalloc(tls, pVfs, zSuper, bp, libc.Int32FromInt32(SQLITE_OPEN_READWRITE)|libc.Int32FromInt32(SQLITE_OPEN_CREATE)|libc.Int32FromInt32(SQLITE_OPEN_EXCLUSIVE)|libc.Int32FromInt32(SQLITE_OPEN_SUPER_JOURNAL), uintptr(0))
		}
		if rc != SQLITE_OK {
			_sqlite3DbFree(tls, db, zSuper-uintptr(4))
			return rc
		}
		/* Write the name of each database file in the transaction into the new
		 ** super-journal file. If an error occurs at this point close
		 ** and delete the super-journal file. All the individual journal files
		 ** still have 'null' as the super-journal pointer, so they will roll
		 ** back independently if a failure occurs.
		 */
		i = 0
		for {
			if !(i < (*Tsqlite3)(unsafe.Pointer(db)).FnDb) {
				break
			}
			pBt3 = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(i)*16))).FpBt
			if _sqlite3BtreeTxnState(tls, pBt3) == int32(SQLITE_TXN_WRITE) {
				zFile = _sqlite3BtreeGetJournalname(tls, pBt3)
				if zFile == uintptr(0) {
					goto _4 /* Ignore TEMP and :memory: databases */
				}
				rc = _sqlite3OsWrite(tls, **(**uintptr)(__ccgo_up(bp)), zFile, _sqlite3Strlen30(tls, zFile)+int32(1), offset)
				offset = offset + int64(_sqlite3Strlen30(tls, zFile)+int32(1))
				if rc != SQLITE_OK {
					_sqlite3OsCloseFree(tls, **(**uintptr)(__ccgo_up(bp)))
					_sqlite3OsDelete(tls, pVfs, zSuper, 0)
					_sqlite3DbFree(tls, db, zSuper-uintptr(4))
					return rc
				}
			}
			goto _4
		_4:
			;
			i = i + 1
		}
		/* Sync the super-journal file. If the IOCAP_SEQUENTIAL device
		 ** flag is set this is not required.
		 */
		if v6 = 0 == _sqlite3OsDeviceCharacteristics(tls, **(**uintptr)(__ccgo_up(bp)))&int32(SQLITE_IOCAP_SEQUENTIAL); v6 {
			v5 = _sqlite3OsSync(tls, **(**uintptr)(__ccgo_up(bp)), int32(SQLITE_SYNC_NORMAL))
			rc = v5
		}
		if v6 && SQLITE_OK != v5 {
			_sqlite3OsCloseFree(tls, **(**uintptr)(__ccgo_up(bp)))
			_sqlite3OsDelete(tls, pVfs, zSuper, 0)
			_sqlite3DbFree(tls, db, zSuper-uintptr(4))
			return rc
		}
		/* Sync all the db files involved in the transaction. The same call
		 ** sets the super-journal pointer in each individual journal. If
		 ** an error occurs here, do not delete the super-journal file.
		 **
		 ** If the error occurs during the first call to
		 ** sqlite3BtreeCommitPhaseOne(), then there is a chance that the
		 ** super-journal file will be orphaned. But we cannot delete it,
		 ** in case the super-journal file name was written into the journal
		 ** file before the failure occurred.
		 */
		i = 0
		for {
			if !(rc == SQLITE_OK && i < (*Tsqlite3)(unsafe.Pointer(db)).FnDb) {
				break
			}
			pBt4 = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(i)*16))).FpBt
			if pBt4 != 0 {
				rc = _sqlite3BtreeCommitPhaseOne(tls, pBt4, zSuper)
			}
			goto _7
		_7:
			;
			i = i + 1
		}
		_sqlite3OsCloseFree(tls, **(**uintptr)(__ccgo_up(bp)))
		if rc != SQLITE_OK {
			_sqlite3DbFree(tls, db, zSuper-uintptr(4))
			return rc
		}
		/* Delete the super-journal file. This commits the transaction. After
		 ** doing this the directory is synced again before any individual
		 ** transaction files are deleted.
		 */
		rc = _sqlite3OsDelete(tls, pVfs, zSuper, int32(1))
		_sqlite3DbFree(tls, db, zSuper-uintptr(4))
		zSuper = uintptr(0)
		if rc != 0 {
			return rc
		}
		/* All files and directories have already been synced, so the following
		 ** calls to sqlite3BtreeCommitPhaseTwo() are only closing files and
		 ** deleting or truncating journals. If something goes wrong while
		 ** this is happening we don't really care. The integrity of the
		 ** transaction is already guaranteed, but some stray 'cold' journals
		 ** may be lying around. Returning an error code won't help matters.
		 */
		_sqlite3BeginBenignMalloc(tls)
		i = 0
		for {
			if !(i < (*Tsqlite3)(unsafe.Pointer(db)).FnDb) {
				break
			}
			pBt5 = (**(**TDb)(__ccgo_up((*Tsqlite3)(unsafe.Pointer(db)).FaDb + uintptr(i)*16))).FpBt
			if pBt5 != 0 {
				_sqlite3BtreeCommitPhaseTwo(tls, pBt5, int32(1))
			}
			goto _8
		_8:
			;
			i = i + 1
		}
		_sqlite3EndBenignMalloc(tls)
		_sqlite3VtabCommit(tls, db)
	}
	return rc
}

// C documentation
//
//	/*
//	** The table object reference passed as the second argument to this function
//	** must represent a virtual table. This function invokes the xBestIndex()
//	** method of the virtual table with the sqlite3_index_info object that
//	** comes in as the 3rd argument to this function.
//	**
//	** If an error occurs, pParse is populated with an error message and an
//	** appropriate error code is returned.  A return of SQLITE_CONSTRAINT from
//	** xBestIndex is not considered an error.  SQLITE_CONSTRAINT indicates that
//	** the current configuration of "unusable" flags in sqlite3_index_info can
//	** not result in a valid plan.
//	**
//	** Whether or not an error is returned, it is the responsibility of the
//	** caller to eventually free p->idxStr if p->needToFreeIdxStr indicates
//	** that this is required.
//	*/
func _vtabBestIndex(tls *libc.TLS, pParse uintptr, pTab uintptr, p uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	var pVtab uintptr
	var rc int32
	_, _ = pVtab, rc
	pVtab = (*TVTable)(unsafe.Pointer(_sqlite3GetVTable(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, pTab))).FpVtab
	(*Tsqlite3)(unsafe.Pointer((*TParse)(unsafe.Pointer(pParse)).Fdb)).FnSchemaLock = (*Tsqlite3)(unsafe.Pointer((*TParse)(unsafe.Pointer(pParse)).Fdb)).FnSchemaLock + 1
	rc = (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*Tsqlite3_module)(unsafe.Pointer((*Tsqlite3_vtab)(unsafe.Pointer(pVtab)).FpModule)).FxBestIndex})))(tls, pVtab, p)
	(*Tsqlite3)(unsafe.Pointer((*TParse)(unsafe.Pointer(pParse)).Fdb)).FnSchemaLock = (*Tsqlite3)(unsafe.Pointer((*TParse)(unsafe.Pointer(pParse)).Fdb)).FnSchemaLock - 1
	if rc != SQLITE_OK && rc != int32(SQLITE_CONSTRAINT) {
		if rc == int32(SQLITE_NOMEM) {
			_sqlite3OomFault(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb)
		} else {
			if !((*Tsqlite3_vtab)(unsafe.Pointer(pVtab)).FzErrMsg != 0) {
				_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+3942, libc.VaList(bp+8, _sqlite3ErrStr(tls, rc)))
			} else {
				_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+3942, libc.VaList(bp+8, (*Tsqlite3_vtab)(unsafe.Pointer(pVtab)).FzErrMsg))
			}
		}
	}
	if (*TVTable)(unsafe.Pointer((*(*struct {
		FnArg  int32
		FazArg uintptr
		Fp     uintptr
	})(unsafe.Pointer(pTab + 44))).Fp)).FbAllSchemas != 0 {
		_sqlite3VtabUsesAllSchemas(tls, pParse)
	}
	Xsqlite3_free(tls, (*Tsqlite3_vtab)(unsafe.Pointer(pVtab)).FzErrMsg)
	(*Tsqlite3_vtab)(unsafe.Pointer(pVtab)).FzErrMsg = uintptr(0)
	return rc
}

// C documentation
//
//	/* Return true if table pTab is read-only.
//	**
//	** A table is read-only if any of the following are true:
//	**
//	**   1) It is a virtual table and no implementation of the xUpdate method
//	**      has been provided
//	**
//	**   2) A trigger is currently being coded and the table is a virtual table
//	**      that is SQLITE_VTAB_DIRECTONLY or if PRAGMA trusted_schema=OFF and
//	**      the table is not SQLITE_VTAB_INNOCUOUS.
//	**
//	**   3) It is a system table (i.e. sqlite_schema), this call is not
//	**      part of a nested parse and writable_schema pragma has not
//	**      been specified
//	**
//	**   4) The table is a shadow table, the database connection is in
//	**      defensive mode, and the current sqlite3_prepare()
//	**      is for a top-level SQL statement.
//	*/
func _vtabIsReadOnly(tls *libc.TLS, pParse uintptr, pTab uintptr) (r int32) {
	bp := tls.Alloc(16)
	defer tls.Free(16)
	if (*Tsqlite3_module)(unsafe.Pointer((*TModule)(unsafe.Pointer((*TVTable)(unsafe.Pointer(_sqlite3GetVTable(tls, (*TParse)(unsafe.Pointer(pParse)).Fdb, pTab))).FpMod)).FpModule)).FxUpdate == uintptr(0) {
		return int32(1)
	}
	/* Within triggers:
	 **   *  Do not allow DELETE, INSERT, or UPDATE of SQLITE_VTAB_DIRECTONLY
	 **      virtual tables
	 **   *  Only allow DELETE, INSERT, or UPDATE of non-SQLITE_VTAB_INNOCUOUS
	 **      virtual tables if PRAGMA trusted_schema=ON.
	 */
	if ((*TParse)(unsafe.Pointer(pParse)).FpToplevel != uintptr(0) || libc.Int32FromUint8((*TParse)(unsafe.Pointer(pParse)).FprepFlags)&int32(SQLITE_PREPARE_FROM_DDL) != 0) && libc.Int32FromUint8((*TVTable)(unsafe.Pointer((*(*struct {
		FnArg  int32
		FazArg uintptr
		Fp     uintptr
	})(unsafe.Pointer(pTab + 44))).Fp)).FeVtabRisk) > libc.BoolInt32((*Tsqlite3)(unsafe.Pointer((*TParse)(unsafe.Pointer(pParse)).Fdb)).Fflags&uint64(SQLITE_TrustedSchema) != uint64(0)) {
		_sqlite3ErrorMsg(tls, pParse, __ccgo_ts+16347, libc.VaList(bp+8, (*TTable)(unsafe.Pointer(pTab)).FzName))
	}
	return 0
}

// C documentation
//
//	/*
//	** Recover the wal-index by reading the write-ahead log file.
//	**
//	** This routine first tries to establish an exclusive lock on the
//	** wal-index to prevent other threads/processes from doing anything
//	** with the WAL or wal-index while recovery is running.  The
//	** WAL_RECOVER_LOCK is also held so that other threads will know
//	** that this thread is running recovery.  If unable to establish
//	** the necessary locks, this routine returns SQLITE_BUSY.
//	*/
func _walIndexRecover(tls *libc.TLS, pWal uintptr) (r int32) {
	bp := tls.Alloc(80)
	defer tls.Free(80)
	var aData, aFrame, aPrivate, pInfo uintptr
	var aFrameCksum [2]Tu32
	var i, iLock, isValid, rc, szFrame, szPage int32
	var iFirst, iFrame, iLast, iLastFrame, iPg, magic, nHdr, nHdr32, version Tu32
	var iOffset Ti64
	var v2, v3 uint32
	var _ /* aBuf at bp+8 */ [32]Tu8
	var _ /* aShare at bp+40 */ uintptr
	var _ /* nSize at bp+0 */ Ti64
	var _ /* nTruncate at bp+48 */ Tu32
	var _ /* pgno at bp+44 */ Tu32
	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = aData, aFrame, aFrameCksum, aPrivate, i, iFirst, iFrame, iLast, iLastFrame, iLock, iOffset, iPg, isValid, magic, nHdr, nHdr32, pInfo, rc, szFrame, szPage, version, v2, v3 /* Size of log file */
	aFrameCksum = [2]Tu32{}                                                                                                                                                                                                                          /* Lock offset to lock for checkpoint */
	/* Obtain an exclusive lock on all byte in the locking range not already
	 ** locked by the caller. The caller is guaranteed to have locked the
	 ** WAL_WRITE_LOCK byte, and may have also locked the WAL_CKPT_LOCK byte.
	 ** If successful, the same bytes that are locked here are unlocked before
	 ** this function returns.
	 */
	iLock = int32(WAL_ALL_BUT_WRITE) + libc.Int32FromUint8((*TWal)(unsafe.Pointer(pWal)).FckptLock)
	rc = _walLockExclusive(tls, pWal, iLock, libc.Int32FromInt32(3)+libc.Int32FromInt32(0)-iLock)
	if rc != 0 {
		return rc
	}
	libc.Xmemset(tls, pWal+52, 0, uint32(48))
	rc = _sqlite3OsFileSize(tls, (*TWal)(unsafe.Pointer(pWal)).FpWalFd, bp)
	if rc != SQLITE_OK {
		goto recovery_error
	}
	if **(**Ti64)(__ccgo_up(bp)) > int64(WAL_HDRSIZE) { /* Buffer to load WAL header into */
		aPrivate = uintptr(0) /* Heap copy of *-shm hash being populated */
		aFrame = uintptr(0)   /* Last frame in wal, based on nSize alone */
		/* Read in the WAL header. */
		rc = _sqlite3OsRead(tls, (*TWal)(unsafe.Pointer(pWal)).FpWalFd, bp+8, int32(WAL_HDRSIZE), 0)
		if rc != SQLITE_OK {
			goto recovery_error
		}
		/* If the database page size is not a power of two, or is greater than
		 ** SQLITE_MAX_PAGE_SIZE, conclude that the WAL file contains no valid
		 ** data. Similarly, if the 'magic' value is invalid, ignore the whole
		 ** WAL file.
		 */
		magic = _sqlite3Get4byte(tls, bp+8)
		szPage = libc.Int32FromUint32(_sqlite3Get4byte(tls, bp+8+8))
		if magic&uint32(0xFFFFFFFE) != uint32(WAL_MAGIC) || szPage&(szPage-int32(1)) != 0 || szPage > int32(SQLITE_MAX_PAGE_SIZE) || szPage < int32(512) {
			goto finished
		}
		(*TWal)(unsafe.Pointer(pWal)).Fhdr.FbigEndCksum = uint8(magic & libc.Uint32FromInt32(0x00000001))
		(*TWal)(unsafe.Pointer(pWal)).FszPage = libc.Uint32FromInt32(szPage)
		(*TWal)(unsafe.Pointer(pWal)).FnCkpt = _sqlite3Get4byte(tls, bp+8+12)
		libc.Xmemcpy(tls, pWal+52+32, bp+8+16, uint32(8))
		/* Verify that the WAL header checksum is correct */
		_walChecksumBytes(tls, libc.BoolInt32(libc.Int32FromUint8((*TWal)(unsafe.Pointer(pWal)).Fhdr.FbigEndCksum) == SQLITE_BIGENDIAN), bp+8, libc.Int32FromInt32(WAL_HDRSIZE)-libc.Int32FromInt32(2)*libc.Int32FromInt32(4), uintptr(0), pWal+52+24)
		if **(**Tu32)(__ccgo_up(pWal + 52 + 24)) != _sqlite3Get4byte(tls, bp+8+24) || **(**Tu32)(__ccgo_up(pWal + 52 + 24 + 1*4)) != _sqlite3Get4byte(tls, bp+8+28) {
			goto finished
		}
		/* Verify that the version number on the WAL format is one that
		 ** are able to understand */
		version = _sqlite3Get4byte(tls, bp+8+4)
		if version != uint32(WAL_MAX_VERSION) {
			rc = _sqlite3CantopenError(tls, int32(68992))
			goto finished
		}
		/* Malloc a buffer to read frames into. */
		szFrame = szPage + int32(WAL_FRAME_HDRSIZE)
		aFrame = Xsqlite3_malloc64(tls, uint64(libc.Uint32FromInt32(szFrame)+(libc.Uint32FromInt64(2)*libc.Uint32FromInt32(libc.Int32FromInt32(HASHTABLE_NPAGE)*libc.Int32FromInt32(2))+libc.Uint32FromInt32(HASHTABLE_NPAGE)*libc.Uint32FromInt64(4))))
		if !(aFrame != 0) {
			rc = int32(SQLITE_NOMEM)
			goto recovery_error
		}
		aData = aFrame + 24
		aPrivate = aData + uintptr(szPage)
		/* Read all frames from the log file. */
		iLastFrame = libc.Uint32FromInt64((**(**Ti64)(__ccgo_up(bp)) - int64(WAL_HDRSIZE)) / int64(szFrame))
		iPg = uint32(0)
		for {
			if !(iPg <= libc.Uint32FromInt32(_walFramePage(tls, iLastFrame))) {
				break
			}
			if iLastFrame < libc.Uint32FromInt32(HASHTABLE_NPAGE)-(libc.Uint32FromInt64(48)*libc.Uint32FromInt32(2)+libc.Uint32FromInt64(40))/libc.Uint32FromInt64(4)+iPg*uint32(HASHTABLE_NPAGE) {
				v2 = iLastFrame
			} else {
				v2 = libc.Uint32FromInt32(HASHTABLE_NPAGE) - (libc.Uint32FromInt64(48)*libc.Uint32FromInt32(2)+libc.Uint32FromInt64(40))/libc.Uint32FromInt64(4) + iPg*uint32(HASHTABLE_NPAGE)
			} /* Index of last frame read */
			iLast = v2
			if iPg == uint32(0) {
				v3 = uint32(0)
			} else {
				v3 = libc.Uint32FromInt32(HASHTABLE_NPAGE) - (libc.Uint32FromInt64(48)*libc.Uint32FromInt32(2)+libc.Uint32FromInt64(40))/libc.Uint32FromInt64(4) + (iPg-uint32(1))*uint32(HASHTABLE_NPAGE)
			}
			iFirst = uint32(1) + v3
			rc = _walIndexPage(tls, pWal, libc.Int32FromUint32(iPg), bp+40)
			if **(**uintptr)(__ccgo_up(bp + 40)) == uintptr(0) {
				break
			}
			**(**uintptr)(__ccgo_up((*TWal)(unsafe.Pointer(pWal)).FapWiData + uintptr(iPg)*4)) = aPrivate
			iFrame = iFirst
			for {
				if !(iFrame <= iLast) {
					break
				}
				iOffset = libc.Int64FromInt32(WAL_HDRSIZE) + libc.Int64FromUint32(iFrame-libc.Uint32FromInt32(1))*int64(szPage+libc.Int32FromInt32(WAL_FRAME_HDRSIZE)) /* dbsize field from frame header */
				/* Read and decode the next log frame. */
				rc = _sqlite3OsRead(tls, (*TWal)(unsafe.Pointer(pWal)).FpWalFd, aFrame, szFrame, iOffset)
				if rc != SQLITE_OK {
					break
				}
				isValid = _walDecodeFrame(tls, pWal, bp+44, bp+48, aData, aFrame)
				if !(isValid != 0) {
					break
				}
				rc = _walIndexAppend(tls, pWal, iFrame, **(**Tu32)(__ccgo_up(bp + 44)))
				if rc != SQLITE_OK {
					break
				}
				/* If nTruncate is non-zero, this is a commit record. */
				if **(**Tu32)(__ccgo_up(bp + 48)) != 0 {
					(*TWal)(unsafe.Pointer(pWal)).Fhdr.FmxFrame = iFrame
					(*TWal)(unsafe.Pointer(pWal)).Fhdr.FnPage = **(**Tu32)(__ccgo_up(bp + 48))
					(*TWal)(unsafe.Pointer(pWal)).Fhdr.FszPage = libc.Uint16FromInt32(szPage&libc.Int32FromInt32(0xff00) | szPage>>libc.Int32FromInt32(16))
					aFrameCksum[0] = **(**Tu32)(__ccgo_up(pWal + 52 + 24))
					aFrameCksum[int32(1)] = **(**Tu32)(__ccgo_up(pWal + 52 + 24 + 1*4))
				}
				goto _4
			_4:
				;
				iFrame = iFrame + 1
			}
			**(**uintptr)(__ccgo_up((*TWal)(unsafe.Pointer(pWal)).FapWiData + uintptr(iPg)*4)) = **(**uintptr)(__ccgo_up(bp + 40))
			if iPg == uint32(0) {
				v2 = libc.Uint32FromInt64(48)*libc.Uint32FromInt32(2) + libc.Uint32FromInt64(40)
			} else {
				v2 = uint32(0)
			}
			nHdr = v2
			nHdr32 = nHdr / uint32(4)
			/* Memcpy() should work fine here, on all reasonable implementations.
			 ** Technically, memcpy() might change the destination to some
			 ** intermediate value before setting to the final value, and that might
			 ** cause a concurrent reader to malfunction.  Memcpy() is allowed to
			 ** do that, according to the spec, but no memcpy() implementation that
			 ** we know of actually does that, which is why we say that memcpy()
			 ** is safe for this.  Memcpy() is certainly a lot faster.
			 */
			libc.Xmemcpy(tls, **(**uintptr)(__ccgo_up(bp + 40))+uintptr(nHdr32)*4, aPrivate+uintptr(nHdr32)*4, libc.Uint32FromInt64(2)*libc.Uint32FromInt32(libc.Int32FromInt32(HASHTABLE_NPAGE)*libc.Int32FromInt32(2))+libc.Uint32FromInt32(HASHTABLE_NPAGE)*libc.Uint32FromInt64(4)-nHdr)
			if iFrame <= iLast {
				break
			}
			goto _1
		_1:
			;
			iPg = iPg + 1
		}
		Xsqlite3_free(tls, aFrame)
	}
	goto finished
finished:
	;
	if rc == SQLITE_OK {
		**(**Tu32)(__ccgo_up(pWal + 52 + 24)) = aFrameCksum[0]
		**(**Tu32)(__ccgo_up(pWal + 52 + 24 + 1*4)) = aFrameCksum[int32(1)]
		_walIndexWriteHdr(tls, pWal)
		/* Reset the checkpoint-header. This is safe because this thread is
		 ** currently holding locks that exclude all other writers and
		 ** checkpointers. Then set the values of read-mark slots 1 through N.
		 */
		pInfo = _walCkptInfo(tls, pWal)
		(*TWalCkptInfo)(unsafe.Pointer(pInfo)).FnBackfill = uint32(0)
		(*TWalCkptInfo)(unsafe.Pointer(pInfo)).FnBackfillAttempted = (*TWal)(unsafe.Pointer(pWal)).Fhdr.FmxFrame
		**(**Tu32)(__ccgo_up(pInfo + 4)) = uint32(0)
		i = int32(1)
		for {
			if !(i < libc.Int32FromInt32(SQLITE_SHM_NLOCK)-libc.Int32FromInt32(3)) {
				break
			}
			rc = _walLockExclusive(tls, pWal, int32(3)+i, int32(1))
			if rc == SQLITE_OK {
				if i == int32(1) && (*TWal)(unsafe.Pointer(pWal)).Fhdr.FmxFrame != 0 {
					**(**Tu32)(__ccgo_up(pInfo + 4 + uintptr(i)*4)) = (*TWal)(unsafe.Pointer(pWal)).Fhdr.FmxFrame
				} else {
					**(**Tu32)(__ccgo_up(pInfo + 4 + uintptr(i)*4)) = uint32(READMARK_NOT_USED)
				}
				_walUnlockExclusive(tls, pWal, int32(3)+i, int32(1))
			} else {
				if rc != int32(SQLITE_BUSY) {
					goto recovery_error
				}
			}
			goto _6
		_6:
			;
			i = i + 1
		}
		/* If more than one frame was recovered from the log file, report an
		 ** event via sqlite3_log(). This is to help with identifying performance
		 ** problems caused by applications routinely shutting down without
		 ** checkpointing the log file.
		 */
		if (*TWal)(unsafe.Pointer(pWal)).Fhdr.FnPage != 0 {
			Xsqlite3_log(tls, libc.Int32FromInt32(SQLITE_NOTICE)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(8), __ccgo_ts+4278, libc.VaList(bp+64, (*TWal)(unsafe.Pointer(pWal)).Fhdr.FmxFrame, (*TWal)(unsafe.Pointer(pWal)).FzWalName))
		}
	}
	goto recovery_error
recovery_error:
	;
	_walUnlockExclusive(tls, pWal, iLock, libc.Int32FromInt32(3)+libc.Int32FromInt32(0)-iLock)
	return rc
}

// C documentation
//
//	/*
//	** This function is called as part of generating VM programs for RANGE
//	** offset PRECEDING/FOLLOWING frame boundaries. Assuming "ASC" order for
//	** the ORDER BY term in the window, and that argument op is OP_Ge, it generates
//	** code equivalent to:
//	**
//	**   if( csr1.peerVal + regVal >= csr2.peerVal ) goto lbl;
//	**
//	** The value of parameter op may also be OP_Gt or OP_Le. In these cases the
//	** operator in the above pseudo-code is replaced with ">" or "<=", respectively.
//	**
//	** If the sort-order for the ORDER BY term in the window is DESC, then the
//	** comparison is reversed. Instead of adding regVal to csr1.peerVal, it is
//	** subtracted. And the comparison operator is inverted to - ">=" becomes "<=",
//	** ">" becomes "<", and so on. So, with DESC sort order, if the argument op
//	** is OP_Ge, the generated code is equivalent to:
//	**
//	**   if( csr1.peerVal - regVal <= csr2.peerVal ) goto lbl;
//	**
//	** A special type of arithmetic is used such that if csr1.peerVal is not
//	** a numeric type (real or integer), then the result of the addition
//	** or subtraction is a a copy of csr1.peerVal.
//	*/
func _windowCodeRangeTest(tls *libc.TLS, p uintptr, op int32, csr1 int32, regVal int32, csr2 int32, lbl int32) {
	var addr, addrDone, addrGe, arith, reg1, reg2, regString, v1 int32
	var pColl, pOrderBy, pParse, v, v2 uintptr
	_, _, _, _, _, _, _, _, _, _, _, _, _ = addr, addrDone, addrGe, arith, pColl, pOrderBy, pParse, reg1, reg2, regString, v, v1, v2
	pParse = (*TWindowCodeArg)(unsafe.Pointer(p)).FpParse
	v = _sqlite3GetVdbe(tls, pParse)
	pOrderBy = (*TWindow)(unsafe.Pointer((*TWindowCodeArg)(unsafe.Pointer(p)).FpMWin)).FpOrderBy /* ORDER BY clause for window */
	reg1 = _sqlite3GetTempReg(tls, pParse)                                                       /* Reg. for csr1.peerVal+regVal */
	reg2 = _sqlite3GetTempReg(tls, pParse)
	v2 = pParse + 48
	*(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1
	v1 = *(*int32)(unsafe.Pointer(v2)) /* Reg. for csr2.peerVal */
	regString = v1                     /* Reg. for constant value '' */
	arith = int32(OP_Add)              /* Jump destination */
	addrDone = _sqlite3VdbeMakeLabel(tls, pParse)
	/* Read the peer-value from each cursor into a register */
	_windowReadPeerValues(tls, p, csr1, reg1)
	_windowReadPeerValues(tls, p, csr2, reg2)
	if libc.Int32FromUint8((*(*TExprList_item)(unsafe.Pointer(pOrderBy + 8))).Ffg.FsortFlags)&int32(KEYINFO_ORDER_DESC) != 0 {
		switch op {
		case int32(OP_Ge):
			op = int32(OP_Le)
		case int32(OP_Gt):
			op = int32(OP_Lt)
		default:
			op = int32(OP_Ge)
			break
		}
		arith = int32(OP_Subtract)
	}
	/* If the BIGNULL flag is set for the ORDER BY, then it is required to
	 ** consider NULL values to be larger than all other values, instead of
	 ** the usual smaller. The VDBE opcodes OP_Ge and so on do not handle this
	 ** (and adding that capability causes a performance regression), so
	 ** instead if the BIGNULL flag is set then cases where either reg1 or
	 ** reg2 are NULL are handled separately in the following block. The code
	 ** generated is equivalent to:
	 **
	 **   if( reg1 IS NULL ){
	 **     if( op==OP_Ge ) goto lbl;
	 **     if( op==OP_Gt && reg2 IS NOT NULL ) goto lbl;
	 **     if( op==OP_Le && reg2 IS NULL ) goto lbl;
	 **   }else if( reg2 IS NULL ){
	 **     if( op==OP_Le ) goto lbl;
	 **   }
	 **
	 ** Additionally, if either reg1 or reg2 are NULL but the jump to lbl is
	 ** not taken, control jumps over the comparison operator coded below this
	 ** block.  */
	if libc.Int32FromUint8((*(*TExprList_item)(unsafe.Pointer(pOrderBy + 8))).Ffg.FsortFlags)&int32(KEYINFO_ORDER_BIGNULL) != 0 {
		/* This block runs if reg1 contains a NULL. */
		addr = _sqlite3VdbeAddOp1(tls, v, int32(OP_NotNull), reg1)
		switch op {
		case int32(OP_Ge):
			_sqlite3VdbeAddOp2(tls, v, int32(OP_Goto), 0, lbl)
		case int32(OP_Gt):
			_sqlite3VdbeAddOp2(tls, v, int32(OP_NotNull), reg2, lbl)
		case int32(OP_Le):
			_sqlite3VdbeAddOp2(tls, v, int32(OP_IsNull), reg2, lbl)
		default: /* no-op */
			break
		}
		_sqlite3VdbeAddOp2(tls, v, int32(OP_Goto), 0, addrDone)
		/* This block runs if reg1 is not NULL, but reg2 is. */
		_sqlite3VdbeJumpHere(tls, v, addr)
		if op == int32(OP_Gt) || op == int32(OP_Ge) {
			v1 = addrDone
		} else {
			v1 = lbl
		}
		_sqlite3VdbeAddOp2(tls, v, int32(OP_IsNull), reg2, v1)
	}
	/* Register reg1 currently contains csr1.peerVal (the peer-value from csr1).
	 ** This block adds (or subtracts for DESC) the numeric value in regVal
	 ** from it. Or, if reg1 is not numeric (it is a NULL, a text value or a blob),
	 ** then leave reg1 as it is. In pseudo-code, this is implemented as:
	 **
	 **   if( reg1>='' ) goto addrGe;
	 **   reg1 = reg1 +/- regVal
	 **   addrGe:
	 **
	 ** Since all strings and blobs are greater-than-or-equal-to an empty string,
	 ** the add/subtract is skipped for these, as required. If reg1 is a NULL,
	 ** then the arithmetic is performed, but since adding or subtracting from
	 ** NULL is always NULL anyway, this case is handled as required too.  */
	_sqlite3VdbeAddOp4(tls, v, int32(OP_String8), 0, regString, 0, __ccgo_ts+1702, -int32(1))
	addrGe = _sqlite3VdbeAddOp3(tls, v, int32(OP_Ge), regString, 0, reg1)
	if op == int32(OP_Ge) && arith == int32(OP_Add) || op == int32(OP_Le) && arith == int32(OP_Subtract) {
		_sqlite3VdbeAddOp3(tls, v, op, reg2, lbl, reg1)
	}
	_sqlite3VdbeAddOp3(tls, v, arith, regVal, reg1, reg1)
	_sqlite3VdbeJumpHere(tls, v, addrGe)
	/* Compare registers reg2 and reg1, taking the jump if required. Note that
	 ** control skips over this test if the BIGNULL flag is set and either
	 ** reg1 or reg2 contain a NULL value.  */
	_sqlite3VdbeAddOp3(tls, v, op, reg2, lbl, reg1)
	pColl = _sqlite3ExprNNCollSeq(tls, pParse, (*(*TExprList_item)(unsafe.Pointer(pOrderBy + 8))).FpExpr)
	_sqlite3VdbeAppendP4(tls, v, pColl, -int32(2))
	_sqlite3VdbeChangeP5(tls, v, uint16(SQLITE_NULLEQ))
	_sqlite3VdbeResolveLabel(tls, v, addrDone)
	_sqlite3ReleaseTempReg(tls, pParse, reg1)
	_sqlite3ReleaseTempReg(tls, pParse, reg2)
}

func init() {
	p := unsafe.Pointer(&_aSyscall)
	*(*uintptr)(unsafe.Add(p, 4)) = __ccgo_fp(_posixOpen)
	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(libc.Xclose)
	*(*uintptr)(unsafe.Add(p, 28)) = __ccgo_fp(libc.Xaccess)
	*(*uintptr)(unsafe.Add(p, 40)) = __ccgo_fp(libc.Xgetcwd)
	*(*uintptr)(unsafe.Add(p, 52)) = __ccgo_fp(libc.Xstat)
	*(*uintptr)(unsafe.Add(p, 64)) = __ccgo_fp(libc.Xfstat)
	*(*uintptr)(unsafe.Add(p, 76)) = __ccgo_fp(libc.Xftruncate)
	*(*uintptr)(unsafe.Add(p, 88)) = __ccgo_fp(libc.Xfcntl)
	*(*uintptr)(unsafe.Add(p, 100)) = __ccgo_fp(libc.Xread)
	*(*uintptr)(unsafe.Add(p, 136)) = __ccgo_fp(libc.Xwrite)
	*(*uintptr)(unsafe.Add(p, 172)) = __ccgo_fp(libc.Xfchmod)
	*(*uintptr)(unsafe.Add(p, 196)) = __ccgo_fp(libc.Xunlink)
	*(*uintptr)(unsafe.Add(p, 208)) = __ccgo_fp(_openDirectory)
	*(*uintptr)(unsafe.Add(p, 220)) = __ccgo_fp(libc.Xmkdir)
	*(*uintptr)(unsafe.Add(p, 232)) = __ccgo_fp(libc.Xrmdir)
	*(*uintptr)(unsafe.Add(p, 244)) = __ccgo_fp(libc.Xfchown)
	*(*uintptr)(unsafe.Add(p, 256)) = __ccgo_fp(libc.Xgeteuid)
	*(*uintptr)(unsafe.Add(p, 268)) = __ccgo_fp(libc.Xmmap)
	*(*uintptr)(unsafe.Add(p, 280)) = __ccgo_fp(libc.Xmunmap)
	*(*uintptr)(unsafe.Add(p, 304)) = __ccgo_fp(_unixGetpagesize)
	*(*uintptr)(unsafe.Add(p, 316)) = __ccgo_fp(libc.Xreadlink)
	*(*uintptr)(unsafe.Add(p, 328)) = __ccgo_fp(libc.Xlstat)
}

/* End of the overrideable system calls */

type t__clock_t = uint32

type t__critical_t = int32

type t__intfptr_t = int32

type t__intptr_t = int32

type t__key_t = int32

type t__ptrdiff_t = int32

type t__register_t = int32

type t__size_t = uint32

type t__ssize_t = int32

type t__suseconds_t = int32

type t__u_register_t = uint32

type t__uintfptr_t = uint32

type t__uintptr_t = uint32

type t__vm_offset_t = uint32

type t__vm_size_t = uint32
