LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xf427
popq %rbp
retq
addq $0x8, %rdi
cmpl $0x204, %esi            # imm = 0x204
jne 0xf43c
leaq 0x6de9e(%rip), %rsi     # 0x7d2d8
jmp 0xf466
movzbl %sil, %eax
cmpl $0x1b, %eax
setae %cl
cmpl $0x2, %eax
sete %dl
orb %cl, %dl
je 0xf459
leaq 0x6de73(%rip), %rsi     # 0x7d2ca
jmp 0xf466
movl %eax, %eax
leaq 0x8439e(%rip), %rcx     # 0x93800
movq (%rcx,%rax,8), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
xorl %r8d, %r8d
popq %rbp
jmp 0xeff4
// File: /workspace/github_c_makefile_star2_O1/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 0x69fe3(%rip), %rsi     # 0x79476
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
xorl %r8d, %r8d
popq %rbp
jmp 0xeff4
// File: /workspace/github_c_makefile_star2_O1/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 0xf2d0
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_O1/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 0x10156
movq %rsi, %rbx
xorl %r14d, %r14d
cmpb $0x0, (%rbx,%r14)
leaq 0x1(%r14), %r14
jne 0x1011f
decl %r14d
andl $0x3fffffff, %r14d      # imm = 0x3FFFFFFF
incl %r14d
movl %r14d, %esi
callq 0x115e9
testq %rax, %rax
je 0x10158
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_O1/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 0x101d7
movl %esi, %r14d
testl %esi, %esi
jle 0x101c1
movq %rdi, %r15
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x1025e
movw $0x2000, 0x24(%rbx)     # imm = 0x2000
movq (%r15), %rax
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x101d7
movl %r14d, %edx
xorl %esi, %esi
callq 0x8200
jmp 0x101d7
movq %rbx, %rdi
callq 0x101e6
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_O1/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 0x10218
btl $0xa, %eax
jae 0x10232
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
je 0x10232
movq 0x8(%rbx), %rdi
callq *%rcx
movq $0x0, 0x28(%rbx)
jmp 0x1023a
movq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0x2f033
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xec23
testb $0x20, %al
jne 0x10241
testb $0x40, %al
jne 0x10250
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x25543
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xf2d0
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeMemGrow
SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve){
  assert( 1 >=
    ((pMem->zMalloc && pMem->zMalloc==pMem->z) ? 1 : 0) +
    (((pMem->flags&MEM_Dyn)&&pMem->xDel) ? 1 : 0) + 
    ((pMem->flags&MEM_Ephem) ? 1 : 0) + 
    ((pMem->flags&MEM_Static) ? 1 : 0)
  );
  assert( (pMem->flags&MEM_RowSet)==0 );

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
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 0x102ad
cmpq %rdi, 0x170(%rax)
ja 0x102ad
cmpq %rdi, 0x178(%rax)
jbe 0x102ad
movzwl 0x150(%rax), %eax
jmp 0x102b3
callq *0x84185(%rip)          # 0x94438
cmpl %r15d, %eax
jge 0x102fa
testl %r14d, %r14d
je 0x102c7
movq 0x8(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0x102e4
movq (%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x9c3a
movq (%rbx), %rdi
movl %r15d, %esi
callq 0x115e9
movq %rax, 0x30(%rbx)
jmp 0x102fa
movq (%rbx), %rdi
movl %r15d, %edx
callq 0x33504
movq %rax, 0x30(%rbx)
movq %rax, 0x8(%rbx)
xorl %r14d, %r14d
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
sete %al
testl %r14d, %r14d
sete %cl
orb %al, %cl
jne 0x1032b
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
sete %al
cmpq %rdi, %rsi
sete %cl
orb %al, %cl
jne 0x1032b
movslq 0x20(%rbx), %rdx
callq 0x82f0
testb $0x4, 0x25(%rbx)
je 0x10340
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x10340
movq 0x8(%rbx), %rdi
callq *%rax
movq 0x30(%rbx), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x1035b
movzwl 0x24(%rbx), %ecx
andl $0xe7ff, %ecx           # imm = 0xE7FF
xorl %eax, %eax
jmp 0x10364
movw $0x1, %cx
movl $0x7, %eax
movw %cx, 0x24(%rbx)
movq $0x0, 0x28(%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: 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 0x103a8
movl 0x58(%rdi), %edx
xorl %eax, %eax
cmpl %edx, (%rcx)
jne 0x1039d
cmpl %esi, 0x4(%rcx)
je 0x103ac
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x10394
jmp 0x103b0
xorl %eax, %eax
jmp 0x103b0
movq 0x8(%rcx), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10452
movl %esi, %r12d
movq %rdi, %r15
movq 0x50(%rdi), %r13
movq 0x120(%r13), %r14
testq %r14, %r14
je 0x103f9
movl 0x58(%r15), %eax
cmpl %eax, (%r14)
jne 0x103f0
cmpl %r12d, 0x4(%r14)
je 0x1046a
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x103e5
movq (%r13), %rdi
movl $0x20, %esi
movq %rcx, %r14
callq 0x115e9
movq %r14, %rcx
testq %rax, %rax
je 0x10452
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 0x1047f
movl $0x0, 0x5c(%r15)
movb $0x1, 0x61(%r15)
jmp 0x1047f
testq %rcx, %rcx
je 0x10487
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 0x1047f
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_O1/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 0x10509
movq %rax, %rdi
callq 0xec61
movq %rax, %r14
testq %rbx, %rbx
je 0x10501
movq (%rbx), %rdi
movl 0x94(%rbx), %esi
callq 0xea22
movl %eax, 0x94(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10509
movq %rax, %r14
movl 0x24(%rax), %eax
btl $0xb, %eax
jae 0x106fa
andl $0xffffe7ff, %eax       # imm = 0xFFFFE7FF
orl $0x1000, %eax           # imm = 0x1000
movw %ax, 0x24(%r14)
testq %rbx, %rbx
je 0x10713
movq (%rbx), %rdi
movl 0x94(%rbx), %esi
callq 0xea22
movl %eax, 0x94(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x109b8
testl %eax, %eax
je 0x108d7
movl %eax, %r13d
leaq 0x1(%rbx), %rax
cmpq $0x2, %rax
jb 0x1095c
movq %r14, %rdi
callq *%rbx
jmp 0x1095c
movl -0x30(%rbp), %edi
movl -0x2c(%rbp), %edx
testq %r14, %r14
je 0x10959
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 0xeff4
movl %eax, %r14d
testb %r12b, %r12b
je 0x10931
testl %r14d, %r14d
jne 0x10931
movq (%r15), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movzbl 0x71(%rax), %esi
movq %r13, %rdi
callq 0x24e59
movl %eax, %r14d
movq (%r15), %rdi
movl %r14d, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xc8f4
movq (%r15), %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xea22
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_O1/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 0x109b8
movl %eax, %ebx
testl %eax, %eax
jne 0x109ab
movq 0x78(%r15), %rax
movslq %r14d, %rcx
imulq $0x38, %rcx, %rcx
leaq (%rax,%rcx), %rdi
addq $-0x38, %rdi
movsd -0x20(%rbp), %xmm0
callq 0xef73
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: 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
movl %esi, %r15d
movq %rdi, %r14
callq 0x100d8
testl %eax, %eax
je 0x109f4
leaq 0x6ca08(%rip), %rsi     # 0x7d3e4
leaq 0x68b56(%rip), %rcx     # 0x79539
movl $0x15, %ebx
movl $0x15, %edi
movl $0xfb2b, %edx           # imm = 0xFB2B
jmp 0x10a50
cmpl $0xbdf20da3, 0x50(%r14) # imm = 0xBDF20DA3
jne 0x10a08
cmpl $0x0, 0x90(%r14)
js 0x10a68
movq (%r14), %rdi
movl $0x15, %ebx
movl $0x15, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xc8f4
movq 0xe0(%r14), %rdx
leaq 0x69f5d(%rip), %rsi     # 0x7a989
movl $0x15, %edi
xorl %eax, %eax
callq 0xb8cc
leaq 0x6c9a5(%rip), %rsi     # 0x7d3e4
leaq 0x68af3(%rip), %rcx     # 0x79539
movl $0x15, %edi
movl $0xfb33, %edx           # imm = 0xFB33
xorl %eax, %eax
callq 0xb8cc
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r15d, %r15d
jle 0x10a7a
movswl 0x88(%r14), %eax
cmpl %r15d, %eax
jge 0x10a92
movq (%r14), %rdi
movl $0x19, %ebx
movl $0x19, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xc8f4
jmp 0x10a57
leal -0x1(%r15), %r12d
movq 0x78(%r14), %rbx
imulq $0x38, %r12, %r13
leaq (%rbx,%r13), %rdi
callq 0xec23
movw $0x1, 0x24(%rbx,%r13)
movq (%r14), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xc8f4
movzwl 0x9a(%r14), %eax
btl $0xa, %eax
jae 0x10a57
cmpl $0x20, %r15d
jg 0x10ae0
movl 0x104(%r14), %ecx
btl %r12d, %ecx
jb 0x10aee
cmpl $-0x1, 0x104(%r14)
jne 0x10a57
orl $0x20, %eax
movw %ax, 0x9a(%r14)
jmp 0x10a57
// File: /workspace/github_c_makefile_star2_O1/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 0x109b8
movl %eax, %r14d
testl %eax, %eax
jne 0x10b57
movq 0x78(%r12), %rax
movslq %r15d, %rcx
imulq $0x38, %rcx, %rcx
leaq (%rax,%rcx), %r15
addq $-0x38, %r15
movq %r15, %rdi
callq 0xec23
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_O1/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 0x10bf9
leaq 0x64519(%rip), %rcx     # 0x750bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rdx), %rdx
popq %rbp
jmp 0x10b0b
movq 0x8(%rdx), %rax
movl 0x20(%rdx), %ecx
movzbl 0x27(%rdx), %r9d
movq %rax, %rdx
movq $-0x1, %r8
jmp 0x10be8
testb $0x40, 0x25(%rdx)
jne 0x10bff
movq 0x8(%rdx), %rax
movl 0x20(%rdx), %ecx
movq %rax, %rdx
movq $-0x1, %r8
xorl %r9d, %r9d
popq %rbp
jmp 0x10892
movsd 0x10(%rdx), %xmm0
popq %rbp
jmp 0x1096e
popq %rbp
jmp 0x109b8
movl 0x18(%rdx), %edx
popq %rbp
jmp 0x10c08
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_bind_zeroblob
SQLITE_API int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
  rc = vdbeUnbind(p, i);
  if( rc==SQLITE_OK ){
    sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
    sqlite3_mutex_leave(p->db->mutex);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r12
callq 0x109b8
movl %eax, %r14d
testl %eax, %eax
jne 0x10c5c
movq 0x78(%r12), %rax
movslq %r15d, %rcx
imulq $0x38, %rcx, %rcx
leaq (%rax,%rcx), %r15
addq $-0x38, %r15
movq %r15, %rdi
callq 0xec23
movabsq $0x104401000000000, %rax # imm = 0x104401000000000
movq %rax, 0x20(%r15)
xorl %eax, %eax
testl %ebx, %ebx
cmovgl %ebx, %eax
movl %eax, 0x18(%r15)
movl %r14d, %eax
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: sqlite3_bind_parameter_index
SQLITE_PRIVATE int sqlite3Strlen30(const char *z){
  const char *z2 = z;
  if( z==0 ) return 0;
  while( *z2 ){ z2++; }
  return 0x3fffffff & (int)(z2 - z);
}

// Assembly:
testq %rsi, %rsi
je 0x10cd4
pushq %rbp
movq %rsp, %rbp
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rsi, %rax
incl %edx
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x10cc0
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
popq %rbp
jmp 0x10cd8
xorl %edx, %edx
jmp 0x10cd8
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeParameterIndex
SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
  int i;
  if( p==0 ){
    return 0;
  }
  if( zName ){
    for(i=0; i<p->nzVar; i++){
      const char *z = p->azVar[i];
      if( z && strncmp(z,zName,nName)==0 && z[nName]==0 ){
        return i+1;
      }
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
sete %r8b
movq %rsi, -0x38(%rbp)
testq %rsi, %rsi
sete %cl
xorl %eax, %eax
orb %r8b, %cl
jne 0x10d6a
movswq 0x8a(%rdi), %r13
testq %r13, %r13
jle 0x10d6a
movq 0x80(%rdi), %rax
movq %rax, -0x40(%rbp)
movslq %edx, %r14
xorl %ebx, %ebx
movq -0x40(%rbp), %rax
movq (%rax,%rbx,8), %r12
movb $0x1, %r15b
testq %r12, %r12
je 0x10d56
movq %r12, %rdi
movq -0x38(%rbp), %rsi
movq %r14, %rdx
callq 0x81b0
testl %eax, %eax
jne 0x10d56
cmpb $0x0, (%r12,%r14)
leal 0x1(%rbx), %eax
setne %r15b
movl -0x2c(%rbp), %ecx
cmovel %eax, %ecx
movl %ecx, -0x2c(%rbp)
testb %r15b, %r15b
je 0x10d67
incq %rbx
cmpq %rbx, %r13
jne 0x10d1e
xorl %eax, %eax
jmp 0x10d6a
movl -0x2c(%rbp), %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: sqlite3_transfer_bindings
SQLITE_API int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
  Vdbe *pFrom = (Vdbe*)pFromStmt;
  Vdbe *pTo = (Vdbe*)pToStmt;
  if( pFrom->nVar!=pTo->nVar ){
    return SQLITE_ERROR;
  }
  if( pTo->isPrepareV2 && pTo->expmask ){
    pTo->expired = 1;
  }
  if( pFrom->isPrepareV2 && pFrom->expmask ){
    pFrom->expired = 1;
  }
  return sqlite3TransferBindings(pFromStmt, pToStmt);
}

// Assembly:
movzwl 0x88(%rdi), %ecx
movl $0x1, %eax
cmpw 0x88(%rsi), %cx
jne 0x10dda
movzwl 0x9a(%rsi), %eax
btl $0xa, %eax
jae 0x10dae
cmpl $0x0, 0x104(%rsi)
je 0x10dae
orl $0x20, %eax
movw %ax, 0x9a(%rsi)
movzwl 0x9a(%rdi), %eax
btl $0xa, %eax
jae 0x10dce
cmpl $0x0, 0x104(%rdi)
je 0x10dce
orl $0x20, %eax
movw %ax, 0x9a(%rdi)
pushq %rbp
movq %rsp, %rbp
callq 0x10ddb
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3TransferBindings
SQLITE_PRIVATE int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
  Vdbe *pFrom = (Vdbe*)pFromStmt;
  Vdbe *pTo = (Vdbe*)pToStmt;
  int i;
  assert( pTo->db==pFrom->db );
  assert( pTo->nVar==pFrom->nVar );
  sqlite3_mutex_enter(pTo->db->mutex);
  for(i=0; i<pFrom->nVar; i++){
    sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
  }
  sqlite3_mutex_leave(pTo->db->mutex);
  return SQLITE_OK;
}

// Assembly:
cmpw $0x0, 0x88(%rdi)
jle 0x10e79
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %rsi, -0x30(%rbp)
movq 0x78(%rsi), %r13
leaq (%r15,%r13), %rdi
movq 0x78(%r14), %rbx
callq 0xec23
movq -0x30(%rbp), %rsi
movq 0x30(%rbx,%r15), %rax
movq %rax, 0x30(%r13,%r15)
movups (%rbx,%r15), %xmm0
movups 0x10(%rbx,%r15), %xmm1
movups 0x20(%rbx,%r15), %xmm2
movups %xmm2, 0x20(%r13,%r15)
movups %xmm1, 0x10(%r13,%r15)
movups %xmm0, (%r13,%r15)
movw $0x1, 0x24(%rbx,%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx,%r15)
incq %r12
movswq 0x88(%r14), %rax
addq $0x38, %r15
cmpq %rax, %r12
jl 0x10e04
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: sqlite3_stmt_status
SQLITE_API int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
  Vdbe *pVdbe = (Vdbe*)pStmt;
  u32 v = pVdbe->aCounter[op];
  if( resetFlag ) pVdbe->aCounter[op] = 0;
  return (int)v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rcx
movl 0xac(%rdi,%rcx,4), %eax
testl %edx, %edx
je 0x10f02
movl $0x0, 0xac(%rdi,%rcx,4)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_value_numeric_type
SQLITE_API int sqlite3_value_numeric_type(sqlite3_value *pVal){
  Mem *pMem = (Mem*)pVal;
  if( pMem->type==SQLITE_TEXT ){
    applyNumericAffinity(pMem);
    sqlite3VdbeMemStoreType(pMem);
  }
  return pMem->type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x3, 0x26(%rdi)
jne 0x10f23
movq %rbx, %rdi
callq 0x10f2e
movq %rbx, %rdi
callq 0x10fc1
movzbl 0x26(%rbx), %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: applyNumericAffinity
static void applyNumericAffinity(Mem *pRec){
  if( (pRec->flags & (MEM_Real|MEM_Int))==0 ){
    double rValue;
    i64 iValue;
    u8 enc = pRec->enc;
    if( (pRec->flags&MEM_Str)==0 ) return;
    if( sqlite3AtoF(pRec->z, &rValue, pRec->n, enc)==0 ) return;
    if( 0==sqlite3Atoi64(pRec->z, &iValue, pRec->n, enc) ){
      pRec->u.i = iValue;
      pRec->flags |= MEM_Int;
    }else{
      pRec->r = rValue;
      pRec->flags |= MEM_Real;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movzwl 0x24(%rdi), %r13d
testb $0xc, %r13b
jne 0x10fb2
testb $0x2, %r13b
je 0x10fb2
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movl 0x20(%rdi), %r14d
movzbl 0x27(%rdi), %r12d
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
movl %r14d, %edx
movl %r12d, %ecx
callq 0x248aa
testl %eax, %eax
je 0x10fb2
leaq -0x30(%rbp), %rsi
movq %r15, %rdi
movl %r14d, %edx
movl %r12d, %ecx
callq 0x16f9b
testl %eax, %eax
je 0x10f9c
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0x10(%rbx)
movw $0x8, %ax
jmp 0x10fa8
movq -0x30(%rbp), %rax
movq %rax, 0x18(%rbx)
movw $0x4, %ax
movzwl %ax, %eax
orl %r13d, %eax
movw %ax, 0x24(%rbx)
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: sqlite3VdbeMemStoreType
SQLITE_PRIVATE void sqlite3VdbeMemStoreType(Mem *pMem){
  int flags = pMem->flags;
  if( flags & MEM_Null ){
    pMem->type = SQLITE_NULL;
  }
  else if( flags & MEM_Int ){
    pMem->type = SQLITE_INTEGER;
  }
  else if( flags & MEM_Real ){
    pMem->type = SQLITE_FLOAT;
  }
  else if( flags & MEM_Str ){
    pMem->type = SQLITE_TEXT;
  }else{
    pMem->type = SQLITE_BLOB;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzwl 0x24(%rdi), %eax
testb $0x1, %al
jne 0x10fdf
testb $0x4, %al
jne 0x10fe5
testb $0x8, %al
jne 0x10feb
testb $0x2, %al
jne 0x10ff1
movb $0x4, 0x26(%rdi)
jmp 0x10ff5
movb $0x5, 0x26(%rdi)
jmp 0x10ff5
movb $0x1, 0x26(%rdi)
jmp 0x10ff5
movb $0x2, 0x26(%rdi)
jmp 0x10ff5
movb $0x3, 0x26(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3DbMallocRaw
SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3 *db, int n){
  void *p;
  assert( db==0 || sqlite3_mutex_held(db->mutex) );
  assert( db==0 || db->pnBytesFreed==0 );
#ifndef SQLITE_OMIT_LOOKASIDE
  if( db ){
    LookasideSlot *pBuf;
    if( db->mallocFailed ){
      return 0;
    }
    if( db->lookaside.bEnabled ){
      if( n>db->lookaside.sz ){
        db->lookaside.anStat[1]++;
      }else if( (pBuf = db->lookaside.pFree)==0 ){
        db->lookaside.anStat[2]++;
      }else{
        db->lookaside.pFree = pBuf->pNext;
        db->lookaside.nOut++;
        db->lookaside.anStat[0]++;
        if( db->lookaside.nOut>db->lookaside.mxOut ){
          db->lookaside.mxOut = db->lookaside.nOut;
        }
        return (void*)pBuf;
      }
    }
  }
#else
  if( db && db->mallocFailed ){
    return 0;
  }
#endif
  p = sqlite3Malloc(n);
  if( !p && db ){
    db->mallocFailed = 1;
  }
  sqlite3MemdebugSetType(p, MEMTYPE_DB |
         ((db && db->lookaside.bEnabled) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x11667
cmpb $0x0, 0x50(%rbx)
je 0x11604
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x11663
movb $0x1, %cl
cmpb $0x0, 0x152(%rbx)
je 0x11663
movzwl 0x150(%rbx), %eax
cmpl %esi, %eax
jge 0x11622
incl 0x160(%rbx)
jmp 0x11663
movq 0x168(%rbx), %rax
testq %rax, %rax
je 0x1165d
movq (%rax), %rcx
movq %rcx, 0x168(%rbx)
movl 0x154(%rbx), %edx
leal 0x1(%rdx), %ecx
movl %ecx, 0x154(%rbx)
incl 0x15c(%rbx)
cmpl 0x158(%rbx), %edx
jl 0x11600
movl %ecx, 0x158(%rbx)
jmp 0x11600
incl 0x164(%rbx)
testb %cl, %cl
je 0x11684
testq %rbx, %rbx
sete %r14b
movl %esi, %edi
callq 0xa2a2
testq %rax, %rax
setne %cl
orb %r14b, %cl
jne 0x11684
movb $0x1, 0x50(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3LocateTable
SQLITE_PRIVATE Table *sqlite3LocateTable(
  Parse *pParse,         /* context in which to report errors */
  int isView,            /* True if looking for a VIEW rather than a TABLE */
  const char *zName,     /* Name of the table we are looking for */
  const char *zDbase     /* Name of the database.  Might be NULL */
){
  Table *p;

  /* Read the database schema. If an error occurs, leave an error message
  ** and code in pParse and return NULL. */
  if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
    return 0;
  }

  p = sqlite3FindTable(pParse->db, zName, zDbase);
  if( p==0 ){
    const char *zMsg = isView ? "no such view" : "no such table";
    if( zDbase ){
      sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
    }else{
      sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
    }
    pParse->checkSchema = 1;
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r15
movl %esi, %r13d
movq %rdi, %rbx
callq 0x36175
testl %eax, %eax
je 0x116b1
xorl %r14d, %r14d
jmp 0x11712
movq (%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x33aab
movq %rax, %r14
testq %rax, %rax
jne 0x11712
testl %r13d, %r13d
leaq 0x6932b(%rip), %rax     # 0x7a9fc
leaq 0x69317(%rip), %rdx     # 0x7a9ef
cmoveq %rax, %rdx
testq %r12, %r12
je 0x116fa
leaq 0x69322(%rip), %rsi     # 0x7aa0a
movq %rbx, %rdi
movq %r12, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x11724
jmp 0x1170e
leaq 0x69313(%rip), %rsi     # 0x7aa14
movq %rbx, %rdi
movq %r15, %rcx
xorl %eax, %eax
callq 0x11724
movb $0x1, 0x1d(%rbx)
movq %r14, %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: sqlite3ErrorMsg
SQLITE_PRIVATE void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
  char *zMsg;
  va_list ap;
  sqlite3 *db = pParse->db;
  va_start(ap, zFormat);
  zMsg = sqlite3VMPrintf(db, zFormat, ap);
  va_end(ap);
  if( db->suppressErr ){
    sqlite3DbFree(db, zMsg);
  }else{
    pParse->nErr++;
    sqlite3DbFree(db, pParse->zErrMsg);
    pParse->zErrMsg = zMsg;
    pParse->rc = SQLITE_ERROR;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq -0xe0(%rbp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x1177b
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq (%rbx), %r14
leaq -0x30(%rbp), %rdx
movq %rdi, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq %r14, %rdi
callq 0x19668
movq %rax, %r15
cmpb $0x0, 0x53(%r14)
je 0x117ba
movq %r14, %rdi
movq %r15, %rsi
callq 0x9c3a
jmp 0x117d4
incl 0x50(%rbx)
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x9c3a
movq %r15, 0x8(%rbx)
movl $0x1, 0x18(%rbx)
addq $0xc8, %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: sqlite3MPrintf
SQLITE_PRIVATE char *sqlite3MPrintf(sqlite3 *db, const char *zFormat, ...){
  va_list ap;
  char *z;
  va_start(ap, zFormat);
  z = sqlite3VMPrintf(db, zFormat, ap);
  va_end(ap);
  return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
leaq -0xd0(%rbp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x1182e
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
leaq -0x20(%rbp), %rdx
movq %r10, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
callq 0x19668
addq $0xd0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeCreate
SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(sqlite3 *db){
  Vdbe *p;
  p = sqlite3DbMallocZero(db, sizeof(Vdbe) );
  if( p==0 ) return 0;
  p->db = db;
  if( db->pVdbe ){
    db->pVdbe->pPrev = p;
  }
  p->pNext = db->pVdbe;
  p->pPrev = 0;
  db->pVdbe = p;
  p->magic = VDBE_MAGIC_INIT;
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x128, %esi            # imm = 0x128
callq 0x115e9
testq %rax, %rax
je 0x118ad
movq %rax, %rbx
movl $0x128, %edx            # imm = 0x128
movq %rax, %rdi
xorl %esi, %esi
callq 0x8200
movq %r14, (%rbx)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x11894
movq %rbx, 0x60(%rax)
movq %rax, 0x68(%rbx)
movq $0x0, 0x60(%rbx)
movq %rbx, 0x8(%r14)
movl $0x26bceaa5, 0x50(%rbx) # imm = 0x26BCEAA5
jmp 0x118af
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3VdbeAddOpList
SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp){
  int addr;
  assert( p->magic==VDBE_MAGIC_INIT );
  if( p->nOp + nOp > p->nOpAlloc && growOpArray(p) ){
    return 0;
  }
  addr = p->nOp;
  if( ALWAYS(nOp>0) ){
    int i;
    VdbeOpList const *pIn = aOp;
    for(i=0; i<nOp; i++, pIn++){
      int p2 = pIn->p2;
      VdbeOp *pOut = &p->aOp[i+addr];
      pOut->opcode = pIn->opcode;
      pOut->p1 = pIn->p1;
      if( p2<0 && (sqlite3OpcodeProperty[pOut->opcode] & OPFLG_JUMP)!=0 ){
        pOut->p2 = addr + ADDR(p2);
      }else{
        pOut->p2 = p2;
      }
      pOut->p3 = pIn->p3;
      pOut->p4type = P4_NOTUSED;
      pOut->p4.p = 0;
      pOut->p5 = 0;
#ifdef SQLITE_DEBUG
      pOut->zComment = 0;
      if( p->db->flags & SQLITE_VdbeAddopTrace ){
        sqlite3VdbePrintOp(0, i+addr, &p->aOp[i+addr]);
      }
#endif
    }
    p->nOp += nOp;
  }
  return addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
movl 0x34(%rdi), %eax
addl %esi, %eax
cmpl 0x38(%rdi), %eax
jle 0x118e8
movq %r15, %rdi
callq 0x35f46
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x1196c
movl 0x34(%r15), %eax
testl %ebx, %ebx
jle 0x11968
movslq %eax, %rdx
movl %ebx, %ecx
shlq $0x3, %rdx
leaq (%rdx,%rdx,2), %rdx
xorl %esi, %esi
leaq 0x6501a(%rip), %rdi     # 0x76920
xorl %r8d, %r8d
movsbl 0x2(%r14,%r8,4), %r10d
movq 0x8(%r15), %r9
movzbl (%r14,%r8,4), %r11d
movb %r11b, (%r9,%rdx)
movsbl 0x1(%r14,%r8,4), %r12d
movl %r12d, 0x4(%r9,%rdx)
testl %r10d, %r10d
jns 0x11939
testb $0x1, (%r11,%rdi)
je 0x11939
notl %r10d
addl %eax, %r10d
movl %r10d, 0x8(%r9,%rdx)
movsbl 0x3(%r14,%r8,4), %r10d
movl %r10d, 0xc(%r9,%rdx)
movb %sil, 0x1(%r9,%rdx)
movq $0x0, 0x10(%r9,%rdx)
movb %sil, 0x3(%r9,%rdx)
incq %r8
addq $0x18, %rdx
cmpq %r8, %rcx
jne 0x11909
addl %ebx, 0x34(%r15)
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: sqlite3VdbeChangeToNoop
SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe *p, int addr){
  if( p->aOp ){
    VdbeOp *pOp = &p->aOp[addr];
    sqlite3 *db = p->db;
    freeP4(db, pOp->p4type, pOp->p4.p);
    memset(pOp, 0, sizeof(pOp[0]));
    pOp->opcode = OP_Noop;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x11b5d
movslq %esi, %rax
leaq (%rax,%rax,2), %r14
movq (%rdi), %rdi
movsbl 0x1(%rbx,%r14,8), %esi
movq 0x10(%rbx,%r14,8), %rdx
callq 0x23197
xorps %xmm0, %xmm0
movups %xmm0, (%rbx,%r14,8)
movq $0x0, 0x10(%rbx,%r14,8)
movb $-0x6b, (%rbx,%r14,8)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3_blob_close
SQLITE_API int sqlite3_blob_close(sqlite3_blob *pBlob){
  Incrblob *p = (Incrblob *)pBlob;
  int rc;
  sqlite3 *db;

  if( p ){
    db = p->db;
    sqlite3_mutex_enter(db->mutex);
    rc = sqlite3_finalize(p->pStmt);
    sqlite3DbFree(db, p);
    sqlite3_mutex_leave(db->mutex);
  }else{
    rc = SQLITE_OK;
  }
  return rc;
}

// Assembly:
testq %rdi, %rdi
je 0x12125
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x20(%rbx), %r14
callq 0xe974
movl %eax, %r15d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9c3a
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: blobReadWrite
static int blobReadWrite(
  sqlite3_blob *pBlob, 
  void *z, 
  int n, 
  int iOffset, 
  int (*xCall)(BtCursor*, u32, u32, void*)
){
  int rc;
  Incrblob *p = (Incrblob *)pBlob;
  Vdbe *v;
  sqlite3 *db;

  if( p==0 ) return SQLITE_MISUSE_BKPT;
  db = p->db;
  sqlite3_mutex_enter(db->mutex);
  v = (Vdbe*)p->pStmt;

  if( n<0 || iOffset<0 || (iOffset+n)>p->nByte ){
    /* Request is out of range. Return a transient error. */
    rc = SQLITE_ERROR;
    sqlite3Error(db, SQLITE_ERROR, 0);
  }else if( v==0 ){
    /* If there is no statement handle, then the blob-handle has
    ** already been invalidated. Return SQLITE_ABORT in this case.
    */
    rc = SQLITE_ABORT;
  }else{
    /* Call either BtreeData() or BtreePutData(). If SQLITE_ABORT is
    ** returned, clean-up the statement handle.
    */
    assert( db == v->db );
    sqlite3BtreeEnterCursor(p->pCsr);
    rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
    sqlite3BtreeLeaveCursor(p->pCsr);
    if( rc==SQLITE_ABORT ){
      sqlite3VdbeFinalize(v);
      p->pStmt = 0;
    }else{
      db->errCode = rc;
      v->rc = rc;
    }
  }
  rc = sqlite3ApiExit(db, rc);
  sqlite3_mutex_leave(db->mutex);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x12189
movq %rsi, %rax
movq %rdi, %r14
movq 0x20(%rdi), %rbx
movl %ecx, %esi
orl %edx, %esi
js 0x1215f
leal (%rcx,%rdx), %esi
cmpl 0x4(%r14), %esi
jle 0x121b6
movl $0x1, %r15d
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0xc8f4
movq %rbx, %rdi
movl %r15d, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xea22
leaq 0x6b254(%rip), %rsi     # 0x7d3e4
leaq 0x673a2(%rip), %rcx     # 0x79539
movl $0x15, %edi
movl $0x11a1c, %edx          # imm = 0x11A1C
xorl %eax, %eax
callq 0xb8cc
movl $0x15, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r14), %r12
movl $0x4, %r15d
testq %r12, %r12
je 0x12176
movq 0x10(%r14), %rdi
addl 0x8(%r14), %ecx
movl %ecx, %esi
movq %rax, %rcx
callq *%r8
cmpl $0x4, %eax
jne 0x121ec
movq %r12, %rdi
callq 0xe9e9
movq $0x0, 0x18(%r14)
jmp 0x12176
movl %eax, 0x44(%rbx)
movl %eax, 0x94(%r12)
movl %eax, %r15d
jmp 0x12176
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3BtreeData
SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
  int rc;

#ifndef SQLITE_OMIT_INCRBLOB
  if ( pCur->eState==CURSOR_INVALID ){
    return SQLITE_ABORT;
  }
#endif

  assert( cursorHoldsMutex(pCur) );
  rc = restoreCursorPosition(pCur);
  if( rc==SQLITE_OK ){
    assert( pCur->eState==CURSOR_VALID );
    assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
    assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
    rc = accessPayload(pCur, offset, amt, pBuf, 0);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movb 0x77(%rdi), %cl
testb %cl, %cl
je 0x1224c
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
xorl %eax, %eax
cmpb $0x3, %cl
jb 0x1222c
movq %r12, %rdi
callq 0x2fe4a
testl %eax, %eax
jne 0x12251
movq %r12, %rdi
movl %r15d, %esi
movl %r14d, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2186f
movl $0x4, %eax
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: sqlite3BtreePutData
SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){
  int rc;
  assert( cursorHoldsMutex(pCsr) );
  assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) );
  assert( pCsr->isIncrblobHandle );

  rc = restoreCursorPosition(pCsr);
  if( rc!=SQLITE_OK ){
    return rc;
  }
  assert( pCsr->eState!=CURSOR_REQUIRESEEK );
  if( pCsr->eState!=CURSOR_VALID ){
    return SQLITE_ABORT;
  }

  /* Save the positions of all other cursors open on this table. This is
  ** required in case any of them are holding references to an xFetch
  ** version of the b-tree page modified by the accessPayload call below.
  **
  ** Note that pCsr must be open on a BTREE_INTKEY table and saveCursorPosition()
  ** and hence saveAllCursors() cannot fail on a BTREE_INTKEY table, hence
  ** saveAllCursors can only return SQLITE_OK.
  */
  VVA_ONLY(rc =) saveAllCursors(pCsr->pBt, pCsr->pgnoRoot, pCsr);
  assert( rc==SQLITE_OK );

  /* Check some assumptions: 
  **   (a) the cursor is open for writing,
  **   (b) there is a read/write transaction open,
  **   (c) the connection holds a write-lock on the table (if required),
  **   (d) there are no conflicting read-locks, and
  **   (e) the cursor points at a valid row of an intKey table.
  */
  if( !pCsr->wrFlag ){
    return SQLITE_READONLY;
  }
  assert( (pCsr->pBt->btsFlags & BTS_READ_ONLY)==0
              && pCsr->pBt->inTransaction==TRANS_WRITE );
  assert( hasSharedCacheTableLock(pCsr->pBtree, pCsr->pgnoRoot, 0, 2) );
  assert( !hasReadConflicts(pCsr->pBtree, pCsr->pgnoRoot) );
  assert( pCsr->apPage[pCsr->iPage]->intKey );

  return accessPayload(pCsr, offset, amt, (unsigned char *)z, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
xorl %eax, %eax
cmpb $0x3, 0x77(%rdi)
jb 0x12292
movq %r12, %rdi
callq 0x2fe4a
testl %eax, %eax
jne 0x122e1
movl $0x4, %eax
cmpb $0x1, 0x77(%r12)
jne 0x122e1
movq 0x8(%r12), %rdi
movl 0x30(%r12), %esi
movq %r12, %rdx
callq 0x21124
cmpb $0x0, 0x74(%r12)
je 0x122dc
movq %r12, %rdi
movl %r15d, %esi
movl %r14d, %edx
movq %rbx, %rcx
movl $0x1, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2186f
movl $0x8, %eax
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: sqlite3_blob_reopen
SQLITE_API int sqlite3_blob_reopen(sqlite3_blob *pBlob, sqlite3_int64 iRow){
  int rc;
  Incrblob *p = (Incrblob *)pBlob;
  sqlite3 *db;

  if( p==0 ) return SQLITE_MISUSE_BKPT;
  db = p->db;
  sqlite3_mutex_enter(db->mutex);

  if( p->pStmt==0 ){
    /* If there is no statement handle, then the blob-handle has
    ** already been invalidated. Return SQLITE_ABORT in this case.
    */
    rc = SQLITE_ABORT;
  }else{
    char *zErr;
    rc = blobSeekToRow(p, iRow, &zErr);
    if( rc!=SQLITE_OK ){
      sqlite3Error(db, rc, (zErr ? "%s" : 0), zErr);
      sqlite3DbFree(db, zErr);
    }
    assert( rc!=SQLITE_SCHEMA );
  }

  rc = sqlite3ApiExit(db, rc);
  assert( rc==SQLITE_OK || p->pStmt==0 );
  sqlite3_mutex_leave(db->mutex);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1235a
movq 0x20(%rdi), %rbx
cmpq $0x0, 0x18(%rdi)
je 0x12389
leaq -0x20(%rbp), %rdx
callq 0x11f8d
movl %eax, %r14d
testl %eax, %eax
je 0x1238f
movq -0x20(%rbp), %r15
testq %r15, %r15
leaq 0x673a0(%rip), %rdx     # 0x796d9
cmoveq %r15, %rdx
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rcx
xorl %eax, %eax
callq 0xc8f4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9c3a
jmp 0x1238f
leaq 0x6b083(%rip), %rsi     # 0x7d3e4
leaq 0x671d1(%rip), %rcx     # 0x79539
movl $0x15, %edi
movl $0x11a67, %edx          # imm = 0x11A67
xorl %eax, %eax
callq 0xb8cc
movl $0x15, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x4, %r14d
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xea22