LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_soft_heap_limit64
SQLITE_API sqlite3_int64 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;
  }
  if( mem0.hardLimit>0 && (n>mem0.hardLimit || n==0) ){
    n = mem0.hardLimit;
  }
  mem0.alarmThreshold = n;
  nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
  AtomicStore(&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 %rbx
movq %rdi, %rbx
callq 0x27bed9
movl %eax, %ecx
movq $-0x1, %rax
testl %ecx, %ecx
jne 0x27c2e7
movq 0x24d907(%rip), %rax    # 0x4c9ba8
testq %rbx, %rbx
js 0x27c2e7
movq 0x24d903(%rip), %rcx    # 0x4c9bb0
cmpq %rbx, %rcx
movq %rbx, %rdx
cmovlq %rcx, %rdx
testq %rbx, %rbx
cmoveq %rcx, %rdx
testq %rcx, %rcx
cmovleq %rbx, %rdx
movq %rdx, 0x24d8dc(%rip)    # 0x4c9ba8
testq %rdx, %rdx
setg %cl
cmpq 0x24d81f(%rip), %rdx    # 0x4c9af8
setle %dl
andb %cl, %dl
movzbl %dl, %ecx
movl %ecx, 0x24d8d1(%rip)    # 0x4c9bb8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_hard_heap_limit64
SQLITE_API sqlite3_int64 sqlite3_hard_heap_limit64(sqlite3_int64 n){
  sqlite3_int64 priorLimit;
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return -1;
#endif
  sqlite3_mutex_enter(mem0.mutex);
  priorLimit = mem0.hardLimit;
  if( n>=0 ){
    mem0.hardLimit = n;
    if( n<mem0.alarmThreshold || mem0.alarmThreshold==0 ){
      mem0.alarmThreshold = n;
    }
  }
  sqlite3_mutex_leave(mem0.mutex);
  return priorLimit;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x27bed9
movl %eax, %ecx
movq $-0x1, %rax
testl %ecx, %ecx
je 0x27c315
popq %rbx
retq
movq 0x24d894(%rip), %rax    # 0x4c9bb0
testq %rbx, %rbx
js 0x27c313
movq %rbx, 0x24d888(%rip)    # 0x4c9bb0
movq 0x24d879(%rip), %rcx    # 0x4c9ba8
cmpq %rbx, %rcx
setle %dl
testq %rcx, %rcx
setne %cl
testb %cl, %dl
jne 0x27c313
movq %rbx, 0x24d862(%rip)    # 0x4c9ba8
jmp 0x27c313
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3Malloc
SQLITE_PRIVATE void *sqlite3Malloc(u64 n){
  void *p;
  if( n==0 || n>=0x7fffff00 ){
    /* A memory allocation of a number of bytes which is near the maximum
    ** signed integer value might cause an integer overflow inside of the
    ** xMalloc().  Hence we limit the maximum size to 0x7fffff00, giving
    ** 255 bytes of overhead.  SQLite itself will never use anything near
    ** this amount.  The only way to reach the limit is with sqlite3_malloc() */
    p = 0;
  }else if( sqlite3GlobalConfig.bMemstat ){
    sqlite3_mutex_enter(mem0.mutex);
    mallocWithAlarm((int)n, &p);
    sqlite3_mutex_leave(mem0.mutex);
  }else{
    p = sqlite3GlobalConfig.m.xMalloc((int)n);
  }
  assert( EIGHT_BYTE_ALIGNMENT(p) );  /* IMP: R-11148-40995 */
  return p;
}

// Assembly:
pushq %rbx
leaq -0x7fffff00(%rdi), %rax
cmpq $-0x7ffffeff, %rax      # imm = 0x80000101
jae 0x27c398
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
movq %rdi, %rbx
cmpl $0x0, 0x24a2be(%rip)    # 0x4c6660
je 0x27c3e3
movl %ebx, %edi
callq *0x24a2f4(%rip)         # 0x4c66a0
cmpq %rbx, 0x24d7bd(%rip)    # 0x4c9b70
jge 0x27c3bc
movq %rbx, 0x24d7b4(%rip)    # 0x4c9b70
movq 0x24d7e5(%rip), %rdx    # 0x4c9ba8
testq %rdx, %rdx
jle 0x27c40e
movslq %eax, %rcx
subq %rcx, %rdx
cmpq %rdx, 0x24d723(%rip)    # 0x4c9af8
jge 0x27c3ec
movl $0x0, 0x24d7d7(%rip)    # 0x4c9bb8
jmp 0x27c40e
movl %ebx, %edi
popq %rbx
jmpq *0x24a294(%rip)         # 0x4c6680
movl $0x1, 0x24d7c2(%rip)    # 0x4c9bb8
movq 0x24d7b3(%rip), %rdx    # 0x4c9bb0
testq %rdx, %rdx
je 0x27c40e
subq %rcx, %rdx
cmpq %rdx, 0x24d6ec(%rip)    # 0x4c9af8
jge 0x27c391
movl %eax, %edi
callq *0x24a26a(%rip)         # 0x4c6680
movq %rax, %rbx
testq %rax, %rax
je 0x27c393
movq %rbx, %rdi
callq *0x24a26d(%rip)         # 0x4c6698
cltq
addq 0x24d6c4(%rip), %rax    # 0x4c9af8
movq %rax, 0x24d6bd(%rip)    # 0x4c9af8
cmpq 0x24d706(%rip), %rax    # 0x4c9b48
jle 0x27c44b
movq %rax, 0x24d6fd(%rip)    # 0x4c9b48
movq 0x24d6ee(%rip), %rcx    # 0x4c9b40
leaq 0x1(%rcx), %rax
movq %rax, 0x24d6e3(%rip)    # 0x4c9b40
cmpq 0x24d72c(%rip), %rcx    # 0x4c9b90
jl 0x27c393
movq %rax, 0x24d71f(%rip)    # 0x4c9b90
jmp 0x27c393
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_free
SQLITE_API void sqlite3_free(void *p){
  if( p==0 ) return;  /* IMP: R-49053-54554 */
  assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
  assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
  if( sqlite3GlobalConfig.bMemstat ){
    sqlite3_mutex_enter(mem0.mutex);
    sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, sqlite3MallocSize(p));
    sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1);
    sqlite3GlobalConfig.m.xFree(p);
    sqlite3_mutex_leave(mem0.mutex);
  }else{
    sqlite3GlobalConfig.m.xFree(p);
  }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x27c4c5
movq %rdi, %rbx
cmpl $0x0, 0x24a1c0(%rip)    # 0x4c6660
je 0x27c4bb
movq %rbx, %rdi
callq *0x24a1ed(%rip)         # 0x4c6698
cltq
subq %rax, 0x24d644(%rip)    # 0x4c9af8
decq 0x24d685(%rip)          # 0x4c9b40
movq %rbx, %rdi
popq %rbx
jmpq *0x24a1c3(%rip)         # 0x4c6688
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_realloc
SQLITE_API void *sqlite3_realloc(void *pOld, int n){
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize() ) return 0;
#endif
  if( n<0 ) n = 0;  /* IMP: R-26507-47431 */
  return sqlite3Realloc(pOld, n);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x27bed9
testl %eax, %eax
je 0x27c4e1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %esi, %esi
testl %ebp, %ebp
cmovgl %ebp, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x27c4f3
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3Realloc
SQLITE_PRIVATE void *sqlite3Realloc(void *pOld, u64 nBytes){
  int nOld, nNew, nDiff;
  void *pNew;
  assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) );
  assert( sqlite3MemdebugNoType(pOld, (u8)~MEMTYPE_HEAP) );
  if( pOld==0 ){
    return sqlite3Malloc(nBytes); /* IMP: R-04300-56712 */
  }
  if( nBytes==0 ){
    sqlite3_free(pOld); /* IMP: R-26507-47431 */
    return 0;
  }
  if( nBytes>=0x7fffff00 ){
    /* The 0x7ffff00 limit term is explained in comments on sqlite3Malloc() */
    return 0;
  }
  nOld = sqlite3MallocSize(pOld);
  /* IMPLEMENTATION-OF: R-46199-30249 SQLite guarantees that the second
  ** argument to xRealloc is always a value returned by a prior call to
  ** xRoundup. */
  nNew = sqlite3GlobalConfig.m.xRoundup((int)nBytes);
  if( nOld==nNew ){
    pNew = pOld;
  }else if( sqlite3GlobalConfig.bMemstat ){
    sqlite3_mutex_enter(mem0.mutex);
    sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, (int)nBytes);
    nDiff = nNew - nOld;
    if( nDiff>0 && sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED) >=
          mem0.alarmThreshold-nDiff ){
      sqlite3MallocAlarm(nDiff);
    }
    pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
    if( pNew==0 && mem0.alarmThreshold>0 ){
      sqlite3MallocAlarm((int)nBytes);
      pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
    }
