LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: checkPtrmap
static void checkPtrmap(
  IntegrityCk *pCheck,   /* Integrity check context */
  Pgno iChild,           /* Child page number */
  u8 eType,              /* Expected pointer map type */
  Pgno iParent,          /* Expected pointer map parent page number */
  char *zContext         /* Context description (used for error msg) */
){
  int rc;
  u8 ePtrmapType;
  Pgno iPtrmapParent;

  rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent);
  if( rc!=SQLITE_OK ){
    if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ) pCheck->mallocFailed = 1;
    checkAppendMsg(pCheck, zContext, "Failed to read ptrmap key=%d", iChild);
    return;
  }

  if( ePtrmapType!=eType || iPtrmapParent!=iParent ){
    checkAppendMsg(pCheck, zContext, 
      "Bad ptr map entry key=%d expected=(%d,%d) got=(%d,%d)", 
      iChild, eType, iParent, ePtrmapType, iPtrmapParent);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %ecx, %r12d
movl %edx, %r13d
movl %esi, %ebx
movq %rdi, %r15
movq (%rdi), %rdi
leaq -0x29(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x21d4e
testl %eax, %eax
je 0x345e1
cmpl $0xc0a, %eax            # imm = 0xC0A
je 0x345b4
cmpl $0x7, %eax
jne 0x345bc
movl $0x1, 0x24(%r15)
leaq 0x45c06(%rip), %rdx     # 0x7a1c9
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x34ce9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl -0x29(%rbp), %r10d
cmpb %r13b, %r10b
sete %al
movl -0x30(%rbp), %r11d
cmpl %r12d, %r11d
sete %cl
testb %cl, %al
jne 0x345d2
movzbl %r13b, %r8d
leaq 0x45be1(%rip), %rdx     # 0x7a1e6
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %ecx
movl %r12d, %r9d
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x34ce9
addq $0x10, %rsp
jmp 0x345d2
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: checkAppendMsg
static void checkAppendMsg(
  IntegrityCk *pCheck,
  char *zMsg1,
  const char *zFormat,
  ...
){
  va_list ap;
  if( !pCheck->mxErr ) return;
  pCheck->mxErr--;
  pCheck->nErr++;
  va_start(ap, zFormat);
  if( pCheck->errMsg.nChar ){
    sqlite3StrAccumAppend(&pCheck->errMsg, "\n", 1);
  }
  if( zMsg1 ){
    sqlite3StrAccumAppend(&pCheck->errMsg, zMsg1, -1);
  }
  sqlite3VXPrintf(&pCheck->errMsg, 1, zFormat, ap);
  va_end(ap);
  if( pCheck->errMsg.accError==STRACCUM_NOMEM ){
    pCheck->mallocFailed = 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rcx, -0xd8(%rbp)
movq %r8, -0xd0(%rbp)
movq %r9, -0xc8(%rbp)
testb %al, %al
je 0x34d40
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movl 0x1c(%rdi), %eax
testl %eax, %eax
je 0x34dd1
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
decl %eax
movl %eax, 0x1c(%rdi)
incl 0x20(%rdi)
leaq -0xf0(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, -0x40(%rbp)
leaq 0x28(%rdi), %r12
cmpl $0x0, 0x40(%rdi)
je 0x34d9b
leaq 0x495d1(%rip), %rsi     # 0x7e35f
movq %r12, %rdi
movl $0x1, %edx
callq 0x172ee
testq %r15, %r15
je 0x34db0
movq %r12, %rdi
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x172ee
leaq -0x40(%rbp), %rcx
movq %r12, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0xa5a5
cmpb $0x1, 0x4d(%rbx)
jne 0x34dd1
movl $0x1, 0x24(%rbx)
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: checkRef
static int checkRef(IntegrityCk *pCheck, Pgno iPage, char *zContext){
  if( iPage==0 ) return 1;
  if( iPage>pCheck->nPage ){
    checkAppendMsg(pCheck, zContext, "invalid page number %d", iPage);
    return 1;
  }
  if( getPageReferenced(pCheck, iPage) ){
    checkAppendMsg(pCheck, zContext, "2nd reference to page %d", iPage);
    return 1;
  }
  setPageReferenced(pCheck, iPage);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0x1, %ebx
testl %esi, %esi
je 0x34e3f
movl %esi, %eax
cmpl %esi, 0x18(%rdi)
jae 0x34e00
leaq 0x4539b(%rip), %rcx     # 0x7a199
jmp 0x34e30
movq 0x10(%rdi), %rsi
movl %eax, %r8d
shrl $0x3, %r8d
movzbl (%rsi,%r8), %r9d
movl %eax, %ecx
andb $0x7, %cl
movl $0x1, %r10d
shll %cl, %r10d
movl %eax, %ecx
andl $0x7, %ecx
btl %ecx, %r9d
jae 0x34e48
leaq 0x45380(%rip), %rcx     # 0x7a1b0
movq %rdx, %rsi
movq %rcx, %rdx
movl %eax, %ecx
xorl %eax, %eax
callq 0x34ce9
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
orb %r9b, %r10b
movb %r10b, (%rsi,%r8)
xorl %ebx, %ebx
jmp 0x34e3f
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: rowSetEntryAlloc
static struct RowSetEntry *rowSetEntryAlloc(RowSet *p){
  assert( p!=0 );
  if( p->nFresh==0 ){
    struct RowSetChunk *pNew;
    pNew = sqlite3DbMallocRaw(p->db, sizeof(*pNew));
    if( pNew==0 ){
      return 0;
    }
    pNew->pNextChunk = p->pChunk;
    p->pChunk = pNew;
    p->pFresh = pNew->aEntry;
    p->nFresh = ROWSET_ENTRY_PER_CHUNK;
  }
  p->nFresh--;
  return p->pFresh++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpw $0x0, 0x30(%rdi)
jne 0x34e8d
movq 0x8(%rbx), %rdi
movl $0x3f8, %esi            # imm = 0x3F8
callq 0x115e9
testq %rax, %rax
je 0x34ea4
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rax, (%rbx)
addq $0x8, %rax
movq %rax, 0x20(%rbx)
movw $0x2a, 0x30(%rbx)
decw 0x30(%rbx)
movq 0x20(%rbx), %rax
leaq 0x18(%rax), %rcx
movq %rcx, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x34e9d
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: rowSetEntrySort
static struct RowSetEntry *rowSetEntrySort(struct RowSetEntry *pIn){
  unsigned int i;
  struct RowSetEntry *pNext, *aBucket[40];

  memset(aBucket, 0, sizeof(aBucket));
  while( pIn ){
    pNext = pIn->pRight;
    pIn->pRight = 0;
    for(i=0; aBucket[i]; i++){
      pIn = rowSetEntryMerge(aBucket[i], pIn);
      aBucket[i] = 0;
    }
    aBucket[i] = pIn;
    pIn = pNext;
  }
  pIn = 0;
  for(i=0; i<sizeof(aBucket)/sizeof(aBucket[0]); i++){
    pIn = rowSetEntryMerge(pIn, aBucket[i]);
  }
  return pIn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdi, %r14
leaq -0x170(%rbp), %rbx
movl $0x140, %edx            # imm = 0x140
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8200
testq %r14, %r14
je 0x34f39
movq 0x8(%r14), %r15
movq $0x0, 0x8(%r14)
movq -0x170(%rbp), %rdi
testq %rdi, %rdi
je 0x34f2a
movl $0x1, %r12d
movq %rbx, %r13
movq %r14, %rsi
callq 0x34f68
movq %rax, %r14
movq $0x0, (%r13)
movl %r12d, %eax
leaq -0x170(,%rax,8), %r13
addq %rbp, %r13
movq (%r13), %rdi
incl %r12d
testq %rdi, %rdi
jne 0x34efb
jmp 0x34f2d
movq %rbx, %r13
movq %r14, (%r13)
movq %r15, %r14
testq %r15, %r15
jne 0x34eda
xorl %ebx, %ebx
xorl %eax, %eax
movq -0x170(%rbp,%rbx,8), %rsi
movq %rax, %rdi
callq 0x34f68
incq %rbx
cmpq $0x28, %rbx
jne 0x34f3d
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: rowSetEntryMerge
static struct RowSetEntry *rowSetEntryMerge(
  struct RowSetEntry *pA,    /* First sorted list to be merged */
  struct RowSetEntry *pB     /* Second sorted list to be merged */
){
  struct RowSetEntry head;
  struct RowSetEntry *pTail;

  pTail = &head;
  while( pA && pB ){
    assert( pA->pRight==0 || pA->v<=pA->pRight->v );
    assert( pB->pRight==0 || pB->v<=pB->pRight->v );
    if( pA->v<pB->v ){
      pTail->pRight = pA;
      pA = pA->pRight;
      pTail = pTail->pRight;
    }else if( pB->v<pA->v ){
      pTail->pRight = pB;
      pB = pB->pRight;
      pTail = pTail->pRight;
    }else{
      pA = pA->pRight;
    }
  }
  if( pA ){
    assert( pA->pRight==0 || pA->v<=pA->pRight->v );
    pTail->pRight = pA;
  }else{
    assert( pB==0 || pB->pRight==0 || pB->v<=pB->pRight->v );
    pTail->pRight = pB;
  }
  return head.pRight;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
setne %cl
sete %al
testq %rsi, %rsi
sete %dl
orb %al, %dl
jne 0x34fd2
leaq -0x18(%rbp), %rax
movq %rsi, %rdx
movq %rdi, %r8
movq (%r8), %rcx
movq (%rdx), %rsi
cmpq %rsi, %rcx
jge 0x34fa4
movq %r8, 0x8(%rax)
movq 0x8(%r8), %rdi
movq %rdx, %rsi
movq %r8, %rax
jmp 0x34fbd
jle 0x34fb6
movq %rdx, 0x8(%rax)
movq 0x8(%rdx), %rsi
movq %r8, %rdi
movq %rdx, %rax
jmp 0x34fbd
movq 0x8(%r8), %rdi
movq %rdx, %rsi
testq %rdi, %rdi
setne %cl
je 0x34fd6
movq %rsi, %rdx
movq %rdi, %r8
testq %rsi, %rsi
jne 0x34f89
jmp 0x34fd6
leaq -0x18(%rbp), %rax
testb %cl, %cl
cmoveq %rsi, %rdi
movq %rdi, 0x8(%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: rowSetListToTree
static struct RowSetEntry *rowSetListToTree(struct RowSetEntry *pList){
  int iDepth;           /* Depth of the tree so far */
  struct RowSetEntry *p;       /* Current tree root */
  struct RowSetEntry *pLeft;   /* Left subtree */

  assert( pList!=0 );
  p = pList;
  pList = p->pRight;
  p->pLeft = p->pRight = 0;
  for(iDepth=1; pList; iDepth++){
    pLeft = p;
    p = pList;
    pList = p->pRight;
    p->pLeft = pLeft;
    p->pRight = rowSetNDeepTree(&pList, iDepth);
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, -0x20(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
testq %rax, %rax
je 0x3503e
movl $0x1, %ebx
leaq -0x20(%rbp), %r14
movq %rax, %r15
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq %rdi, 0x10(%r15)
movq %r14, %rdi
movl %ebx, %esi
callq 0x3509c
movq %rax, 0x8(%r15)
incl %ebx
movq -0x20(%rbp), %rax
movq %r15, %rdi
testq %rax, %rax
jne 0x35011
jmp 0x35041
movq %rdi, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: rowSetTreeToList
static void rowSetTreeToList(
  struct RowSetEntry *pIn,         /* Root of the input tree */
  struct RowSetEntry **ppFirst,    /* Write head of the output list here */
  struct RowSetEntry **ppLast      /* Write tail of the output list here */
){
  assert( pIn!=0 );
  if( pIn->pLeft ){
    struct RowSetEntry *p;
    rowSetTreeToList(pIn->pLeft, ppFirst, &p);
    p->pRight = pIn;
  }else{
    *ppFirst = pIn;
  }
  if( pIn->pRight ){
    rowSetTreeToList(pIn->pRight, &pIn->pRight, ppLast);
  }else{
    *ppLast = pIn;
  }
  assert( (*ppLast)->pRight==0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
leaq -0x20(%rbp), %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x3507e
movq %r14, %rdx
callq 0x3504f
movq -0x20(%rbp), %rax
movq %r15, 0x8(%rax)
jmp 0x35081
movq %r15, (%rsi)
leaq 0x8(%r15), %rsi
movq 0x8(%r15), %rdi
testq %rdi, %rdi
jne 0x35060
movq %r15, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: rowSetNDeepTree
static struct RowSetEntry *rowSetNDeepTree(
  struct RowSetEntry **ppList,
  int iDepth
){
  struct RowSetEntry *p;         /* Root of the new tree */
  struct RowSetEntry *pLeft;     /* Left subtree */
  if( *ppList==0 ){
    return 0;
  }
  if( iDepth==1 ){
    p = *ppList;
    *ppList = p->pRight;
    p->pLeft = p->pRight = 0;
    return p;
  }
  pLeft = rowSetNDeepTree(ppList, iDepth-1);
  p = *ppList;
  if( p==0 ){
    return pLeft;
  }
  p->pLeft = pLeft;
  *ppList = p->pRight;
  p->pRight = rowSetNDeepTree(ppList, iDepth-1);
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x350c9
movl %esi, %r15d
movq %rdi, %r14
cmpl $0x1, %esi
jne 0x350cd
movq 0x8(%rbx), %rax
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0x35102
xorl %ebx, %ebx
jmp 0x35102
decl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x3509c
movq (%r14), %rbx
testq %rbx, %rbx
je 0x350ff
movq %rax, 0x10(%rbx)
movq 0x8(%rbx), %rax
movq %rax, (%r14)
movq %r14, %rdi
movl %r15d, %esi
callq 0x3509c
movq %rax, 0x8(%rbx)
jmp 0x35102
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: execSql
static int execSql(sqlite3 *db, char **pzErrMsg, const char *zSql){
  sqlite3_stmt *pStmt;
  VVA_ONLY( int rc; )
  if( !zSql ){
    return SQLITE_NOMEM;
  }
  if( SQLITE_OK!=sqlite3_prepare(db, zSql, -1, &pStmt, 0) ){
    sqlite3SetString(pzErrMsg, db, sqlite3_errmsg(db));
    return sqlite3_errcode(db);
  }
  VVA_ONLY( rc = ) sqlite3_step(pStmt);
  assert( rc!=SQLITE_ROW || (db->flags&SQLITE_CountRows) );
  return vacuumFinalize(db, pStmt, pzErrMsg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdx, %rdx
je 0x35174
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, (%rsp)
leaq -0x20(%rbp), %r9
movq %rdx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x12dde
testl %eax, %eax
je 0x35184
movq %rbx, %rdi
callq 0x12bfd
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x24616
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x12ba4
movl $0x7, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0xf4d2
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x353cd
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3BtreeCommit
SQLITE_PRIVATE int sqlite3BtreeCommit(Btree *p){
  int rc;
  sqlite3BtreeEnter(p);
  rc = sqlite3BtreeCommitPhaseOne(p, 0);
  if( rc==SQLITE_OK ){
    rc = sqlite3BtreeCommitPhaseTwo(p, 0);
  }
  sqlite3BtreeLeave(p);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rax, 0x8(%rcx)
xorl %esi, %esi
callq 0xe383
testl %eax, %eax
je 0x351ce
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe2d0
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3BtreeSetAutoVacuum
SQLITE_PRIVATE int sqlite3BtreeSetAutoVacuum(Btree *p, int autoVacuum){
#ifdef SQLITE_OMIT_AUTOVACUUM
  return SQLITE_READONLY;
#else
  BtShared *pBt = p->pBt;
  int rc = SQLITE_OK;
  u8 av = (u8)autoVacuum;

  sqlite3BtreeEnter(p);
  if( (pBt->btsFlags & BTS_PAGESIZE_FIXED)!=0 && (av ?1:0)!=pBt->autoVacuum ){
    rc = SQLITE_READONLY;
  }else{
    pBt->autoVacuum = av ?1:0;
    pBt->incrVacuum = av==2 ?1:0;
  }
  sqlite3BtreeLeave(p);
  return rc;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rax, 0x8(%rcx)
testb $0x2, 0x26(%rcx)
je 0x35203
testb %sil, %sil
setne %dl
movl $0x8, %eax
cmpb %dl, 0x21(%rcx)
jne 0x35216
movzbl %sil, %eax
testl %eax, %eax
setne 0x21(%rcx)
cmpl $0x2, %eax
sete 0x22(%rcx)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: execExecSql
static int execExecSql(sqlite3 *db, char **pzErrMsg, const char *zSql){
  sqlite3_stmt *pStmt;
  int rc;

  rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
  if( rc!=SQLITE_OK ) return rc;

  while( SQLITE_ROW==sqlite3_step(pStmt) ){
    rc = execSql(db, pzErrMsg, (char*)sqlite3_column_text(pStmt, 0));
    if( rc!=SQLITE_OK ){
      vacuumFinalize(db, pStmt, pzErrMsg);
      return rc;
    }
  }

  return vacuumFinalize(db, pStmt, pzErrMsg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq $0x0, (%rsp)
leaq -0x28(%rbp), %r9
movq %rdx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x12dde
movl %eax, %r12d
testl %eax, %eax
jne 0x35291
movq -0x28(%rbp), %r15
movq %r15, %rdi
callq 0xf4d2
cmpl $0x64, %eax
jne 0x352a1
movq %r15, %rdi
xorl %esi, %esi
callq 0x10690
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x35110
testl %eax, %eax
je 0x35256
movl %eax, %r12d
movq -0x28(%rbp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x353cd
movl %r12d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x353cd
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: vacuumFinalize
static int vacuumFinalize(sqlite3 *db, sqlite3_stmt *pStmt, char **pzErrMsg){
  int rc;
  rc = sqlite3VdbeFinalize((Vdbe*)pStmt);
  if( rc ){
    sqlite3SetString(pzErrMsg, db, sqlite3_errmsg(db));
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0xe9e9
movl %eax, %ebx
testl %eax, %eax
je 0x35403
movq %r15, %rdi
callq 0x12bfd
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x24616
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: growVTrans
static int growVTrans(sqlite3 *db){
  const int ARRAY_INCR = 5;

  /* Grow the sqlite3.aVTrans array if required */
  if( (db->nVTrans%ARRAY_INCR)==0 ){
    VTable **aVTrans;
    int nBytes = sizeof(sqlite3_vtab *) * (db->nVTrans + ARRAY_INCR);
    aVTrans = sqlite3DbRealloc(db, (void *)db->aVTrans, nBytes);
    if( !aVTrans ){
      return SQLITE_NOMEM;
    }
    memset(&aVTrans[db->nVTrans], 0, sizeof(sqlite3_vtab *)*ARRAY_INCR);
    db->aVTrans = aVTrans;
  }

  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x1a4(%rdi), %eax
imull $0xcccccccd, %eax, %ecx # imm = 0xCCCCCCCD
addl $0x19999999, %ecx       # imm = 0x19999999
xorl %ebx, %ebx
cmpl $0x33333332, %ecx       # imm = 0x33333332
ja 0x35478
movq %rdi, %r14
leal 0x28(,%rax,8), %edx
movq 0x1c8(%rdi), %rsi
callq 0x174d4
testq %rax, %rax
je 0x35473
movslq 0x1a4(%r14), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax,%rcx,8)
movups %xmm0, (%rax,%rcx,8)
movq $0x0, 0x20(%rax,%rcx,8)
movq %rax, 0x1c8(%r14)
jmp 0x35478
movl $0x7, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: growOpArray
static int growOpArray(Vdbe *p){
  VdbeOp *pNew;
  int nNew = (p->nOpAlloc ? p->nOpAlloc*2 : (int)(1024/sizeof(Op)));
  pNew = sqlite3DbRealloc(p->db, p->aOp, nNew*sizeof(Op));
  if( pNew ){
    p->nOpAlloc = sqlite3DbMallocSize(p->db, pNew)/sizeof(Op);
    p->aOp = pNew;
  }
  return (pNew ? SQLITE_OK : SQLITE_NOMEM);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x38(%rdi), %eax
movl %eax, %ecx
shll $0x4, %ecx
testl %eax, %eax
leal (%rcx,%rcx,2), %eax
movl $0x3f0, %edx            # imm = 0x3F0
cmovnel %eax, %edx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
callq 0x174d4
testq %rax, %rax
je 0x35fc3
movq %rax, %r14
movq (%rbx), %rax
testq %rax, %rax
je 0x35f9c
cmpq %r14, 0x170(%rax)
ja 0x35f9c
cmpq %r14, 0x178(%rax)
jbe 0x35f9c
movzwl 0x150(%rax), %eax
jmp 0x35fa5
movq %r14, %rdi
callq *0x5e493(%rip)          # 0x94438
cltq
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq $0x4, %rdx
movl %edx, 0x38(%rbx)
movq %r14, 0x8(%rbx)
xorl %eax, %eax
jmp 0x35fc8
movl $0x7, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3KeyInfoAlloc
SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N){
  KeyInfo *p = sqlite3DbMallocZero(db, 
                   sizeof(KeyInfo) + (N+1)*(sizeof(CollSeq*)+1));
  if( p ){
    p->aSortOrder = (u8*)&p->aColl[N+1];
    p->nField = (u16)N;
    p->enc = ENC(db);
    p->db = db;
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leal (%r14,%r14,8), %r12d
addl $0x29, %r12d
movl %r12d, %esi
callq 0x115e9
movq %rax, %r15
testq %rax, %rax
je 0x36030
leal 0x1(%r14), %r13d
movslq %r12d, %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x8200
movslq %r13d, %rax
leaq (%r15,%rax,8), %rax
addq $0x18, %rax
movq %rax, 0x10(%r15)
movw %r14w, 0xa(%r15)
movq 0x20(%rbx), %rax
movq 0x18(%rax), %rax
movb 0x71(%rax), %al
movb %al, 0x8(%r15)
movq %rbx, (%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3ReadSchema
SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse){
  int rc = SQLITE_OK;
  sqlite3 *db = pParse->db;
  assert( sqlite3_mutex_held(db->mutex) );
  if( !db->init.busy ){
    rc = sqlite3Init(db, &pParse->zErrMsg);
  }
  if( rc!=SQLITE_OK ){
    pParse->rc = rc;
    pParse->nErr++;
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
xorl %eax, %eax
cmpb $0x0, 0x99(%rdi)
jne 0x36195
leaq 0x8(%rbx), %rsi
callq 0x361a6
testl %eax, %eax
je 0x3619f
movl %eax, 0x18(%rbx)
incl 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3Init
SQLITE_PRIVATE int sqlite3Init(sqlite3 *db, char **pzErrMsg){
  int i, rc;
  int commit_internal = !(db->flags&SQLITE_InternChanges);
  
  assert( sqlite3_mutex_held(db->mutex) );
  rc = SQLITE_OK;
  db->init.busy = 1;
  for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
    if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue;
    rc = sqlite3InitOne(db, i, pzErrMsg);
    if( rc ){
      sqlite3ResetOneSchema(db, i);
    }
  }

  /* Once all the other databases have been initialized, load the schema
  ** for the TEMP database. This is loaded last, as the TEMP database
  ** schema may contain references to objects in other databases.
  */
#ifndef SQLITE_OMIT_TEMPDB
  if( rc==SQLITE_OK && ALWAYS(db->nDb>1)
                    && !DbHasProperty(db, 1, DB_SchemaLoaded) ){
    rc = sqlite3InitOne(db, 1, pzErrMsg);
    if( rc ){
      sqlite3ResetOneSchema(db, 1);
    }
  }
#endif

  db->init.busy = 0;
  if( rc==SQLITE_OK && commit_internal ){
    sqlite3CommitInternalChanges(db);
  }

  return rc; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
movl 0x2c(%rdi), %eax
movl %eax, -0x2c(%rbp)
movb $0x1, 0x99(%rdi)
movl $0x18, %r14d
xorl %r12d, %r12d
movslq 0x28(%rbx), %rax
cmpq %rax, %r12
jge 0x36229
movq 0x20(%rbx), %rax
movq (%rax,%r14), %rax
cmpq $0x1, %r12
sete %cl
orb 0x72(%rax), %cl
xorl %r15d, %r15d
testb $0x1, %cl
jne 0x3621b
movq %rbx, %rdi
movl %r12d, %esi
movq -0x38(%rbp), %rdx
callq 0x3628f
testl %eax, %eax
je 0x3621b
movl %eax, %r13d
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2c895
movl %r13d, %r15d
incq %r12
addq $0x20, %r14
testl %r15d, %r15d
je 0x361d4
jmp 0x36267
xorl %r15d, %r15d
cmpl $0x2, %eax
jl 0x36267
movq 0x20(%rbx), %rax
movq 0x38(%rax), %rax
testb $0x1, 0x72(%rax)
jne 0x36267
movq %rbx, %rdi
movl $0x1, %esi
movq -0x38(%rbp), %rdx
callq 0x3628f
testl %eax, %eax
je 0x36267
movl %eax, %r14d
movq 0x20(%rbx), %rax
movq 0x38(%rax), %rdi
callq 0x30334
movl %r14d, %r15d
movl -0x2c(%rbp), %eax
andl $0x2, %eax
movb $0x0, 0x99(%rbx)
orl %r15d, %eax
jne 0x3627d
andb $-0x3, 0x2c(%rbx)
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3BtreeSetCacheSize
SQLITE_PRIVATE int sqlite3BtreeSetCacheSize(Btree *p, int mxPage){
  BtShared *pBt = p->pBt;
  assert( sqlite3_mutex_held(p->db->mutex) );
  sqlite3BtreeEnter(p);
  sqlite3PagerSetCachesize(pBt->pPager, mxPage);
  sqlite3BtreeLeave(p);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq (%rcx), %rax
movq 0x110(%rax), %rdx
movl %esi, 0x1c(%rdx)
movq 0x40(%rdx), %rdi
testq %rdi, %rdi
je 0x3668c
movq 0x5de68(%rip), %rcx     # 0x944d0
testl %esi, %esi
jns 0x36689
movslq %esi, %rax
shlq $0xa, %rax
negq %rax
movslq 0x20(%rdx), %rsi
movslq 0x24(%rdx), %r8
addq %rsi, %r8
cqto
idivq %r8
movq %rax, %rsi
popq %rbp
jmpq *%rcx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VtabUnlockList
SQLITE_PRIVATE void sqlite3VtabUnlockList(sqlite3 *db){
  VTable *p = db->pDisconnect;
  db->pDisconnect = 0;

  assert( sqlite3BtreeHoldsAllMutexes(db) );
  assert( sqlite3_mutex_held(db->mutex) );

  if( p ){
    sqlite3ExpirePreparedStatements(db);
    do {
      VTable *pNext = p->pNext;
      sqlite3VtabUnlock(p);
      p = pNext;
    }while( p );
  }
}

// Assembly:
movq %rdi, %rax
movq 0x1d0(%rdi), %rdi
movq $0x0, 0x1d0(%rax)
testq %rdi, %rdi
je 0x366db
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x366c4
orb $0x20, 0x9a(%rax)
movq 0x68(%rax), %rax
jmp 0x366b2
movq 0x28(%rdi), %rbx
callq 0x23229
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x366c4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3CollapseDatabaseArray
SQLITE_PRIVATE void sqlite3CollapseDatabaseArray(sqlite3 *db){
  int i, j;
  for(i=j=2; i<db->nDb; i++){
    struct Db *pDb = &db->aDb[i];
    if( pDb->pBt==0 ){
      sqlite3DbFree(db, pDb->zName);
      pDb->zName = 0;
      continue;
    }
    if( j<i ){
      db->aDb[j] = db->aDb[i];
    }
    j++;
  }
  memset(&db->aDb[j], 0, (db->nDb-j)*sizeof(db->aDb[j]));
  db->nDb = j;
  if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
    memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
    sqlite3DbFree(db, db->aDb);
    db->aDb = db->aDbStatic;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x28(%rdi), %eax
movl $0x2, %r14d
cmpl $0x3, %eax
jl 0x3675f
movl $0x2, %r15d
movl $0x40, %r12d
movq 0x20(%rbx), %rax
leaq (%rax,%r12), %r13
cmpq $0x0, 0x8(%rax,%r12)
je 0x3673b
movslq %r14d, %rcx
cmpq %rcx, %r15
jle 0x36736
shlq $0x5, %rcx
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
incl %r14d
jmp 0x3674f
movq (%r13), %rsi
movq %rbx, %rdi
callq 0x9c3a
movq $0x0, (%r13)
incq %r15
movslq 0x28(%rbx), %rax
addq $0x20, %r12
cmpq %rax, %r15
jl 0x36707
movslq %r14d, %r14
movq %r14, %rdi
shlq $0x5, %rdi
addq 0x20(%rbx), %rdi
subl %r14d, %eax
movslq %eax, %rdx
shlq $0x5, %rdx
xorl %esi, %esi
callq 0x8200
movl %r14d, 0x28(%rbx)
cmpl $0x2, %r14d
jg 0x367c6
movq 0x20(%rbx), %rsi
leaq 0x2c0(%rbx), %r14
cmpq %r14, %rsi
je 0x367c6
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups 0x30(%rsi), %xmm3
movups %xmm3, 0x30(%r14)
movups %xmm2, 0x20(%r14)
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
movq %rbx, %rdi
callq 0x9c3a
movq %r14, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqliteDeleteColumnNames
static void sqliteDeleteColumnNames(sqlite3 *db, Table *pTable){
  int i;
  Column *pCol;
  assert( pTable!=0 );
  if( (pCol = pTable->aCol)!=0 ){
    for(i=0; i<pTable->nCol; i++, pCol++){
      sqlite3DbFree(db, pCol->zName);
      sqlite3ExprDelete(db, pCol->pDflt);
      sqlite3DbFree(db, pCol->zDflt);
      sqlite3DbFree(db, pCol->zType);
      sqlite3DbFree(db, pCol->zColl);
    }
    sqlite3DbFree(db, pTable->aCol);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8(%rsi), %r15
testq %r15, %r15
je 0x36859
movq %rsi, %r14
movq %rdi, %rbx
cmpw $0x0, 0x42(%rsi)
jle 0x36845
xorl %r12d, %r12d
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x9c3a
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x34068
movq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0x9c3a
movq 0x18(%r15), %rsi
movq %rbx, %rdi
callq 0x9c3a
movq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x9c3a
incl %r12d
addq $0x30, %r15
movswl 0x42(%r14), %eax
cmpl %eax, %r12d
jl 0x367f9
movq 0x8(%r14), %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9c3a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: fkTriggerDelete
static void fkTriggerDelete(sqlite3 *dbMem, Trigger *p){
  if( p ){
    TriggerStep *pStep = p->step_list;
    sqlite3ExprDelete(dbMem, pStep->pWhere);
    sqlite3ExprListDelete(dbMem, pStep->pExprList);
    sqlite3SelectDelete(dbMem, pStep->pSelect);
    sqlite3ExprDelete(dbMem, p->pWhen);
    sqlite3DbFree(dbMem, p);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x368bd
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x38(%rsi), %r15
movq 0x28(%r15), %rsi
callq 0x34068
movq 0x30(%r15), %rsi
movq %r14, %rdi
callq 0x3410b
movq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x340e4
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x34068
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9c3a
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3Utf8Read
SQLITE_PRIVATE u32 sqlite3Utf8Read(
  const unsigned char **pz    /* Pointer to string from which to read char */
){
  unsigned int c;

  /* Same as READ_UTF8() above but without the zTerm parameter.
  ** For this routine, we assume the UTF8 string is always zero-terminated.
  */
  c = *((*pz)++);
  if( c>=0xc0 ){
    c = sqlite3Utf8Trans1[c-0xc0];
    while( (*(*pz) & 0xc0)==0x80 ){
      c = (c<<6) + (0x3f & *((*pz)++));
    }
    if( c<0x80
        || (c&0xFFFFF800)==0xD800
        || (c&0xFFFFFFFE)==0xFFFE ){  c = 0xFFFD; }
  }
  return c;
}

// Assembly:
movq (%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rdi)
movzbl (%rax), %eax
cmpl $0xc0, %eax
jb 0x3693e
pushq %rbp
movq %rsp, %rbp
addl $0xffffff40, %eax       # imm = 0xFFFFFF40
leaq 0x3faae(%rip), %rcx     # 0x76390
movzbl (%rax,%rcx), %ecx
movq (%rdi), %rax
movb (%rax), %dl
andb $-0x40, %dl
negb %dl
jno 0x36910
incq %rax
shll $0x6, %ecx
movq %rax, (%rdi)
movzbl -0x1(%rax), %edx
andl $0x3f, %edx
orl %edx, %ecx
movb (%rax), %dl
andb $-0x40, %dl
incq %rax
negb %dl
jo 0x368f5
movl %ecx, %eax
andl $0xfffff800, %eax       # imm = 0xFFFFF800
movl %ecx, %edx
andl $-0x2, %edx
cmpl $0xd800, %eax           # imm = 0xD800
movl $0xfffd, %esi           # imm = 0xFFFD
movl %ecx, %eax
cmovel %esi, %eax
cmpl $0x80, %ecx
cmovbl %esi, %eax
cmpl $0xfffe, %edx           # imm = 0xFFFE
cmovel %esi, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeSetNumCols
SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){
  Mem *pColName;
  int n;
  sqlite3 *db = p->db;

  releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
  sqlite3DbFree(db, p->aColName);
  n = nResColumn*COLNAME_N;
  p->nResColumn = (u16)nResColumn;
  p->aColName = pColName = (Mem*)sqlite3DbMallocZero(db, sizeof(Mem)*n );
  if( p->aColName==0 ) return;
  while( n-- > 0 ){
    pColName->flags = MEM_Null;
    pColName->db = p->db;
    pColName++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %r15
movq 0x20(%rdi), %rdi
movzwl 0x48(%r14), %esi
addl %esi, %esi
callq 0x2309b
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x9c3a
movw %bx, 0x48(%r14)
imull $0x70, %ebx, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x115e9
movq %rax, %r15
testq %rax, %rax
je 0x36eea
movslq %r12d, %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x8200
movq %r15, 0x20(%r14)
testl %ebx, %ebx
jle 0x36eee
movq (%r14), %rax
leal 0x1(,%rbx,2), %ecx
movw $0x1, 0x24(%r15)
movq %rax, (%r15)
addq $0x38, %r15
decl %ecx
cmpl $0x1, %ecx
jg 0x36ed3
jmp 0x36eee
movq %r15, 0x20(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3Utf8CharLen
SQLITE_PRIVATE int sqlite3Utf8CharLen(const char *zIn, int nByte){
  int r = 0;
  const u8 *z = (const u8*)zIn;
  const u8 *zTerm;
  if( nByte>=0 ){
    zTerm = &z[nByte];
  }else{
    zTerm = (const u8*)(-1);
  }
  assert( z<=zTerm );
  while( *z!=0 && z<zTerm ){
    SQLITE_SKIP_UTF8(z);
    r++;
  }
  return r;
}

// Assembly:
movl %esi, %eax
addq %rdi, %rax
testl %esi, %esi
movq $-0x1, %rcx
cmovnsq %rax, %rcx
movb (%rdi), %dl
testb %dl, %dl
setne %al
cmpq %rdi, %rcx
seta %sil
andb %al, %sil
xorl %eax, %eax
cmpb $0x1, %sil
jne 0x36f4d
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
cmpb $-0x40, %dl
jb 0x36f3c
movb 0x1(%rdi), %dl
incq %rdi
andb $-0x40, %dl
negb %dl
jo 0x36f2d
jmp 0x36f3f
incq %rdi
incl %eax
movb (%rdi), %dl
testb %dl, %dl
je 0x36f4c
cmpq %rcx, %rdi
jb 0x36f28
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3DeleteTriggerStep
SQLITE_PRIVATE void sqlite3DeleteTriggerStep(sqlite3 *db, TriggerStep *pTriggerStep){
  while( pTriggerStep ){
    TriggerStep * pTmp = pTriggerStep;
    pTriggerStep = pTriggerStep->pNext;

    sqlite3ExprDelete(db, pTmp->pWhere);
    sqlite3ExprListDelete(db, pTmp->pExprList);
    sqlite3SelectDelete(db, pTmp->pSelect);
    sqlite3IdListDelete(db, pTmp->pIdList);

    sqlite3DbFree(db, pTmp);
  }
}

// Assembly:
testq %rsi, %rsi
je 0x36fb4
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%r14), %rsi
movq 0x40(%r14), %r15
movq %rbx, %rdi
callq 0x34068
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x3410b
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x340e4
movq 0x38(%r14), %rsi
movq %rbx, %rdi
callq 0x3429d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9c3a
movq %r15, %r14
testq %r15, %r15
jne 0x36f63
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: yy_find_shift_action
static int yy_find_shift_action(
  yyParser *pParser,        /* The parser */
  YYCODETYPE iLookAhead     /* The look-ahead token */
){
  int i;
  int stateno = pParser->yystack[pParser->yyidx].stateno;
 
  if( stateno>YY_SHIFT_COUNT
   || (i = yy_shift_ofst[stateno])==YY_SHIFT_USE_DFLT ){
    return yy_default[stateno];
  }
  assert( iLookAhead!=YYNOCODE );
  i += iLookAhead;
  if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){
    if( iLookAhead>0 ){
#ifdef YYFALLBACK
      YYCODETYPE iFallback;            /* Fallback token */
      if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0])
             && (iFallback = yyFallback[iLookAhead])!=0 ){
#ifndef NDEBUG
        if( yyTraceFILE ){
          fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
             yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
        }
#endif
        return yy_find_shift_action(pParser, iFallback);
      }
#endif
#ifdef YYWILDCARD
      {
        int j = i - iLookAhead + YYWILDCARD;
        if( 
#if YY_SHIFT_MIN+YYWILDCARD<0
          j>=0 &&
#endif
#if YY_SHIFT_MAX+YYWILDCARD>=YY_ACTTAB_COUNT
          j<YY_ACTTAB_COUNT &&
#endif
          yy_lookahead[j]==YYWILDCARD
        ){
#ifndef NDEBUG
          if( yyTraceFILE ){
            fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
               yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[YYWILDCARD]);
          }
#endif /* NDEBUG */
          return yy_action[j];
        }
      }
#endif /* YYWILDCARD */
    }
    return yy_default[stateno];
  }else{
    return yy_action[i];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movslq (%rdi), %rax
shlq $0x5, %rax
movzwl 0x10(%rdi,%rax), %ebx
cmpq $0x1a1, %rbx            # imm = 0x1A1
ja 0x37147
leaq 0x3fa1b(%rip), %rax     # 0x76ae0
movswl (%rax,%rbx,2), %ecx
cmpl $-0x46, %ecx
je 0x37147
movzbl %sil, %eax
leal (%rcx,%rax), %edx
cmpl $0x61b, %edx            # imm = 0x61B
ja 0x370f9
movl %edx, %edx
leaq 0x4023a(%rip), %r8      # 0x77320
cmpb %sil, (%rdx,%r8)
jne 0x370f9
leaq 0x4089d(%rip), %rax     # 0x77990
leaq (%rax,%rdx,2), %rax
jmp 0x37152
testb %sil, %sil
je 0x37147
cmpb $0x42, %sil
ja 0x3711c
leaq 0x40835(%rip), %rdx     # 0x77940
movb (%rax,%rdx), %al
testb %al, %al
je 0x3711c
movzbl %al, %esi
callq 0x3709f
jmp 0x3713f
movb $0x1, %dl
cmpw $-0x43, %cx
jl 0x37143
addl $0x43, %ecx
leaq 0x401f2(%rip), %rax     # 0x77320
cmpb $0x43, (%rcx,%rax)
jne 0x37143
leaq 0x40855(%rip), %rax     # 0x77990
movzwl (%rax,%rcx,2), %eax
xorl %edx, %edx
jmp 0x37143
testb %dl, %dl
je 0x37155
leaq 0x3fce2(%rip), %rax     # 0x76e30
leaq (%rax,%rbx,2), %rax
movzwl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: yy_pop_parser_stack
static int yy_pop_parser_stack(yyParser *pParser){
  YYCODETYPE yymajor;
  yyStackEntry *yytos = &pParser->yystack[pParser->yyidx];

  /* There is no mechanism by which the parser stack can be popped below
  ** empty in SQLite.  */
  if( NEVER(pParser->yyidx<0) ) return 0;
#ifndef NDEBUG
  if( yyTraceFILE && pParser->yyidx>=0 ){
    fprintf(yyTraceFILE,"%sPopping %s\n",
      yyTracePrompt,
      yyTokenName[yytos->major]);
  }
#endif
  yymajor = yytos->major;
  yy_destructor(pParser, yymajor, &yytos->minor);
  pParser->yyidx--;
  return yymajor;
}

// Assembly:
movslq (%rdi), %rax
testq %rax, %rax
js 0x38d90
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
shlq $0x5, %rax
leaq (%rdi,%rax), %rdx
addq $0x18, %rdx
movzbl -0x6(%rdx), %esi
callq 0x38cb9
decl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3BeginTransaction
SQLITE_PRIVATE void sqlite3BeginTransaction(Parse *pParse, int type){
  sqlite3 *db;
  Vdbe *v;
  int i;

  assert( pParse!=0 );
  db = pParse->db;
  assert( db!=0 );
/*  if( db->aDb[0].pBt==0 ) return; */
  if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){
    return;
  }
  v = sqlite3GetVdbe(pParse);
  if( !v ) return;
  if( type!=TK_DEFERRED ){
    for(i=0; i<db->nDb; i++){
      sqlite3VdbeAddOp2(v, OP_Transaction, i, (type==TK_EXCLUSIVE)+1);
      sqlite3VdbeUsesBtree(v, i);
    }
  }
  sqlite3VdbeAddOp2(v, OP_AutoCommit, 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %r12
leaq 0x41b50(%rip), %rdx     # 0x7ad18
movl $0x16, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45d75
testl %eax, %eax
je 0x391e4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x45b57
testq %rax, %rax
je 0x391db
movq %rax, %rbx
cmpl $0x7, %r14d
je 0x39243
cmpl $0x0, 0x28(%r12)
jle 0x39243
xorl %r15d, %r15d
cmpl $0x9, %r14d
sete %r15b
incl %r15d
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x4, %esi
movl %r14d, %edx
movl %r15d, %ecx
xorl %r8d, %r8d
callq 0x45b9e
movl $0x1, %eax
movl %r14d, %ecx
shll %cl, %eax
orl %eax, 0xa0(%rbx)
incl %r14d
cmpl 0x28(%r12), %r14d
jl 0x39213
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x45b9e
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3CommitTransaction
SQLITE_PRIVATE void sqlite3CommitTransaction(Parse *pParse){
  Vdbe *v;

  assert( pParse!=0 );
  assert( pParse->db!=0 );
  if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "COMMIT", 0, 0) ){
    return;
  }
  v = sqlite3GetVdbe(pParse);
  if( v ){
    sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, 0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x41ad5(%rip), %rdx     # 0x7ad44
movl $0x16, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45d75
testl %eax, %eax
je 0x39289
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x45b57
testq %rax, %rax
je 0x39282
movq %rax, %rdi
movl $0x3, %esi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x45b9e
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3RollbackTransaction
SQLITE_PRIVATE void sqlite3RollbackTransaction(Parse *pParse){
  Vdbe *v;

  assert( pParse!=0 );
  assert( pParse->db!=0 );
  if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "ROLLBACK", 0, 0) ){
    return;
  }
  v = sqlite3GetVdbe(pParse);
  if( v ){
    sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, 1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x44022(%rip), %rdx     # 0x7d2e5
movl $0x16, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45d75
testl %eax, %eax
je 0x392dd
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
callq 0x45b57
testq %rax, %rax
je 0x392d6
movq %rax, %rdi
movl $0x3, %esi
movl $0x1, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x45b9e
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3Savepoint
SQLITE_PRIVATE void sqlite3Savepoint(Parse *pParse, int op, Token *pName){
  char *zName = sqlite3NameFromToken(pParse->db, pName);
  if( zName ){
    Vdbe *v = sqlite3GetVdbe(pParse);
#ifndef SQLITE_OMIT_AUTHORIZATION
    static const char * const az[] = { "BEGIN", "RELEASE", "ROLLBACK" };
    assert( !SAVEPOINT_BEGIN && SAVEPOINT_RELEASE==1 && SAVEPOINT_ROLLBACK==2 );
#endif
    if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
      sqlite3DbFree(pParse->db, zName);
      return;
    }
    sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %r15
movq (%rdi), %rdi
movq %rdx, %rsi
callq 0x45df3
testq %rax, %rax
je 0x39379
movq %rax, %rbx
movq %r15, %rdi
callq 0x45b57
testq %rax, %rax
je 0x39366
movq %rax, %r12
movl %r14d, %eax
leaq 0x3f518(%rip), %rcx     # 0x78860
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
movq %r15, %rdi
movl $0x20, %esi
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x45d75
testl %eax, %eax
je 0x39382
movq (%r15), %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9c3a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movl $0x2, %esi
movl %r14d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x45b9e
movq %r12, %rdi
movl %eax, %esi
movq %rbx, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11975
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3AddColumnType
SQLITE_PRIVATE void sqlite3AddColumnType(Parse *pParse, Token *pType){
  Table *p;
  Column *pCol;

  p = pParse->pNewTable;
  if( p==0 || NEVER(p->nCol<1) ) return;
  pCol = &p->aCol[p->nCol-1];
  assert( pCol->zType==0 );
  pCol->zType = sqlite3NameFromToken(pParse->db, pType);
  pCol->affinity = sqlite3AffinityType(pCol->zType);
}

// Assembly:
movq 0x238(%rdi), %rax
testq %rax, %rax
je 0x39e47
movswq 0x42(%rax), %rcx
testq %rcx, %rcx
jle 0x39e47
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rax), %rbx
decl %ecx
leaq (%rcx,%rcx,2), %r14
shlq $0x4, %r14
movq (%rdi), %rdi
callq 0x45df3
movq %rax, 0x18(%rbx,%r14)
movq %rax, %rdi
callq 0x4b1e7
movb %al, 0x29(%rbx,%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3AddDefaultValue
SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse *pParse, ExprSpan *pSpan){
  Table *p;
  Column *pCol;
  sqlite3 *db = pParse->db;
  p = pParse->pNewTable;
  if( p!=0 ){
    pCol = &(p->aCol[p->nCol-1]);
    if( !sqlite3ExprIsConstantOrFunction(pSpan->pExpr) ){
      sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
          pCol->zName);
    }else{
      /* A copy of pExpr is used instead of the original, as pExpr contains
      ** tokens that point to volatile memory. The 'span' of the expression
      ** is required by pragma table_info.
      */
      sqlite3ExprDelete(db, pCol->pDflt);
      pCol->pDflt = sqlite3ExprDup(db, pSpan->pExpr, EXPRDUP_REDUCE);
      sqlite3DbFree(db, pCol->zDflt);
      pCol->zDflt = sqlite3DbStrNDup(db, (char*)pSpan->zStart,
                                     (int)(pSpan->zEnd - pSpan->zStart));
    }
  }
  sqlite3ExprDelete(db, pSpan->pExpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq (%rdi), %rbx
movq 0x238(%rdi), %rax
testq %rax, %rax
je 0x39f5d
movq %rdi, %r15
movswq 0x42(%rax), %rcx
leaq (%rcx,%rcx,2), %r13
shlq $0x4, %r13
addq 0x8(%rax), %r13
movq (%r14), %rsi
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %r12
movaps %xmm0, (%r12)
movaps %xmm0, 0x10(%r12)
movq $0x0, 0x20(%r12)
movl $0x2, 0x20(%r12)
leaq 0x11be7(%rip), %rax     # 0x4ba98
movq %rax, (%r12)
leaq 0x11c1e(%rip), %rax     # 0x4bada
movq %rax, 0x8(%r12)
movq %r12, %rdi
callq 0x470d7
cmpl $0x0, 0x20(%r12)
je 0x39f48
movq -0x28(%r13), %rsi
movq %rbx, %rdi
callq 0x34068
movq (%r14), %rsi
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x48163
movq %rax, -0x28(%r13)
movq -0x20(%r13), %rsi
movq %rbx, %rdi
callq 0x9c3a
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x39f42
movq 0x10(%r14), %r12
movq %rax, -0x30(%rbp)
subq %rax, %r12
leal 0x1(%r12), %esi
movq %rbx, %rdi
callq 0x115e9
movq %rax, %r15
testq %rax, %rax
je 0x39f42
movslq %r12d, %r12
movq %r15, %rdi
movq -0x30(%rbp), %rsi
movq %r12, %rdx
callq 0x82f0
movb $0x0, (%r15,%r12)
movq %r15, -0x20(%r13)
jmp 0x39f5d
movq -0x30(%r13), %rdx
leaq 0x41459(%rip), %rsi     # 0x7b3ac
movq %r15, %rdi
xorl %eax, %eax
callq 0x11724
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x34068
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3PExpr
SQLITE_PRIVATE Expr *sqlite3PExpr(
  Parse *pParse,          /* Parsing context */
  int op,                 /* Expression opcode */
  Expr *pLeft,            /* Left operand */
  Expr *pRight,           /* Right operand */
  const Token *pToken     /* Argument token */
){
  Expr *p;
  if( op==TK_AND && pLeft && pRight ){
    /* Take advantage of short-circuit false optimization for AND */
    p = sqlite3ExprAnd(pParse->db, pLeft, pRight);
  }else{
    p = sqlite3ExprAlloc(pParse->db, op, pToken, 1);
    sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
  }
  if( p ) {
    sqlite3ExprCheckHeight(pParse, p->nHeight);
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
cmpl $0x45, %esi
setne %al
testq %rdx, %rdx
sete %cl
testq %r15, %r15
sete %dl
orb %cl, %dl
movq (%rdi), %rdi
orb %al, %dl
jne 0x39fb6
movq %r12, %rsi
movq %r15, %rdx
callq 0x4a740
movq %rax, %r14
jmp 0x39fd7
movq %r8, %rdx
movl $0x1, %ecx
callq 0x4a949
movq %rax, %r14
movq (%rbx), %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x4aa98
testq %r14, %r14
je 0x39ff9
movq (%rbx), %rax
movl 0x74(%rax), %edx
cmpl 0x28(%r14), %edx
jge 0x39ff9
leaq 0x40ed8(%rip), %rsi     # 0x7aec7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11724
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq