LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
movslq 0x28(%rdi), %rax
testq %rax, %rax
jle 0xdf12
movq 0x20(%rbx), %rcx
movq %rax, %rdx
shlq $0x5, %rdx
xorl %esi, %esi
movq 0x8(%rcx,%rsi), %rdi
testq %rdi, %rdi
je 0xded8
movq (%rdi), %r8
movq 0x8(%rdi), %rdi
movq %r8, 0x8(%rdi)
addq $0x20, %rsi
cmpq %rsi, %rdx
jne 0xdec3
testl %eax, %eax
jle 0xdf12
movl $0x18, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rcx
movq (%rcx,%r14), %rdi
testq %rdi, %rdi
je 0xdf03
callq 0x30c3e
movl 0x28(%rbx), %eax
incq %r15
movslq %eax, %rcx
addq $0x20, %r14
cmpq %rcx, %r15
jl 0xdeee
andb $-0x3, 0x2c(%rbx)
movq %rbx, %rdi
callq 0x36d92
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x36de0
// File: /workspace/github_c_makefile_star2_O3/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 0xd1b2
testl %eax, %eax
jne 0xdfb1
movq 0x18(%r15), %rax
movq 0x50(%rax), %r12
movb 0x12(%r12), %cl
cmpb %bl, %cl
jne 0xdf83
xorl %eax, %eax
cmpb %cl, 0x13(%r12)
je 0xdfb1
movq %r14, %rdi
movl $0x2, %esi
callq 0xd1b2
testl %eax, %eax
jne 0xdfb1
movq 0x18(%r15), %rax
movq 0x68(%rax), %rdi
callq 0xdfbf
testl %eax, %eax
jne 0xdfb1
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_O3/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 0xe3b0
movq (%rdi), %rax
testq %rax, %rax
je 0xe3bd
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %ebx, %ebx
movl $0x8, %esi
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_O3/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 0xe472
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %r12
movq %rax, 0x8(%r12)
cmpb $0x2, %cl
jne 0xe460
movl %esi, %r14d
movq (%r12), %r15
movl 0x2c(%r15), %eax
testl %eax, %eax
jne 0xe43e
cmpb $0x2, 0x13(%r15)
jne 0xe416
cmpb $0x0, 0x8(%r15)
je 0xe416
cmpb $0x1, 0x9(%r15)
jne 0xe416
xorl %eax, %eax
movb $0x1, %cl
jmp 0xe43a
movzbl 0x16(%r15), %esi
movq %r15, %rdi
movl $0x1, %edx
callq 0x1decc
cmpb $0xd, %al
je 0xe434
movzbl %al, %ecx
cmpl $0xa, %ecx
jne 0xe43e
movl %eax, 0x2c(%r15)
movb $0x6, %cl
movb %cl, 0x13(%r15)
testl %r14d, %r14d
jne 0xe447
testl %eax, %eax
jne 0xe46a
movb $0x1, 0x24(%r12)
movq 0x58(%r12), %rdi
callq 0x1dcec
movq $0x0, 0x58(%r12)
movq %rbx, %rdi
callq 0x20c21
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xe74e
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 0xe6dc
decl 0x18(%rcx)
cmpl $0x0, 0x3c(%r14)
je 0xe700
movq (%rax), %rax
addq $0x70, %rax
movq %rax, %rcx
movq (%rax), %rdx
leaq 0x40(%rdx), %rax
cmpq %r14, %rdx
jne 0xe6ea
movq 0x40(%r14), %rax
movq %rax, (%rcx)
movq 0x8(%r14), %rdi
xorl %r12d, %r12d
xorl %esi, %esi
callq 0xe75d
movl 0x30(%r14), %r15d
cmpl $0x65, %r15d
cmovel %r12d, %r15d
movq (%r14), %rdi
movl %r15d, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xca2d
movq (%r14), %rdi
testq %rdi, %rdi
je 0xe744
callq 0xe803
cmpq $0x0, (%r14)
je 0xe744
movq %r14, %rdi
callq 0xa3c7
movq %rbx, %rdi
callq 0xe803
jmp 0xe751
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq (%rdi), %rax
movq %rax, 0x8(%r14)
testl %esi, %esi
jne 0xe78c
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x20df0
movl %eax, %esi
testl %eax, %eax
je 0xe794
movq %rbx, %rdi
callq 0x22b98
cmpb $0x2, 0x10(%rbx)
jne 0xe7f3
movq (%r14), %rdi
callq 0x1de22
leaq -0x18(%rbp), %rdx
movq %r14, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
callq 0x20068
testl %eax, %eax
jne 0xe7dd
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rcx
movl 0x1c(%rcx), %ecx
bswapl %ecx
testl %ecx, %ecx
jne 0xe7d0
movq (%r14), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, 0x3c(%r14)
movq 0x68(%rax), %rdi
callq 0xddd3
movb $0x1, 0x24(%r14)
movq 0x58(%r14), %rdi
callq 0x1dcec
movq $0x0, 0x58(%r14)
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x20c21
// File: /workspace/github_c_makefile_star2_O3/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 0xea84
movq (%rdi), %rbx
testq %rbx, %rbx
je 0xea88
callq 0xeac6
movq %rbx, %rdi
movl %eax, %esi
callq 0xeaff
movl %eax, %r14d
movq %rbx, %rdi
callq 0xe803
movl %r14d, %eax
jmp 0xeac1
xorl %ebx, %ebx
jmp 0xeabf
leaq 0x6adce(%rip), %rsi     # 0x7985d
movl $0x15, %ebx
movl $0x15, %edi
xorl %eax, %eax
callq 0xb9c7
leaq 0x6e93d(%rip), %rsi     # 0x7d3e4
leaq 0x6aa8b(%rip), %rcx     # 0x79539
movl $0x15, %edi
movl $0xf7a0, %edx           # imm = 0xF7A0
xorl %eax, %eax
callq 0xb9c7
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeae4
xorl %r14d, %r14d
cmpl $0xbdf20da3, %eax       # imm = 0xBDF20DA3
jne 0xeaef
movq %rbx, %rdi
callq 0xebb4
movl %eax, %r14d
movq %rbx, %rdi
callq 0x22dfd
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeb40
movq %rdi, %r14
cmpl $0xc0a, %ebx            # imm = 0xC0A
je 0xeb1f
cmpb $0x0, 0x50(%r14)
je 0xeb3a
movl $0x7, %ebx
movq %r14, %rdi
movl $0x7, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xca2d
movb $0x0, 0x50(%r14)
movl 0x48(%r14), %eax
jmp 0xeb45
movl $0xff, %eax
andl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xebb1
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xebb4
xorl %ecx, %ecx
movl %ecx, 0x94(%rbx)
movw $0xff02, 0x98(%rbx)     # imm = 0xFF02
movl $0xbdf20da3, 0x50(%rbx) # imm = 0xBDF20DA3
movl %ecx, 0x9c(%rbx)
movabsq $-0xffffffff, %rdx      # imm = 0xFFFFFFFF00000001
movq %rdx, 0x8c(%rbx)
movl %ecx, 0xa8(%rbx)
movq $0x0, 0xc8(%rbx)
movq (%rbx), %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xeaff
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
cmpw $0x0, 0x88(%rdi)
jle 0xecd0
movq 0x78(%rbx), %rdi
xorl %r14d, %r14d
xorl %r15d, %r15d
addq %r14, %rdi
callq 0xecfd
movq 0x78(%rbx), %rdi
movw $0x1, 0x24(%rdi,%r14)
incq %r15
movswq 0x88(%rbx), %rax
addq $0x38, %r14
cmpq %rax, %r15
jl 0xeca8
movzwl 0x9a(%rbx), %eax
btl $0xa, %eax
jae 0xecf0
cmpl $0x0, 0x104(%rbx)
je 0xecf0
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_O3/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
testl $0x2460, %eax           # imm = 0x2460
je 0xed19
movq %rbx, %rdi
callq 0x102d5
movq (%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x9ca4
movq $0x0, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xed6b
movq %rbx, %rdi
callq 0xed87
movl 0x24(%rbx), %eax
andl $-0x13, %eax
orl $0x10, %eax
movw %ax, 0x24(%rbx)
cmpl $0x0, 0x20(%rbx)
je 0xed7e
movq 0x8(%rbx), %rax
jmp 0xed80
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xef29
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xeddf
movq %rdi, %rbx
movl 0x18(%rdi), %esi
addl 0x20(%rdi), %esi
cmpl $0x2, %esi
movl $0x1, %eax
cmovll %eax, %esi
movl $0x1, %edx
callq 0x1034d
movl $0x7, %r14d
testl %eax, %eax
jne 0xeddf
movslq 0x20(%rbx), %rdi
addq 0x8(%rbx), %rdi
movslq 0x18(%rbx), %rdx
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x8200
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_O3/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 0xee28
movzbl %sil, %esi
movq %rbx, %rdi
callq 0xef29
testq %rax, %rax
je 0xee36
movzwl 0x24(%rbx), %eax
btl $0xe, %eax
movl 0x20(%rbx), %eax
jae 0xee38
addl 0x18(%rbx), %eax
jmp 0xee38
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xee94
testb $0x4, %al
jne 0xee9a
testb $0x12, %al
je 0xeea1
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x10(%rbp), %rbx
movq $0x0, (%rbx)
movq 0x8(%rdi), %rax
movl 0x20(%rdi), %edx
movzbl 0x27(%rdi), %ecx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x243b1
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_O3/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 0xeeed
testb $0x8, %al
jne 0xeef2
testb $0x12, %al
je 0xef1f
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x10(%rbp), %rbx
movq $0x0, (%rbx)
movq 0x8(%rdi), %rax
movl 0x20(%rdi), %edx
movzbl 0x27(%rdi), %ecx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16fda
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x18(%rdi), %rax
retq
movsd 0x10(%rdi), %xmm0
movapd 0x6a481(%rip), %xmm1    # 0x79380
andpd %xmm0, %xmm1
ucomisd 0x6a39d(%rip), %xmm1    # 0x792a8
cvttsd2si %xmm0, %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmovbeq %rcx, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xef76
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzwl 0x24(%rdi), %ecx
testb $0x1, %cl
jne 0xefb4
movl %esi, %r14d
movl %ecx, %eax
shrl $0x3, %eax
andl $0x2, %eax
orl %ecx, %eax
movw %ax, 0x24(%rbx)
btl $0xe, %ecx
jae 0xef64
movq %rbx, %rdi
callq 0xed87
movzwl 0x24(%rbx), %eax
movzbl %r14b, %esi
testb $0x2, %al
jne 0xef79
movq %rbx, %rdi
callq 0x24f72
jmp 0xefa4
xorl %eax, %eax
retq
andl $-0x9, %esi
movq %rbx, %rdi
callq 0x24930
testb $0x8, %r14b
je 0xef9c
testb $0x1, 0x8(%rbx)
je 0xef9c
movq %rbx, %rdi
callq 0x24eb1
testl %eax, %eax
jne 0xefb4
movq %rbx, %rdi
callq 0x24f22
andb $-0x9, %r14b
cmpb %r14b, 0x27(%rbx)
jne 0xefb4
movq 0x8(%rbx), %rax
jmp 0xefb6
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
movq %rdi, %rbx
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm1
movsd %xmm1, -0x20(%rbp)
movsd -0x10(%rbp), %xmm1
ucomisd -0x20(%rbp), %xmm1
jne 0xf0a7
jp 0xf0a7
movq %rbx, %rdi
movsd %xmm0, -0x18(%rbp)
callq 0xecfd
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x10(%rbx)
movw $0x8, 0x24(%rbx)
movb $0x2, 0x26(%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %rbp
jmp 0xf373
// File: /workspace/github_c_makefile_star2_O3/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 0xf39d
movq 0x18(%rbx), %rcx
movq (%rcx), %rdx
movq 0xf8(%rdx), %rsi
movq %rsi, 0x8(%rcx)
movq %rcx, 0xf8(%rdx)
testb $0x20, %al
je 0xf3ae
movq 0x18(%rbx), %rdi
callq 0x25025
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_O3/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
testl $0x2460, %eax           # imm = 0x2460
je 0xf437
movq %rbx, %rdi
callq 0x102d5
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 0xf480
testb $0x8, 0x25(%r14)
jne 0xf480
orl $0x1000, %eax           # imm = 0x1000
movw %ax, 0x24(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x24eb1
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
movq %rsp, %rbp
movl %esi, 0x5c(%rdi)
movb $0x1, 0x61(%rdi)
testb $0x1, 0x2c(%rdi)
jne 0xf4cb
popq %rbp
retq
addq $0x8, %rdi
cmpl $0x204, %esi            # imm = 0x204
jne 0xf4e0
leaq 0x6ddfa(%rip), %rsi     # 0x7d2d8
jmp 0xf50a
movzbl %sil, %eax
cmpl $0x1b, %eax
setae %cl
cmpl $0x2, %eax
sete %dl
orb %cl, %dl
je 0xf4fd
leaq 0x6ddcf(%rip), %rsi     # 0x7d2ca
jmp 0xf50a
movl %eax, %eax
leaq 0x842fa(%rip), %rcx     # 0x93800
movq (%rcx,%rax,8), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
xorl %r8d, %r8d
popq %rbp
jmp 0xf0d7
// File: /workspace/github_c_makefile_star2_O3/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 0x69f3f(%rip), %rsi     # 0x79476
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
xorl %r8d, %r8d
popq %rbp
jmp 0xf0d7
// File: /workspace/github_c_makefile_star2_O3/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 0xf373
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_O3/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 %r14
pushq %rbx
testq %rsi, %rsi
je 0x10245
movq %rsi, %rbx
xorl %r14d, %r14d
cmpb $0x0, (%rbx,%r14)
leaq 0x1(%r14), %r14
jne 0x1020e
decl %r14d
andl $0x3fffffff, %r14d      # imm = 0x3FFFFFFF
incl %r14d
movl %r14d, %esi
callq 0x11721
testq %rax, %rax
je 0x10245
movl %r14d, %edx
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x82f0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x102c6
movl %esi, %r14d
testl %esi, %esi
jle 0x102b0
movq %rdi, %r15
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x1034d
movw $0x2000, 0x24(%rbx)     # imm = 0x2000
movq (%r15), %rax
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x102c6
movl %r14d, %edx
xorl %esi, %esi
callq 0x8200
jmp 0x102c6
movq %rbx, %rdi
callq 0x102d5
movw $0x1, 0x24(%rbx)
movq $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_O3/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 0x10307
btl $0xa, %eax
jae 0x10321
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
je 0x10321
movq 0x8(%rbx), %rdi
callq *%rcx
movq $0x0, 0x28(%rbx)
jmp 0x10329
movq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0x2f8b1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xecfd
testb $0x20, %al
jne 0x10330
testb $0x40, %al
jne 0x1033f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x25025
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xf373
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
movl %edx, %r14d
cmpl $0x21, %esi
movl $0x20, %r15d
cmovgel %esi, %r15d
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x30(%rdi), %rdi
testq %rax, %rax
sete %cl
testq %rdi, %rdi
sete %dl
orb %cl, %dl
jne 0x1039d
cmpq %rdi, 0x170(%rax)
ja 0x1039d
cmpq %rdi, 0x178(%rax)
jbe 0x1039d
movzwl 0x150(%rax), %eax
jmp 0x103a3
callq *0x84095(%rip)          # 0x94438
cmpl %r15d, %eax
jge 0x103f1
testl %r14d, %r14d
je 0x103d6
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
movq 0x30(%rbx), %rsi
cmpq %rsi, %rax
jne 0x103dd
leaq 0x8(%rbx), %r12
movq %rax, %rsi
movl %r15d, %edx
callq 0x33c1f
movq %rax, 0x30(%rbx)
movq %rax, 0x8(%rbx)
jmp 0x10426
movq (%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x9ca4
movq (%rbx), %rdi
movl %r15d, %esi
callq 0x11721
movq %rax, 0x30(%rbx)
leaq 0x8(%rbx), %r12
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
sete %al
testl %r14d, %r14d
sete %cl
orb %al, %cl
jne 0x10426
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
sete %al
cmpq %rdi, %rsi
sete %cl
orb %al, %cl
jne 0x10426
movslq 0x20(%rbx), %rdx
callq 0x82f0
testb $0x4, 0x25(%rbx)
je 0x1043b
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x1043b
movq (%r12), %rdi
callq *%rax
movq 0x30(%rbx), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x10456
movzwl 0x24(%rbx), %ecx
andl $0xe7ff, %ecx           # imm = 0xE7FF
xorl %eax, %eax
jmp 0x1045f
movw $0x1, %cx
movl $0x7, %eax
movw %cx, 0x24(%rbx)
movq $0x0, 0x28(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x50(%rdi), %rax
movq 0x120(%rax), %rcx
testq %rcx, %rcx
je 0x104a1
movl 0x58(%rdi), %edx
xorl %eax, %eax
cmpl %edx, (%rcx)
jne 0x10496
cmpl %esi, 0x4(%rcx)
je 0x104a5
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x1048d
jmp 0x104a9
xorl %eax, %eax
jmp 0x104a9
movq 0x8(%rcx), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1054b
movl %esi, %r12d
movq %rdi, %r15
movq 0x50(%rdi), %r13
movq 0x120(%r13), %r14
testq %r14, %r14
je 0x104f2
movl 0x58(%r15), %eax
cmpl %eax, (%r14)
jne 0x104e9
cmpl %r12d, 0x4(%r14)
je 0x10563
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x104de
movq (%r13), %rdi
movl $0x20, %esi
movq %rcx, %r14
callq 0x11721
movq %r14, %rcx
testq %rax, %rax
je 0x1054b
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movl 0x58(%r15), %eax
movl %eax, (%r14)
movl %r12d, 0x4(%r14)
movq 0x120(%r13), %rax
movq %rax, 0x18(%r14)
movq %r14, 0x120(%r13)
cmpb $0x0, 0x61(%r15)
jne 0x10578
movl $0x0, 0x5c(%r15)
movb $0x1, 0x61(%r15)
jmp 0x10578
testq %rcx, %rcx
je 0x10580
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 0x10578
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_O3/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 0x10602
movq %rax, %rdi
callq 0xed3b
movq %rax, %r14
testq %rbx, %rbx
je 0x105fa
movq (%rbx), %rdi
movl 0x94(%rbx), %esi
callq 0xeaff
movl %eax, 0x94(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_column_value
SQLITE_API sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){
  Mem *pOut = columnMem(pStmt, i);
  if( pOut->flags&MEM_Static ){
    pOut->flags &= ~MEM_Static;
    pOut->flags |= MEM_Ephem;
  }
  columnMallocFailure(pStmt);
  return (sqlite3_value *)pOut;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x10602
movq %rax, %r14
movl 0x24(%rax), %eax
btl $0xb, %eax
jae 0x107f3
andl $0xffffe7ff, %eax       # imm = 0xFFFFE7FF
orl $0x1000, %eax           # imm = 0x1000
movw %ax, 0x24(%r14)
testq %rbx, %rbx
je 0x1080c
movq (%rbx), %rdi
movl 0x94(%rbx), %esi
callq 0xeaff
movl %eax, 0x94(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: bindText
static int bindText(
  sqlite3_stmt *pStmt,   /* The statement to bind against */
  int i,                 /* Index of the parameter to bind */
  const void *zData,     /* Pointer to the data to be bound */
  int nData,             /* Number of bytes of data to be bound */
  void (*xDel)(void*),   /* Destructor for the data */
  u8 encoding            /* Encoding for the data */
){
  Vdbe *p = (Vdbe *)pStmt;
  Mem *pVar;
  int rc;

  rc = vdbeUnbind(p, i);
  if( rc==SQLITE_OK ){
    if( zData!=0 ){
      pVar = &p->aVar[i-1];
      rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
      if( rc==SQLITE_OK && encoding!=0 ){
        rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
      }
      sqlite3Error(p->db, rc, 0);
      rc = sqlite3ApiExit(p->db, rc);
    }
    sqlite3_mutex_leave(p->db->mutex);
  }else if( xDel!=SQLITE_STATIC && xDel!=SQLITE_TRANSIENT ){
    xDel((void*)zData);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, -0x30(%rbp)
movq %r8, %rbx
movl %ecx, -0x2c(%rbp)
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r15
callq 0x10ab1
testl %eax, %eax
je 0x109d0
movl %eax, %r13d
leaq 0x1(%rbx), %rax
cmpq $0x2, %rax
jb 0x10a55
movq %r14, %rdi
callq *%rbx
jmp 0x10a55
movl -0x30(%rbp), %edi
movl -0x2c(%rbp), %edx
testq %r14, %r14
je 0x10a52
movq 0x78(%r15), %rax
movslq %r12d, %rcx
imulq $0x38, %rcx, %rcx
leaq (%rax,%rcx), %r13
addq $-0x38, %r13
movzbl %dil, %r12d
movq %r13, %rdi
movq %r14, %rsi
movl %r12d, %ecx
movq %rbx, %r8
callq 0xf0d7
movl %eax, %r14d
testb %r12b, %r12b
je 0x10a2a
testl %r14d, %r14d
jne 0x10a2a
movq (%r15), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movzbl 0x71(%rax), %esi
movq %r13, %rdi
callq 0x24930
movl %eax, %r14d
movq (%r15), %rdi
movl %r14d, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xca2d
movq (%r15), %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xeaff
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_bind_double
SQLITE_API int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
  rc = vdbeUnbind(p, i);
  if( rc==SQLITE_OK ){
    sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
    sqlite3_mutex_leave(p->db->mutex);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, -0x20(%rbp)
movl %esi, %r14d
movq %rdi, %r15
callq 0x10ab1
movl %eax, %ebx
testl %eax, %eax
jne 0x10aa4
movq 0x78(%r15), %rax
movslq %r14d, %rcx
imulq $0x38, %rcx, %rcx
leaq (%rax,%rcx), %rdi
addq $-0x38, %rdi
movsd -0x20(%rbp), %xmm0
callq 0xf056
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: vdbeUnbind
static int vdbeUnbind(Vdbe *p, int i){
  Mem *pVar;
  if( vdbeSafetyNotNull(p) ){
    return SQLITE_MISUSE_BKPT;
  }
  sqlite3_mutex_enter(p->db->mutex);
  if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
    sqlite3Error(p->db, SQLITE_MISUSE, 0);
    sqlite3_mutex_leave(p->db->mutex);
    sqlite3_log(SQLITE_MISUSE, 
        "bind on a busy prepared statement: [%s]", p->zSql);
    return SQLITE_MISUSE_BKPT;
  }
  if( i<1 || i>p->nVar ){
    sqlite3Error(p->db, SQLITE_RANGE, 0);
    sqlite3_mutex_leave(p->db->mutex);
    return SQLITE_RANGE;
  }
  i--;
  pVar = &p->aVar[i];
  sqlite3VdbeMemRelease(pVar);
  pVar->flags = MEM_Null;
  sqlite3Error(p->db, SQLITE_OK, 0);

  /* If the bit corresponding to this variable in Vdbe.expmask is set, then 
  ** binding a new value to this variable invalidates the current query plan.
  **
  ** IMPLEMENTATION-OF: R-48440-37595 If the specific value bound to host
  ** parameter in the WHERE clause might influence the choice of query plan
  ** for a statement, then the statement will be automatically recompiled,
  ** as if there had been a schema change, on the first sqlite3_step() call
  ** following any change to the bindings of that parameter.
  */
  if( p->isPrepareV2 &&
     ((i<32 && p->expmask & ((u32)1 << i)) || p->expmask==0xffffffff)
  ){
    p->expired = 1;
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10b2e
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x10b37
cmpl $0xbdf20da3, 0x50(%r14) # imm = 0xBDF20DA3
jne 0x10ae7
cmpl $0x0, 0x90(%r14)
js 0x10b7f
movl $0x15, %ebx
movl $0x15, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xca2d
movq 0xe0(%r14), %rdx
leaq 0x69e81(%rip), %rsi     # 0x7a989
movl $0x15, %edi
xorl %eax, %eax
callq 0xb9c7
leaq 0x6c8c9(%rip), %rsi     # 0x7d3e4
leaq 0x68a17(%rip), %rcx     # 0x79539
movl $0x15, %edi
movl $0xfb33, %edx           # imm = 0xFB33
jmp 0x10b67
leaq 0x68db4(%rip), %rsi     # 0x798e9
jmp 0x10b3e
leaq 0x68d1f(%rip), %rsi     # 0x7985d
movl $0x15, %ebx
movl $0x15, %edi
xorl %eax, %eax
callq 0xb9c7
leaq 0x6c88e(%rip), %rsi     # 0x7d3e4
leaq 0x689dc(%rip), %rcx     # 0x79539
movl $0x15, %edi
movl $0xfb2b, %edx           # imm = 0xFB2B
xorl %eax, %eax
callq 0xb9c7
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %r15d
testl %esi, %esi
jle 0x10b93
movswl 0x88(%r14), %eax
cmpl %r15d, %eax
jge 0x10ba8
movl $0x19, %ebx
movl $0x19, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xca2d
jmp 0x10b6e
leal -0x1(%r15), %r12d
movq 0x78(%r14), %rbx
imulq $0x38, %r12, %r13
leaq (%rbx,%r13), %rdi
callq 0xecfd
movw $0x1, 0x24(%rbx,%r13)
movq (%r14), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xca2d
movzwl 0x9a(%r14), %eax
btl $0xa, %eax
jae 0x10b6e
movl 0x104(%r14), %ecx
cmpl $0x20, %r15d
ja 0x10bfb
btl %r12d, %ecx
jb 0x10c04
jmp 0x10b6e
cmpl $-0x1, %ecx
jne 0x10b6e
orl $0x20, %eax
movw %ax, 0x9a(%r14)
jmp 0x10b6e
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_bind_int64
SQLITE_API int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
  rc = vdbeUnbind(p, i);
  if( rc==SQLITE_OK ){
    sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
    sqlite3_mutex_leave(p->db->mutex);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r12
callq 0x10ab1
movl %eax, %r14d
testl %eax, %eax
jne 0x10c6d
movq 0x78(%r12), %rax
movslq %r15d, %rcx
imulq $0x38, %rcx, %rcx
leaq (%rax,%rcx), %r15
addq $-0x38, %r15
movq %r15, %rdi
callq 0xecfd
movq %rbx, 0x18(%r15)
movw $0x4, 0x24(%r15)
movb $0x1, 0x26(%r15)
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_bind_value
SQLITE_API int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
  int rc;
  switch( pValue->type ){
    case SQLITE_INTEGER: {
      rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
      break;
    }
    case SQLITE_FLOAT: {
      rc = sqlite3_bind_double(pStmt, i, pValue->r);
      break;
    }
    case SQLITE_BLOB: {
      if( pValue->flags & MEM_Zero ){
        rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero);
      }else{
        rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT);
      }
      break;
    }
    case SQLITE_TEXT: {
      rc = bindText(pStmt,i,  pValue->z, pValue->n, SQLITE_TRANSIENT,
                              pValue->enc);
      break;
    }
    default: {
      rc = sqlite3_bind_null(pStmt, i);
      break;
    }
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl 0x26(%rdx), %eax
decl %eax
cmpl $0x3, %eax
ja 0x10d0f
leaq 0x64447(%rip), %rcx     # 0x75100
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rdx), %rdx
popq %rbp
jmp 0x10c21
movq 0x8(%rdx), %rax
movl 0x20(%rdx), %ecx
movzbl 0x27(%rdx), %r9d
movq %rax, %rdx
movq $-0x1, %r8
jmp 0x10cfe
testb $0x40, 0x25(%rdx)
jne 0x10d15
movq 0x8(%rdx), %rax
movl 0x20(%rdx), %ecx
movq %rax, %rdx
movq $-0x1, %r8
xorl %r9d, %r9d
popq %rbp
jmp 0x1098b
movsd 0x10(%rdx), %xmm0
popq %rbp
jmp 0x10a67
popq %rbp
jmp 0x10ab1
movl 0x18(%rdx), %edx
popq %rbp
jmp 0x10d1e