LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: findBtree
static Btree *findBtree(sqlite3 *pErrorDb, sqlite3 *pDb, const char *zDb){
  int i = sqlite3FindDbName(pDb, zDb);

  if( i==1 ){
    Parse *pParse;
    int rc = 0;
    pParse = sqlite3StackAllocZero(pErrorDb, sizeof(*pParse));
    if( pParse==0 ){
      sqlite3Error(pErrorDb, SQLITE_NOMEM, "out of memory");
      rc = SQLITE_NOMEM;
    }else{
      pParse->db = pDb;
      if( sqlite3OpenTempDatabase(pParse) ){
        sqlite3Error(pErrorDb, pParse->rc, "%s", pParse->zErrMsg);
        rc = SQLITE_ERROR;
      }
      sqlite3DbFree(pErrorDb, pParse->zErrMsg);
      sqlite3StackFree(pErrorDb, pParse);
    }
    if( rc ){
      return 0;
    }
  }

  if( i<0 ){
    sqlite3Error(pErrorDb, SQLITE_ERROR, "unknown database %s", zDb);
    return 0;
  }

  return pDb->aDb[i].pBt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x13dd2
movl %eax, %r12d
cmpl $0x1, %eax
jne 0xbf5e
movq %rbx, %rdi
movl $0x298, %esi            # imm = 0x298
callq 0xf4ae
testq %rax, %rax
je 0xbf7f
movq %rax, %r15
movq %r14, (%rax)
movq %rax, %rdi
callq 0x17523
testl %eax, %eax
je 0xbf98
movl 0x18(%r15), %esi
movq 0x8(%r15), %rcx
leaq 0x5f7c1(%rip), %rdx     # 0x6b6f9
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xbdb1
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x968b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x968b
jmp 0xbfbf
testl %r12d, %r12d
jns 0xbfaf
leaq 0x5f828(%rip), %rdx     # 0x6b792
xorl %r14d, %r14d
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0xbdb1
jmp 0xbfbf
leaq 0x5f7fe(%rip), %rdx     # 0x6b784
xorl %r14d, %r14d
pushq $0x7
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0xbdb1
jmp 0xbfbf
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x968b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x968b
movq 0x20(%r14), %rax
movl %r12d, %ecx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3BtreeGetMeta
SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){
  BtShared *pBt = p->pBt;

  sqlite3BtreeEnter(p);
  assert( p->inTrans>TRANS_NONE );
  assert( SQLITE_OK==querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK) );
  assert( pBt->pPage1 );
  assert( idx>=0 && idx<=15 );

  *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]);

  /* If auto-vacuum is disabled in this build and this is an auto-vacuum
  ** database, mark the database as read-only.  */
#ifdef SQLITE_OMIT_AUTOVACUUM
  if( idx==BTREE_LARGEST_ROOT_PAGE && *pMeta>0 ){
    pBt->btsFlags |= BTS_READ_ONLY;
  }
#endif

  sqlite3BtreeLeave(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x18(%rcx), %rax
movq 0x50(%rax), %rax
shll $0x2, %esi
movslq %esi, %rcx
leaq (%rax,%rcx), %rdi
addq $0x24, %rdi
callq 0x180a3
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3PagerUnref
SQLITE_PRIVATE void sqlite3PagerUnref(DbPage *pPg){
  if( pPg ){
    Pager *pPager = pPg->pPager;
    if( pPg->flags & PGHDR_MMAP ){
      pagerReleaseMapPage(pPg);
    }else{
      sqlite3PcacheRelease(pPg);
    }
    pagerUnlockIfUnused(pPager);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xcf8a
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x20(%rdi), %rbx
testb $0x40, 0x2c(%rdi)
jne 0xcf8b
callq 0x1ce42
jmp 0xcfc7
retq
decl 0x98(%rbx)
movq 0xa8(%rbx), %rax
movq %rax, 0x18(%rdi)
movq %rdi, 0xa8(%rbx)
movq 0x48(%rbx), %rax
movl 0x28(%rdi), %ecx
decl %ecx
movslq 0xbc(%rbx), %rsi
imulq %rcx, %rsi
movq 0x8(%rdi), %rdx
movq (%rax), %rcx
movq %rax, %rdi
callq *0x90(%rcx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1dc37
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3BtreeUpdateMeta
SQLITE_PRIVATE int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){
  BtShared *pBt = p->pBt;
  unsigned char *pP1;
  int rc;
  assert( idx>=1 && idx<=15 );
  sqlite3BtreeEnter(p);
  assert( p->inTrans==TRANS_WRITE );
  assert( pBt->pPage1!=0 );
  pP1 = pBt->pPage1->aData;
  rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
  if( rc==SQLITE_OK ){
    put4byte(&pP1[36 + idx*4], iMeta);
#ifndef SQLITE_OMIT_AUTOVACUUM
    if( idx==BTREE_INCR_VACUUM ){
      assert( pBt->autoVacuum || iMeta==0 );
      assert( iMeta==0 || iMeta==1 );
      pBt->incrVacuum = (u8)iMeta;
    }
#endif
  }
  sqlite3BtreeLeave(p);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movq (%rdi), %rax
movq 0x8(%rdi), %r15
movq %rax, 0x8(%r15)
movq 0x18(%r15), %rax
movq 0x50(%rax), %r12
movq 0x68(%rax), %rdi
callq 0xd10b
testl %eax, %eax
jne 0xd01a
movslq %r14d, %rcx
movl %ebx, %edx
bswapl %edx
movl %edx, 0x24(%r12,%rcx,4)
cmpl $0x7, %ecx
jne 0xd01a
movb %bl, 0x22(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3ResetAllSchemasOfConnection
SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){
  int i;
  sqlite3BtreeEnterAll(db);
  for(i=0; i<db->nDb; i++){
    Db *pDb = &db->aDb[i];
    if( pDb->pSchema ){
      sqlite3SchemaClear(pDb->pSchema);
    }
  }
  db->flags &= ~SQLITE_InternChanges;
  sqlite3VtabUnlockList(db);
  sqlite3BtreeLeaveAll(db);
  sqlite3CollapseDatabaseArray(db);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x933b
pushq $0x18
popq %r14
xorl %r15d, %r15d
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jge 0xd060
movq 0x20(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0xd057
callq 0x2bdcf
incq %r15
addq $0x20, %r14
jmp 0xd03c
andb $-0x3, 0x2c(%rbx)
movq %rbx, %rdi
callq 0x316c4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x316fd
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3BtreeSetVersion
SQLITE_PRIVATE int sqlite3BtreeSetVersion(Btree *pBtree, int iVersion){
  BtShared *pBt = pBtree->pBt;
  int rc;                         /* Return code */
 
  assert( iVersion==1 || iVersion==2 );

  /* If setting the version fields to 1, do not automatically open the
  ** WAL connection, even if the version fields are currently set to 2.
  */
  pBt->btsFlags &= ~BTS_NO_WAL;
  if( iVersion==1 ) pBt->btsFlags |= BTS_NO_WAL;

  rc = sqlite3BtreeBeginTrans(pBtree, 0);
  if( rc==SQLITE_OK ){
    u8 *aData = pBt->pPage1->aData;
    if( aData[18]!=(u8)iVersion || aData[19]!=(u8)iVersion ){
      rc = sqlite3BtreeBeginTrans(pBtree, 2);
      if( rc==SQLITE_OK ){
        rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
        if( rc==SQLITE_OK ){
          aData[18] = (u8)iVersion;
          aData[19] = (u8)iVersion;
        }
      }
    }
  }

  pBt->btsFlags &= ~BTS_NO_WAL;
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movzwl 0x26(%r15), %eax
andl $-0x11, %eax
xorl %ecx, %ecx
cmpl $0x1, %esi
sete %cl
shll $0x4, %ecx
orl %eax, %ecx
movw %cx, 0x26(%r15)
xorl %esi, %esi
callq 0xc487
testl %eax, %eax
jne 0xd0fd
movq 0x18(%r15), %rax
movq 0x50(%rax), %r12
movb 0x12(%r12), %cl
cmpb %bl, %cl
jne 0xd0d1
xorl %eax, %eax
cmpb %cl, 0x13(%r12)
je 0xd0fd
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0xc487
testl %eax, %eax
jne 0xd0fd
movq 0x18(%r15), %rax
movq 0x68(%rax), %rdi
callq 0xd10b
testl %eax, %eax
jne 0xd0fd
movb %bl, 0x12(%r12)
movb %bl, 0x13(%r12)
xorl %eax, %eax
andb $-0x11, 0x26(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3PagerSync
SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager){
  int rc = SQLITE_OK;
  if( !pPager->noSync ){
    assert( !MEMDB );
    rc = sqlite3OsSync(pPager->fd, pPager->syncFlags);
  }else if( isOpen(pPager->fd) ){
    assert( !MEMDB );
    rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC_OMITTED, 0);
    if( rc==SQLITE_NOTFOUND ){
      rc = SQLITE_OK;
    }
  }
  return rc;
}

// Assembly:
movq %rdi, %rax
cmpb $0x0, 0xb(%rdi)
movq 0x48(%rdi), %rdi
je 0xd5db
movq (%rdi), %rax
testq %rax, %rax
je 0xd5e8
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %ebx, %ebx
pushq $0x8
popq %rsi
xorl %edx, %edx
callq *0x50(%rax)
cmpl $0xc, %eax
cmovel %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movzbl 0xf(%rax), %esi
movq (%rdi), %rax
movq 0x28(%rax), %rax
jmpq *%rax
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3BtreeCommitPhaseTwo
SQLITE_PRIVATE int sqlite3BtreeCommitPhaseTwo(Btree *p, int bCleanup){

  if( p->inTrans==TRANS_NONE ) return SQLITE_OK;
  sqlite3BtreeEnter(p);
  btreeIntegrity(p);

  /* If the handle has a write-transaction open, commit the shared-btrees 
  ** transaction and set the shared state to TRANS_READ.
  */
  if( p->inTrans==TRANS_WRITE ){
    int rc;
    BtShared *pBt = p->pBt;
    assert( pBt->inTransaction==TRANS_WRITE );
    assert( pBt->nTransaction>0 );
    rc = sqlite3PagerCommitPhaseTwo(pBt->pPager);
    if( rc!=SQLITE_OK && bCleanup==0 ){
      sqlite3BtreeLeave(p);
      return rc;
    }
    pBt->inTransaction = TRANS_READ;
    btreeClearHasContent(pBt);
  }

  btreeEndTransaction(p);
  sqlite3BtreeLeave(p);
  return SQLITE_OK;
}

// Assembly:
movb 0x10(%rdi), %cl
xorl %eax, %eax
testb %cl, %cl
je 0xd694
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %r14
movq %rax, 0x8(%r14)
cmpb $0x2, %cl
jne 0xd682
movl %esi, %r15d
movq (%r14), %r12
movl 0x2c(%r12), %eax
testl %eax, %eax
jne 0xd66c
cmpb $0x2, 0x13(%r12)
jne 0xd643
cmpb $0x0, 0x8(%r12)
je 0xd643
cmpb $0x1, 0x9(%r12)
jne 0xd643
xorl %eax, %eax
movb $0x1, %cl
jmp 0xd667
movzbl 0x16(%r12), %esi
pushq $0x1
popq %rdx
movq %r12, %rdi
callq 0x1b71b
cmpb $0xd, %al
je 0xd660
movzbl %al, %ecx
cmpl $0xa, %ecx
jne 0xd66c
movl %eax, 0x2c(%r12)
movb $0x6, %cl
movb %cl, 0x13(%r12)
testl %r15d, %r15d
jne 0xd675
testl %eax, %eax
jne 0xd68c
movb $0x1, 0x24(%r14)
movq %r14, %rdi
callq 0x1debc
movq %rbx, %rdi
callq 0x1deda
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3BtreeCommitPhaseOne
SQLITE_PRIVATE int sqlite3BtreeCommitPhaseOne(Btree *p, const char *zMaster){
  int rc = SQLITE_OK;
  if( p->inTrans==TRANS_WRITE ){
    BtShared *pBt = p->pBt;
    sqlite3BtreeEnter(p);
#ifndef SQLITE_OMIT_AUTOVACUUM
    if( pBt->autoVacuum ){
      rc = autoVacuumCommit(pBt);
      if( rc!=SQLITE_OK ){
        sqlite3BtreeLeave(p);
        return rc;
      }
    }
    if( pBt->bDoTruncate ){
      sqlite3PagerTruncateImage(pBt->pPager, pBt->nPage);
    }
#endif
    rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zMaster, 0);
    sqlite3BtreeLeave(p);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %r15d, %r15d
cmpb $0x2, 0x10(%rdi)
jne 0xd738
movq %rsi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %r14
movq %rax, 0x8(%r14)
cmpb $0x0, 0x21(%r14)
je 0xd6da
movq (%r14), %r15
movq %r14, %rdi
callq 0x1dfb7
cmpb $0x0, 0x22(%r14)
je 0xd703
cmpb $0x0, 0x23(%r14)
movq (%r14), %rdi
je 0xd6eb
movl 0x3c(%r14), %eax
movl %eax, 0x1c(%rdi)
movq %rbx, %rsi
xorl %edx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd2a7
movl 0x3c(%r14), %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x1dfda
cmpl %r12d, %eax
je 0xd72a
movl 0x7a123(%rip), %eax     # 0x87840
xorl %edx, %edx
divl 0x30(%r14)
incl %eax
cmpl %eax, %r12d
jne 0xd74a
movl $0xce1f, %edi           # imm = 0xCE1F
callq 0x1a1fc
pushq $0xb
popq %r15
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, -0x38(%rbp)
movq 0x18(%r14), %rax
movq 0x50(%rax), %rdi
addq $0x24, %rdi
callq 0x180a3
movl %eax, %r15d
movq %r14, %rdi
movl %r12d, %esi
movl %eax, %edx
callq 0x1e01d
cmpl %r12d, %eax
jbe 0xd77b
movl $0xce24, %edi           # imm = 0xCE24
jmp 0xd72f
movl %eax, %r13d
movl %r15d, -0x2c(%rbp)
xorl %r15d, %r15d
cmpl %r12d, %eax
jae 0xd7b7
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1e0b8
movl %eax, %r15d
jmp 0xd7b7
testl %r15d, %r15d
jne 0xd7bc
movq %r14, %rdi
movl %r13d, %esi
movl %r12d, %edx
pushq $0x1
popq %rcx
callq 0x1e18a
movl %eax, %r15d
decl %r12d
cmpl %r13d, %r12d
ja 0xd79b
testl %r15d, %r15d
sete %al
cmpl $0x65, %r15d
sete %cl
cmpl $0x0, -0x2c(%rbp)
je 0xd814
orb %al, %cl
je 0xd814
movq 0x18(%r14), %rax
movq 0x68(%rax), %rdi
callq 0xd10b
movq 0x18(%r14), %rcx
movq 0x50(%rcx), %rcx
andl $0x0, 0x20(%rcx)
movq 0x18(%r14), %rcx
movq 0x50(%rcx), %rcx
andl $0x0, 0x24(%rcx)
movl %eax, %r15d
movq 0x18(%r14), %rax
movq 0x50(%rax), %rax
movl %r13d, %ecx
bswapl %ecx
movl %ecx, 0x1c(%rax)
movb $0x1, 0x23(%r14)
movl %r13d, 0x3c(%r14)
testl %r15d, %r15d
movq -0x38(%rbp), %rdi
je 0xd6da
callq 0x1b675
jmp 0xd738
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_backup_finish
SQLITE_API int sqlite3_backup_finish(sqlite3_backup *p){
  sqlite3_backup **pp;                 /* Ptr to head of pagers backup list */
  sqlite3 *pSrcDb;                     /* Source database connection */
  int rc;                              /* Value to return */

  /* Enter the mutexes */
  if( p==0 ) return SQLITE_OK;
  pSrcDb = p->pSrcDb;
  sqlite3_mutex_enter(pSrcDb->mutex);
  sqlite3BtreeEnter(p->pSrc);
  if( p->pDestDb ){
    sqlite3_mutex_enter(p->pDestDb->mutex);
  }

  /* Detach this backup from the source pager. */
  if( p->pDestDb ){
    p->pSrc->nBackup--;
  }
  if( p->isAttached ){
    pp = sqlite3PagerBackupPtr(sqlite3BtreePager(p->pSrc));
    while( *pp!=p ){
      pp = &(*pp)->pNext;
    }
    *pp = p->pNext;
  }

  /* If a transaction is still open on the Btree, roll it back. */
  sqlite3BtreeRollback(p->pDest, SQLITE_OK);

  /* Set the error code of the destination database handle. */
  rc = (p->rc==SQLITE_DONE) ? SQLITE_OK : p->rc;
  sqlite3Error(p->pDestDb, rc, 0);

  /* Exit the mutexes and free the backup context structure. */
  if( p->pDestDb ){
    sqlite3LeaveMutexAndCloseZombie(p->pDestDb);
  }
  sqlite3BtreeLeave(p->pSrc);
  if( p->pDestDb ){
    /* 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(). */
    sqlite3_free(p);
  }
  sqlite3LeaveMutexAndCloseZombie(pSrcDb);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xd8d0
movq %rdi, %r14
movq 0x20(%rdi), %rbx
movq 0x28(%rdi), %rcx
movq (%rcx), %rdx
movq 0x8(%rcx), %rax
movq %rdx, 0x8(%rax)
cmpq $0x0, (%rdi)
je 0xd85e
decl 0x18(%rcx)
cmpl $0x0, 0x3c(%r14)
je 0xd882
movq (%rax), %rax
addq $0x70, %rax
movq %rax, %rcx
movq (%rax), %rdx
leaq 0x40(%rdx), %rax
cmpq %r14, %rdx
jne 0xd86c
movq 0x40(%r14), %rax
movq %rax, (%rcx)
movq 0x8(%r14), %rdi
xorl %r12d, %r12d
xorl %esi, %esi
callq 0xd8df
movl 0x30(%r14), %r15d
cmpl $0x65, %r15d
cmovel %r12d, %r15d
movq (%r14), %rdi
movl %r15d, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xbdb1
movq (%r14), %rdi
testq %rdi, %rdi
je 0xd8c6
callq 0xd97e
cmpq $0x0, (%r14)
je 0xd8c6
movq %r14, %rdi
callq 0x9c7b
movq %rbx, %rdi
callq 0xd97e
jmp 0xd8d3
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3BtreeRollback
SQLITE_PRIVATE int sqlite3BtreeRollback(Btree *p, int tripCode){
  int rc;
  BtShared *pBt = p->pBt;
  MemPage *pPage1;

  sqlite3BtreeEnter(p);
  if( tripCode==SQLITE_OK ){
    rc = tripCode = saveAllCursors(pBt, 0, 0);
  }else{
    rc = SQLITE_OK;
  }
  if( tripCode ){
    sqlite3BtreeTripAllCursors(p, tripCode);
  }
  btreeIntegrity(p);

  if( p->inTrans==TRANS_WRITE ){
    int rc2;

    assert( TRANS_WRITE==pBt->inTransaction );
    rc2 = sqlite3PagerRollback(pBt->pPager);
    if( rc2!=SQLITE_OK ){
      rc = rc2;
    }

    /* The rollback may have destroyed the pPage1->aData value.  So
    ** call btreeGetPage() on page 1 again to make
    ** sure pPage1->aData is set correctly. */
    if( btreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){
      int nPage = get4byte(28+(u8*)pPage1->aData);
      testcase( nPage==0 );
      if( nPage==0 ) sqlite3PagerPagecount(pBt->pPager, &nPage);
      testcase( pBt->nPage!=nPage );
      pBt->nPage = nPage;
      releasePage(pPage1);
    }
    assert( countValidCursors(pBt, 1)==0 );
    pBt->inTransaction = TRANS_READ;
    btreeClearHasContent(pBt);
  }

  btreeEndTransaction(p);
  sqlite3BtreeLeave(p);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq (%rdi), %rax
movq %rax, 0x8(%r14)
testl %esi, %esi
jne 0xd90d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1e0b8
movl %eax, %esi
testl %eax, %eax
je 0xd915
movq %rbx, %rdi
callq 0x1fa8e
cmpb $0x2, 0x10(%rbx)
jne 0xd96c
movq (%r14), %rdi
callq 0x1b675
pushq $0x1
popq %rsi
leaq -0x20(%rbp), %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x1d84e
testl %eax, %eax
jne 0xd95f
movq -0x20(%rbp), %r15
movq 0x50(%r15), %rdi
addq $0x1c, %rdi
callq 0x180a3
testl %eax, %eax
jne 0xd953
movq (%r14), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x3c(%r14)
movq %r15, %rdi
callq 0x1d90e
movb $0x1, 0x24(%r14)
movq %r14, %rdi
callq 0x1debc
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1deda
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_finalize
SQLITE_API int sqlite3_finalize(sqlite3_stmt *pStmt){
  int rc;
  if( pStmt==0 ){
    /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL
    ** pointer is a harmless no-op. */
    rc = SQLITE_OK;
  }else{
    Vdbe *v = (Vdbe*)pStmt;
    sqlite3 *db = v->db;
    if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT;
    sqlite3_mutex_enter(db->mutex);
    rc = sqlite3VdbeFinalize(v);
    rc = sqlite3ApiExit(db, rc);
    sqlite3LeaveMutexAndCloseZombie(db);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xdbd4
movq %rdi, %r14
movq (%rdi), %rbx
callq 0xdbfd
testl %eax, %eax
je 0xdbd8
movl $0xf7a0, %edi           # imm = 0xF7A0
callq 0x9008
pushq $0x15
popq %rax
jmp 0xdbf8
xorl %eax, %eax
jmp 0xdbf8
movq %r14, %rdi
callq 0xdc20
movq %rbx, %rdi
movl %eax, %esi
callq 0xdc59
movl %eax, %r14d
movq %rbx, %rdi
callq 0xd97e
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeFinalize
SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe *p){
  int rc = SQLITE_OK;
  if( p->magic==VDBE_MAGIC_RUN || p->magic==VDBE_MAGIC_HALT ){
    rc = sqlite3VdbeReset(p);
    assert( (rc & p->db->errMask)==rc );
  }
  sqlite3VdbeDelete(p);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x50(%rdi), %eax
cmpl $0x519c2973, %eax       # imm = 0x519C2973
je 0xdc3e
xorl %r14d, %r14d
cmpl $0xbdf20da3, %eax       # imm = 0xBDF20DA3
jne 0xdc49
movq %rbx, %rdi
callq 0xdcd1
movl %eax, %r14d
movq %rbx, %rdi
callq 0x1fcce
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3ApiExit
SQLITE_PRIVATE int sqlite3ApiExit(sqlite3* db, int rc){
  /* If the db handle is not NULL, then we must hold the connection handle
  ** mutex here. Otherwise the read (and possible write) of db->mallocFailed 
  ** is unsafe, as is the call to sqlite3Error().
  */
  assert( !db || sqlite3_mutex_held(db->mutex) );
  if( db && (db->mallocFailed || rc==SQLITE_IOERR_NOMEM) ){
    sqlite3Error(db, SQLITE_NOMEM, 0);
    db->mallocFailed = 0;
    rc = SQLITE_NOMEM;
  }
  return rc & (db ? db->errMask : 0xff);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
testq %rdi, %rdi
je 0xdc95
movq %rdi, %r14
cmpl $0xc0a, %ebx            # imm = 0xC0A
je 0xdc79
cmpb $0x0, 0x50(%r14)
je 0xdc8f
pushq $0x7
popq %rbx
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xbdb1
movb $0x0, 0x50(%r14)
movl 0x48(%r14), %eax
jmp 0xdc9a
movl $0xff, %eax
andl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_reset
SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt){
  int rc;
  if( pStmt==0 ){
    rc = SQLITE_OK;
  }else{
    Vdbe *v = (Vdbe*)pStmt;
    sqlite3_mutex_enter(v->db->mutex);
    rc = sqlite3VdbeReset(v);
    sqlite3VdbeRewind(v);
    assert( (rc & (v->db->errMask))==rc );
    rc = sqlite3ApiExit(v->db, rc);
    sqlite3_mutex_leave(v->db->mutex);
  }
  return rc;
}

// Assembly:
testq %rdi, %rdi
je 0xdcce
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xdcd1
movl %eax, %r14d
movq %rbx, %rdi
callq 0xdd92
movq (%rbx), %rdi
movl %r14d, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0xdc59
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_clear_bindings
SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
  int i;
  int rc = SQLITE_OK;
  Vdbe *p = (Vdbe*)pStmt;
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
#endif
  sqlite3_mutex_enter(mutex);
  for(i=0; i<p->nVar; i++){
    sqlite3VdbeMemRelease(&p->aVar[i]);
    p->aVar[i].flags = MEM_Null;
  }
  if( p->isPrepareV2 && p->expmask ){
    p->expired = 1;
  }
  sqlite3_mutex_leave(mutex);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movswq 0x88(%rbx), %rax
cmpq %rax, %r15
jge 0xde17
movq 0x78(%rbx), %rdi
addq %r14, %rdi
callq 0xde44
movq 0x78(%rbx), %rax
movw $0x1, 0x24(%rax,%r14)
incq %r15
addq $0x38, %r14
jmp 0xdde9
movzwl 0x9a(%rbx), %eax
btl $0xa, %eax
jae 0xde37
cmpl $0x0, 0x104(%rbx)
je 0xde37
orl $0x20, %eax
movw %ax, 0x9a(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeMemRelease
SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p){
  VdbeMemRelease(p);
  sqlite3DbFree(p->db, p->zMalloc);
  p->z = 0;
  p->zMalloc = 0;
  p->xDel = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzwl 0x24(%rdi), %eax
testw $0x2460, %ax            # imm = 0x2460
je 0xde5f
movq %rbx, %rdi
callq 0xf251
movq (%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x968b
andq $0x0, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_value_blob
SQLITE_API const void *sqlite3_value_blob(sqlite3_value *pVal){
  Mem *p = (Mem*)pVal;
  if( p->flags & (MEM_Blob|MEM_Str) ){
    sqlite3VdbeMemExpandBlob(p);
    p->flags &= ~MEM_Str;
    p->flags |= MEM_Blob;
    return p->n ? p->z : 0;
  }else{
    return sqlite3_value_text(pVal);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x12, 0x24(%rdi)
je 0xdeae
movq %rbx, %rdi
callq 0xdec5
movl 0x24(%rbx), %eax
andl $-0x13, %eax
orl $0x10, %eax
movw %ax, 0x24(%rbx)
cmpl $0x0, 0x20(%rbx)
je 0xdebc
movq 0x8(%rbx), %rax
jmp 0xdebe
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xdf1e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeMemExpandBlob
SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){
  if( pMem->flags & MEM_Zero ){
    int nByte;
    assert( pMem->flags&MEM_Blob );
    assert( (pMem->flags&MEM_RowSet)==0 );
    assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );

    /* Set nByte to the number of bytes required to store the expanded blob. */
    nByte = pMem->n + pMem->u.nZero;
    if( nByte<=0 ){
      nByte = 1;
    }
    if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
      return SQLITE_NOMEM;
    }

    memset(&pMem->z[pMem->n], 0, pMem->u.nZero);
    pMem->n += pMem->u.nZero;
    pMem->flags &= ~(MEM_Zero|MEM_Term);
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
xorl %r14d, %r14d
testb $0x40, 0x25(%rdi)
je 0xdf16
movq %rdi, %rbx
movl 0x18(%rdi), %esi
addl 0x20(%rdi), %esi
cmpl $0x2, %esi
pushq $0x1
popq %rdx
cmovll %edx, %esi
callq 0xf2c6
testl %eax, %eax
je 0xdef6
pushq $0x7
popq %r14
jmp 0xdf16
movslq 0x20(%rbx), %rdi
addq 0x8(%rbx), %rdi
movslq 0x18(%rbx), %rdx
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x81e0
movl 0x18(%rbx), %eax
addl %eax, 0x20(%rbx)
andb $-0x43, 0x25(%rbx)
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3ValueBytes
SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
  Mem *p = (Mem*)pVal;
  if( (p->flags & MEM_Blob)!=0 || sqlite3ValueText(pVal, enc) ){
    if( p->flags & MEM_Zero ){
      return p->n + p->u.nZero;
    }else{
      return p->n;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzwl 0x24(%rdi), %eax
testb $0x10, %al
jne 0xdf5f
movzbl %sil, %esi
movq %rbx, %rdi
callq 0xe05a
testq %rax, %rax
je 0xdf6d
movzwl 0x24(%rbx), %eax
btl $0xe, %eax
movl 0x20(%rbx), %eax
jae 0xdf6f
addl 0x18(%rbx), %eax
jmp 0xdf6f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeRealValue
SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem *pMem){
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );
  if( pMem->flags & MEM_Real ){
    return pMem->r;
  }else if( pMem->flags & MEM_Int ){
    return (double)pMem->u.i;
  }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
    /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
    double val = (double)0;
    sqlite3AtoF(pMem->z, &val, pMem->n, pMem->enc);
    return val;
  }else{
    /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
    return (double)0;
  }
}

// Assembly:
movzwl 0x24(%rdi), %eax
testb $0x8, %al
jne 0xdfc8
testb $0x4, %al
jne 0xdfce
testb $0x12, %al
je 0xdfd5
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x10(%rbp), %rbx
andq $0x0, (%rbx)
movq 0x8(%rdi), %rax
movl 0x20(%rdi), %edx
movzbl 0x27(%rdi), %ecx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x20fe3
movsd (%rbx), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movsd 0x10(%rdi), %xmm0
retq
cvtsi2sdq 0x18(%rdi), %xmm0
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeIntValue
SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem *pMem){
  int flags;
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );
  flags = pMem->flags;
  if( flags & MEM_Int ){
    return pMem->u.i;
  }else if( flags & MEM_Real ){
    return doubleToInt64(pMem->r);
  }else if( flags & (MEM_Str|MEM_Blob) ){
    i64 value = 0;
    assert( pMem->z || pMem->n==0 );
    testcase( pMem->z==0 );
    sqlite3Atoi64(pMem->z, &value, pMem->n, pMem->enc);
    return value;
  }else{
    return 0;
  }
}

// Assembly:
movzwl 0x24(%rdi), %eax
testb $0x4, %al
jne 0xe01e
testb $0x8, %al
jne 0xe023
testb $0x12, %al
je 0xe050
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x10(%rbp), %rbx
andq $0x0, (%rbx)
movq 0x8(%rdi), %rax
movl 0x20(%rdi), %edx
movzbl 0x27(%rdi), %ecx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x15296
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x18(%rdi), %rax
retq
movsd 0x10(%rdi), %xmm0
movapd 0x5d370(%rip), %xmm1    # 0x6b3a0
andpd %xmm0, %xmm1
ucomisd 0x5d27c(%rip), %xmm1    # 0x6b2b8
cvttsd2si %xmm0, %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmovbeq %rcx, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3ValueText
SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
  if( !pVal ) return 0;

  assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
  assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
  assert( (pVal->flags & MEM_RowSet)==0 );

  if( pVal->flags&MEM_Null ){
    return 0;
  }
  assert( (MEM_Blob>>3) == MEM_Str );
  pVal->flags |= (pVal->flags & MEM_Blob)>>3;
  ExpandBlob(pVal);
  if( pVal->flags&MEM_Str ){
    sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
    if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
      assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
      if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
        return 0;
      }
    }
    sqlite3VdbeMemNulTerminate(pVal); /* IMP: R-31275-44060 */
  }else{
    assert( (pVal->flags&MEM_Blob)==0 );
    sqlite3VdbeMemStringify(pVal, enc);
    assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
  }
  assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
              || pVal->db->mallocFailed );
  if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
    return pVal->z;
  }else{
    return 0;
  }
}

// Assembly:
testq %rdi, %rdi
je 0xe0a7
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzwl 0x24(%rdi), %ecx
testb $0x1, %cl
jne 0xe0e5
movl %esi, %r14d
movl %ecx, %eax
shrl $0x3, %eax
andl $0x2, %eax
orl %ecx, %eax
movw %ax, 0x24(%rbx)
btl $0xe, %ecx
jae 0xe095
movq %rbx, %rdi
callq 0xdec5
movzwl 0x24(%rbx), %eax
movzbl %r14b, %esi
testb $0x2, %al
jne 0xe0aa
movq %rbx, %rdi
callq 0x21a5a
jmp 0xe0d5
xorl %eax, %eax
retq
andl $-0x9, %esi
movq %rbx, %rdi
callq 0x2144b
testb $0x8, %r14b
je 0xe0cd
testb $0x1, 0x8(%rbx)
je 0xe0cd
movq %rbx, %rdi
callq 0x2199f
testl %eax, %eax
jne 0xe0e5
movq %rbx, %rdi
callq 0x21a0c
andb $-0x9, %r14b
cmpb %r14b, 0x27(%rbx)
jne 0xe0e5
movq 0x8(%rbx), %rax
jmp 0xe0e7
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeMemSetDouble
SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
  if( sqlite3IsNaN(val) ){
    sqlite3VdbeMemSetNull(pMem);
  }else{
    sqlite3VdbeMemRelease(pMem);
    pMem->r = val;
    pMem->flags = MEM_Real;
    pMem->type = SQLITE_FLOAT;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd %xmm0, -0x10(%rbp)
callq 0x1570b
testl %eax, %eax
je 0xe18b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe43c
movq %rbx, %rdi
callq 0xde44
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x10(%rbx)
movw $0x8, 0x24(%rbx)
movb $0x2, 0x26(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_result_error
SQLITE_API void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
  pCtx->isError = SQLITE_ERROR;
  pCtx->fErrorOrAux = 1;
  sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, 0x5c(%rdi)
movb $0x1, 0x61(%rdi)
addq $0x8, %rdi
movl $0x1, %ecx
movabsq $-0x1, %r8
popq %rbp
jmp 0xe1d3
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_result_error16
SQLITE_API void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
  pCtx->isError = SQLITE_ERROR;
  pCtx->fErrorOrAux = 1;
  sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, 0x5c(%rdi)
movb $0x1, 0x61(%rdi)
addq $0x8, %rdi
movl $0x2, %ecx
movabsq $-0x1, %r8
popq %rbp
jmp 0xe1d3
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeMemSetInt64
SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
  sqlite3VdbeMemRelease(pMem);
  pMem->u.i = val;
  pMem->flags = MEM_Int;
  pMem->type = SQLITE_INTEGER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xde44
movq %rbx, 0x18(%r14)
movw $0x4, 0x24(%r14)
movb $0x1, 0x26(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeMemSetNull
SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem *pMem){
  if( pMem->flags & MEM_Frame ){
    VdbeFrame *pFrame = pMem->u.pFrame;
    pFrame->pParent = pFrame->v->pDelFrame;
    pFrame->v->pDelFrame = pFrame;
  }
  if( pMem->flags & MEM_RowSet ){
    sqlite3RowSetClear(pMem->u.pRowSet);
  }
  MemSetTypeFlag(pMem, MEM_Null);
  pMem->type = SQLITE_NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzwl 0x24(%rdi), %eax
testb $0x40, %al
je 0xe466
movq 0x18(%rbx), %rcx
movq (%rcx), %rdx
movq 0xf8(%rdx), %rsi
movq %rsi, 0x8(%rcx)
movq %rcx, 0xf8(%rdx)
testb $0x20, %al
je 0xe477
movq 0x18(%rbx), %rdi
callq 0x21ae9
movzwl 0x24(%rbx), %eax
andl $0xffffbe00, %eax       # imm = 0xFFFFBE00
incl %eax
movw %ax, 0x24(%rbx)
movb $0x5, 0x26(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeMemCopy
SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
  int rc = SQLITE_OK;

  assert( (pFrom->flags & MEM_RowSet)==0 );
  VdbeMemRelease(pTo);
  memcpy(pTo, pFrom, MEMCELLSIZE);
  pTo->flags &= ~MEM_Dyn;

  if( pTo->flags&(MEM_Str|MEM_Blob) ){
    if( 0==(pFrom->flags&MEM_Static) ){
      pTo->flags |= MEM_Ephem;
      rc = sqlite3VdbeMemMakeWriteable(pTo);
    }
  }

  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x24(%rdi), %eax
testw $0x2460, %ax            # imm = 0x2460
je 0xe4ff
movq %rbx, %rdi
callq 0xf251
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movzwl 0x24(%rbx), %ecx
movl %ecx, %eax
andl $0xfbff, %eax           # imm = 0xFBFF
movw %ax, 0x24(%rbx)
testb $0x12, %cl
je 0xe548
testb $0x8, 0x25(%r14)
jne 0xe548
orl $0x1000, %eax           # imm = 0x1000
movw %ax, 0x24(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2199f
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeMemSetZeroBlob
SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
  sqlite3VdbeMemRelease(pMem);
  pMem->flags = MEM_Blob|MEM_Zero;
  pMem->type = SQLITE_BLOB;
  pMem->n = 0;
  if( n<0 ) n = 0;
  pMem->u.nZero = n;
  pMem->enc = SQLITE_UTF8;

#ifdef SQLITE_OMIT_INCRBLOB
  sqlite3VdbeMemGrow(pMem, n, 0);
  if( pMem->z ){
    pMem->n = n;
    memset(pMem->z, 0, n);
  }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0xde44
movabsq $0x104401000000000, %rax # imm = 0x104401000000000
movq %rax, 0x20(%r14)
xorl %eax, %eax
testl %ebx, %ebx
cmovgl %ebx, %eax
movl %eax, 0x18(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_result_error_code
SQLITE_API void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
  pCtx->isError = errCode;
  pCtx->fErrorOrAux = 1;
  if( pCtx->s.flags & MEM_Null ){
    sqlite3VdbeMemSetStr(&pCtx->s, sqlite3ErrStr(errCode), -1, 
                         SQLITE_UTF8, SQLITE_STATIC);
  }
}

// Assembly:
movl %esi, 0x5c(%rdi)
movb $0x1, 0x61(%rdi)
testb $0x1, 0x2c(%rdi)
jne 0xe595
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rbx
movl %esi, %edi
callq 0xe5c3
pushq $-0x1
popq %rdx
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %rax, %rsi
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe1d3
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_result_error_toobig
SQLITE_API void sqlite3_result_error_toobig(sqlite3_context *pCtx){
  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
  pCtx->isError = SQLITE_TOOBIG;
  pCtx->fErrorOrAux = 1;
  sqlite3VdbeMemSetStr(&pCtx->s, "string or blob too big", -1, 
                       SQLITE_UTF8, SQLITE_STATIC);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x12, 0x5c(%rdi)
movb $0x1, 0x61(%rdi)
addq $0x8, %rdi
leaq 0x5ce78(%rip), %rsi     # 0x6b496
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
xorl %r8d, %r8d
popq %rbp
jmp 0xe1d3
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_result_error_nomem
SQLITE_API void sqlite3_result_error_nomem(sqlite3_context *pCtx){
  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
  sqlite3VdbeMemSetNull(&pCtx->s);
  pCtx->isError = SQLITE_NOMEM;
  pCtx->fErrorOrAux = 1;
  pCtx->s.db->mallocFailed = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rdi
callq 0xe43c
movl $0x7, 0x5c(%rbx)
movb $0x1, %al
movb %al, 0x61(%rbx)
movq 0x8(%rbx), %rcx
movb %al, 0x50(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3DbStrDup
SQLITE_PRIVATE char *sqlite3DbStrDup(sqlite3 *db, const char *z){
  char *zNew;
  size_t n;
  if( z==0 ){
    return 0;
  }
  n = sqlite3Strlen30(z) + 1;
  assert( (n&0x7fffffff)==n );
  zNew = sqlite3DbMallocRaw(db, (int)n);
  if( zNew ){
    memcpy(zNew, z, n);
  }
  return zNew;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xf1be
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x8f8e
movl %eax, %r14d
incl %r14d
movq %r15, %rdi
movl %r14d, %esi
callq 0x103b4
testq %rax, %rax
je 0xf1be
movl %r14d, %edx
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x82c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_aggregate_context
SQLITE_API void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
  Mem *pMem;
  assert( p && p->pFunc && p->pFunc->xStep );
  assert( sqlite3_mutex_held(p->s.db->mutex) );
  pMem = p->pMem;
  testcase( nByte<0 );
  if( (pMem->flags & MEM_Agg)==0 ){
    if( nByte<=0 ){
      sqlite3VdbeMemReleaseExternal(pMem);
      pMem->flags = MEM_Null;
      pMem->z = 0;
    }else{
      sqlite3VdbeMemGrow(pMem, nByte, 0);
      pMem->flags = MEM_Agg;
      pMem->u.pDef = p->pFunc;
      if( pMem->z ){
        memset(pMem->z, 0, nByte);
      }
    }
  }
  return (void*)pMem->z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x40(%rdi), %rbx
testb $0x20, 0x25(%rbx)
jne 0xf242
movl %esi, %r14d
testl %esi, %esi
jle 0xf22f
movq %rdi, %r15
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0xf2c6
movw $0x2000, 0x24(%rbx)     # imm = 0x2000
movq (%r15), %rax
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xf242
movl %r14d, %edx
xorl %esi, %esi
callq 0x81e0
jmp 0xf242
movq %rbx, %rdi
callq 0xf251
movw $0x1, 0x24(%rbx)
andq $0x0, 0x8(%rbx)
movq 0x8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeMemReleaseExternal
SQLITE_PRIVATE void sqlite3VdbeMemReleaseExternal(Mem *p){
  assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
  if( p->flags&MEM_Agg ){
    sqlite3VdbeMemFinalize(p, p->u.pDef);
    assert( (p->flags & MEM_Agg)==0 );
    sqlite3VdbeMemRelease(p);
  }else if( p->flags&MEM_Dyn && p->xDel ){
    assert( (p->flags&MEM_RowSet)==0 );
    assert( p->xDel!=SQLITE_DYNAMIC );
    p->xDel((void *)p->z);
    p->xDel = 0;
  }else if( p->flags&MEM_RowSet ){
    sqlite3RowSetClear(p->u.pRowSet);
  }else if( p->flags&MEM_Frame ){
    sqlite3VdbeMemSetNull(p);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzwl 0x24(%rdi), %eax
btl $0xd, %eax
jb 0xf280
btl $0xa, %eax
jae 0xf29a
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
je 0xf29a
movq 0x8(%rbx), %rdi
callq *%rcx
andq $0x0, 0x28(%rbx)
jmp 0xf2a2
movq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0x2b826
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xde44
testb $0x20, %al
jne 0xf2a9
testb $0x40, %al
jne 0xf2b8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21ae9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe43c
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeMemGrow
SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve){
  assert( 1 >=
    ((pMem->zMalloc && pMem->zMalloc==pMem->z) ? 1 : 0) +
    (((pMem->flags&MEM_Dyn)&&pMem->xDel) ? 1 : 0) + 
    ((pMem->flags&MEM_Ephem) ? 1 : 0) + 
    ((pMem->flags&MEM_Static) ? 1 : 0)
  );
  assert( (pMem->flags&MEM_RowSet)==0 );

  /* If the preserve flag is set to true, then the memory cell must already
  ** contain a valid string or blob value.  */
  assert( preserve==0 || pMem->flags&(MEM_Blob|MEM_Str) );

  if( n<32 ) n = 32;
  if( sqlite3DbMallocSize(pMem->db, pMem->zMalloc)<n ){
    if( preserve && pMem->z==pMem->zMalloc ){
      pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
      preserve = 0;
    }else{
      sqlite3DbFree(pMem->db, pMem->zMalloc);
      pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n);
    }
  }

  if( pMem->z && preserve && pMem->zMalloc && pMem->z!=pMem->zMalloc ){
    memcpy(pMem->zMalloc, pMem->z, pMem->n);
  }
  if( pMem->flags&MEM_Dyn && pMem->xDel ){
    assert( pMem->xDel!=SQLITE_DYNAMIC );
    pMem->xDel((void *)(pMem->z));
  }

  pMem->z = pMem->zMalloc;
  if( pMem->z==0 ){
    pMem->flags = MEM_Null;
  }else{
    pMem->flags &= ~(MEM_Ephem|MEM_Static);
  }
  pMem->xDel = 0;
  return (pMem->z ? SQLITE_OK : SQLITE_NOMEM);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rdi, %rbx
cmpl $0x21, %esi
pushq $0x20
popq %r15
cmovgel %esi, %r15d
movq (%rdi), %rdi
movq 0x30(%rbx), %rsi
callq 0x155aa
cmpl %r15d, %eax
jge 0xf336
movq 0x30(%rbx), %rsi
testl %r14d, %r14d
je 0xf304
movq 0x8(%rbx), %rax
cmpq %rsi, %rax
je 0xf31d
movq (%rbx), %rdi
callq 0x968b
movq (%rbx), %rdi
movl %r15d, %esi
callq 0x103b4
movq %rax, 0x30(%rbx)
jmp 0xf336
movq (%rbx), %rdi
movq %rax, %rsi
movl %r15d, %edx
callq 0x2eac1
movq %rax, 0x30(%rbx)
movq %rax, 0x8(%rbx)
xorl %r14d, %r14d
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
sete %al
testl %r14d, %r14d
sete %cl
orb %al, %cl
jne 0xf367
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
sete %al
cmpq %rdi, %rsi
sete %cl
orb %al, %cl
jne 0xf367
movslq 0x20(%rbx), %rdx
callq 0x82c0
testb $0x4, 0x25(%rbx)
je 0xf37c
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0xf37c
movq 0x8(%rbx), %rdi
callq *%rax
movq 0x30(%rbx), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xf397
movzwl 0x24(%rbx), %ecx
andl $0xe7ff, %ecx           # imm = 0xE7FF
xorl %eax, %eax
jmp 0xf39e
movw $0x1, %cx
pushq $0x7
popq %rax
movw %cx, 0x24(%rbx)
andq $0x0, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_get_auxdata
SQLITE_API void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
  AuxData *pAuxData;

  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
  for(pAuxData=pCtx->pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNext){
    if( pAuxData->iOp==pCtx->iOp && pAuxData->iArg==iArg ) break;
  }

  return (pAuxData ? pAuxData->pAux : 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x120, %ecx            # imm = 0x120
addq 0x50(%rdi), %rcx
xorl %eax, %eax
movq (%rcx), %rcx
testq %rcx, %rcx
je 0xf3df
movl (%rcx), %edx
cmpl 0x58(%rdi), %edx
jne 0xf3d5
cmpl %esi, 0x4(%rcx)
je 0xf3db
addq $0x18, %rcx
jmp 0xf3c1
movq 0x8(%rcx), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_set_auxdata
SQLITE_API void sqlite3_set_auxdata(
  sqlite3_context *pCtx, 
  int iArg, 
  void *pAux, 
  void (*xDelete)(void*)
){
  AuxData *pAuxData;
  Vdbe *pVdbe = pCtx->pVdbe;

  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
  if( iArg<0 ) goto failed;

  for(pAuxData=pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNext){
    if( pAuxData->iOp==pCtx->iOp && pAuxData->iArg==iArg ) break;
  }
  if( pAuxData==0 ){
    pAuxData = sqlite3DbMallocZero(pVdbe->db, sizeof(AuxData));
    if( !pAuxData ) goto failed;
    pAuxData->iOp = pCtx->iOp;
    pAuxData->iArg = iArg;
    pAuxData->pNext = pVdbe->pAuxData;
    pVdbe->pAuxData = pAuxData;
    if( pCtx->fErrorOrAux==0 ){
      pCtx->isError = 0;
      pCtx->fErrorOrAux = 1;
    }
  }else if( pAuxData->xDelete ){
    pAuxData->xDelete(pAuxData->pAux);
  }

  pAuxData->pAux = pAux;
  pAuxData->xDelete = xDelete;
  return;

failed:
  if( xDelete ){
    xDelete(pAux);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
testl %esi, %esi
js 0xf46a
movl %esi, %r12d
movq %rdi, %r15
movq 0x50(%rdi), %rax
leaq 0x120(%rax), %r13
movq %r13, %r14
movq (%r14), %r14
testq %r14, %r14
je 0xf427
movl (%r14), %edx
cmpl 0x58(%r15), %edx
jne 0xf421
cmpl %r12d, 0x4(%r14)
je 0xf482
addq $0x18, %r14
jmp 0xf40a
movq (%rax), %rdi
pushq $0x20
popq %rsi
movq %rcx, %r14
callq 0xf4ae
movq %r14, %rcx
testq %rax, %rax
je 0xf46a
movq %rax, %r14
movl 0x58(%r15), %eax
movl %eax, (%r14)
movl %r12d, 0x4(%r14)
movq (%r13), %rax
movq %rax, 0x18(%r14)
movq %r14, (%r13)
cmpb $0x0, 0x61(%r15)
jne 0xf497
andl $0x0, 0x5c(%r15)
movb $0x1, 0x61(%r15)
jmp 0xf497
testq %rcx, %rcx
je 0xf49f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rcx
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xf497
movq 0x8(%r14), %rdi
movq %rcx, %r15
callq *%rax
movq %r15, %rcx
movq %rbx, 0x8(%r14)
movq %rcx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3DbMallocZero
SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3 *db, int n){
  void *p = sqlite3DbMallocRaw(db, n);
  if( p ){
    memset(p, 0, n);
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
callq 0x103b4
testq %rax, %rax
je 0xf4d3
movslq %ebx, %rdx
movq %rax, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x81e0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_column_blob
SQLITE_API const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
  const void *val;
  val = sqlite3_value_blob( columnMem(pStmt,i) );
  /* Even though there is no encoding conversion, value_blob() might
  ** need to call malloc() to expand the result of a zeroblob() 
  ** expression. 
  */
  columnMallocFailure(pStmt);
  return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xf53c
movq %rax, %rdi
callq 0xde7e
movq %rax, %r14
movq %rbx, %rdi
callq 0xf58b
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq