LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/output.c
// Function: saveToDB
int saveToDB( char *title,char *city, char *address, char *type, char *price, char *infourl, char *source)
{
	pthread_mutex_lock(&lock);
	char sql[2048] = { 0 };
	sprintf(sql,"insert into house(title,city,address,type,price,infourl,source) values('%s','%s','%s','%s','%s','%s','%s')",title,city,address,type,price,infourl,source);
	int ret = sqlite3_exec(db,sql,0,0,&err);
	if (ret != SQLITE_OK )
	{
		puts(sql);
		pthread_mutex_unlock(&lock);
		return -1;
	}
	pthread_mutex_unlock(&lock);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movq %r9, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x88793(%rip), %rdi     # 0x92f78
callq 0xa610
leaq -0x840(%rbp), %r12
movl $0x800, %edx            # imm = 0x800
movq %r12, %rdi
xorl %esi, %esi
callq 0xa220
subq $0x8, %rsp
leaq 0x6c8a6(%rip), %rsi     # 0x770b1
movq %r12, %rdi
movq %rbx, %rdx
xorl %ebx, %ebx
movq %r15, %rcx
movq %r14, %r8
movq %r13, %r9
xorl %eax, %eax
pushq 0x10(%rbp)
pushq -0x30(%rbp)
pushq -0x38(%rbp)
callq 0xa4f0
addq $0x20, %rsp
movq 0x88769(%rip), %rdi     # 0x92fa0
leaq 0x8876a(%rip), %r8      # 0x92fa8
movq %r12, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xa140
testl %eax, %eax
je 0xa85f
leaq -0x840(%rbp), %rdi
callq 0xa110
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leaq 0x88712(%rip), %rdi     # 0x92f78
callq 0xa390
movl %ebx, %eax
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_compileoption_used
SQLITE_STDCALL sqlite3_compileoption_used(const char *zOptName){
  int i, n;

#if SQLITE_ENABLE_API_ARMOR
  if( zOptName==0 ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  if( sqlite3StrNICmp(zOptName, "SQLITE_", 7)==0 ) zOptName += 7;
  n = sqlite3Strlen30(zOptName);

  /* Since ArraySize(azCompileOpt) is normally in single digits, a
  ** linear search is adequate.  No need for a binary search. */
  for(i=0; i<ArraySize(azCompileOpt); i++){
    if( sqlite3StrNICmp(zOptName, azCompileOpt[i], n)==0
     && sqlite3IsIdChar((unsigned char)azCompileOpt[i][n])==0
    ){
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xae1c
movq %rdi, %rbx
xorl %ecx, %ecx
leaq 0x6d575(%rip), %rax     # 0x78360
leaq 0x7025e(%rip), %rdx     # 0x7b050
movzbl (%rbx,%rcx), %esi
testq %rsi, %rsi
je 0xae22
movzbl (%rsi,%rax), %esi
movzbl (%rcx,%rdx), %edi
movb (%rdi,%rax), %dil
cmpb %dil, %sil
jne 0xae2c
incq %rcx
cmpq $0x7, %rcx
jne 0xadf2
movl $0x7, %eax
jmp 0xae3d
xorl %ebx, %ebx
xorl %eax, %eax
jmp 0xae4d
movzbl (%rcx,%rdx), %ecx
movb (%rcx,%rax), %dil
xorl %esi, %esi
movzbl %dil, %eax
xorl %ecx, %ecx
cmpl %eax, %esi
movl $0x7, %eax
cmovneq %rcx, %rax
addq %rax, %rbx
movq %rbx, %rdi
callq 0xa190
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl %eax, %r14d
movb $0x1, %r12b
xorl %ecx, %ecx
leaq 0x84824(%rip), %r13     # 0x8f680
movq (%r13,%rcx,8), %r15
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0xa570
testl %eax, %eax
je 0xae88
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %r12b
movl $0x0, %r12d
jne 0xae5c
jmp 0xaeb5
movzbl (%r15,%r14), %eax
leaq 0x6d5fc(%rip), %rcx     # 0x78490
movb (%rax,%rcx), %dl
testb $0x46, %dl
setne %al
movl $0x1, %ecx
testb %r12b, %al
movl $0x0, %r12d
jne 0xae5c
xorl %eax, %eax
testb $0x46, %dl
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_status
SQLITE_STDCALL sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){
  sqlite3_int64 iCur, iHwtr;
  int rc;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;
#endif
  rc = sqlite3_status64(op, &iCur, &iHwtr, resetFlag);
  if( rc==0 ){
    *pCurrent = (int)iCur;
    *pHighwater = (int)iHwtr;
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq -0x20(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0xa250
testl %eax, %eax
jne 0xb045
movl -0x20(%rbp), %ecx
movl %ecx, (%r14)
movl -0x18(%rbp), %ecx
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3VdbeClearObject
SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){
  SubProgram *pSub, *pNext;
  int i;
  assert( p->db==0 || p->db==db );
  releaseMemArray(p->aVar, p->nVar);
  releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
  for(pSub=p->pProgram; pSub; pSub=pNext){
    pNext = pSub->pNext;
    vdbeFreeOpArray(db, pSub->aOp, pSub->nOp);
    sqlite3DbFree(db, pSub);
  }
  for(i=p->nzVar-1; i>=0; i--) sqlite3DbFree(db, p->azVar[i]);
  vdbeFreeOpArray(db, p->aOp, p->nOp);
  sqlite3DbFree(db, p->aColName);
  sqlite3DbFree(db, p->zSql);
  sqlite3DbFree(db, p->pFree);
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
  for(i=0; i<p->nScan; i++){
    sqlite3DbFree(db, p->aScan[i].zName);
  }
  sqlite3DbFree(db, p->aScan);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x68(%rsi), %rdi
movswl 0x78(%rsi), %esi
callq 0x283c4
movq 0x20(%r14), %rdi
movzwl 0x88(%r14), %esi
addl %esi, %esi
callq 0x283c4
movq 0x108(%r14), %r15
testq %r15, %r15
je 0xb6ec
movq 0x20(%r15), %r12
movq (%r15), %rsi
movl 0x8(%r15), %edx
movq %rbx, %rdi
callq 0x28468
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb752
movq %r12, %r15
testq %r12, %r12
jne 0xb6c6
movswq 0x7a(%r14), %r15
testq %r15, %r15
jle 0xb713
incq %r15
movq 0x70(%r14), %rax
movq -0x10(%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0xb752
decq %r15
cmpq $0x1, %r15
ja 0xb6f9
movq 0x8(%r14), %rsi
movl 0x3c(%r14), %edx
movq %rbx, %rdi
callq 0x28468
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0xb752
movq 0xe0(%r14), %rsi
movq %rbx, %rdi
callq 0xb752
movq 0xe8(%r14), %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb752
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3MutexInit
SQLITE_PRIVATE int sqlite3MutexInit(void){ 
  int rc = SQLITE_OK;
  if( !sqlite3GlobalConfig.mutex.xMutexAlloc ){
    /* If the xMutexAlloc method has not been set, then the user did not
    ** install a mutex implementation via sqlite3_config() prior to 
    ** sqlite3_initialize() being called. This block copies pointers to
    ** the default implementation into the sqlite3GlobalConfig structure.
    */
    sqlite3_mutex_methods const *pFrom;
    sqlite3_mutex_methods *pTo = &sqlite3GlobalConfig.mutex;

    if( sqlite3GlobalConfig.bCoreMutex ){
      pFrom = sqlite3DefaultMutex();
    }else{
      pFrom = sqlite3NoopMutex();
    }
    pTo->xMutexInit = pFrom->xMutexInit;
    pTo->xMutexEnd = pFrom->xMutexEnd;
    pTo->xMutexFree = pFrom->xMutexFree;
    pTo->xMutexEnter = pFrom->xMutexEnter;
    pTo->xMutexTry = pFrom->xMutexTry;
    pTo->xMutexLeave = pFrom->xMutexLeave;
    pTo->xMutexHeld = pFrom->xMutexHeld;
    pTo->xMutexNotheld = pFrom->xMutexNotheld;
    sqlite3MemoryBarrier();
    pTo->xMutexAlloc = pFrom->xMutexAlloc;
  }
  assert( sqlite3GlobalConfig.mutex.xMutexInit );
  rc = sqlite3GlobalConfig.mutex.xMutexInit();

#ifdef SQLITE_DEBUG
  GLOBAL(int, mutexIsInit) = 1;
#endif

  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x8553d(%rip)     # 0x913a8
jne 0xbf34
cmpl $0x0, 0x854bc(%rip)     # 0x91334
leaq 0xfeb7(%rip), %rax      # 0x1bd36
leaq 0xfd98(%rip), %rcx      # 0x1bc1e
cmoveq %rax, %rcx
movq %rcx, 0x85507(%rip)     # 0x91398
leaq 0xfea6(%rip), %rax      # 0x1bd3e
leaq 0xfd87(%rip), %rcx      # 0x1bc26
cmoveq %rax, %rcx
movq %rcx, 0x854f6(%rip)     # 0x913a0
leaq 0xfea0(%rip), %rax      # 0x1bd51
leaq 0xfe39(%rip), %rcx      # 0x1bcf1
cmoveq %rax, %rcx
leaq 0xfe94(%rip), %rax      # 0x1bd57
leaq 0xfe43(%rip), %rdx      # 0x1bd0d
cmoveq %rax, %rdx
movq %rcx, 0x854db(%rip)     # 0x913b0
movq %rdx, 0x854dc(%rip)     # 0x913b8
leaq 0xfe7a(%rip), %rax      # 0x1bd5d
leaq 0xfe2d(%rip), %rcx      # 0x1bd17
cmoveq %rax, %rcx
movq %rcx, 0x854cb(%rip)     # 0x913c0
leaq 0xfe69(%rip), %rax      # 0x1bd65
leaq 0xfe29(%rip), %rcx      # 0x1bd2c
cmoveq %rax, %rcx
movq %rcx, 0x854ba(%rip)     # 0x913c8
xorps %xmm0, %xmm0
movups %xmm0, 0x854b8(%rip)    # 0x913d0
mfence
leaq 0xfe24(%rip), %rax      # 0x1bd46
leaq 0xfd05(%rip), %rcx      # 0x1bc2e
cmoveq %rax, %rcx
movq %rcx, 0x85474(%rip)     # 0x913a8
popq %rbp
jmpq *0x8545d(%rip)          # 0x91398
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_soft_heap_limit64
SQLITE_STDCALL sqlite3_soft_heap_limit64(sqlite3_int64 n){
  sqlite3_int64 priorLimit;
  sqlite3_int64 excess;
  sqlite3_int64 nUsed;
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return -1;
#endif
  sqlite3_mutex_enter(mem0.mutex);
  priorLimit = mem0.alarmThreshold;
  if( n<0 ){
    sqlite3_mutex_leave(mem0.mutex);
    return priorLimit;
  }
  mem0.alarmThreshold = n;
  nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
  mem0.nearlyFull = (n>0 && n<=nUsed);
  sqlite3_mutex_leave(mem0.mutex);
  excess = sqlite3_memory_used() - n;
  if( excess>0 ) sqlite3_release_memory((int)(excess & 0x7fffffff));
  return priorLimit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0xa080
movq $-0x1, %rbx
testl %eax, %eax
jne 0xc006
movq 0x870c6(%rip), %rdi     # 0x93058
testq %rdi, %rdi
je 0xbf9d
callq *0x8541b(%rip)          # 0x913b8
movq 0x870bc(%rip), %rbx     # 0x93060
testq %r14, %r14
js 0xbff1
movq %r14, 0x870b0(%rip)     # 0x93060
setne %al
cmpq %r14, 0x86ff6(%rip)     # 0x92fb0
setge %cl
andb %al, %cl
movzbl %cl, %eax
movl %eax, 0x870b4(%rip)     # 0x9307c
movq 0x87089(%rip), %rdi     # 0x93058
testq %rdi, %rdi
je 0xc006
callq *0x853ee(%rip)          # 0x913c8
movq 0x87077(%rip), %r14     # 0x93058
testq %r14, %r14
je 0xc006
movq %r14, %rdi
callq *0x853c9(%rip)          # 0x913b8
jmp 0xbffd
movq 0x87060(%rip), %r14     # 0x93058
testq %r14, %r14
je 0xc006
movq %r14, %rdi
callq *0x853c2(%rip)          # 0x913c8
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_vmprintf
SQLITE_API char *SQLITE_STDCALL sqlite3_vmprintf(const char *zFormat, va_list ap){
  char *z;
  char zBase[SQLITE_PRINT_BUF_SIZE];
  StrAccum acc;

#ifdef SQLITE_ENABLE_API_ARMOR  
  if( zFormat==0 ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize() ) return 0;
#endif
  sqlite3StrAccumInit(&acc, 0, zBase, sizeof(zBase), SQLITE_MAX_LENGTH);
  sqlite3VXPrintf(&acc, 0, zFormat, ap);
  z = sqlite3StrAccumFinish(&acc);
  return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa080
testl %eax, %eax
je 0xc4dc
xorl %eax, %eax
jmp 0xc52b
leaq -0x90(%rbp), %rax
leaq -0x40(%rbp), %r15
movq %rax, 0x8(%r15)
movq %rax, 0x10(%r15)
movq $0x0, (%r15)
movabsq $0x4600000000, %rax     # imm = 0x4600000000
movq %rax, 0x18(%r15)
movl $0x3b9aca00, 0x20(%r15) # imm = 0x3B9ACA00
movw $0x0, 0x24(%r15)
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xc536
movq %r15, %rdi
callq 0xdbce
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3StrAccumFinish
SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum *p){
  if( p->zText ){
    assert( (p->zText==p->zBase)==(p->bMalloced==0) );
    p->zText[p->nChar] = 0;
    if( p->mxAlloc>0 && p->bMalloced==0 ){
      p->zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
      if( p->zText ){
        memcpy(p->zText, p->zBase, p->nChar+1);
        p->bMalloced = 1;
      }else{
        setStrAccumError(p, STRACCUM_NOMEM);
      }
    }
  }
  return p->zText;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xdc2b
movl 0x18(%rbx), %ecx
movb $0x0, (%rax,%rcx)
cmpl $0x0, 0x20(%rbx)
je 0xdc2b
cmpb $0x0, 0x25(%rbx)
jne 0xdc2b
movq (%rbx), %rdi
movl 0x18(%rbx), %esi
incl %esi
callq 0x145aa
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0xdc20
movq 0x8(%rbx), %rsi
movl 0x18(%rbx), %edx
incl %edx
movq %rax, %rdi
callq 0xa320
movb $0x1, 0x25(%rbx)
jmp 0xdc2b
movb $0x1, 0x24(%rbx)
movl $0x0, 0x1c(%rbx)
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_mprintf
SQLITE_API char *SQLITE_CDECL sqlite3_mprintf(const char *zFormat, ...){
  va_list ap;
  char *z;
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize() ) return 0;
#endif
  va_start(ap, zFormat);
  z = sqlite3_vmprintf(zFormat, ap);
  va_end(ap);
  return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movq %rsi, -0xc8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %r8, -0xb0(%rbp)
movq %r9, -0xa8(%rbp)
testb %al, %al
je 0xdc92
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)
callq 0xa080
testl %eax, %eax
je 0xdc9f
xorl %eax, %eax
jmp 0xdccb
leaq -0xd0(%rbp), %rax
leaq -0x20(%rbp), %rsi
movq %rax, 0x10(%rsi)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0xa410
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_vsnprintf
SQLITE_API char *SQLITE_STDCALL sqlite3_vsnprintf(int n, char *zBuf, const char *zFormat, va_list ap){
  StrAccum acc;
  if( n<=0 ) return zBuf;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( zBuf==0 || zFormat==0 ) {
    (void)SQLITE_MISUSE_BKPT;
    if( zBuf ) zBuf[0] = 0;
    return zBuf;
  }
#endif
  sqlite3StrAccumInit(&acc, 0, zBuf, n, 0);
  sqlite3VXPrintf(&acc, 0, zFormat, ap);
  return sqlite3StrAccumFinish(&acc);
}

// Assembly:
movq %rsi, %rax
testl %edi, %edi
jle 0xdd21
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
leaq -0x30(%rbp), %rbx
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq $0x0, (%rbx)
xorl %eax, %eax
movl %eax, 0x18(%rbx)
movl %edi, 0x1c(%rbx)
movl %eax, 0x20(%rbx)
movw $0x0, 0x24(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc536
movq %rbx, %rdi
callq 0xdbce
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3_stricmp
SQLITE_STDCALL sqlite3_stricmp(const char *zLeft, const char *zRight){
  register unsigned char *a, *b;
  if( zLeft==0 ){
    return zRight ? -1 : 0;
  }else if( zRight==0 ){
    return 1;
  }
  a = (unsigned char *)zLeft;
  b = (unsigned char *)zRight;
  while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
  return UpperToLower[*a] - UpperToLower[*b];
}

// Assembly:
testq %rdi, %rdi
je 0xe0a6
testq %rsi, %rsi
je 0xe0ae
pushq %rbp
movq %rsp, %rbp
movb (%rdi), %al
testb %al, %al
je 0xe0b4
incq %rdi
leaq 0x6a2dd(%rip), %rcx     # 0x78360
movzbl %al, %edx
movb (%rdx,%rcx), %dl
movzbl (%rsi), %r8d
cmpb (%r8,%rcx), %dl
jne 0xe0a1
incq %rsi
movb (%rdi), %al
incq %rdi
testb %al, %al
jne 0xe083
xorl %eax, %eax
movzbl %al, %eax
jmp 0xe0b6
xorl %eax, %eax
negq %rsi
sbbl %eax, %eax
retq
movl $0x1, %eax
retq
xorl %eax, %eax
leaq 0x6a2a3(%rip), %rcx     # 0x78360
movzbl (%rax,%rcx), %eax
movzbl (%rsi), %edx
movzbl (%rdx,%rcx), %ecx
subl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3BtreeGetMeta
SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){
  BtShared *pBt = p->pBt;

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

  if( idx==BTREE_DATA_VERSION ){
    *pMeta = sqlite3PagerDataVersion(pBt->pPager) + p->iDataVersion;
  }else{
    *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]);
  }

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

  sqlite3BtreeLeave(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq 0x8(%rdi), %r12
cmpb $0x0, 0x11(%rdi)
je 0x10091
incl 0x14(%rbx)
cmpb $0x0, 0x12(%rbx)
jne 0x10091
movq %rbx, %rdi
callq 0x2520c
cmpl $0xf, %r15d
jne 0x100a6
movq (%r12), %rcx
movl 0x1c(%rbx), %eax
addl 0x84(%rcx), %eax
jmp 0x100b8
movq 0x18(%r12), %rax
movq 0x50(%rax), %rax
movslq %r15d, %rcx
movl 0x24(%rax,%rcx,4), %eax
bswapl %eax
movl %eax, (%r14)
cmpb $0x0, 0x11(%rbx)
je 0x100c6
decl 0x14(%rbx)
je 0x100cf
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x25292
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PagerWrite
SQLITE_PRIVATE int sqlite3PagerWrite(PgHdr *pPg){
  Pager *pPager = pPg->pPager;
  assert( (pPg->flags & PGHDR_MMAP)==0 );
  assert( pPager->eState>=PAGER_WRITER_LOCKED );
  assert( assert_pager_state(pPager) );
  if( pPager->errCode ){
    return pPager->errCode;
  }else if( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){
    if( pPager->nSavepoint ) return subjournalPageIfRequired(pPg);
    return SQLITE_OK;
  }else if( pPager->sectorSize > (u32)pPager->pageSize ){
    return pagerWriteLargeSector(pPg);
  }else{
    return pager_write(pPg);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x20(%rdi), %rcx
movl 0x2c(%rcx), %eax
testl %eax, %eax
je 0x10801
popq %rbp
retq
testb $0x4, 0x2c(%rdi)
je 0x1080f
movl 0x1c(%rcx), %eax
cmpl 0x28(%rdi), %eax
jae 0x10829
movl 0xb8(%rcx), %eax
cmpl 0xbc(%rcx), %eax
jbe 0x10823
popq %rbp
jmp 0x25fe6
popq %rbp
jmp 0x26188
cmpl $0x0, 0x80(%rcx)
je 0x10838
popq %rbp
jmp 0x1f760
xorl %eax, %eax
jmp 0x107ff
// File: /workspace/github_c_makefile_star2_O3/shifengbin[P]bishe/Output/../Persistence/sqlite3.c
// Function: sqlite3PagerSync
SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zMaster){
  int rc = SQLITE_OK;

  if( isOpen(pPager->fd) ){
    void *pArg = (void*)zMaster;
    rc = sqlite3OsFileControl(pPager->fd, SQLITE_FCNTL_SYNC, pArg);
    if( rc==SQLITE_NOTFOUND ) rc = SQLITE_OK;
  }
  if( rc==SQLITE_OK && !pPager->noSync ){
    assert( !MEMDB );
    rc = sqlite3OsSync(pPager->fd, pPager->syncFlags);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x10a83
movq %rsi, %rdx
movl $0x15, %esi
callq *0x50(%rax)
cmpl $0xc, %eax
je 0x10a83
testl %eax, %eax
jne 0x10a8b
xorl %eax, %eax
cmpb $0x0, 0xb(%rbx)
je 0x10a92
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x48(%rbx), %rdi
movzbl 0xf(%rbx), %esi
movq (%rdi), %rax
movq 0x28(%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
movq 0x8(%rdi), %r14
cmpb $0x0, 0x11(%rdi)
je 0x10f78
incl 0x14(%rbx)
cmpb $0x0, 0x12(%rbx)
jne 0x10f78
movq %rbx, %rdi
callq 0x2520c
testl %r12d, %r12d
je 0x1100e
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x282ac
cmpb $0x2, 0x10(%rbx)
jne 0x10fee
movq (%r14), %rdi
callq 0x23683
leaq -0x28(%rbp), %rdx
movq %r14, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
callq 0x25730
testl %eax, %eax
jne 0x10fd8
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rcx
movl 0x1c(%rcx), %ecx
bswapl %ecx
testl %ecx, %ecx
jne 0x10fcb
movq (%r14), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, 0x3c(%r14)
movq 0x70(%rax), %rdi
callq 0x24e28
movb $0x1, 0x24(%r14)
movq 0x58(%r14), %rdi
callq 0x2354d
movq $0x0, 0x58(%r14)
movq %rbx, %rdi
callq 0x26635
cmpb $0x0, 0x11(%rbx)
je 0x11001
decl 0x14(%rbx)
je 0x11037
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x10f8f
xorl %r15d, %r15d
xorl %esi, %esi
xorl %edx, %edx
callq 0x26ab6
movl %eax, %r12d
testl %eax, %eax
jne 0x10f81
jmp 0x10f8f
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x25292
// File: /workspace/github_c_makefile_star2_O3/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 0x116d3
movq %rbx, %rdi
callq 0x116fb
testl %eax, %eax
je 0x116e6
xorl %eax, %eax
jmp 0x116f4
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x118a2
orb $0x10, 0x8(%rbx)
cmpl $0x0, 0xc(%rbx)
je 0x116cf
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x118d4
movl 0x8(%rdi), %eax
movl %eax, %ecx
notl %ecx
testl $0x202, %ecx            # imm = 0x202
jne 0x118c6
cmpb %sil, 0xa(%rdi)
jne 0x118c6
movq 0x10(%rdi), %rax
jmp 0x118d6
testb $0x1, %al
jne 0x118d4
movzbl %sil, %esi
popq %rbp
jmp 0x2a4f1
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl 0x8(%rdi), %eax
btl $0xe, %eax
jae 0x119c5
movq %rbx, %rdi
callq 0x116fb
movzwl 0x8(%rbx), %eax
testb $0x12, %al
je 0x11a18
cmpl $0x0, 0x20(%rbx)
je 0x119d9
movq 0x10(%rbx), %rcx
cmpq 0x18(%rbx), %rcx
je 0x11a18
movl 0xc(%rbx), %esi
addl $0x2, %esi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2a35d
movl %eax, %ecx
movl $0x7, %eax
testl %ecx, %ecx
jne 0x11a23
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)
movl $0x200, %eax            # imm = 0x200
orl 0x8(%rbx), %eax
andl $0xefff, %eax           # imm = 0xEFFF
movw %ax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x11fb0
movq %rbx, %rdi
callq 0x2a210
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 0x11fef
testb $0x8, 0x9(%r14)
jne 0x11fef
orl $0x1000, %eax           # imm = 0x1000
movw %ax, 0x8(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x119a7
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x68fbc(%rip), %rsi     # 0x7b0a6
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
xorl %r8d, %r8d
popq %rbp
jmp 0x11bc0
// File: /workspace/github_c_makefile_star2_O3/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 0x1211e
callq 0x2a210
movq (%rbx), %rdi
jmp 0x12124
movw $0x1, 0x8(%rdi)
movl $0x7, 0x24(%rbx)
movb $0x1, %al
movb %al, 0x29(%rbx)
movq 0x28(%rdi), %rcx
movb %al, 0x51(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x12df0
popq %rbp
jmp 0x12df6
movq 0x10(%rax), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x12ead
movl 0x20(%rdi), %edx
xorl %eax, %eax
cmpl %edx, (%rcx)
jne 0x12ea2
cmpl %esi, 0x4(%rcx)
je 0x12eb1
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x12e99
jmp 0x12eb5
xorl %eax, %eax
jmp 0x12eb5
movq 0x8(%rcx), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x13003
movq %rax, %rdi
callq 0xa530
movq %rax, %r14
movq %rbx, %rdi
callq 0x130ad
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x65d8c(%rip), %rbx     # 0x78da0
testq %rdi, %rdi
je 0x1309f
movq %rdi, %r14
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1305a
movl %esi, %r15d
movzwl 0x88(%r14), %ecx
cmpl %esi, %ecx
jbe 0x1305a
movq (%r14), %rcx
movq 0x18(%rcx), %rdi
testq %rdi, %rdi
je 0x1304e
callq *0x7e36e(%rip)          # 0x913b8
movq 0x28(%r14), %rax
movl %r15d, %ecx
imulq $0x38, %rcx, %rbx
addq %rax, %rbx
jmp 0x1309f
movq (%r14), %rax
testq %rax, %rax
je 0x1309f
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x13074
callq *0x7e347(%rip)          # 0x913b8
movq (%r14), %rax
movl $0x19, 0x44(%rax)
movq 0x140(%rax), %rdi
testq %rdi, %rdi
je 0x1309f
movzwl 0x8(%rdi), %eax
testl $0x2460, %eax           # imm = 0x2460
je 0x13099
callq 0x2a210
jmp 0x1309f
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_O3/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 0x135ef
leaq 0x1(%r8), %rax
cmpq $0x2, %rax
jb 0x135e9
pushq %rbp
movq %rsp, %rbp
movq %rdx, %rdi
callq *%r8
popq %rbp
movl $0x12, %eax
retq
xorl %r9d, %r9d
jmp 0x13496
// File: /workspace/github_c_makefile_star2_O3/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 0x13940
leaq 0x1(%r8), %rax
cmpq $0x2, %rax
jb 0x1393a
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 0x13496
// File: /workspace/github_c_makefile_star2_O3/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 0x2ac8c
testl %eax, %eax
je 0x13f0b
leaq -0x30(%rbp), %rsi
movq %r12, %rdi
movl %r15d, %edx
movl %r13d, %ecx
callq 0x2b20b
testl %eax, %eax
je 0x13ef9
movsd -0x38(%rbp), %xmm0
movsd %xmm0, (%rbx)
movl 0x8(%rbx), %eax
movl %eax, %ecx
orl $0x8, %ecx
movw %cx, 0x8(%rbx)
testl %r14d, %r14d
je 0x13f0b
movapd 0x67113(%rip), %xmm1    # 0x7afc0
andpd %xmm0, %xmm1
ucomisd 0x67027(%rip), %xmm1    # 0x7aee0
jae 0x13f0b
cvttsd2si %xmm0, %rcx
xorps %xmm1, %xmm1
cvtsi2sd %rcx, %xmm1
ucomisd %xmm1, %xmm0
setp %dl
setne %sil
orb %dl, %sil
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
addq %rcx, %rdx
cmpq $-0x2, %rdx
setae %dl
orb %sil, %dl
jne 0x13f0b
movq %rcx, (%rbx)
andl $0xbe00, %eax           # imm = 0xBE00
jmp 0x13f04
movq -0x30(%rbp), %rax
movq %rax, (%rbx)
movzwl 0x8(%rbx), %eax
orl $0x4, %eax
movw %ax, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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), %r14
movl $0x128, %esi            # imm = 0x128
movq %r14, %rdi
callq 0x145aa
movq %rax, %r15
testq %rax, %rax
je 0x14a29
movq %r15, %rdi
addq $0x8, %rdi
movl $0x120, %edx            # imm = 0x120
xorl %esi, %esi
callq 0xa220
movq %r14, (%r15)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x14a0d
movq %r15, 0x50(%rax)
movq %rax, 0x58(%r15)
movq $0x0, 0x50(%r15)
movq %r15, 0x8(%r14)
movl $0x26bceaa5, 0x44(%r15) # imm = 0x26BCEAA5
movq %rbx, 0x30(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movl %esi, %r14d
movq %rdi, %rbx
movl 0x3c(%rdi), %eax
leal (%rax,%r14), %ecx
movq 0x30(%rdi), %rdx
cmpl 0x60(%rdx), %ecx
jle 0x14aa5
movq %rbx, %rdi
callq 0x3eb4a
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x14b0b
movl 0x3c(%rbx), %eax
movl %eax, %ecx
testl %r14d, %r14d
jle 0x14b05
movslq %eax, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x8(%rbx), %rcx
movl %r14d, %edx
xorl %esi, %esi
xorl %edi, %edi
movb (%r15,%rdi,4), %r8b
movb %r8b, (%rcx)
movsbl 0x1(%r15,%rdi,4), %r8d
movl %r8d, 0x4(%rcx)
movsbl 0x2(%r15,%rdi,4), %r8d
movl %r8d, 0x8(%rcx)
movsbl 0x3(%r15,%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 0x14ac2
movl 0x3c(%rbx), %ecx
addl %r14d, %ecx
movl %ecx, 0x3c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x151e6
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x80(%rdi), %rsi
movq %r14, %rdi
callq 0xb752
movq 0x150(%rbx), %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3c97e
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x155d6
callq *0x7bde2(%rip)          # 0x913b8
movq %r15, 0x180(%rbx)
movq %r14, 0x188(%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x155fa
orb $0x8, 0x8c(%rax)
movq 0x58(%rax), %rax
jmp 0x155e8
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x15609
callq *0x7bdbf(%rip)          # 0x913c8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x15f05
movq %rdi, %rbx
movl 0x5c(%rdi), %eax
cmpl $0xa029a697, %eax       # imm = 0xA029A697
je 0x15ee4
cmpl $0xf03b7906, %eax       # imm = 0xF03B7906
je 0x15ee4
cmpl $0x4b771290, %eax       # imm = 0x4B771290
jne 0x15f3e
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x15ef3
callq *0x7b4c5(%rip)          # 0x913b8
cmpb $0x0, 0x51(%rbx)
je 0x15f11
leaq 0x65527(%rip), %r14     # 0x7b427
jmp 0x15fa8
leaq 0x6551b(%rip), %r14     # 0x7b427
jmp 0x15fb7
movq 0x140(%rbx), %rdi
movl $0x1, %esi
callq 0x118a2
movq %rax, %r14
testq %rax, %rax
jne 0x15fa8
movl 0x44(%rbx), %eax
cmpq $0x204, %rax            # imm = 0x204
jne 0x15f80
leaq 0x6945a(%rip), %r14     # 0x7f396
jmp 0x15fa8
leaq 0x667e7(%rip), %rsi     # 0x7c72c
leaq 0x694d2(%rip), %rdx     # 0x7f41e
movl $0x15, %edi
xorl %eax, %eax
callq 0xa4c0
leaq 0x69543(%rip), %rsi     # 0x7f4a2
leaq 0x65227(%rip), %rcx     # 0x7b18d
movl $0x15, %edi
movl $0x20c48, %edx          # imm = 0x20C48
xorl %eax, %eax
callq 0xa4c0
leaq 0x69346(%rip), %r14     # 0x7f2c4
jmp 0x15fb7
movzbl %al, %eax
cmpl $0x1b, %eax
setae %cl
cmpq $0x2, %rax
sete %dl
orb %cl, %dl
je 0x15f9d
leaq 0x693ed(%rip), %r14     # 0x7f388
jmp 0x15fa8
leaq 0x7ad4c(%rip), %rcx     # 0x90cf0
movq (%rcx,%rax,8), %r14
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x15fb7
callq *0x7b411(%rip)          # 0x913c8
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xa080
movl %eax, %r12d
testl %eax, %eax
jne 0x165f9
xorl %r13d, %r13d
cmpl $0x0, 0x7adf1(%rip)     # 0x91334
je 0x1656a
movl $0x2, %edi
callq *0x7ae58(%rip)          # 0x913a8
testq %rax, %rax
je 0x1656a
movq %rax, %r14
movq %rax, %rdi
callq *0x7ae57(%rip)          # 0x913b8
movl $0x0, -0x2c(%rbp)
jmp 0x16572
movb $0x1, %al
movl %eax, -0x2c(%rbp)
xorl %r14d, %r14d
movl 0x7cc0f(%rip), %r15d    # 0x93188
testq %r15, %r15
je 0x16598
movq 0x7cc0b(%rip), %rax     # 0x93190
xorl %r13d, %r13d
cmpq %rbx, (%rax,%r13,8)
je 0x16598
incq %r13
cmpq %r13, %r15
jne 0x16588
jmp 0x165a0
xorl %r12d, %r12d
cmpl %r15d, %r13d
jne 0x165ea
movq 0x7cbe9(%rip), %r13     # 0x93190
callq 0xa080
movl $0x7, %r12d
testl %eax, %eax
jne 0x165ea
incl %r15d
shlq $0x3, %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0xc2eb
testq %rax, %rax
je 0x165ea
movq %rax, 0x7cbbc(%rip)     # 0x93190
movl 0x7cbae(%rip), %ecx     # 0x93188
movq %rbx, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x7cba1(%rip)     # 0x93188
xorl %r12d, %r12d
cmpb $0x0, -0x2c(%rbp)
jne 0x165f9
movq %r14, %rdi
callq *0x7adcf(%rip)          # 0x913c8
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x15e3a
testq %r15, %r15
je 0x16805
testl %eax, %eax
je 0x16805
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x16785
callq *0x7ac33(%rip)          # 0x913b8
movq %rbx, %rdi
callq 0xb408
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 0x3f17d
movq %r12, %rcx
movl %eax, %r12d
cmpl $0x11, %eax
jne 0x167ec
movq (%r14), %rdi
movq %rcx, %r12
callq 0xa4d0
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 0x3f17d
movl %eax, %r12d
movq %rbx, %rdi
callq 0xb463
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1682a
callq *0x7abc5(%rip)          # 0x913c8
jmp 0x1682a
leaq 0x68c96(%rip), %rsi     # 0x7f4a2
leaq 0x6497a(%rip), %rcx     # 0x7b18d
movl $0x15, %r12d
movl $0x15, %edi
movl $0x1abb1, %edx          # imm = 0x1ABB1
xorl %eax, %eax
callq 0xa4c0
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq