LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3BtreeRollback
SQLITE_PRIVATE int sqlite3BtreeRollback(Btree *p, int tripCode, int writeOnly){
  int rc;
  BtShared *pBt = p->pBt;
  MemPage *pPage1;

  assert( writeOnly==1 || writeOnly==0 );
  assert( tripCode==SQLITE_ABORT_ROLLBACK || tripCode==SQLITE_OK );
  sqlite3BtreeEnter(p);
  if( tripCode==SQLITE_OK ){
    rc = tripCode = saveAllCursors(pBt, 0, 0);
    if( rc ) writeOnly = 0;
  }else{
    rc = SQLITE_OK;
  }
  if( tripCode ){
    int rc2 = sqlite3BtreeTripAllCursors(p, tripCode, writeOnly);
    assert( rc==SQLITE_OK || (writeOnly==0 && rc2==SQLITE_OK) );
    if( rc2!=SQLITE_OK ) rc = rc2;
  }
  btreeIntegrity(p);

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movq 0x8(%rdi), %r14
cmpb $0x0, 0x11(%rdi)
je 0x10f05
incl 0x14(%rbx)
cmpb $0x0, 0x12(%rbx)
jne 0x10f05
movq %rbx, %rdi
callq 0x25420
testl %r12d, %r12d
jne 0x10f2f
movq 0x10(%r14), %rdi
xorl %r13d, %r13d
movl $0x0, %r12d
testq %rdi, %rdi
je 0x10f28
xorl %esi, %esi
xorl %edx, %edx
callq 0x26d3a
movl %eax, %r12d
testl %r12d, %r12d
cmovnel %r13d, %r15d
testl %r12d, %r12d
je 0x10f42
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x286d9
cmpb $0x2, 0x10(%rbx)
jne 0x10fa6
movq (%r14), %rdi
callq 0x2387b
leaq -0x30(%rbp), %rdx
movq %r14, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
callq 0x2599b
testl %eax, %eax
jne 0x10f90
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rcx
movl 0x1c(%rcx), %ecx
bswapl %ecx
testl %ecx, %ecx
jne 0x10f7e
movq (%r14), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, 0x3c(%r14)
testq %rax, %rax
je 0x10f90
movq 0x70(%rax), %rdi
callq 0x25020
movb $0x1, 0x24(%r14)
movq 0x58(%r14), %rdi
callq 0x23746
movq $0x0, 0x58(%r14)
movq %rbx, %rdi
callq 0x26897
cmpb $0x0, 0x11(%rbx)
je 0x10fb9
decl 0x14(%rbx)
je 0x10fc8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x254a6
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: invokeProfileCallback
static SQLITE_NOINLINE void invokeProfileCallback(sqlite3 *db, Vdbe *p){
  sqlite3_int64 iNow;
  assert( p->startTime>0 );
  assert( db->xProfile!=0 );
  assert( db->init.busy==0 );
  assert( p->zSql!=0 );
  sqlite3OsCurrentTimeInt64(db->pVfs, &iNow);
  db->xProfile(db->pProfileArg, p->zSql, (iNow - p->startTime)*1000000);
  p->startTime = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq -0x20(%rbp), %r15
movq %r15, %rsi
callq 0x289f2
movq 0xe0(%r14), %rdi
movq 0xe0(%rbx), %rsi
movq (%r15), %rax
subq 0xb8(%rbx), %rax
imulq $0xf4240, %rax, %rdx    # imm = 0xF4240
callq *0xd8(%r14)
movq $0x0, 0xb8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_value_blob
SQLITE_API const void *SQLITE_STDCALL sqlite3_value_blob(sqlite3_value *pVal){
  Mem *p = (Mem*)pVal;
  if( p->flags & (MEM_Blob|MEM_Str) ){
    if( sqlite3VdbeMemExpandBlob(p)!=SQLITE_OK ){
      assert( p->flags==MEM_Null && p->z==0 );
      return 0;
    }
    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, 0x8(%rdi)
je 0x11651
movq %rbx, %rdi
callq 0x11679
testl %eax, %eax
je 0x11664
xorl %eax, %eax
jmp 0x11672
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x11820
orb $0x10, 0x8(%rbx)
cmpl $0x0, 0xc(%rbx)
je 0x1164d
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/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_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){
    return pVal->z;
  }
  if( pVal->flags&MEM_Null ){
    return 0;
  }
  return valueToText(pVal, enc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x11852
movl 0x8(%rdi), %eax
movl %eax, %ecx
notl %ecx
testl $0x202, %ecx            # imm = 0x202
jne 0x11844
cmpb %sil, 0xa(%rdi)
jne 0x11844
movq 0x10(%rdi), %rax
jmp 0x11854
testb $0x1, %al
jne 0x11852
movzbl %sil, %esi
popq %rbp
jmp 0x2a918
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeMemMakeWriteable
SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *pMem){
  int f;
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( (pMem->flags&MEM_RowSet)==0 );
  ExpandBlob(pMem);
  f = pMem->flags;
  if( (f&(MEM_Str|MEM_Blob)) && (pMem->szMalloc==0 || pMem->z!=pMem->zMalloc) ){
    if( sqlite3VdbeMemGrow(pMem, pMem->n + 2, 1) ){
      return SQLITE_NOMEM;
    }
    pMem->z[pMem->n] = 0;
    pMem->z[pMem->n+1] = 0;
    pMem->flags |= MEM_Term;
  }
  pMem->flags &= ~MEM_Ephem;
#ifdef SQLITE_DEBUG
  pMem->pScopyFrom = 0;
#endif

  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x40, 0x9(%rdi)
je 0x1193e
movq %rbx, %rdi
callq 0x11679
testb $0x12, 0x8(%rbx)
je 0x1198f
cmpl $0x0, 0x20(%rbx)
je 0x11954
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
je 0x1198f
movl 0xc(%rbx), %esi
addl $0x2, %esi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2a792
movl %eax, %ecx
movl $0x7, %eax
testl %ecx, %ecx
jne 0x11995
movq 0x10(%rbx), %rax
movslq 0xc(%rbx), %rcx
xorl %edx, %edx
movb %dl, (%rax,%rcx)
movq 0x10(%rbx), %rax
movslq 0xc(%rbx), %rcx
movb %dl, 0x1(%rax,%rcx)
orb $0x2, 0x9(%rbx)
andb $-0x11, 0x9(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_result_error
SQLITE_STDCALL sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  pCtx->isError = SQLITE_ERROR;
  pCtx->fErrorOrAux = 1;
  sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, 0x24(%rdi)
movb $0x1, 0x29(%rdi)
movq (%rdi), %rdi
movl $0x1, %ecx
movq $-0x1, %r8
popq %rbp
jmp 0x11b32
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_result_error16
SQLITE_STDCALL sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  pCtx->isError = SQLITE_ERROR;
  pCtx->fErrorOrAux = 1;
  sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, 0x24(%rdi)
movb $0x1, 0x29(%rdi)
movq (%rdi), %rdi
movl $0x2, %ecx
movq $-0x1, %r8
popq %rbp
jmp 0x11b32
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeMemCopy
SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
  int rc = SQLITE_OK;

  /* The pFrom==0 case in the following assert() is when an sqlite3_value
  ** from sqlite3_value_dup() is used as the argument
  ** to sqlite3_result_value(). */
  assert( pTo->db==pFrom->db || pFrom->db==0 );
  assert( (pFrom->flags & MEM_RowSet)==0 );
  if( VdbeMemDynamic(pTo) ) vdbeMemClearExternAndSetNull(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 0x8(%rdi), %eax
testl $0x2460, %eax           # imm = 0x2460
je 0x11f4f
movq %rbx, %rdi
callq 0x2a646
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movzwl 0x8(%rbx), %ecx
movl %ecx, %eax
andl $0xfbff, %eax           # imm = 0xFBFF
movw %ax, 0x8(%rbx)
testb $0x12, %cl
je 0x11f8e
testb $0x8, 0x9(%r14)
jne 0x11f8e
orl $0x1000, %eax           # imm = 0x1000
movw %ax, 0x8(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x11927
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_result_error_toobig
SQLITE_STDCALL sqlite3_result_error_toobig(sqlite3_context *pCtx){
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  pCtx->isError = SQLITE_TOOBIG;
  pCtx->fErrorOrAux = 1;
  sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1, 
                       SQLITE_UTF8, SQLITE_STATIC);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x12, 0x24(%rdi)
movb $0x1, 0x29(%rdi)
movq (%rdi), %rdi
leaq 0x6b00d(%rip), %rsi     # 0x7d096
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
xorl %r8d, %r8d
popq %rbp
jmp 0x11b32
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_result_error_nomem
SQLITE_STDCALL sqlite3_result_error_nomem(sqlite3_context *pCtx){
  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
  sqlite3VdbeMemSetNull(pCtx->pOut);
  pCtx->isError = SQLITE_NOMEM;
  pCtx->fErrorOrAux = 1;
  pCtx->pOut->db->mallocFailed = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movzwl 0x8(%rdi), %eax
testl $0x2460, %eax           # imm = 0x2460
je 0x120ba
callq 0x2a646
jmp 0x120c0
movw $0x1, 0x8(%rdi)
movl $0x7, 0x24(%rbx)
movb $0x1, %al
movb %al, 0x29(%rbx)
movq (%rbx), %rcx
movq 0x28(%rcx), %rcx
movb %al, 0x51(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_aggregate_context
SQLITE_API void *SQLITE_STDCALL sqlite3_aggregate_context(sqlite3_context *p, int nByte){
  assert( p && p->pFunc && p->pFunc->xStep );
  assert( sqlite3_mutex_held(p->pOut->db->mutex) );
  testcase( nByte<0 );
  if( (p->pMem->flags & MEM_Agg)==0 ){
    return createAggContext(p, nByte);
  }else{
    return (void*)p->pMem->z;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rax
testb $0x20, 0x9(%rax)
jne 0x12d93
popq %rbp
jmp 0x12d99
movq 0x10(%rax), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_get_auxdata
SQLITE_API void *SQLITE_STDCALL sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
  AuxData *pAuxData;

  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
#if SQLITE_ENABLE_STAT3_OR_STAT4
  if( pCtx->pVdbe==0 ) return 0;
#else
  assert( pCtx->pVdbe!=0 );
#endif
  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 0x18(%rdi), %rax
movq 0x120(%rax), %rcx
testq %rcx, %rcx
je 0x12e53
movl 0x20(%rdi), %edx
xorl %eax, %eax
cmpl %edx, (%rcx)
jne 0x12e48
cmpl %esi, 0x4(%rcx)
je 0x12e57
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x12e3f
jmp 0x12e5b
xorl %eax, %eax
jmp 0x12e5b
movq 0x8(%rcx), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_column_blob
SQLITE_API const void *SQLITE_STDCALL 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 0x12fa9
movq %rax, %rdi
callq 0xa520
movq %rax, %r14
movq %rbx, %rdi
callq 0x1304a
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: columnMem
static Mem *columnMem(sqlite3_stmt *pStmt, int i){
  Vdbe *pVm;
  Mem *pOut;

  pVm = (Vdbe *)pStmt;
  if( pVm && pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){
    sqlite3_mutex_enter(pVm->db->mutex);
    pOut = &pVm->pResultSet[i];
  }else{
    if( pVm && ALWAYS(pVm->db) ){
      sqlite3_mutex_enter(pVm->db->mutex);
      sqlite3Error(pVm->db, SQLITE_RANGE);
    }
    pOut = (Mem*)columnNullValue();
  }
  return pOut;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x67da6(%rip), %rbx     # 0x7ad60
testq %rdi, %rdi
je 0x1303c
movq %rdi, %r14
cmpq $0x0, 0x28(%rdi)
je 0x12ff7
movl %esi, %r15d
movzwl 0x88(%r14), %eax
cmpl %esi, %eax
jbe 0x12ff7
movq (%r14), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x12fea
callq *0x803be(%rip)          # 0x933a8
movl %r15d, %eax
imulq $0x38, %rax, %rbx
addq 0x28(%r14), %rbx
jmp 0x1303c
movq (%r14), %rax
testq %rax, %rax
je 0x1303c
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x1300e
callq *0x8039a(%rip)          # 0x933a8
movq (%r14), %rax
movl $0x19, 0x44(%rax)
movq 0x140(%rax), %rdi
testq %rdi, %rdi
je 0x1303c
movzwl 0x8(%rdi), %eax
testl $0x2460, %eax           # imm = 0x2460
je 0x13036
callq 0x2a646
jmp 0x1303c
movw $0x1, 0x8(%rdi)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_bind_blob64
SQLITE_STDCALL sqlite3_bind_blob64(
  sqlite3_stmt *pStmt, 
  int i, 
  const void *zData, 
  sqlite3_uint64 nData, 
  void (*xDel)(void*)
){
  assert( xDel!=SQLITE_DYNAMIC );
  if( nData>0x7fffffff ){
    return invokeValueDestructor(zData, xDel, 0);
  }else{
    return bindText(pStmt, i, zData, (int)nData, xDel, 0);
  }
}

// Assembly:
movq %rcx, %rax
shrq $0x1f, %rax
je 0x13594
leaq 0x1(%r8), %rax
cmpq $0x2, %rax
jb 0x1358e
pushq %rbp
movq %rsp, %rbp
movq %rdx, %rdi
callq *%r8
popq %rbp
movl $0x12, %eax
retq
xorl %r9d, %r9d
jmp 0x13433
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_bind_text64
SQLITE_STDCALL sqlite3_bind_text64( 
  sqlite3_stmt *pStmt, 
  int i, 
  const char *zData, 
  sqlite3_uint64 nData, 
  void (*xDel)(void*),
  unsigned char enc
){
  assert( xDel!=SQLITE_DYNAMIC );
  if( nData>0x7fffffff ){
    return invokeValueDestructor(zData, xDel, 0);
  }else{
    if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
    return bindText(pStmt, i, zData, (int)nData, xDel, enc);
  }
}

// Assembly:
movq %rcx, %rax
shrq $0x1f, %rax
je 0x138c8
leaq 0x1(%r8), %rax
cmpq $0x2, %rax
jb 0x138c2
pushq %rbp
movq %rsp, %rbp
movq %rdx, %rdi
callq *%r8
popq %rbp
movl $0x12, %eax
retq
cmpb $0x4, %r9b
movzbl %r9b, %eax
movl $0x2, %r9d
cmovnel %eax, %r9d
movzbl %r9b, %r9d
jmp 0x13433
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: applyNumericAffinity
static void applyNumericAffinity(Mem *pRec, int bTryForInt){
  double rValue;
  i64 iValue;
  u8 enc = pRec->enc;
  assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real))==MEM_Str );
  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->u.r = rValue;
    pRec->flags |= MEM_Real;
    if( bTryForInt ) sqlite3VdbeIntegerAffinity(pRec);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x10(%rdi), %r12
movl 0xc(%rdi), %r15d
movzbl 0xa(%rdi), %r13d
leaq -0x38(%rbp), %rsi
movq %r12, %rdi
movl %r15d, %edx
movl %r13d, %ecx
callq 0x2b0ae
testl %eax, %eax
je 0x13e4a
leaq -0x30(%rbp), %rsi
movq %r12, %rdi
movl %r15d, %edx
movl %r13d, %ecx
callq 0x2b65d
testl %eax, %eax
je 0x13e3f
movsd -0x38(%rbp), %xmm0
movsd %xmm0, (%rbx)
orb $0x8, 0x8(%rbx)
testl %r14d, %r14d
je 0x13e4a
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x32a77
movq -0x30(%rbp), %rax
movq %rax, (%rbx)
orb $0x4, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeCreate
SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(Parse *pParse){
  sqlite3 *db = pParse->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;
  p->pParse = pParse;
  assert( pParse->aLabel==0 );
  assert( pParse->nLabel==0 );
  assert( pParse->nOpAlloc==0 );
  assert( pParse->szOpAlloc==0 );
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
movl $0x128, %esi            # imm = 0x128
movq %r15, %rdi
callq 0x144ee
testq %rax, %rax
je 0x1499b
movq %rax, %r14
movl $0x128, %edx            # imm = 0x128
movq %rax, %rdi
xorl %esi, %esi
callq 0xa210
movq %r15, (%r14)
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x1497d
movq %r14, 0x50(%rax)
movq %rax, 0x58(%r14)
movq $0x0, 0x50(%r14)
movq %r14, 0x8(%r15)
movl $0x26bceaa5, 0x44(%r14) # imm = 0x26BCEAA5
movq %rbx, 0x30(%r14)
jmp 0x1499e
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeAddOpList
SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp, int iLineno){
  int addr, i;
  VdbeOp *pOut;
  assert( nOp>0 );
  assert( p->magic==VDBE_MAGIC_INIT );
  if( p->nOp + nOp > p->pParse->nOpAlloc && growOpArray(p, nOp) ){
    return 0;
  }
  addr = p->nOp;
  pOut = &p->aOp[addr];
  for(i=0; i<nOp; i++, aOp++, pOut++){
    pOut->opcode = aOp->opcode;
    pOut->p1 = aOp->p1;
    pOut->p2 = aOp->p2;
    assert( aOp->p2>=0 );
    pOut->p3 = aOp->p3;
    pOut->p4type = P4_NOTUSED;
    pOut->p4.p = 0;
    pOut->p5 = 0;
#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
    pOut->zComment = 0;
#endif
#ifdef SQLITE_VDBE_COVERAGE
    pOut->iSrcLine = iLineno+i;
#else
    (void)iLineno;
#endif
#ifdef SQLITE_DEBUG
    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 %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
movl 0x3c(%rdi), %eax
addl %esi, %eax
movq 0x30(%rdi), %rcx
cmpl 0x60(%rcx), %eax
jle 0x14a14
movq %r15, %rdi
callq 0x3fb49
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x14a75
movl 0x3c(%r15), %eax
testl %ebx, %ebx
jle 0x14a71
movslq %eax, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x8(%r15), %rcx
movl %ebx, %edx
xorl %esi, %esi
xorl %edi, %edi
movb (%r14,%rdi,4), %r8b
movb %r8b, (%rcx)
movsbl 0x1(%r14,%rdi,4), %r8d
movl %r8d, 0x4(%rcx)
movsbl 0x2(%r14,%rdi,4), %r8d
movl %r8d, 0x8(%rcx)
movsbl 0x3(%r14,%rdi,4), %r8d
movl %r8d, 0xc(%rcx)
movb %sil, 0x1(%rcx)
movq $0x0, 0x10(%rcx)
movb %sil, 0x3(%rcx)
addq $0x18, %rcx
incq %rdi
cmpl %edi, %edx
jne 0x14a31
addl %ebx, 0x3c(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeChangeToNoop
SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe *p, int addr){
  if( addr<p->nOp ){
    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:
cmpl %esi, 0x3c(%rdi)
jle 0x14c29
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rbx
movslq %esi, %rcx
leaq (%rcx,%rcx,2), %r14
movsbl 0x1(%rbx,%r14,8), %esi
movq 0x10(%rbx,%r14,8), %rdx
movq %rax, %rdi
callq 0x288fd
xorps %xmm0, %xmm0
movups %xmm0, (%rbx,%r14,8)
movq $0x0, 0x10(%rbx,%r14,8)
movb $-0x5f, (%rbx,%r14,8)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3ParserReset
SQLITE_PRIVATE void sqlite3ParserReset(Parse *pParse){
  if( pParse ){
    sqlite3 *db = pParse->db;
    sqlite3DbFree(db, pParse->aLabel);
    sqlite3ExprListDelete(db, pParse->pConstExpr);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x15172
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x80(%rdi), %rsi
movq %r14, %rdi
callq 0xb6df
movq 0x150(%rbx), %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3d971
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_set_authorizer
SQLITE_STDCALL sqlite3_set_authorizer(
  sqlite3 *db,
  int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
  void *pArg
){
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  db->xAuth = (sqlite3_xauth)xAuth;
  db->pAuthArg = pArg;
  sqlite3ExpirePreparedStatements(db);
  sqlite3_mutex_leave(db->mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x15560
callq *0x7de48(%rip)          # 0x933a8
movq %r15, 0x180(%rbx)
movq %r14, 0x188(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x15584
orb $0x8, 0x8c(%rax)
movq 0x58(%rax), %rax
jmp 0x15572
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x15593
callq *0x7de25(%rip)          # 0x933b8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_errmsg
SQLITE_API const char *SQLITE_STDCALL sqlite3_errmsg(sqlite3 *db){
  const char *z;
  if( !db ){
    return sqlite3ErrStr(SQLITE_NOMEM);
  }
  if( !sqlite3SafetyCheckSickOrOk(db) ){
    return sqlite3ErrStr(SQLITE_MISUSE_BKPT);
  }
  sqlite3_mutex_enter(db->mutex);
  if( db->mallocFailed ){
    z = sqlite3ErrStr(SQLITE_NOMEM);
  }else{
    testcase( db->pErr==0 );
    z = (char*)sqlite3_value_text(db->pErr);
    assert( !db->mallocFailed );
    if( z==0 ){
      z = sqlite3ErrStr(db->errCode);
    }
  }
  sqlite3_mutex_leave(db->mutex);
  return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x15f42
movq %rdi, %rbx
callq 0x19be0
testl %eax, %eax
je 0x15f4e
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x15f30
callq *0x7d478(%rip)          # 0x933a8
cmpb $0x0, 0x51(%rbx)
je 0x15f76
leaq 0x674da(%rip), %r14     # 0x7d417
jmp 0x15fcb
leaq 0x674ce(%rip), %r14     # 0x7d417
jmp 0x15fda
leaq 0x6b53d(%rip), %rsi     # 0x81492
leaq 0x67221(%rip), %rcx     # 0x7d17d
movl $0x15, %edi
movl $0x20c48, %edx          # imm = 0x20C48
xorl %eax, %eax
callq 0xa4b0
leaq 0x6b340(%rip), %r14     # 0x812b4
jmp 0x15fda
movq 0x140(%rbx), %rdi
movl $0x1, %esi
callq 0x11820
movq %rax, %r14
testq %rax, %rax
jne 0x15fcb
movl 0x44(%rbx), %eax
cmpq $0x204, %rax            # imm = 0x204
jne 0x15fa3
leaq 0x6b3e5(%rip), %r14     # 0x81386
jmp 0x15fcb
movzbl %al, %eax
cmpl $0x1b, %eax
setae %cl
cmpq $0x2, %rax
sete %dl
orb %cl, %dl
je 0x15fc0
leaq 0x6b3ba(%rip), %r14     # 0x81378
jmp 0x15fcb
leaq 0x7cd29(%rip), %rcx     # 0x92cf0
movq (%rcx,%rax,8), %r14
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x15fda
callq *0x7d3de(%rip)          # 0x933b8
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_auto_extension
SQLITE_STDCALL sqlite3_auto_extension(void (*xInit)(void)){
  int rc = SQLITE_OK;
#ifndef SQLITE_OMIT_AUTOINIT
  rc = sqlite3_initialize();
  if( rc ){
    return rc;
  }else
#endif
  {
    u32 i;
#if SQLITE_THREADSAFE
    sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
#endif
    wsdAutoextInit;
    sqlite3_mutex_enter(mutex);
    for(i=0; i<wsdAutoext.nExt; i++){
      if( wsdAutoext.aExt[i]==xInit ) break;
    }
    if( i==wsdAutoext.nExt ){
      u64 nByte = (wsdAutoext.nExt+1)*sizeof(wsdAutoext.aExt[0]);
      void (**aNew)(void);
      aNew = sqlite3_realloc64(wsdAutoext.aExt, nByte);
      if( aNew==0 ){
        rc = SQLITE_NOMEM;
      }else{
        wsdAutoext.aExt = aNew;
        wsdAutoext.aExt[wsdAutoext.nExt] = xInit;
        wsdAutoext.nExt++;
      }
    }
    sqlite3_mutex_leave(mutex);
    assert( (rc&0xff)==rc );
    return rc;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0xa080
movl %eax, %r15d
testl %eax, %eax
jne 0x16580
cmpl $0x0, 0x7ce58(%rip)     # 0x93324
je 0x164de
movl $0x2, %edi
callq *0x7cebf(%rip)          # 0x93398
movq %rax, %r14
jmp 0x164e1
xorl %r14d, %r14d
testq %r14, %r14
je 0x164ef
movq %r14, %rdi
callq *0x7ceb9(%rip)          # 0x933a8
movl 0x7ec82(%rip), %r12d    # 0x95178
xorl %r15d, %r15d
movl $0x0, %eax
testq %r12, %r12
je 0x1651d
movq 0x7ec76(%rip), %rcx     # 0x95180
xorl %eax, %eax
cmpq %rbx, (%rcx,%rax,8)
je 0x1651d
incq %rax
cmpl %eax, %r12d
jne 0x1650c
movl %r12d, %eax
cmpl %r12d, %eax
jne 0x16572
movq 0x7ec57(%rip), %r15     # 0x95180
callq 0xa080
testl %eax, %eax
je 0x16536
xorl %eax, %eax
jmp 0x16548
incl %r12d
shlq $0x3, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xc1a4
testq %rax, %rax
je 0x1656c
movq %rax, 0x7ec2c(%rip)     # 0x95180
movl 0x7ec1e(%rip), %ecx     # 0x95178
movq %rbx, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x7ec11(%rip)     # 0x95178
xorl %r15d, %r15d
jmp 0x16572
movl $0x7, %r15d
testq %r14, %r14
je 0x16580
movq %r14, %rdi
callq *0x7ce38(%rip)          # 0x933b8
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3LockAndPrepare
static int sqlite3LockAndPrepare(
  sqlite3 *db,              /* Database handle. */
  const char *zSql,         /* UTF-8 encoded SQL statement. */
  int nBytes,               /* Length of zSql in bytes. */
  int saveSqlFlag,          /* True to copy SQL text into the sqlite3_stmt */
  Vdbe *pOld,               /* VM being reprepared */
  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
  const char **pzTail       /* OUT: End of parsed string */
){
  int rc;

#ifdef SQLITE_ENABLE_API_ARMOR
  if( ppStmt==0 ) return SQLITE_MISUSE_BKPT;
#endif
  *ppStmt = 0;
  if( !sqlite3SafetyCheckOk(db)||zSql==0 ){
    return SQLITE_MISUSE_BKPT;
  }
  sqlite3_mutex_enter(db->mutex);
  sqlite3BtreeEnterAll(db);
  rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail);
  if( rc==SQLITE_SCHEMA ){
    sqlite3_finalize(*ppStmt);
    rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail);
  }
  sqlite3BtreeLeaveAll(db);
  sqlite3_mutex_leave(db->mutex);
  assert( rc==SQLITE_OK || *ppStmt==0 );
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %r12
movl %ecx, -0x30(%rbp)
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %rbx
movq $0x0, (%r9)
callq 0x15e93
testq %r15, %r15
je 0x16795
testl %eax, %eax
je 0x16795
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x16715
callq *0x7cc93(%rip)          # 0x933a8
movq %rbx, %rdi
callq 0xb3a2
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, -0x2c(%rbp)
movl %r13d, %edx
movl -0x30(%rbp), %r13d
movl %r13d, %ecx
movq %r12, %r8
movq %r14, %r9
callq 0x40172
movq %r12, %rcx
movl %eax, %r12d
cmpl $0x11, %eax
jne 0x1677c
movq (%r14), %rdi
movq %rcx, %r12
callq 0xa4c0
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movl -0x2c(%rbp), %edx
movl %r13d, %ecx
movq %r12, %r8
movq %r14, %r9
callq 0x40172
movl %eax, %r12d
movq %rbx, %rdi
callq 0xb3fa
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x167ba
callq *0x7cc25(%rip)          # 0x933b8
jmp 0x167ba
leaq 0x6acf6(%rip), %rsi     # 0x81492
leaq 0x669da(%rip), %rcx     # 0x7d17d
movl $0x15, %r12d
movl $0x15, %edi
movl $0x1abb1, %edx          # imm = 0x1ABB1
xorl %eax, %eax
callq 0xa4b0
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_vtab_config
SQLITE_CDECL sqlite3_vtab_config(sqlite3 *db, int op, ...){
  va_list ap;
  int rc = SQLITE_OK;

#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  va_start(ap, op);
  switch( op ){
    case SQLITE_VTAB_CONSTRAINT_SUPPORT: {
      VtabCtx *p = db->pVtabCtx;
      if( !p ){
        rc = SQLITE_MISUSE_BKPT;
      }else{
        assert( p->pTab==0 || (p->pTab->tabFlags & TF_Virtual)!=0 );
        p->pVTable->bConstraint = (u8)va_arg(ap, int);
      }
      break;
    }
    default:
      rc = SQLITE_MISUSE_BKPT;
      break;
  }
  va_end(ap);

  if( rc!=SQLITE_OK ) sqlite3Error(db, rc);
  sqlite3_mutex_leave(db->mutex);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq %rdx, -0xd0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %r8, -0xc0(%rbp)
movq %r9, -0xb8(%rbp)
testb %al, %al
je 0x17577
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 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x17586
callq *0x7be22(%rip)          # 0x933a8
leaq -0xe0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x30(%rbp)
cmpl $0x1, %r14d
jne 0x175d1
movq 0x1c0(%rbx), %rax
testq %rax, %rax
je 0x175f4
movl -0x30(%rbp), %edx
cmpq $0x28, %rdx
ja 0x1761e
movq %rdx, %rcx
addq -0x20(%rbp), %rcx
addl $0x8, %edx
movl %edx, -0x30(%rbp)
jmp 0x1762a
leaq 0x69eba(%rip), %rsi     # 0x81492
leaq 0x65b9e(%rip), %rcx     # 0x7d17d
xorl %r15d, %r15d
movl $0x15, %r14d
movl $0x15, %edi
movl $0x1d0d8, %edx          # imm = 0x1D0D8
jmp 0x17615
leaq 0x69e97(%rip), %rsi     # 0x81492
leaq 0x65b7b(%rip), %rcx     # 0x7d17d
xorl %r15d, %r15d
movl $0x15, %r14d
movl $0x15, %edi
movl $0x1d0d0, %edx          # imm = 0x1D0D0
xorl %eax, %eax
callq 0xa4b0
jmp 0x17638
movq -0x28(%rbp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, -0x28(%rbp)
movb (%rcx), %cl
movq (%rax), %rax
movb %cl, 0x1c(%rax)
xorl %r14d, %r14d
movb $0x1, %r15b
testb %r15b, %r15b
jne 0x17665
movl %r14d, 0x44(%rbx)
movq 0x140(%rbx), %rdi
testq %rdi, %rdi
je 0x17665
movzwl 0x8(%rdi), %eax
testl $0x2460, %eax           # imm = 0x2460
je 0x1765f
callq 0x2a646
jmp 0x17665
movw $0x1, 0x8(%rdi)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x17674
callq *0x7bd44(%rip)          # 0x933b8
movl %r14d, %eax
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_busy_handler
SQLITE_STDCALL sqlite3_busy_handler(
  sqlite3 *db,
  int (*xBusy)(void*,int),
  void *pArg
){
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  sqlite3_mutex_enter(db->mutex);
  db->busyHandler.xFunc = xBusy;
  db->busyHandler.pArg = pArg;
  db->busyHandler.nBusy = 0;
  db->busyTimeout = 0;
  sqlite3_mutex_leave(db->mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x18c7d
callq *0x7a72b(%rip)          # 0x933a8
movq %r15, 0x2a8(%rbx)
movq %r14, 0x2b0(%rbx)
xorl %eax, %eax
movl %eax, 0x2b8(%rbx)
movl %eax, 0x308(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x18ca8
callq *0x7a710(%rip)          # 0x933b8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_progress_handler
SQLITE_STDCALL sqlite3_progress_handler(
  sqlite3 *db, 
  int nOps,
  int (*xProgress)(void*), 
  void *pArg
){
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  if( nOps>0 ){
    db->xProgress = xProgress;
    db->nProgressOps = (unsigned)nOps;
    db->pProgressArg = pArg;
  }else{
    db->xProgress = 0;
    db->nProgressOps = 0;
    db->pProgressArg = 0;
  }
  sqlite3_mutex_leave(db->mutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movl %esi, %r15d
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x18cdb
callq *0x7a6cd(%rip)          # 0x933a8
testl %r15d, %r15d
jle 0x18cf7
movq %r12, 0x190(%rbx)
movl %r15d, 0x1a0(%rbx)
movq %r14, 0x198(%rbx)
jmp 0x18d0b
leaq 0x190(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x18d22
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *0x7a696(%rip)          # 0x933b8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_busy_timeout
SQLITE_STDCALL sqlite3_busy_timeout(sqlite3 *db, int ms){
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  if( ms>0 ){
    sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);
    db->busyTimeout = ms;
  }else{
    sqlite3_busy_handler(db, 0, 0);
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testl %esi, %esi
jle 0x18d86
movl %esi, %r14d
testq %rdi, %rdi
je 0x18d4b
callq *0x7a65d(%rip)          # 0x933a8
leaq 0x6d(%rip), %rax        # 0x18dbf
movq %rax, 0x2a8(%rbx)
movq %rbx, 0x2b0(%rbx)
xorl %eax, %eax
movl %eax, 0x2b8(%rbx)
movl %eax, 0x308(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x18d7d
callq *0x7a63b(%rip)          # 0x933b8
movl %r14d, 0x308(%rbx)
jmp 0x18db8
testq %rdi, %rdi
je 0x18d91
callq *0x7a617(%rip)          # 0x933a8
xorl %eax, %eax
movl %eax, 0x308(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x2a8(%rbx)
movl %eax, 0x2b8(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x18db8
callq *0x7a600(%rip)          # 0x933b8
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_create_function_v2
SQLITE_STDCALL sqlite3_create_function_v2(
  sqlite3 *db,
  const char *zFunc,
  int nArg,
  int enc,
  void *p,
  void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
  void (*xStep)(sqlite3_context*,int,sqlite3_value **),
  void (*xFinal)(sqlite3_context*),
  void (*xDestroy)(void *)
){
  int rc = SQLITE_ERROR;
  FuncDestructor *pArg = 0;

#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  if( xDestroy ){
    pArg = (FuncDestructor *)sqlite3DbMallocZero(db, sizeof(FuncDestructor));
    if( !pArg ){
      xDestroy(p);
      goto out;
    }
    pArg->xDestroy = xDestroy;
    pArg->pUserData = p;
  }
  rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p, xFunc, xStep, xFinal, pArg);
  if( pArg && pArg->nRef==0 ){
    assert( rc!=SQLITE_OK );
    xDestroy(p);
    sqlite3DbFree(db, pArg);
  }

 out:
  rc = sqlite3ApiExit(db, rc);
  sqlite3_mutex_leave(db->mutex);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, -0x38(%rbp)
movq %r8, %r14
movl %ecx, -0x2c(%rbp)
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x18e52
callq *0x7a556(%rip)          # 0x933a8
cmpq $0x0, 0x20(%rbp)
je 0x18e84
movl $0x18, %esi
movq %rbx, %rdi
callq 0x144ee
testq %rax, %rax
je 0x18ed1
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq 0x20(%rbp), %rax
movq %rax, 0x8(%r12)
movq %r14, 0x10(%r12)
jmp 0x18e87
xorl %r12d, %r12d
subq $0x8, %rsp
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
movl -0x2c(%rbp), %ecx
movq %r14, %r8
movq -0x38(%rbp), %r9
pushq %r12
pushq 0x18(%rbp)
pushq 0x10(%rbp)
callq 0x18f21
addq $0x20, %rsp
movl %eax, %r15d
testq %r12, %r12
je 0x18edd
cmpl $0x0, (%r12)
jne 0x18edd
movq %r14, %rdi
callq *0x20(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb6df
jmp 0x18edd
movq %r14, %rdi
callq *0x20(%rbp)
movl $0x1, %r15d
cmpl $0xc0a, %r15d           # imm = 0xC0A
je 0x18ef2
cmpb $0x0, 0x51(%rbx)
jne 0x18ef2
andl 0x48(%rbx), %r15d
jmp 0x18f00
movq %rbx, %rdi
callq 0x28aa8
movl $0x7, %r15d
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x18f0f
callq *0x7a4a9(%rip)          # 0x933b8
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_overload_function
SQLITE_STDCALL sqlite3_overload_function(
  sqlite3 *db,
  const char *zName,
  int nArg
){
  int nName = sqlite3Strlen30(zName);
  int rc = SQLITE_OK;

#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){
    return SQLITE_MISUSE_BKPT;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){
    rc = sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
                           0, sqlite3InvalidFunction, 0, 0, 0);
  }
  rc = sqlite3ApiExit(db, rc);
  sqlite3_mutex_leave(db->mutex);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
testq %rsi, %rsi
je 0x192eb
movq %r15, %rdi
callq 0xa190
movq %rax, %r13
andl $0x3fffffff, %r13d      # imm = 0x3FFFFFFF
jmp 0x192ee
xorl %r13d, %r13d
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x192fd
callq *0x7a0ab(%rip)          # 0x933a8
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
movl %r14d, %ecx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x19393
testq %rax, %rax
jne 0x1934f
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x236(%rip), %r9        # 0x1956c
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x18f21
movl %eax, %r12d
cmpl $0xc0a, %r12d           # imm = 0xC0A
je 0x19364
cmpb $0x0, 0x51(%rbx)
jne 0x19364
andl 0x48(%rbx), %r12d
jmp 0x19372
movq %rbx, %rdi
callq 0x28aa8
movl $0x7, %r12d
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x19381
callq *0x7a037(%rip)          # 0x933b8
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_trace
SQLITE_API void *SQLITE_STDCALL sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
  void *pOld;

#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  pOld = db->pTraceArg;
  db->xTrace = xTrace;
  db->pTraceArg = pArg;
  sqlite3_mutex_leave(db->mutex);
  return pOld;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x195e5
callq *0x79dc3(%rip)          # 0x933a8
movq 0x18(%r14), %rdi
movq 0xd0(%r14), %r12
movq %r15, 0xc8(%r14)
movq %rbx, 0xd0(%r14)
testq %rdi, %rdi
je 0x19609
callq *0x79daf(%rip)          # 0x933b8
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_profile
SQLITE_API void *SQLITE_STDCALL sqlite3_profile(
  sqlite3 *db,
  void (*xProfile)(void*,const char*,sqlite_uint64),
  void *pArg
){
  void *pOld;

#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  pOld = db->pProfileArg;
  db->xProfile = xProfile;
  db->pProfileArg = pArg;
  sqlite3_mutex_leave(db->mutex);
  return pOld;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x19638
callq *0x79d70(%rip)          # 0x933a8
movq 0x18(%r14), %rdi
movq 0xe0(%r14), %r12
movq %r15, 0xd8(%r14)
movq %rbx, 0xe0(%r14)
testq %rdi, %rdi
je 0x1965c
callq *0x79d5c(%rip)          # 0x933b8
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_commit_hook
SQLITE_API void *SQLITE_STDCALL sqlite3_commit_hook(
  sqlite3 *db,              /* Attach the hook to this database */
  int (*xCallback)(void*),  /* Function to invoke on each commit */
  void *pArg                /* Argument to the function */
){
  void *pOld;

#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  pOld = db->pCommitArg;
  db->xCommitCallback = xCallback;
  db->pCommitArg = pArg;
  sqlite3_mutex_leave(db->mutex);
  return pOld;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1968b
callq *0x79d1d(%rip)          # 0x933a8
movq 0x18(%r14), %rdi
movq 0xe8(%r14), %r12
movq %r15, 0xf0(%r14)
movq %rbx, 0xe8(%r14)
testq %rdi, %rdi
je 0x196af
callq *0x79d09(%rip)          # 0x933b8
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_update_hook
SQLITE_API void *SQLITE_STDCALL sqlite3_update_hook(
  sqlite3 *db,              /* Attach the hook to this database */
  void (*xCallback)(void*,int,char const *,char const *,sqlite_int64),
  void *pArg                /* Argument to the function */
){
  void *pRet;

#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  pRet = db->pUpdateArg;
  db->xUpdateCallback = xCallback;
  db->pUpdateArg = pArg;
  sqlite3_mutex_leave(db->mutex);
  return pRet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x196de
callq *0x79cca(%rip)          # 0x933a8
movq 0x18(%r14), %rdi
movq 0x108(%r14), %r12
movq %r15, 0x110(%r14)
movq %rbx, 0x108(%r14)
testq %rdi, %rdi
je 0x19702
callq *0x79cb6(%rip)          # 0x933b8
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_rollback_hook
SQLITE_API void *SQLITE_STDCALL sqlite3_rollback_hook(
  sqlite3 *db,              /* Attach the hook to this database */
  void (*xCallback)(void*), /* Callback function */
  void *pArg                /* Argument to the function */
){
  void *pRet;

#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  pRet = db->pRollbackArg;
  db->xRollbackCallback = xCallback;
  db->pRollbackArg = pArg;
  sqlite3_mutex_leave(db->mutex);
  return pRet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x19731
callq *0x79c77(%rip)          # 0x933a8
movq 0x18(%r14), %rdi
movq 0xf8(%r14), %r12
movq %r15, 0x100(%r14)
movq %rbx, 0xf8(%r14)
testq %rdi, %rdi
je 0x19755
callq *0x79c63(%rip)          # 0x933b8
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_wal_autocheckpoint
SQLITE_STDCALL sqlite3_wal_autocheckpoint(sqlite3 *db, int nFrame){
#ifdef SQLITE_OMIT_WAL
  UNUSED_PARAMETER(db);
  UNUSED_PARAMETER(nFrame);
#else
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
#endif
  if( nFrame>0 ){
    sqlite3_wal_hook(db, sqlite3WalDefaultHook, SQLITE_INT_TO_PTR(nFrame));
  }else{
    sqlite3_wal_hook(db, 0, 0);
  }
#endif
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
jle 0x19798
movl %esi, %r14d
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x19781
callq *0x79c27(%rip)          # 0x933a8
leaq 0x92(%rip), %rax        # 0x1981a
movq %rax, 0x118(%rbx)
movq %r14, 0x120(%rbx)
jmp 0x197b1
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x197a7
callq *0x79c01(%rip)          # 0x933a8
xorps %xmm0, %xmm0
movups %xmm0, 0x118(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x197c0
callq *0x79bf8(%rip)          # 0x933b8
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_wal_hook
SQLITE_API void *SQLITE_STDCALL sqlite3_wal_hook(
  sqlite3 *db,                    /* Attach the hook to this db handle */
  int(*xCallback)(void *, sqlite3*, const char*, int),
  void *pArg                      /* First argument passed to xCallback() */
){
#ifndef SQLITE_OMIT_WAL
  void *pRet;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(db->mutex);
  pRet = db->pWalArg;
  db->xWalCallback = xCallback;
  db->pWalArg = pArg;
  sqlite3_mutex_leave(db->mutex);
  return pRet;
#else
  return 0;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x197ea
callq *0x79bbe(%rip)          # 0x933a8
movq 0x18(%r14), %rdi
movq 0x120(%r14), %r12
movq %r15, 0x118(%r14)
movq %rbx, 0x120(%r14)
testq %rdi, %rdi
je 0x1980e
callq *0x79baa(%rip)          # 0x933b8
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq