LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sumStep
static void sumStep(sqlite3_context *context, int argc, sqlite3_value **argv){
  SumCtx *p;
  int type;
  assert( argc==1 );
  UNUSED_PARAMETER(argc);
  p = sqlite3_aggregate_context(context, sizeof(*p));
  type = sqlite3_value_numeric_type(argv[0]);
  if( p && type!=SQLITE_NULL ){
    p->cnt++;
    if( type==SQLITE_INTEGER ){
      i64 v = sqlite3_value_int64(argv[0]);
      p->rSum += v;
      if( (p->approx|p->overflow)==0 && sqlite3AddInt64(&p->iSum, v) ){
        p->overflow = 1;
      }
    }else{
      p->rSum += sqlite3_value_double(argv[0]);
      p->approx = 1;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x117d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x12ce0
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x86e9a
cmpl $0x5, -0x24(%rbp)
je 0x86e9a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
cmpl $0x1, -0x24(%rbp)
jne 0x86e78
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x105c0
movq %rax, -0x30(%rbp)
cvtsi2sdq -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movzbl 0x19(%rax), %eax
movq -0x20(%rbp), %rcx
movzbl 0x18(%rcx), %ecx
orl %ecx, %eax
cmpl $0x0, %eax
jne 0x86e76
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %rsi
callq 0x3ad20
cmpl $0x0, %eax
je 0x86e76
movq -0x20(%rbp), %rax
movb $0x1, 0x18(%rax)
jmp 0x86e98
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x10430
movq -0x20(%rbp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x19(%rax)
jmp 0x86e9a
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sumFinalize
static void sumFinalize(sqlite3_context *context){
  SumCtx *p;
  p = sqlite3_aggregate_context(context, 0);
  if( p && p->cnt>0 ){
    if( p->overflow ){
      sqlite3_result_error(context,"integer overflow",-1);
    }else if( p->approx ){
      sqlite3_result_double(context, p->rSum);
    }else{
      sqlite3_result_int64(context, p->iSum);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x117d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x86f20
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jle 0x86f20
movq -0x10(%rbp), %rax
cmpb $0x0, 0x18(%rax)
je 0x86eee
movq -0x8(%rbp), %rdi
leaq 0x2aad5(%rip), %rsi     # 0xb19b7
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x108b0
jmp 0x86f1e
movq -0x10(%rbp), %rax
cmpb $0x0, 0x19(%rax)
je 0x86f0b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x10820
jmp 0x86f1c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x10c90
jmp 0x86f1e
jmp 0x86f20
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: totalFinalize
static void totalFinalize(sqlite3_context *context){
  SumCtx *p;
  p = sqlite3_aggregate_context(context, 0);
  /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
  sqlite3_result_double(context, p ? p->rSum : (double)0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x117d0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x86f69
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x86f73
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x86f73
movq -0x18(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
callq 0x10820
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: avgFinalize
static void avgFinalize(sqlite3_context *context){
  SumCtx *p;
  p = sqlite3_aggregate_context(context, 0);
  if( p && p->cnt>0 ){
    sqlite3_result_double(context, p->rSum/(double)p->cnt);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x117d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x86fdc
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jle 0x86fdc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
cvtsi2sdq 0x10(%rax), %xmm1
divsd %xmm1, %xmm0
callq 0x10820
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: countStep
static void countStep(sqlite3_context *context, int argc, sqlite3_value **argv){
  CountCtx *p;
  p = sqlite3_aggregate_context(context, sizeof(*p));
  if( (argc==0 || SQLITE_NULL!=sqlite3_value_type(argv[0])) && p ){
    p->n++;
  }

#ifndef SQLITE_OMIT_DEPRECATED
  /* The sqlite3_aggregate_count() function is deprecated.  But just to make
  ** sure it still operates correctly, verify that its count agrees with our 
  ** internal count when using count(*) and when the total count can be
  ** expressed as a 32-bit integer. */
  assert( argc==1 || p==0 || p->n>0x7fffffff
          || p->n==sqlite3_aggregate_count(context) );
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x117d0
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x87032
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x10770
movl %eax, %ecx
movl $0x5, %eax
cmpl %ecx, %eax
je 0x87047
cmpq $0x0, -0x20(%rbp)
je 0x87047
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: groupConcatStep
static void groupConcatStep(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  const char *zVal;
  StrAccum *pAccum;
  const char *zSep;
  int nVal, nSep;
  assert( argc==1 || argc==2 );
  if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
  pAccum = (StrAccum*)sqlite3_aggregate_context(context, sizeof(*pAccum));

  if( pAccum ){
    sqlite3 *db = sqlite3_context_db_handle(context);
    int firstTerm = pAccum->useMalloc==0;
    pAccum->useMalloc = 2;
    pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
    if( !firstTerm ){
      if( argc==2 ){
        zSep = (char*)sqlite3_value_text(argv[1]);
        nSep = sqlite3_value_bytes(argv[1]);
      }else{
        zSep = ",";
        nSep = 1;
      }
      sqlite3StrAccumAppend(pAccum, zSep, nSep);
    }
    zVal = (char*)sqlite3_value_text(argv[0]);
    nVal = sqlite3_value_bytes(argv[0]);
    sqlite3StrAccumAppend(pAccum, zVal, nVal);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x10770
cmpl $0x5, %eax
jne 0x870d9
jmp 0x871af
movq -0x8(%rbp), %rdi
movl $0x28, %esi
callq 0x117d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x871af
movq -0x8(%rbp), %rdi
callq 0x117b0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x24(%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x44(%rbp)
movq -0x28(%rbp), %rax
movb $0x2, 0x24(%rax)
movq -0x40(%rbp), %rax
movl 0x68(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x20(%rax)
cmpl $0x0, -0x44(%rbp)
jne 0x87180
cmpl $0x2, -0xc(%rbp)
jne 0x8715e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10350
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10370
movl %eax, -0x38(%rbp)
jmp 0x87170
leaq 0x28ce4(%rip), %rax     # 0xafe49
movq %rax, -0x30(%rbp)
movl $0x1, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x38(%rbp), %edx
callq 0x1bb70
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x10350
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x10370
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x1bb70
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: groupConcatFinalize
static void groupConcatFinalize(sqlite3_context *context){
  StrAccum *pAccum;
  pAccum = sqlite3_aggregate_context(context, 0);
  if( pAccum ){
    if( pAccum->accError==STRACCUM_TOOBIG ){
      sqlite3_result_error_toobig(context);
    }else if( pAccum->accError==STRACCUM_NOMEM ){
      sqlite3_result_error_nomem(context);
    }else{    
      sqlite3_result_text(context, sqlite3StrAccumFinish(pAccum), -1, 
                          sqlite3_free);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x117d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8723f
movq -0x10(%rbp), %rax
movzbl 0x25(%rax), %eax
cmpl $0x2, %eax
jne 0x871fa
movq -0x8(%rbp), %rdi
callq 0x110d0
jmp 0x8723d
movq -0x10(%rbp), %rax
movzbl 0x25(%rax), %eax
cmpl $0x1, %eax
jne 0x87212
movq -0x8(%rbp), %rdi
callq 0x11120
jmp 0x8723b
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc310
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leaq -0x7ce16(%rip), %rcx    # 0xa420
callq 0x10d80
jmp 0x8723d
jmp 0x8723f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3FuncDefInsert
SQLITE_PRIVATE void sqlite3FuncDefInsert(
  FuncDefHash *pHash,  /* The hash table into which to insert */
  FuncDef *pDef        /* The function definition to insert */
){
  FuncDef *pOther;
  int nName = sqlite3Strlen30(pDef->zName);
  u8 c1 = (u8)pDef->zName[0];
  int h = (sqlite3UpperToLower[c1] + nName) % ArraySize(pHash->a);
  pOther = functionSearch(pHash, h, pDef->zName, nName);
  if( pOther ){
    assert( pOther!=pDef && pOther->pNext!=pDef );
    pDef->pNext = pOther->pNext;
    pOther->pNext = pDef;
  }else{
    pDef->pNext = 0;
    pDef->pHash = pHash->a[h];
    pHash->a[h] = pDef;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x92f0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movb (%rax), %al
movb %al, -0x1d(%rbp)
movzbl -0x1d(%rbp), %eax
movl %eax, %ecx
leaq 0x238b6(%rip), %rax     # 0xaab40
movzbl (%rax,%rcx), %eax
addl -0x1c(%rbp), %eax
movl $0x17, %ecx
cltd
idivl %ecx
movl %edx, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
movl -0x1c(%rbp), %ecx
callq 0x87490
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x872dc
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x8730c
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3RegisterDateTimeFunctions
SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void){
  static SQLITE_WSD FuncDef aDateTimeFuncs[] = {
#ifndef SQLITE_OMIT_DATETIME_FUNCS
    FUNCTION(julianday,        -1, 0, 0, juliandayFunc ),
    FUNCTION(date,             -1, 0, 0, dateFunc      ),
    FUNCTION(time,             -1, 0, 0, timeFunc      ),
    FUNCTION(datetime,         -1, 0, 0, datetimeFunc  ),
    FUNCTION(strftime,         -1, 0, 0, strftimeFunc  ),
    FUNCTION(current_time,      0, 0, 0, ctimeFunc     ),
    FUNCTION(current_timestamp, 0, 0, 0, ctimestampFunc),
    FUNCTION(current_date,      0, 0, 0, cdateFunc     ),
#else
    STR_FUNCTION(current_time,      0, "%H:%M:%S",          0, currentTimeFunc),
    STR_FUNCTION(current_date,      0, "%Y-%m-%d",          0, currentTimeFunc),
    STR_FUNCTION(current_timestamp, 0, "%Y-%m-%d %H:%M:%S", 0, currentTimeFunc),
#endif
  };
  int i;
  FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
  FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aDateTimeFuncs);

  for(i=0; i<ArraySize(aDateTimeFuncs); i++){
    sqlite3FuncDefInsert(pHash, &aFunc[i]);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x4ac89(%rip), %rax     # 0xd1fb8
movq %rax, -0x10(%rbp)
leaq 0x4a796(%rip), %rax     # 0xd1ad0
movq %rax, -0x18(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x8, -0x4(%rbp)
jge 0x8736e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x4(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rsi
callq 0x87250
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x87345
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3AlterFunctions
SQLITE_PRIVATE void sqlite3AlterFunctions(void){
  static SQLITE_WSD FuncDef aAlterTableFuncs[] = {
    FUNCTION(sqlite_rename_table,   2, 0, 0, renameTableFunc),
#ifndef SQLITE_OMIT_TRIGGER
    FUNCTION(sqlite_rename_trigger, 2, 0, 0, renameTriggerFunc),
#endif
#ifndef SQLITE_OMIT_FOREIGN_KEY
    FUNCTION(sqlite_rename_parent,  3, 0, 0, renameParentFunc),
#endif
  };
  int i;
  FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
  FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aAlterTableFuncs);

  for(i=0; i<ArraySize(aAlterTableFuncs); i++){
    sqlite3FuncDefInsert(pHash, &aFunc[i]);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x4ac29(%rip), %rax     # 0xd1fb8
movq %rax, -0x10(%rbp)
leaq 0x4a976(%rip), %rax     # 0xd1d10
movq %rax, -0x18(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x3, -0x4(%rbp)
jge 0x873ce
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x4(%rbp), %rax
imulq $0x48, %rax, %rax
addq %rax, %rsi
callq 0x87250
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x873a5
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: contextMalloc
static void *contextMalloc(sqlite3_context *context, i64 nByte){
  char *z;
  sqlite3 *db = sqlite3_context_db_handle(context);
  assert( nByte>0 );
  testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH] );
  testcase( nByte==db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
  if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
    sqlite3_result_error_toobig(context);
    z = 0;
  }else{
    z = sqlite3Malloc((int)nByte);
    if( !z ){
      sqlite3_result_error_nomem(context);
    }
  }
  return z;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x117b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq 0x68(%rcx), %rcx
cmpq %rcx, %rax
jle 0x87421
movq -0x8(%rbp), %rdi
callq 0x110d0
movq $0x0, -0x18(%rbp)
jmp 0x87442
movq -0x10(%rbp), %rax
movl %eax, %edi
callq 0xa3c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x87440
movq -0x8(%rbp), %rdi
callq 0x11120
jmp 0x87442
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: functionSearch
static FuncDef *functionSearch(
  FuncDefHash *pHash,  /* Hash table to search */
  int h,               /* Hash of the name */
  const char *zFunc,   /* Name of function */
  int nFunc            /* Number of bytes in zFunc */
){
  FuncDef *p;
  for(p=pHash->a[h]; p; p=p->pHash){
    if( sqlite3StrNICmp(p->zName, zFunc, nFunc)==0 && p->zName[nFunc]==0 ){
      return p;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x87505
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x9210
cmpl $0x0, %eax
jne 0x874f5
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x874f5
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8750d
jmp 0x874f7
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x874b6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: dateFunc
static void dateFunc(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  DateTime x;
  if( isDate(context, argc, argv, &x)==0 ){
    char zBuf[100];
    computeYMD(&x);
    sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d", x.Y, x.M, x.D);
    sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x87e10
cmpl $0x0, %eax
jne 0x875f9
leaq -0x48(%rbp), %rdi
callq 0x896c0
leaq -0xb0(%rbp), %rsi
movl -0x40(%rbp), %ecx
movl -0x3c(%rbp), %r8d
movl -0x38(%rbp), %r9d
movl $0x64, %edi
leaq 0x2a4a0(%rip), %rdx     # 0xb1a76
movb $0x0, %al
callq 0xc540
movq -0x8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq $-0x1, %rcx
callq 0x10d80
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: timeFunc
static void timeFunc(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  DateTime x;
  if( isDate(context, argc, argv, &x)==0 ){
    char zBuf[100];
    computeHMS(&x);
    sqlite3_snprintf(sizeof(zBuf), zBuf, "%02d:%02d:%02d", x.h, x.m, (int)x.s);
    sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x87e10
cmpl $0x0, %eax
jne 0x8768b
leaq -0x48(%rbp), %rdi
callq 0x898b0
leaq -0xb0(%rbp), %rsi
movl -0x34(%rbp), %ecx
movl -0x30(%rbp), %r8d
cvttsd2si -0x28(%rbp), %r9d
movl $0x64, %edi
leaq 0x2a42c(%rip), %rdx     # 0xb1a94
movb $0x0, %al
callq 0xc540
movq -0x8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq $-0x1, %rcx
callq 0x10d80
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: datetimeFunc
static void datetimeFunc(
  sqlite3_context *context,
  int argc,
  sqlite3_value **argv
){
  DateTime x;
  if( isDate(context, argc, argv, &x)==0 ){
    char zBuf[100];
    computeYMD_HMS(&x);
    sqlite3_snprintf(sizeof(zBuf), zBuf, "%04d-%02d-%02d %02d:%02d:%02d",
                     x.Y, x.M, x.D, x.h, x.m, (int)(x.s));
    sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x87e10
cmpl $0x0, %eax
jne 0x87733
leaq -0x48(%rbp), %rdi
callq 0x89690
leaq -0xb0(%rbp), %rsi
movl -0x40(%rbp), %ecx
movl -0x3c(%rbp), %r8d
movl -0x38(%rbp), %r9d
movl -0x34(%rbp), %r11d
movl -0x30(%rbp), %r10d
cvttsd2si -0x28(%rbp), %eax
movl $0x64, %edi
leaq 0x2a382(%rip), %rdx     # 0xb1a85
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movb $0x0, %al
callq 0xc540
movq -0x8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq $-0x1, %rcx
callq 0x10d80
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: isDate
static int isDate(
  sqlite3_context *context, 
  int argc, 
  sqlite3_value **argv, 
  DateTime *p
){
  int i;
  const unsigned char *z;
  int eType;
  memset(p, 0, sizeof(*p));
  if( argc==0 ){
    return setDateTimeToCurrent(context, p);
  }
  if( (eType = sqlite3_value_type(argv[0]))==SQLITE_FLOAT
                   || eType==SQLITE_INTEGER ){
    p->iJD = (sqlite3_int64)(sqlite3_value_double(argv[0])*86400000.0 + 0.5);
    p->validJD = 1;
  }else{
    z = sqlite3_value_text(argv[0]);
    if( !z || parseDateOrTime(context, (char*)z, p) ){
      return 1;
    }
  }
  for(i=1; i<argc; i++){
    z = sqlite3_value_text(argv[i]);
    if( z==0 || parseModifier(context, (char*)z, p) ) return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x8200
cmpl $0x0, -0x14(%rbp)
jne 0x87e52
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x880f0
movl %eax, -0x4(%rbp)
jmp 0x87f3c
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x10770
movl %eax, -0x3c(%rbp)
cmpl $0x2, %eax
je 0x87e6c
cmpl $0x1, -0x3c(%rbp)
jne 0x87ea6
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x10430
movsd 0x25f98(%rip), %xmm1    # 0xade18
mulsd %xmm1, %xmm0
movsd 0x25f64(%rip), %xmm1    # 0xaddf0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movb $0x1, 0x2a(%rax)
jmp 0x87ede
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x10350
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x87ed3
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x88150
cmpl $0x0, %eax
je 0x87edc
movl $0x1, -0x4(%rbp)
jmp 0x87f3c
jmp 0x87ede
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x87f35
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10350
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x87f1f
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x88250
cmpl $0x0, %eax
je 0x87f28
movl $0x1, -0x4(%rbp)
jmp 0x87f3c
jmp 0x87f2a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x87ee5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: computeJD
static void computeJD(DateTime *p){
  int Y, M, D, A, B, X1, X2;

  if( p->validJD ) return;
  if( p->validYMD ){
    Y = p->Y;
    M = p->M;
    D = p->D;
  }else{
    Y = 2000;  /* If no YMD specified, assume 2000-Jan-01 */
    M = 1;
    D = 1;
  }
  if( M<=2 ){
    Y--;
    M += 12;
  }
  A = Y/100;
  B = 2 - A + (A/4);
  X1 = 36525*(Y+4716)/100;
  X2 = 306001*(M+1)/10000;
  p->iJD = (sqlite3_int64)((X1 + X2 + D + B - 1524.5 ) * 86400000);
  p->validJD = 1;
  if( p->validHMS ){
    p->iJD += p->h*3600000 + p->m*60000 + (sqlite3_int64)(p->s*1000);
    if( p->validTZ ){
      p->iJD -= p->tz*60000;
      p->validYMD = 0;
      p->validHMS = 0;
      p->validTZ = 0;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x2a(%rax)
je 0x87f67
jmp 0x880df
movq -0x8(%rbp), %rax
cmpb $0x0, 0x28(%rax)
je 0x87f91
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x87fa6
movl $0x7d0, -0xc(%rbp)      # imm = 0x7D0
movl $0x1, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
cmpl $0x2, -0x10(%rbp)
jg 0x87fbe
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0xc, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movl $0x2, %eax
subl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x18(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
addl $0x126c, %eax           # imm = 0x126C
imull $0x8ead, %eax, %eax     # imm = 0x8EAD
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
imull $0x4ab51, %eax, %eax    # imm = 0x4AB51
movl $0x2710, %ecx           # imm = 0x2710
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
addl -0x14(%rbp), %eax
addl -0x1c(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd 0x25e3c(%rip), %xmm1    # 0xade70
subsd %xmm1, %xmm0
movsd 0x25dd8(%rip), %xmm1    # 0xade18
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x2a(%rax)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x29(%rax)
je 0x880df
movq -0x8(%rbp), %rax
imull $0x36ee80, 0x14(%rax), %eax # imm = 0x36EE80
movq -0x8(%rbp), %rcx
imull $0xea60, 0x18(%rcx), %ecx # imm = 0xEA60
addl %ecx, %eax
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movsd 0x25def(%rip), %xmm0    # 0xade78
mulsd 0x20(%rax), %xmm0
cvttsd2si %xmm0, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x2b(%rax)
je 0x880dd
movq -0x8(%rbp), %rax
imull $0xea60, 0x1c(%rax), %eax # imm = 0xEA60
movslq %eax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x29(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x2b(%rax)
jmp 0x880df
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: setDateTimeToCurrent
static int setDateTimeToCurrent(sqlite3_context *context, DateTime *p){
  sqlite3 *db = sqlite3_context_db_handle(context);
  if( sqlite3OsCurrentTimeInt64(db->pVfs, &p->iJD)==SQLITE_OK ){
    p->validJD = 1;
    return 0;
  }else{
    return 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x117b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x32110
cmpl $0x0, %eax
jne 0x88133
movq -0x18(%rbp), %rax
movb $0x1, 0x2a(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x8813a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: parseDateOrTime
static int parseDateOrTime(
  sqlite3_context *context, 
  const char *zDate, 
  DateTime *p
){
  double r;
  if( parseYyyyMmDd(zDate,p)==0 ){
    return 0;
  }else if( parseHhMmSs(zDate, p)==0 ){
    return 0;
  }else if( sqlite3StrICmp(zDate,"now")==0){
    return setDateTimeToCurrent(context, p);
  }else if( sqlite3AtoF(zDate, &r, sqlite3Strlen30(zDate), SQLITE_UTF8) ){
    p->iJD = (sqlite3_int64)(r*86400000.0 + 0.5);
    p->validJD = 1;
    return 0;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x88c10
cmpl $0x0, %eax
jne 0x88182
movl $0x0, -0x4(%rbp)
jmp 0x88238
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x88dd0
cmpl $0x0, %eax
jne 0x881a0
movl $0x0, -0x4(%rbp)
jmp 0x88238
movq -0x18(%rbp), %rdi
leaq 0x29871(%rip), %rsi     # 0xb1a1c
callq 0xc970
cmpl $0x0, %eax
jne 0x881c7
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x880f0
movl %eax, -0x4(%rbp)
jmp 0x88238
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x92f0
movq -0x30(%rbp), %rdi
movl %eax, %edx
leaq -0x28(%rbp), %rsi
movl $0x1, %ecx
callq 0x308d0
cmpl $0x0, %eax
je 0x8822b
movsd -0x28(%rbp), %xmm0
movsd 0x25c1a(%rip), %xmm1    # 0xade18
mulsd %xmm1, %xmm0
movsd 0x25be6(%rip), %xmm1    # 0xaddf0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x2a(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x88238
jmp 0x8822d
jmp 0x8822f
jmp 0x88231
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: parseYyyyMmDd
static int parseYyyyMmDd(const char *zDate, DateTime *p){
  int Y, M, D, neg;

  if( zDate[0]=='-' ){
    zDate++;
    neg = 1;
  }else{
    neg = 0;
  }
  if( getDigits(zDate,4,0,9999,'-',&Y,2,1,12,'-',&M,2,1,31,0,&D)!=3 ){
    return 1;
  }
  zDate += 10;
  while( sqlite3Isspace(*zDate) || 'T'==*(u8*)zDate ){ zDate++; }
  if( parseHhMmSs(zDate, p)==0 ){
    /* We got the time */
  }else if( *zDate==0 ){
    p->validHMS = 0;
  }else{
    return 1;
  }
  p->validJD = 0;
  p->validYMD = 1;
  p->Y = neg ? -Y : Y;
  p->M = M;
  p->D = D;
  if( p->validTZ ){
    computeJD(p);
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x88c44
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x28(%rbp)
jmp 0x88c4b
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
xorl %edx, %edx
movl $0x270f, %ecx           # imm = 0x270F
movl $0x2d, %r8d
leaq -0x1c(%rbp), %r9
leaq -0x20(%rbp), %r10
leaq -0x24(%rbp), %rax
movl $0x2, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0xc, 0x10(%rsp)
movl $0x2d, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movl $0x2, 0x28(%rsp)
movl $0x1, 0x30(%rsp)
movl $0x1f, 0x38(%rsp)
movl $0x0, 0x40(%rsp)
movq %rax, 0x48(%rsp)
movb $0x0, %al
callq 0x89000
cmpl $0x3, %eax
je 0x88cce
movl $0x1, -0x4(%rbp)
jmp 0x88db9
movq -0x10(%rbp), %rax
addq $0xa, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x21d56(%rip), %rax     # 0xaaa40
movzbl (%rax,%rcx), %ecx
andl $0x1, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
jne 0x88d0f
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
movl $0x54, %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x88d18
jmp 0x88d26
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x88cda
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x88dd0
cmpl $0x0, %eax
jne 0x88d3a
jmp 0x88d5b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x88d50
movq -0x18(%rbp), %rax
movb $0x0, 0x29(%rax)
jmp 0x88d59
movl $0x1, -0x4(%rbp)
jmp 0x88db9
jmp 0x88d5b
movq -0x18(%rbp), %rax
movb $0x0, 0x2a(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x28(%rax)
cmpl $0x0, -0x28(%rbp)
je 0x88d7b
xorl %eax, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x88d81
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpb $0x0, 0x2b(%rax)
je 0x88db2
movq -0x18(%rbp), %rdi
callq 0x87f50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: parseTimezone
static int parseTimezone(const char *zDate, DateTime *p){
  int sgn = 0;
  int nHr, nMn;
  int c;
  while( sqlite3Isspace(*zDate) ){ zDate++; }
  p->tz = 0;
  c = *zDate;
  if( c=='-' ){
    sgn = -1;
  }else if( c=='+' ){
    sgn = +1;
  }else if( c=='Z' || c=='z' ){
    zDate++;
    goto zulu_time;
  }else{
    return c!=0;
  }
  zDate++;
  if( getDigits(zDate, 2, 0, 14, ':', &nHr, 2, 0, 59, 0, &nMn)!=2 ){
    return 1;
  }
  zDate += 5;
  p->tz = sgn*(nMn + nHr*60);
zulu_time:
  while( sqlite3Isspace(*zDate) ){ zDate++; }
  return *zDate!=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x216d9(%rip), %rax     # 0xaaa40
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x89381
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x89357
movq -0x18(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x28(%rbp)
cmpl $0x2d, -0x28(%rbp)
jne 0x893a5
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0x893e7
cmpl $0x2b, -0x28(%rbp)
jne 0x893b4
movl $0x1, -0x1c(%rbp)
jmp 0x893e5
cmpl $0x5a, -0x28(%rbp)
je 0x893c0
cmpl $0x7a, -0x28(%rbp)
jne 0x893d1
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8946c
cmpl $0x0, -0x28(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x894ad
jmp 0x893e7
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
xorl %edx, %edx
movl $0xe, %ecx
movl $0x3a, %r8d
leaq -0x20(%rbp), %r9
leaq -0x24(%rbp), %rax
movl $0x2, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x3b, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movb $0x0, %al
callq 0x89000
cmpl $0x2, %eax
je 0x8944a
movl $0x1, -0x4(%rbp)
jmp 0x894ad
movq -0x10(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %ecx
movl -0x24(%rbp), %eax
imull $0x3c, -0x20(%rbp), %edx
addl %edx, %eax
imull %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c(%rax)
jmp 0x8946e
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x215c2(%rip), %rax     # 0xaaa40
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x89498
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8946e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: computeYMD
static void computeYMD(DateTime *p){
  int Z, A, B, C, D, E, X1;
  if( p->validYMD ) return;
  if( !p->validJD ){
    p->Y = 2000;
    p->M = 1;
    p->D = 1;
  }else{
    Z = (int)((p->iJD + 43200000)/86400000);
    A = (int)((Z - 1867216.25)/36524.25);
    A = Z + 1 + A - (A/4);
    B = A + 1524;
    C = (int)((B - 122.1)/365.25);
    D = (36525*C)/100;
    E = (int)((B-D)/30.6001);
    X1 = (int)(30.6001*E);
    p->D = B - D - X1;
    p->M = E<14 ? E-1 : E-13;
    p->Y = p->M>2 ? C - 4716 : C - 4715;
  }
  p->validYMD = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x28(%rax)
je 0x896d7
jmp 0x89844
movq -0x8(%rbp), %rax
cmpb $0x0, 0x2a(%rax)
jne 0x89707
movq -0x8(%rbp), %rax
movl $0x7d0, 0x8(%rax)       # imm = 0x7D0
movq -0x8(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x8983c
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x2932e00, %rax        # imm = 0x2932E00
movl $0x5265c00, %ecx        # imm = 0x5265C00
cqto
idivq %rcx
movl %eax, -0xc(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
movsd 0x247b2(%rip), %xmm1    # 0xadee0
subsd %xmm1, %xmm0
movsd 0x2479e(%rip), %xmm1    # 0xaded8
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x10(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x5f4, %eax            # imm = 0x5F4
movl %eax, -0x14(%rbp)
cvtsi2sdl -0x14(%rbp), %xmm0
movsd 0x24752(%rip), %xmm1    # 0xaded0
subsd %xmm1, %xmm0
movsd 0x2473e(%rip), %xmm1    # 0xadec8
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
imull $0x8ead, -0x18(%rbp), %eax # imm = 0x8EAD
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
subl -0x1c(%rbp), %eax
cvtsi2sd %eax, %xmm0
movsd 0x24707(%rip), %xmm1    # 0xadec0
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x20(%rbp)
cvtsi2sdl -0x20(%rbp), %xmm1
movsd 0x246ef(%rip), %xmm0    # 0xadec0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %ecx
subl -0x1c(%rbp), %ecx
subl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
cmpl $0xe, -0x20(%rbp)
jge 0x897fd
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x89806
movl -0x20(%rbp), %eax
subl $0xd, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
cmpl $0x2, 0xc(%rax)
jle 0x89827
movl -0x18(%rbp), %eax
subl $0x126c, %eax           # imm = 0x126C
movl %eax, -0x30(%rbp)
jmp 0x89832
movl -0x18(%rbp), %eax
subl $0x126b, %eax           # imm = 0x126B
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x28(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: computeHMS
static void computeHMS(DateTime *p){
  int s;
  if( p->validHMS ) return;
  computeJD(p);
  s = (int)((p->iJD + 43200000) % 86400000);
  p->s = s/1000.0;
  s = (int)p->s;
  p->s -= s;
  p->h = s/3600;
  s -= p->h*3600;
  p->m = s/60;
  p->s += s - p->m*60;
  p->validHMS = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x29(%rax)
je 0x898cb
jmp 0x8998f
movq -0x8(%rbp), %rdi
callq 0x87f50
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x2932e00, %rax        # imm = 0x2932E00
movl $0x5265c00, %ecx        # imm = 0x5265C00
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0xc(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
movsd 0x2457b(%rip), %xmm1    # 0xade78
divsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movq -0x8(%rbp), %rax
cvttsd2si 0x20(%rax), %eax
movl %eax, -0xc(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rax)
movl -0xc(%rbp), %eax
movl $0xe10, %ecx            # imm = 0xE10
cltd
idivl %ecx
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
imull $0xe10, 0x14(%rax), %ecx # imm = 0xE10
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
imull $0x3c, 0x18(%rcx), %ecx
subl %ecx, %eax
cvtsi2sd %eax, %xmm0
movq -0x8(%rbp), %rax
addsd 0x20(%rax), %xmm0
movsd %xmm0, 0x20(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x29(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: renameTableFunc
static void renameTableFunc(
  sqlite3_context *context,
  int NotUsed,
  sqlite3_value **argv
){
  unsigned char const *zSql = sqlite3_value_text(argv[0]);
  unsigned char const *zTableName = sqlite3_value_text(argv[1]);

  int token;
  Token tname;
  unsigned char const *zCsr = zSql;
  int len = 0;
  char *zRet;

  sqlite3 *db = sqlite3_context_db_handle(context);

  UNUSED_PARAMETER(NotUsed);

  /* The principle used to locate the table name in the CREATE TABLE 
  ** statement is that the table name is the first non-space token that
  ** is immediately followed by a TK_LP or TK_USING token.
  */
  if( zSql ){
    do {
      if( !*zCsr ){
        /* Ran out of input before finding an opening bracket. Return NULL. */
        return;
      }

      /* Store the token that zCsr points to in tname. */
      tname.z = (char*)zCsr;
      tname.n = len;

      /* Advance zCsr to the next token. Store that token type in 'token',
      ** and its length in 'len' (to be used next iteration of this loop).
      */
      do {
        zCsr += len;
        len = sqlite3GetToken(zCsr, &token);
      } while( token==TK_SPACE );
      assert( len>0 );
    } while( token!=TK_LP && token!=TK_USING );

    zRet = sqlite3MPrintf(db, "%.*s\"%w\"%s", ((u8*)tname.z) - zSql, zSql, 
       zTableName, tname.z+tname.n);
    sqlite3_result_text(context, zRet, -1, SQLITE_DYNAMIC);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x10350
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10350
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x117b0
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x89aad
jmp 0x899fd
movq -0x48(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x89a0b
jmp 0x89aad
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x4c(%rbp), %ecx
movq -0x48(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x49ae0
movl %eax, -0x4c(%rbp)
cmpl $0x95, -0x2c(%rbp)
je 0x89a19
jmp 0x89a45
xorl %eax, %eax
cmpl $0x16, -0x2c(%rbp)
movb %al, -0x61(%rbp)
je 0x89a5a
cmpl $0x79, -0x2c(%rbp)
setne %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x899fd
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq -0x20(%rbp), %rax
subq %rax, %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x40(%rbp), %r9
movl -0x38(%rbp), %eax
addq %rax, %r9
leaq 0x2806a(%rip), %rsi     # 0xb1af3
movb $0x0, %al
callq 0x137f0
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leaq -0x80118(%rip), %rcx    # 0x9990
callq 0x10d80
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3MemMalloc
static void *sqlite3MemMalloc(int nByte){
#ifdef SQLITE_MALLOCSIZE
  void *p = SQLITE_MALLOC( nByte );
  if( p==0 ){
    testcase( sqlite3GlobalConfig.xLog!=0 );
    sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
  }
  return p;
#else
  sqlite3_int64 *p;
  assert( nByte>0 );
  nByte = ROUND8(nByte);
  p = SQLITE_MALLOC( nByte+8 );
  if( p ){
    p[0] = nByte;
    p++;
  }else{
    testcase( sqlite3GlobalConfig.xLog!=0 );
    sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes of memory", nByte);
  }
  return (void *)p;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x7, %eax
andl $-0x8, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x8, %eax
movslq %eax, %rdi
callq 0x8590
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x89e79
movslq -0x4(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x89e8f
movl -0x4(%rbp), %edx
movl $0x7, %edi
leaq 0x27c81(%rip), %rsi     # 0xb1b09
movb $0x0, %al
callq 0xc5f0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3MemFree
static void sqlite3MemFree(void *pPrior){
#ifdef SQLITE_MALLOCSIZE
  SQLITE_FREE(pPrior);
#else
  sqlite3_int64 *p = (sqlite3_int64*)pPrior;
  assert( pPrior!=0 );
  p--;
  SQLITE_FREE(p);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8520
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3MemRealloc
static void *sqlite3MemRealloc(void *pPrior, int nByte){
#ifdef SQLITE_MALLOCSIZE
  void *p = SQLITE_REALLOC(pPrior, nByte);
  if( p==0 ){
    testcase( sqlite3GlobalConfig.xLog!=0 );
    sqlite3_log(SQLITE_NOMEM,
      "failed memory resize %u to %u bytes",
      SQLITE_MALLOCSIZE(pPrior), nByte);
  }
  return p;
#else
  sqlite3_int64 *p = (sqlite3_int64*)pPrior;
  assert( pPrior!=0 && nByte>0 );
  assert( nByte==ROUND8(nByte) ); /* EV: R-46199-30249 */
  p--;
  p = SQLITE_REALLOC(p, nByte+8 );
  if( p ){
    p[0] = nByte;
    p++;
  }else{
    testcase( sqlite3GlobalConfig.xLog!=0 );
    sqlite3_log(SQLITE_NOMEM,
      "failed memory resize %u to %u bytes",
      sqlite3MemSize(pPrior), nByte);
  }
  return (void*)p;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
addl $0x8, %eax
movslq %eax, %rsi
callq 0x8710
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x89f29
movslq -0xc(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x89f4a
movq -0x8(%rbp), %rdi
callq 0x89f60
movl %eax, %edx
movl -0xc(%rbp), %ecx
movl $0x7, %edi
leaq 0x27bec(%rip), %rsi     # 0xb1b2f
movb $0x0, %al
callq 0xc5f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: sqlite3MemSize
static int sqlite3MemSize(void *pPrior){
#ifdef SQLITE_MALLOCSIZE
  return pPrior ? (int)SQLITE_MALLOCSIZE(pPrior) : 0;
#else
  sqlite3_int64 *p;
  if( pPrior==0 ) return 0;
  p = (sqlite3_int64*)pPrior;
  p--;
  return (int)p[0];
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x89f78
movl $0x0, -0x4(%rbp)
jmp 0x89f96
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/sqlite3.c
// Function: pcache1Init
static int pcache1Init(void *NotUsed){
  UNUSED_PARAMETER(NotUsed);
  assert( pcache1.isInit==0 );
  memset(&pcache1, 0, sizeof(pcache1));
  if( sqlite3GlobalConfig.bCoreMutex ){
    pcache1.grp.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_LRU);
    pcache1.mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_STATIC_PMEM);
  }
  pcache1.grp.mxPinned = 10;
  pcache1.isInit = 1;
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x4809d(%rip), %rdi     # 0xd2090
xorl %esi, %esi
movl $0x60, %edx
callq 0x8200
cmpl $0x0, 0x4648e(%rip)     # 0xd0494
je 0x8a020
movl $0x8, %eax
movq %rax, 0x4807c(%rip)     # 0xd2090
movl $0x8, %eax
movq %rax, 0x480b8(%rip)     # 0xd20d8
movl $0xa, 0x48076(%rip)     # 0xd20a0
movl $0x1, 0x48084(%rip)     # 0xd20b8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)