#endif
    if( pNew ){
      nNew = sqlite3MallocSize(pNew);
      sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
    }
    sqlite3_mutex_leave(mem0.mutex);
  }else{
    pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
  }
  assert( EIGHT_BYTE_ALIGNMENT(pNew) ); /* IMP: R-11148-40995 */
  return pNew;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x27c58d
movq %rdi, %rbx
testq %r14, %r14
je 0x27c599
cmpq $0x7ffffeff, %r14       # imm = 0x7FFFFEFF
ja 0x27c5a1
movq %rbx, %rdi
callq *0x24a173(%rip)         # 0x4c6698
movl %eax, %ebp
movl %r14d, %edi
callq *0x24a170(%rip)         # 0x4c66a0
cmpl %eax, %ebp
je 0x27c5a3
cmpl $0x0, 0x24a125(%rip)    # 0x4c6660
je 0x27c5ab
cmpq %r14, 0x24d62c(%rip)    # 0x4c9b70
jge 0x27c54d
movq %r14, 0x24d623(%rip)    # 0x4c9b70
movq %rbx, %rdi
movl %eax, %esi
callq *0x24a138(%rip)         # 0x4c6690
testq %rax, %rax
je 0x27c5a1
movq %rax, %rbx
movq %rax, %rdi
callq *0x24a12f(%rip)         # 0x4c6698
subl %ebp, %eax
cltq
addq 0x24d584(%rip), %rax    # 0x4c9af8
movq %rax, 0x24d57d(%rip)    # 0x4c9af8
cmpq 0x24d5c6(%rip), %rax    # 0x4c9b48
jle 0x27c5a3
movq %rax, 0x24d5bd(%rip)    # 0x4c9b48
jmp 0x27c5a3
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x27c381
movq %rbx, %rdi
callq 0x27c490
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x24a0de(%rip), %rcx    # 0x4c6690
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
popq %r14
popq %rbp
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_str_append
SQLITE_API void sqlite3_str_append(sqlite3_str *p, const char *z, int N){
  assert( z!=0 || N==0 );
  assert( p->zText!=0 || p->nChar==0 || p->accError );
  assert( N>=0 );
  assert( p->accError==0 || p->nAlloc==0 || p->mxAlloc==0 );
  if( p->nChar+N >= p->nAlloc ){
    enlargeAndAppend(p,z,N);
  }else if( N ){
    assert( p->zText );
    p->nChar += N;
    memcpy(&p->zText[p->nChar-N], z, N);
  }
}

// Assembly:
movl 0x18(%rdi), %eax
leal (%rax,%rdx), %ecx
cmpl 0x10(%rdi), %ecx
jae 0x27e098
testl %edx, %edx
je 0x27e09d
movl %ecx, 0x18(%rdi)
addq 0x8(%rdi), %rax
movslq %edx, %rdx
movq %rax, %rdi
jmp 0x17660
jmp 0x27e2ca
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: printfTempBuf
static char *printfTempBuf(sqlite3_str *pAccum, sqlite3_int64 n){
  char *z;
  if( pAccum->accError ) return 0;
  if( n>pAccum->nAlloc && n>pAccum->mxAlloc ){
    setStrAccumError(pAccum, SQLITE_TOOBIG);
    return 0;
  }
  z = sqlite3DbMallocRaw(pAccum->db, n);
  if( z==0 ){
    setStrAccumError(pAccum, SQLITE_NOMEM);
  }
  return z;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, 0x1c(%rdi)
je 0x27e0b6
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %rbx
movl 0x10(%rdi), %eax
cmpq %rsi, %rax
jge 0x27e0d8
movl 0x14(%rbx), %eax
cmpq %rsi, %rax
jge 0x27e0d8
movq %rbx, %rdi
movl $0x12, %esi
callq 0x28c483
jmp 0x27e0a8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x27e0e7
callq 0x28c518
jmp 0x27e0ef
movq %rsi, %rdi
callq 0x27c381
movq %rax, %r14
testq %rax, %rax
jne 0x27e0ab
movb $0x7, 0x1c(%rbx)
cmpl $0x0, 0x14(%rbx)
je 0x27e0ab
movq %rbx, %rdi
callq 0x27e394
jmp 0x27e0ab
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3StrAccumEnlarge
static int sqlite3StrAccumEnlarge(StrAccum *p, int N){
  char *zNew;
  assert( p->nChar+(i64)N >= p->nAlloc ); /* Only called if really needed */
  if( p->accError ){
    testcase(p->accError==SQLITE_TOOBIG);
    testcase(p->accError==SQLITE_NOMEM);
    return 0;
  }
  if( p->mxAlloc==0 ){
    setStrAccumError(p, SQLITE_TOOBIG);
    return p->nAlloc - p->nChar - 1;
  }else{
    char *zOld = isMalloced(p) ? p->zText : 0;
    i64 szNew = p->nChar;
    szNew += N + 1;
    if( szNew+p->nChar<=p->mxAlloc ){
      /* Force exponential buffer size growth as long as it does not overflow,
      ** to avoid having to call this routine too often */
      szNew += p->nChar;
    }
    if( szNew > p->mxAlloc ){
      sqlite3_str_reset(p);
      setStrAccumError(p, SQLITE_TOOBIG);
      return 0;
    }else{
      p->nAlloc = (int)szNew;
    }
    if( p->db ){
      zNew = sqlite3DbRealloc(p->db, zOld, p->nAlloc);
    }else{
      zNew = sqlite3Realloc(zOld, p->nAlloc);
    }
    if( zNew ){
      assert( p->zText!=0 || p->nChar==0 );
      if( !isMalloced(p) && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar);
      p->zText = zNew;
      p->nAlloc = sqlite3DbMallocSize(p->db, zNew);
      p->printfFlags |= SQLITE_PRINTF_MALLOCED;
    }else{
      sqlite3_str_reset(p);
      setStrAccumError(p, SQLITE_NOMEM);
      return 0;
    }
  }
  return N;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
xorl %r14d, %r14d
cmpb $0x0, 0x1c(%rdi)
je 0x27e1a5
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %rbx
movl 0x14(%rdi), %eax
testq %rax, %rax
je 0x27e1bc
movl %esi, %ebp
testb $0x4, 0x1d(%rbx)
jne 0x27e1d6
xorl %esi, %esi
jmp 0x27e1da
movq %rbx, %rdi
movl $0x12, %esi
callq 0x28c483
movl 0x18(%rbx), %r14d
notl %r14d
addl 0x10(%rbx), %r14d
jmp 0x27e19d
movq 0x8(%rbx), %rsi
movl 0x18(%rbx), %edx
movslq %ebp, %rdi
leaq (%rdi,%rdx), %rcx
incq %rcx
addq %rdx, %rdi
addq %rdi, %rdx
incq %rdx
cmpq %rax, %rdx
cmovleq %rdx, %rcx
cmpq %rax, %rcx
jle 0x27e216
movq %rbx, %rdi
callq 0x27e394
movq %rbx, %rdi
movl $0x12, %esi
callq 0x28c483
xorl %r14d, %r14d
jmp 0x27e19d
movl %ecx, 0x10(%rbx)
movq (%rbx), %rdi
movl %ecx, %edx
testq %rdi, %rdi
je 0x27e22a
callq 0x28c4c8
jmp 0x27e235
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x27c4f3
movq %rax, %r14
testq %rax, %rax
je 0x27e29b
testb $0x4, 0x1d(%rbx)
jne 0x27e257
movl 0x18(%rbx), %edx
testq %rdx, %rdx
je 0x27e257
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x17660
movq %r14, 0x8(%rbx)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x27e283
cmpq %r14, 0x1c0(%rcx)
jbe 0x27e283
movl $0x80, %eax
cmpq %r14, 0x1b0(%rcx)
jbe 0x27e28c
cmpq %r14, 0x1b8(%rcx)
jbe 0x27e2c1
movq %r14, %rdi
callq *0x24840c(%rip)         # 0x4c6698
movl %eax, 0x10(%rbx)
orb $0x4, 0x1d(%rbx)
movl %ebp, %r14d
jmp 0x27e19d
movq %rbx, %rdi
callq 0x27e394
movb $0x7, 0x1c(%rbx)
xorl %r14d, %r14d
cmpl $0x0, 0x14(%rbx)
je 0x27e19d
movq %rbx, %rdi
callq 0x27e394
jmp 0x27e19d
movzwl 0x176(%rcx), %eax
jmp 0x27e28c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: enlargeAndAppend
static void SQLITE_NOINLINE enlargeAndAppend(StrAccum *p, const char *z, int N){
  N = sqlite3StrAccumEnlarge(p, N);
  if( N>0 ){
    memcpy(&p->zText[p->nChar], z, N);
    p->nChar += N;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %esi
callq 0x27e190
testl %eax, %eax
jle 0x27e2f5
movl %eax, %ebp
movl 0x18(%rbx), %edi
addq 0x8(%rbx), %rdi
movl %eax, %edx
movq %r14, %rsi
callq 0x17660
addl %ebp, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_str_finish
SQLITE_API char *sqlite3_str_finish(sqlite3_str *p){
  char *z;
  if( p!=0 && p!=&sqlite3OomStr ){
    z = sqlite3StrAccumFinish(p);
    sqlite3_free(p);
  }else{
    z = 0;
  }
  return z;
}

// Assembly:
testq %rdi, %rdi
sete %al
leaq 0x2484f9(%rip), %rcx    # 0x4c6800
cmpq %rcx, %rdi
sete %cl
orb %al, %cl
jne 0x27e333
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x27e336
movq %rax, %r14
movq %rbx, %rdi
callq 0x27c490
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3StrAccumFinish
SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum *p){
  if( p->zText ){
    p->zText[p->nChar] = 0;
    if( p->mxAlloc>0 && !isMalloced(p) ){
      return strAccumFinishRealloc(p);
    }
  }
  return p->zText;
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x27e356
movl 0x18(%rdi), %ecx
movb $0x0, (%rax,%rcx)
cmpl $0x0, 0x14(%rdi)
je 0x27e356
testb $0x4, 0x1d(%rdi)
je 0x28c67c
movq 0x8(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_str_reset
SQLITE_API void sqlite3_str_reset(StrAccum *p){
  if( isMalloced(p) ){
    sqlite3DbFree(p->db, p->zText);
    p->printfFlags &= ~SQLITE_PRINTF_MALLOCED;
  }
  p->nAlloc = 0;
  p->nChar = 0;
  p->zText = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testb $0x4, 0x1d(%rdi)
je 0x27e3b3
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x27e3af
movq (%rbx), %rdi
callq 0x28c3e7
andb $-0x5, 0x1d(%rbx)
xorl %eax, %eax
movl %eax, 0x10(%rbx)
movl %eax, 0x18(%rbx)
movq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_str_new
SQLITE_API sqlite3_str *sqlite3_str_new(sqlite3 *db){
  sqlite3_str *p = sqlite3_malloc64(sizeof(*p));
  if( p ){
    sqlite3StrAccumInit(p, 0, 0, 0,
            db ? db->aLimit[SQLITE_LIMIT_LENGTH] : SQLITE_MAX_LENGTH);
  }else{
    p = &sqlite3OomStr;
  }
  return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x27bed9
testl %eax, %eax
je 0x27e3d6
xorl %eax, %eax
jmp 0x27e3e0
movl $0x20, %edi
callq 0x27c381
testq %rax, %rax
je 0x27e3ef
testq %rbx, %rbx
je 0x27e3f8
movl 0x7c(%rbx), %ecx
jmp 0x27e3fd
leaq 0x24840a(%rip), %rax    # 0x4c6800
jmp 0x27e414
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
xorl %edx, %edx
movl %edx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl %ecx, 0x14(%rax)
movl %edx, 0x18(%rax)
movw $0x0, 0x1c(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_vmprintf
SQLITE_API char *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);
  sqlite3_str_vappendf(&acc, zFormat, ap);
  z = sqlite3StrAccumFinish(&acc);
  return z;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x27bed9
testl %eax, %eax
je 0x27e432
xorl %eax, %eax
jmp 0x27e478
leaq 0x20(%rsp), %rax
movq %rsp, %r15
movq %rax, 0x8(%r15)
movq $0x0, (%r15)
movabsq $0x3b9aca0000000046, %rax # imm = 0x3B9ACA0000000046
movq %rax, 0x10(%r15)
movl $0x0, 0x18(%r15)
movw $0x0, 0x1c(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x27c5ec
movq %r15, %rdi
callq 0x27e336
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_vsnprintf
SQLITE_API char *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);
  sqlite3_str_vappendf(&acc, zFormat, ap);
  zBuf[acc.nChar] = 0;
  return zBuf;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testl %edi, %edi
jle 0x27e565
leaq 0x8(%rsp), %r14
movq %rbx, 0x8(%r14)
xorl %eax, %eax
movq %rax, (%r14)
movl %edi, 0x10(%r14)
movq %rax, 0x14(%r14)
movw $0x0, 0x1c(%r14)
movq %r14, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x27c5ec
movl 0x18(%r14), %eax
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_stricmp
SQLITE_API int sqlite3_stricmp(const char *zLeft, const char *zRight){
  if( zLeft==0 ){
    return zRight ? -1 : 0;
  }else if( zRight==0 ){
    return 1;
  }
  return sqlite3StrICmp(zLeft, zRight);
}

// Assembly:
testq %rdi, %rdi
je 0x27e940
testq %rsi, %rsi
je 0x27e948
xorl %ecx, %ecx
leaq 0x15c148(%rip), %rdx    # 0x3daa60
movzbl (%rdi,%rcx), %eax
movzbl (%rsi,%rcx), %r8d
cmpb %r8b, %al
jne 0x27e92d
testq %rax, %rax
jne 0x27e93b
jmp 0x27e94e
movzbl (%rax,%rdx), %eax
movzbl (%r8,%rdx), %r8d
subl %r8d, %eax
jne 0x27e947
incq %rcx
jmp 0x27e918
xorl %eax, %eax
negq %rsi
sbbl %eax, %eax
retq
movl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_strnicmp
SQLITE_API int sqlite3_strnicmp(const char *zLeft, const char *zRight, int N){
  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( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
  return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];
}

// Assembly:
testq %rdi, %rdi
je 0x27e99c
testq %rsi, %rsi
je 0x27e9a4
testl %edx, %edx
jle 0x27e9bd
movl %edx, %eax
leaq (%rdi,%rax), %rcx
addq %rsi, %rax
leaq 0x15c0f1(%rip), %r8     # 0x3daa60
movzbl (%rdi), %r9d
testq %r9, %r9
je 0x27e9aa
movb (%r9,%r8), %r9b
movzbl (%rsi), %r10d
cmpb (%r10,%r8), %r9b
jne 0x27e9aa
decl %edx
incq %rdi
incq %rsi
leal 0x1(%rdx), %r9d
cmpl $0x1, %r9d
jg 0x27e96f
xorl %edx, %edx
jmp 0x27e9b0
xorl %eax, %eax
negq %rsi
sbbl %eax, %eax
retq
movl $0x1, %eax
retq
movq %rdi, %rcx
movq %rsi, %rax
testl %edx, %edx
setle %dl
movq %rcx, %rdi
movq %rax, %rsi
jmp 0x27e9bf
movb $0x1, %dl
xorl %eax, %eax
testb %dl, %dl
je 0x27e9c6
retq
movzbl (%rdi), %eax
leaq 0x15c090(%rip), %rcx    # 0x3daa60
movzbl (%rax,%rcx), %eax
movzbl (%rsi), %edx
movzbl (%rdx,%rcx), %ecx
subl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: unixDelete
static int unixDelete(
  sqlite3_vfs *NotUsed,     /* VFS containing this as the xDelete method */
  const char *zPath,        /* Name of file to be deleted */
  int dirSync               /* If true, fsync() directory after deleting file */
){
  int rc = SQLITE_OK;
  UNUSED_PARAMETER(NotUsed);
  SimulateIOError(return SQLITE_IOERR_DELETE);
  if( osUnlink(zPath)==(-1) ){
    if( errno==ENOENT
#if OS_VXWORKS
        || osAccess(zPath,0)!=0
#endif
    ){
      rc = SQLITE_IOERR_DELETE_NOENT;
    }else{
      rc = unixLogError(SQLITE_IOERR_DELETE, "unlink", zPath);
    }
    return rc;
  }
#ifndef SQLITE_DISABLE_DIRSYNC
  if( (dirSync & 1)!=0 ){
    int fd;
    rc = osOpenDirectory(zPath, &fd);
    if( rc==SQLITE_OK ){
      if( full_fsync(fd,0,0) ){
        rc = unixLogError(SQLITE_IOERR_DIR_FSYNC, "fsync", zPath);
      }
      robust_close(0, fd, __LINE__);
    }else{
      assert( rc==SQLITE_CANTOPEN );
      rc = SQLITE_OK;
    }
  }
#endif
  return rc;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rsi, %rdi
callq *0x2479c6(%rip)         # 0x4c6c58
cmpl $-0x1, %eax
je 0x27f2e4
xorl %ebx, %ebx
testb $0x1, %bpl
je 0x27f336
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq *0x2479bf(%rip)         # 0x4c6c70
xorl %ebx, %ebx
testl %eax, %eax
jne 0x27f336
movl 0xc(%rsp), %edi
callq 0x176c0
testl %eax, %eax
je 0x27f30e
leaq 0x160072(%rip), %rsi    # 0x3df33d
movl $0x50a, %ebx            # imm = 0x50A
movl $0x50a, %edi            # imm = 0x50A
movq %r14, %rdx
movl $0x9b7c, %ecx           # imm = 0x9B7C
callq 0x28de48
jmp 0x27f310
callq 0x17060
movl $0x170a, %ebx           # imm = 0x170A
cmpl $0x2, (%rax)
je 0x27f336
leaq 0x15ff7e(%rip), %rsi    # 0x3df278
movl $0xa0a, %ebx            # imm = 0xA0A
movl $0xa0a, %edi            # imm = 0xA0A
movq %r14, %rdx
movl $0x9b72, %ecx           # imm = 0x9B72
jmp 0x27f331
xorl %ebx, %ebx
movl 0xc(%rsp), %edi
callq *0x2477d6(%rip)         # 0x4c6af0
testl %eax, %eax
je 0x27f336
leaq 0x152cdf(%rip), %rsi    # 0x3d2004
movl $0x100a, %edi           # imm = 0x100A
xorl %edx, %edx
movl $0x9b7e, %ecx           # imm = 0x9B7E
callq 0x28de48
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: unixAccess
static int unixAccess(
  sqlite3_vfs *NotUsed,   /* The VFS containing this xAccess method */
  const char *zPath,      /* Path of the file to examine */
  int flags,              /* What do we want to learn about the zPath file? */
  int *pResOut            /* Write result boolean here */
){
  UNUSED_PARAMETER(NotUsed);
  SimulateIOError( return SQLITE_IOERR_ACCESS; );
  assert( pResOut!=0 );

  /* The spec says there are three possible values for flags.  But only
  ** two of them are actually used */
  assert( flags==SQLITE_ACCESS_EXISTS || flags==SQLITE_ACCESS_READWRITE );

  if( flags==SQLITE_ACCESS_EXISTS ){
    struct stat buf;
    *pResOut = 0==osStat(zPath, &buf) &&
                (!S_ISREG(buf.st_mode) || buf.st_size>0);
  }else{
    *pResOut = osAccess(zPath, W_OK|R_OK)==0;
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
movq %rcx, %rbx
movq %rsi, %rdi
testl %edx, %edx
je 0x27f367
movl $0x6, %esi
callq *0x2477aa(%rip)         # 0x4c6b08
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
jmp 0x27f395
movq %rsp, %rsi
callq *0x2477c8(%rip)         # 0x4c6b38
xorl %ecx, %ecx
testl %eax, %eax
jne 0x27f395
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
setne %al
cmpq $0x0, 0x30(%rsp)
setg %cl
orb %al, %cl
movzbl %cl, %ecx
movl %ecx, (%rbx)
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: unixRandomness
static int unixRandomness(sqlite3_vfs *NotUsed, int nBuf, char *zBuf){
  UNUSED_PARAMETER(NotUsed);
  assert((size_t)nBuf>=(sizeof(time_t)+sizeof(int)));

  /* We have to initialize zBuf to prevent valgrind from reporting
  ** errors.  The reports issued by valgrind are incorrect - we would
  ** prefer that the randomness be increased by making use of the
  ** uninitialized space in zBuf - but valgrind errors tend to worry
  ** some users.  Rather than argue, it seems easier just to initialize
  ** the whole array and silence valgrind, even if that means less randomness
  ** in the random seed.
  **
  ** When testing, initializing zBuf[] to zero is all we do.  That means
  ** that we always use the same random number sequence.  This makes the
  ** tests repeatable.
  */
  memset(zBuf, 0, nBuf);
  randomnessPid = osGetpid(0);
#if !defined(SQLITE_TEST) && !defined(SQLITE_OMIT_RANDOMNESS)
  {
    int fd, got;
    fd = robust_open("/dev/urandom", O_RDONLY, 0);
    if( fd<0 ){
      time_t t;
      time(&t);
      memcpy(zBuf, &t, sizeof(t));
      memcpy(&zBuf[sizeof(t)], &randomnessPid, sizeof(randomnessPid));
      assert( sizeof(t)+sizeof(randomnessPid)<=(size_t)nBuf );
      nBuf = sizeof(t) + sizeof(randomnessPid);
    }else{
      do{ got = osRead(fd, zBuf, nBuf); }while( got<0 && errno==EINTR );
      robust_close(0, fd, __LINE__);
    }
  }
#endif
  return nBuf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movslq %esi, %r15
movq %rdx, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x173a0
callq 0x17af0
movl %eax, 0x24a5a5(%rip)    # 0x4c9da8
leaq 0x15fb80(%rip), %rdi    # 0x3df38a
xorl %esi, %esi
xorl %edx, %edx
callq 0x28dd65
testl %eax, %eax
js 0x27f85b
movl %eax, %ebp
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq *0x247371(%rip)         # 0x4c6b98
testl %eax, %eax
jns 0x27f835
callq 0x17060
cmpl $0x4, (%rax)
je 0x27f819
movl %ebp, %edi
callq *0x2472b3(%rip)         # 0x4c6af0
testl %eax, %eax
je 0x27f87b
leaq 0x1527bc(%rip), %rsi    # 0x3d2004
movl $0x100a, %edi           # imm = 0x100A
xorl %edx, %edx
movl $0x9c84, %ecx           # imm = 0x9C84
callq 0x28de48
jmp 0x27f87b
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x17740
movq (%rbx), %rax
movq %rax, (%r14)
movl 0x24a536(%rip), %eax    # 0x4c9da8
movl %eax, 0x8(%r14)
movl $0xc, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: unixCurrentTimeInt64
static int unixCurrentTimeInt64(sqlite3_vfs *NotUsed, sqlite3_int64 *piNow){
  static const sqlite3_int64 unixEpoch = 24405875*(sqlite3_int64)8640000;
  int rc = SQLITE_OK;
#if defined(NO_GETTOD)
  time_t t;
  time(&t);
  *piNow = ((sqlite3_int64)t)*1000 + unixEpoch;
#elif OS_VXWORKS
  struct timespec sNow;
  clock_gettime(CLOCK_REALTIME, &sNow);
  *piNow = unixEpoch + 1000*(sqlite3_int64)sNow.tv_sec + sNow.tv_nsec/1000000;
#else
  struct timeval sNow;
  (void)gettimeofday(&sNow, 0);  /* Cannot fail given valid arguments */
  *piNow = unixEpoch + 1000*(sqlite3_int64)sNow.tv_sec + sNow.tv_usec/1000;
#endif

#ifdef SQLITE_TEST
  if( sqlite3_current_time ){
    *piNow = 1000*(sqlite3_int64)sqlite3_current_time + unixEpoch;
  }
#endif
  UNUSED_PARAMETER(NotUsed);
  return rc;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x17c90
movabsq $0x20c49ba5e353f7cf, %rax # imm = 0x20C49BA5E353F7CF
imulq 0x8(%r14)
imulq $0x3e8, (%r14), %rax    # imm = 0x3E8
movq %rdx, %rcx
shrq $0x3f, %rcx
sarq $0x7, %rdx
addq %rcx, %rdx
addq %rax, %rdx
movabsq $0xbfc83e532200, %rax   # imm = 0xBFC83E532200
addq %rdx, %rax
movq %rax, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ErrorWithMsg
SQLITE_PRIVATE void sqlite3ErrorWithMsg(sqlite3 *db, int err_code, const char *zFormat, ...){
  assert( db!=0 );
  db->errCode = err_code;
  sqlite3SystemError(db, err_code);
  if( zFormat==0 ){
    sqlite3Error(db, err_code);
  }else if( db->pErr || (db->pErr = sqlite3ValueNew(db))!=0 ){
    char *z;
    va_list ap;
    va_start(ap, zFormat);
    z = sqlite3VMPrintf(db, zFormat, ap);
    va_end(ap);
    sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x27fc74
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movl %esi, 0x50(%rdi)
cmpl $0xc0a, %esi            # imm = 0xC0A
sete %al
movl %esi, %ecx
andl $0xfb, %ecx
cmpl $0xa, %ecx
setne %cl
orb %al, %cl
jne 0x27fcae
movq (%rbx), %rdi
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x27fca9
xorl %esi, %esi
xorl %edx, %edx
callq *%rax
jmp 0x27fcab
xorl %eax, %eax
movl %eax, 0x58(%rbx)
testq %r14, %r14
je 0x27fd3f
cmpq $0x0, 0x160(%rbx)
jne 0x27fce8
movl $0x38, %esi
movq %rbx, %rdi
callq 0x283569
testq %rax, %rax
je 0x27fd65
movw $0x1, 0x8(%rax)
movq %rbx, 0x28(%rax)
movq %rax, 0x160(%rbx)
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28e62e
movq 0x160(%rbx), %rdi
testq %rdi, %rdi
je 0x27fd6c
leaq 0x2790(%rip), %r8       # 0x2824bb
movq %rax, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
callq 0x281f27
jmp 0x27fd6c
movl %ebp, 0x50(%rbx)
testl %ebp, %ebp
jne 0x27fd50
cmpq $0x0, 0x160(%rbx)
je 0x27fd6c
movq %rbx, %rdi
movl %ebp, %esi
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x28e696
movq %rax, 0x160(%rbx)
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: findBtree
static Btree *findBtree(sqlite3 *pErrorDb, sqlite3 *pDb, const char *zDb){
  int i = sqlite3FindDbName(pDb, zDb);

  if( i==1 ){
    Parse sParse;
    int rc = 0;
    memset(&sParse, 0, sizeof(sParse));
    sParse.db = pDb;
    if( sqlite3OpenTempDatabase(&sParse) ){
      sqlite3ErrorWithMsg(pErrorDb, sParse.rc, "%s", sParse.zErrMsg);
      rc = SQLITE_ERROR;
    }
    sqlite3DbFree(pErrorDb, sParse.zErrMsg);
    sqlite3ParserReset(&sParse);
    if( rc ){
      return 0;
    }
  }

  if( i<0 ){
    sqlite3ErrorWithMsg(pErrorDb, SQLITE_ERROR, "unknown database %s", zDb);
    return 0;
  }

  return pDb->aDb[i].pBt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x289cd9
movl %eax, %ebp
cmpl $0x1, %eax
jne 0x27fe1e
leaq 0x8(%rsp), %r12
movl $0x1a8, %edx            # imm = 0x1A8
movq %r12, %rdi
xorl %esi, %esi
callq 0x173a0
movq %r15, (%r12)
movq %r12, %rdi
callq 0x28e6f9
testl %eax, %eax
je 0x27fe02
movl 0x20(%rsp), %esi
movq 0x10(%rsp), %r14
leaq 0x1523fb(%rip), %rdx    # 0x3d21d1
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x27fc17
testq %r14, %r14
je 0x27fdf3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28c3e7
leaq 0x8(%rsp), %rdi
callq 0x285775
xorl %r15d, %r15d
jmp 0x27fe4f
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x27fe14
movq %rbx, %rdi
callq 0x28c3e7
leaq 0x8(%rsp), %rdi
callq 0x285775
testl %ebp, %ebp
js 0x27fe33
movq 0x20(%r15), %rax
movl %ebp, %ecx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %r15
jmp 0x27fe4f
leaq 0x15f55d(%rip), %rdx    # 0x3df397
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rcx
xorl %eax, %eax
callq 0x27fc17
movq %r15, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ResetAllSchemasOfConnection
SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3 *db){
  int i;
  sqlite3BtreeEnterAll(db);
  for(i=0; i<db->nDb; i++){
    Db *pDb = &db->aDb[i];
    if( pDb->pSchema ){
      if( db->nSchemaLock==0 ){
        sqlite3SchemaClear(pDb->pSchema);
      }else{
        DbSetProperty(db, i, DB_ResetWanted);
      }
    }
  }
  db->mDbFlags &= ~(DBFLAG_SchemaChange|DBFLAG_SchemaKnownOk);
  sqlite3VtabUnlockList(db);
  sqlite3BtreeLeaveAll(db);
  if( db->nSchemaLock==0 ){
    sqlite3CollapseDatabaseArray(db);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x28(%rdi), %rax
testq %rax, %rax
jle 0x280d48
movq 0x20(%rbx), %rcx
shlq $0x5, %rax
xorl %edx, %edx
movq 0x8(%rcx,%rdx), %rsi
testq %rsi, %rsi
je 0x280d3f
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
movq %rdi, 0x8(%rsi)
addq $0x20, %rdx
cmpq %rdx, %rax
jne 0x280d2a
cmpl $0x0, 0x28(%rbx)
jle 0x280d85
movl $0x18, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x280d75
cmpl $0x0, 0x48(%rbx)
je 0x280d70
orb $0x8, 0x72(%rdi)
jmp 0x280d75
callq 0x2a6f82
incq %r15
movslq 0x28(%rbx), %rax
addq $0x20, %r14
cmpq %rax, %r15
jl 0x280d57
andb $-0x12, 0x2c(%rbx)
movq %rbx, %rdi
callq 0x2af7a6
cmpl $0x0, 0x48(%rbx)
je 0x280d9d
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2b2ce2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/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( (pPg->flags & PGHDR_WRITEABLE)!=0 && pPager->dbSize>=pPg->pgno ){
    if( pPager->nSavepoint ) return subjournalPageIfRequired(pPg);
    return SQLITE_OK;
  }else if( pPager->errCode ){
    return pPager->errCode;
  }else if( pPager->sectorSize > (u32)pPager->pageSize ){
    assert( pPager->tempFile==0 );
    return pagerWriteLargeSector(pPg);
  }else{
    return pager_write(pPg);
  }
}

// Assembly:
movq 0x28(%rdi), %rcx
testb $0x4, 0x34(%rdi)
je 0x280e4c
movl 0x1c(%rcx), %eax
cmpl 0x30(%rdi), %eax
jae 0x280e6b
movl 0x2c(%rcx), %eax
testl %eax, %eax
je 0x280e54
retq
movl 0xb8(%rcx), %eax
cmpl 0xbc(%rcx), %eax
ja 0x297184
jmp 0x297311
cmpl $0x0, 0x80(%rcx)
jne 0x28f9fe
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3PagerSync
SQLITE_PRIVATE int sqlite3PagerSync(Pager *pPager, const char *zSuper){
  int rc = SQLITE_OK;
  void *pArg = (void*)zSuper;
  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 %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x281072
movq %rsi, %rdx
movl $0x15, %esi
callq *0x50(%rax)
jmp 0x281077
movl $0xc, %eax
xorl %ecx, %ecx
cmpl $0xc, %eax
cmovel %ecx, %eax
testl %eax, %eax
jne 0x28108b
cmpb $0x0, 0xb(%rbx)
je 0x28108d
xorl %eax, %eax
popq %rbx
retq
movzbl 0xe(%rbx), %esi
movl $0x0, %eax
testl %esi, %esi
je 0x28108b
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
popq %rbx
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/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 ){
      btreeSetNPage(pBt, pPage1);
      releasePageOne(pPage1);
    }
    assert( countValidCursors(pBt, 1)==0 );
    pBt->inTransaction = TRANS_READ;
    btreeClearHasContent(pBt);
  }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq (%rdi), %rax
movq %rax, 0x8(%r14)
testl %esi, %esi
jne 0x2814be
movq 0x10(%r14), %rdi
xorl %r15d, %r15d
movl $0x0, %esi
testq %rdi, %rdi
je 0x2814b8
xorl %esi, %esi
xorl %edx, %edx
callq 0x297c7e
movl %eax, %esi
testl %esi, %esi
cmovnel %r15d, %ebp
testl %esi, %esi
je 0x2814cc
movq %rbx, %rdi
movl %ebp, %edx
callq 0x29979b
cmpb $0x2, 0x10(%rbx)
jne 0x281526
movq (%r14), %rdi
callq 0x293290
movq %rsp, %rdx
movq %r14, %rdi
movl $0x1, %esi
xorl %ecx, %ecx
callq 0x296bb1
testl %eax, %eax
jne 0x281510
movq (%rsp), %rdi
movq 0x50(%rdi), %rax
movl 0x1c(%rax), %eax
bswapl %eax
testl %eax, %eax
jne 0x281507
movq (%r14), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x40(%r14)
callq 0x296c8e
movb $0x1, 0x24(%r14)
movq 0x60(%r14), %rdi
callq 0x294293
movq $0x0, 0x60(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2977d4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: invokeProfileCallback
static SQLITE_NOINLINE void invokeProfileCallback(sqlite3 *db, Vdbe *p){
  sqlite3_int64 iNow;
  sqlite3_int64 iElapse;
  assert( p->startTime>0 );
  assert( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0 );
  assert( db->init.busy==0 );
  assert( p->zSql!=0 );
  sqlite3OsCurrentTimeInt64(db->pVfs, &iNow);
  iElapse = (iNow - p->startTime)*1000000;
#ifndef SQLITE_OMIT_DEPRECATED
  if( db->xProfile ){
    db->xProfile(db->pProfileArg, p->zSql, iElapse);
  }
#endif
  if( db->mTrace & SQLITE_TRACE_PROFILE ){
    db->trace.xV2(SQLITE_TRACE_PROFILE, db->pTraceArg, p, (void*)&iElapse);
  }
  p->startTime = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x299a74
movq (%r15), %rax
subq 0xb8(%rbx), %rax
imulq $0xf4240, %rax, %rdx    # imm = 0xF4240
movq %rdx, (%rsp)
movq 0xf0(%r14), %rax
testq %rax, %rax
je 0x2818e1
movq 0xf8(%r14), %rdi
movq 0xf0(%rbx), %rsi
callq *%rax
testb $0x2, 0x68(%r14)
je 0x281901
movq 0xe8(%r14), %rsi
movq %rsp, %rcx
movl $0x2, %edi
movq %rbx, %rdx
callq *0xe0(%r14)
movq $0x0, 0xb8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_reset
SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt){
  int rc;
  if( pStmt==0 ){
    rc = SQLITE_OK;
  }else{
    Vdbe *v = (Vdbe*)pStmt;
    sqlite3 *db = v->db;
    sqlite3_mutex_enter(db->mutex);
    checkProfileCallback(db, v);
    rc = sqlite3VdbeReset(v);
    sqlite3VdbeRewind(v);
    assert( (rc & (db->errMask))==rc );
    rc = sqlite3ApiExit(db, rc);
    sqlite3_mutex_leave(db->mutex);
  }
  return rc;
}

// Assembly:
testq %rdi, %rdi
je 0x2819ba
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rbx
cmpq $0x0, 0xb8(%rdi)
jle 0x28196e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x281891
movq %r14, %rdi
callq 0x2819d2
movl $0x2df20da3, 0x24(%r14) # imm = 0x2DF20DA3
movl $0x0, 0x38(%r14)
movw $0xff02, 0xc2(%r14)     # imm = 0xFF02
xorl %ecx, %ecx
movq %rcx, 0x3c(%r14)
movabsq $-0xffffffff, %rdx      # imm = 0xFFFFFFFF00000001
movq %rdx, 0x30(%r14)
movq %rcx, 0x50(%r14)
cmpl $0xc0a, %eax            # imm = 0xC0A
je 0x2819bd
cmpb $0x0, 0x61(%rbx)
jne 0x2819bd
andl 0x54(%rbx), %eax
jmp 0x2819ca
xorl %eax, %eax
retq
movq %rbx, %rdi
callq 0x299b1a
movl $0x7, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_clear_bindings
SQLITE_API int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
  int i;
  int rc = SQLITE_OK;
  Vdbe *p = (Vdbe*)pStmt;
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
#endif
  sqlite3_mutex_enter(mutex);
  for(i=0; i<p->nVar; i++){
    sqlite3VdbeMemRelease(&p->aVar[i]);
    p->aVar[i].flags = MEM_Null;
  }
  assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 );
  if( p->expmask ){
    p->expired = 1;
  }
  sqlite3_mutex_leave(mutex);
  return rc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpw $0x0, 0x20(%rdi)
jle 0x281aef
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x80(%rbx), %rdi
testb $0x24, 0x9(%rdi,%r14)
jne 0x281ac7
cmpl $0x0, 0x20(%rdi,%r14)
je 0x281acf
addq %r14, %rdi
callq 0x29b45b
movq 0x80(%rbx), %rax
movw $0x1, 0x8(%rax,%r14)
incq %r15
movswq 0x20(%rbx), %rax
addq $0x38, %r14
cmpq %rax, %r15
jl 0x281ab0
cmpl $0x0, 0x114(%rbx)
je 0x281b0b
movzwl 0xc6(%rbx), %eax
andl $-0x4, %eax
incl %eax
movw %ax, 0xc6(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_value_blob
SQLITE_API const void *sqlite3_value_blob(sqlite3_value *pVal){
  Mem *p = (Mem*)pVal;
  if( p->flags & (MEM_Blob|MEM_Str) ){
    if( ExpandBlob(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 %rbx
movq %rdi, %rbx
movzwl 0x8(%rdi), %eax
testb $0x12, %al
je 0x281b41
btl $0xe, %eax
jae 0x281b31
movq %rbx, %rdi
callq 0x281b53
testl %eax, %eax
jne 0x281b4f
orb $0x10, 0x8(%rbx)
cmpl $0x0, 0xc(%rbx)
je 0x281b4f
movq 0x10(%rbx), %rax
jmp 0x281b51
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x281c96
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeMemExpandBlob
SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){
  int nByte;
  assert( pMem->flags & MEM_Zero );
  assert( (pMem->flags&MEM_Blob)!=0 || MemNullNochng(pMem) );
  testcase( sqlite3_value_nochange(pMem) );
  assert( !sqlite3VdbeMemIsRowSet(pMem) );
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );

  /* Set nByte to the number of bytes required to store the expanded blob. */
  nByte = pMem->n + pMem->u.nZero;
  if( nByte<=0 ){
    if( (pMem->flags & MEM_Blob)==0 ) return SQLITE_OK;
    nByte = 1;
  }
  if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
    return SQLITE_NOMEM_BKPT;
  }

  memset(&pMem->z[pMem->n], 0, pMem->u.nZero);
  pMem->n += pMem->u.nZero;
  pMem->flags &= ~(MEM_Zero|MEM_Term);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %esi
addl 0xc(%rdi), %esi
jg 0x281b6d
movl $0x1, %esi
xorl %ebp, %ebp
testb $0x10, 0x8(%rbx)
je 0x281ba0
movq %rbx, %rdi
movl $0x1, %edx
callq 0x29b54f
movl $0x7, %ebp
testl %eax, %eax
jne 0x281ba0
movslq 0xc(%rbx), %rdi
addq 0x10(%rbx), %rdi
movslq (%rbx), %rdx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x173a0
movl (%rbx), %eax
addl %eax, 0xc(%rbx)
andb $-0x43, 0x9(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3ValueBytes
SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
  Mem *p = (Mem*)pVal;
  assert( (p->flags & MEM_Null)==0 || (p->flags & (MEM_Str|MEM_Blob))==0 );
  if( (p->flags & MEM_Str)!=0 && pVal->enc==enc ){
    return p->n;
  }
  if( (p->flags & MEM_Blob)!=0 ){
    if( p->flags & MEM_Zero ){
      return p->n + p->u.nZero;
    }else{
      return p->n;
    }
  }
  if( p->flags & MEM_Null ) return 0;
  return valueBytes(pVal, enc);
}

// Assembly:
movzwl 0x8(%rdi), %ecx
testb $0x2, %cl
je 0x281bcd
cmpb %sil, 0xa(%rdi)
jne 0x281bcd
movl 0xc(%rdi), %eax
retq
testb $0x10, %cl
jne 0x281be2
xorl %eax, %eax
testb $0x1, %cl
jne 0x281beb
movzbl %sil, %esi
jmp 0x29b6dd
btl $0xe, %ecx
movl 0xc(%rdi), %eax
jb 0x281bec
retq
addl (%rdi), %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeIntValue
SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem *pMem){
  int flags;
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );
  flags = pMem->flags;
  if( flags & (MEM_Int|MEM_IntReal) ){
    testcase( flags & MEM_IntReal );
    return pMem->u.i;
  }else if( flags & MEM_Real ){
    return doubleToInt64(pMem->u.r);
  }else if( (flags & (MEM_Str|MEM_Blob))!=0 && pMem->z!=0 ){
    return memIntValue(pMem);
  }else{
    return 0;
  }
}

// Assembly:
movzwl 0x8(%rdi), %eax
testb $0x24, %al
je 0x281c29
movq (%rdi), %rax
retq
testb $0x8, %al
jne 0x281c3d
testb $0x12, %al
je 0x281c46
cmpq $0x0, 0x10(%rdi)
je 0x281c46
jmp 0x29c4c4
movsd (%rdi), %xmm0
jmp 0x29c498
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_value_pointer
SQLITE_API void *sqlite3_value_pointer(sqlite3_value *pVal, const char *zPType){
  Mem *p = (Mem*)pVal;
  if( (p->flags&(MEM_TypeMask|MEM_Term|MEM_Subtype)) ==
                 (MEM_Null|MEM_Term|MEM_Subtype)
   && zPType!=0
   && p->eSubtype=='p'
   && strcmp(p->u.zPType, zPType)==0
  ){
    return (void*)p->z;
  }else{
    return 0;
  }
}

// Assembly:
xorl %eax, %eax
testq %rsi, %rsi
je 0x281c8f
pushq %rbx
movq %rdi, %rbx
movzwl 0x8(%rdi), %ecx
andl $0xc3bf, %ecx           # imm = 0xC3BF
movzwl %cx, %ecx
cmpl $0x8201, %ecx           # imm = 0x8201
jne 0x281c8e
cmpb $0x70, 0xb(%rbx)
jne 0x281c8c
movq (%rbx), %rdi
callq 0x17a40
testl %eax, %eax
je 0x281c90
xorl %eax, %eax
popq %rbx
retq
movq 0x10(%rbx), %rax
jmp 0x281c8e