LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_sameName
static int PTRCALL
PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
{
  for (;;) {
    switch (BYTE_TYPE(enc, ptr1)) {
#define LEAD_CASE(n) \
    case BT_LEAD ## n: \
      if (*ptr1++ != *ptr2++) \
        return 0;
    LEAD_CASE(4) LEAD_CASE(3) LEAD_CASE(2)
#undef LEAD_CASE
      /* fall through */
      if (*ptr1++ != *ptr2++)
        return 0;
      break;
    case BT_NONASCII:
    case BT_NMSTRT:
#ifdef XML_NS
    case BT_COLON:
#endif
    case BT_HEX:
    case BT_DIGIT:
    case BT_NAME:
    case BT_MINUS:
      if (*ptr2++ != *ptr1++)
        return 0;
      if (MINBPC(enc) > 1) {
        if (*ptr2++ != *ptr1++)
          return 0;
        if (MINBPC(enc) > 2) {
          if (*ptr2++ != *ptr1++)
            return 0;
          if (MINBPC(enc) > 3) {
            if (*ptr2++ != *ptr1++)
              return 0;
          }
        }
      }
      break;
    default:
      if (MINBPC(enc) == 1 && *ptr1 == *ptr2)
        return 1;
      switch (BYTE_TYPE(enc, ptr2)) {
      case BT_LEAD2:
      case BT_LEAD3:
      case BT_LEAD4:
      case BT_NONASCII:
      case BT_NMSTRT:
#ifdef XML_NS
      case BT_COLON:
#endif
      case BT_HEX:
      case BT_DIGIT:
      case BT_NAME:
      case BT_MINUS:
        return 0;
      default:
        return 1;
      }
    }
  }
  /* not reached */
}

// Assembly:
movl $0x2f400000, %ecx       # imm = 0x2F400000
movb 0x1(%rsi), %r8b
movzbl %r8b, %eax
cmpl $0xdb, %eax
jg 0x258749
leal -0xd8(%rax), %r9d
cmpl $0x4, %r9d
jae 0x258757
movb (%rsi), %al
cmpb (%rdx), %al
jne 0x2587a8
incq %rsi
incq %rdx
movb (%rsi), %al
cmpb (%rdx), %al
jne 0x2587a8
incq %rsi
incq %rdx
movb (%rsi), %r8b
xorl %eax, %eax
cmpb (%rdx), %r8b
jne 0x2587aa
movb 0x1(%rsi), %r8b
cmpb 0x1(%rdx), %r8b
je 0x25879b
jmp 0x2587aa
cmpl $0xff, %eax
jne 0x258781
cmpb $-0x3, (%rsi)
jbe 0x25878b
jmp 0x2587ab
testl %eax, %eax
jne 0x25878b
movzbl (%rsi), %eax
movzbl 0x88(%rdi,%rax), %eax
cmpl $0x1d, %eax
ja 0x25877a
btl %eax, %ecx
jb 0x25878b
cmpl $0x6, %eax
je 0x258727
cmpl $0x7, %eax
je 0x258717
cmpl $0x5, %eax
je 0x258733
jmp 0x2587ab
addl $0xffffff24, %eax       # imm = 0xFFFFFF24
cmpl $0x4, %eax
jb 0x2587ab
movb (%rdx), %r9b
xorl %eax, %eax
cmpb (%rsi), %r9b
jne 0x2587aa
cmpb %r8b, 0x1(%rdx)
jne 0x2587aa
addq $0x2, %rdx
addq $0x2, %rsi
jmp 0x2586fb
xorl %eax, %eax
retq
movzbl 0x1(%rdx), %ecx
leal -0xdc(%rcx), %eax
cmpl $0x4, %eax
jae 0x2587c0
movl $0x1, %eax
retq
xorl %eax, %eax
testl %ecx, %ecx
je 0x2587d5
cmpl $0xff, %ecx
jne 0x2587aa
cmpb $-0x3, (%rdx)
jbe 0x2587aa
jmp 0x2587ba
movzbl (%rdx), %ecx
movzbl 0x88(%rdi,%rcx), %ecx
cmpl $0x1d, %ecx
ja 0x2587ba
movl $0x2f4000e0, %edx       # imm = 0x2F4000E0
btl %ecx, %edx
jb 0x2587aa
jmp 0x2587ba
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_skipS
PREFIX(skipS)(const ENCODING *enc, const char *ptr)
{
  for (;;) {
    switch (BYTE_TYPE(enc, ptr)) {
    case BT_LF:
    case BT_CR:
    case BT_S:
      ptr += MINBPC(enc);
      break;
    default:
      return ptr;
    }
  }
}

// Assembly:
cmpb $0x0, 0x1(%rsi)
je 0x2588b7
movq %rsi, %rax
retq
movl $0x200600, %ecx         # imm = 0x200600
movzbl (%rsi), %eax
movzbl 0x88(%rdi,%rax), %eax
cmpl $0x15, %eax
ja 0x2588b3
btl %eax, %ecx
jae 0x2588b3
leaq 0x2(%rsi), %rax
cmpb $0x0, 0x3(%rsi)
movq %rax, %rsi
je 0x2588bc
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_predefinedEntityName
static int PTRCALL
PREFIX(predefinedEntityName)(__attribute__ ((unused)) const ENCODING *enc, const char *ptr,
                             const char *end)
{
  switch ((end - ptr)/MINBPC(enc)) {
  case 2:
    if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
      switch (BYTE_TO_ASCII(enc, ptr)) {
      case ASCII_l:
        return ASCII_LT;
      case ASCII_g:
        return ASCII_GT;
      }
    }
    break;
  case 3:
    if (CHAR_MATCHES(enc, ptr, ASCII_a)) {
      ptr += MINBPC(enc);
      if (CHAR_MATCHES(enc, ptr, ASCII_m)) {
        ptr += MINBPC(enc);
        if (CHAR_MATCHES(enc, ptr, ASCII_p))
          return ASCII_AMP;
      }
    }
    break;
  case 4:
    switch (BYTE_TO_ASCII(enc, ptr)) {
    case ASCII_q:
      ptr += MINBPC(enc);
      if (CHAR_MATCHES(enc, ptr, ASCII_u)) {
        ptr += MINBPC(enc);
        if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
          ptr += MINBPC(enc);
          if (CHAR_MATCHES(enc, ptr, ASCII_t))
            return ASCII_QUOT;
        }
      }
      break;
    case ASCII_a:
      ptr += MINBPC(enc);
      if (CHAR_MATCHES(enc, ptr, ASCII_p)) {
        ptr += MINBPC(enc);
        if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
          ptr += MINBPC(enc);
          if (CHAR_MATCHES(enc, ptr, ASCII_s))
            return ASCII_APOS;
        }
      }
      break;
    }
  }
  return 0;
}

// Assembly:
subq %rsi, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
addq %rdx, %rax
sarq %rax
cmpq $0x4, %rax
je 0x258d68
cmpq $0x3, %rax
je 0x258d3e
cmpq $0x2, %rax
jne 0x258d6e
cmpb $0x0, 0x3(%rsi)
jne 0x258d6e
cmpb $0x74, 0x2(%rsi)
jne 0x258d6e
xorl %eax, %eax
cmpb $0x0, 0x1(%rsi)
jne 0x258d70
movb (%rsi), %al
xorl %ecx, %ecx
cmpb $0x67, %al
movl $0x3e, %edx
cmovnel %ecx, %edx
cmpb $0x6c, %al
movl $0x3c, %eax
cmovnel %edx, %eax
retq
cmpb $0x0, 0x1(%rsi)
jne 0x258d6e
cmpb $0x61, (%rsi)
jne 0x258d6e
cmpb $0x0, 0x3(%rsi)
jne 0x258d6e
cmpb $0x6d, 0x2(%rsi)
jne 0x258d6e
cmpb $0x0, 0x5(%rsi)
jne 0x258d6e
movl $0x26, %eax
cmpb $0x70, 0x4(%rsi)
jne 0x258d6e
jmp 0x258d70
cmpb $0x0, 0x1(%rsi)
je 0x258d71
xorl %eax, %eax
retq
movzbl (%rsi), %eax
cmpl $0x61, %eax
je 0x258da9
cmpl $0x71, %eax
jne 0x258d6e
cmpb $0x0, 0x3(%rsi)
jne 0x258d6e
cmpb $0x75, 0x2(%rsi)
jne 0x258d6e
cmpb $0x0, 0x5(%rsi)
jne 0x258d6e
cmpb $0x6f, 0x4(%rsi)
jne 0x258d6e
cmpb $0x0, 0x7(%rsi)
jne 0x258d6e
movl $0x22, %eax
cmpb $0x74, 0x6(%rsi)
jne 0x258d6e
jmp 0x258d70
cmpb $0x0, 0x3(%rsi)
jne 0x258d6e
cmpb $0x70, 0x2(%rsi)
jne 0x258d6e
cmpb $0x0, 0x5(%rsi)
jne 0x258d6e
cmpb $0x6f, 0x4(%rsi)
jne 0x258d6e
cmpb $0x0, 0x7(%rsi)
jne 0x258d6e
movl $0x27, %eax
cmpb $0x73, 0x6(%rsi)
jne 0x258d6e
jmp 0x258d70
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_status64
SQLITE_API int sqlite3_status64(
  int op,
  sqlite3_int64 *pCurrent,
  sqlite3_int64 *pHighwater,
  int resetFlag
){
  sqlite3_mutex *pMutex;
  wsdStatInit;
  if( op<0 || op>=ArraySize(wsdStat.nowValue) ){
    return SQLITE_MISUSE_BKPT;
  }
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;
#endif
  pMutex = statMutex[op] ? sqlite3Pcache1Mutex() : sqlite3MallocMutex();
  sqlite3_mutex_enter(pMutex);
  *pCurrent = wsdStat.nowValue[op];
  *pHighwater = wsdStat.mxValue[op];
  if( resetFlag ){
    wsdStat.mxValue[op] = wsdStat.nowValue[op];
  }
  sqlite3_mutex_leave(pMutex);
  (void)pMutex;  /* Prevent warning when SQLITE_THREADSAFE=0 */
  return SQLITE_OK;
}

// Assembly:
pushq %rbx
cmpl $0xa, %edi
jb 0x271e3b
leaq 0x163db6(%rip), %rsi    # 0x3d5bcb
leaq 0x16862b(%rip), %rdx    # 0x3da447
leaq 0x163c0e(%rip), %r8     # 0x3d5a31
movl $0x15, %ebx
movl $0x15, %edi
movl $0x53d5, %ecx           # imm = 0x53D5
xorl %eax, %eax
callq 0x274d08
jmp 0x271e5e
movl %edi, %eax
leaq 0x24ccb4(%rip), %rdi    # 0x4beaf8
movq (%rdi,%rax,8), %r8
movq %r8, (%rsi)
movq 0x50(%rdi,%rax,8), %rsi
movq %rsi, (%rdx)
xorl %ebx, %ebx
testl %ecx, %ecx
je 0x271e5e
movq %r8, 0x50(%rdi,%rax,8)
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3LookasideUsed
SQLITE_PRIVATE int sqlite3LookasideUsed(sqlite3 *db, int *pHighwater){
  u32 nInit = countLookasideSlots(db->lookaside.pInit);
  u32 nFree = countLookasideSlots(db->lookaside.pFree);
#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
  nInit += countLookasideSlots(db->lookaside.pSmallInit);
  nFree += countLookasideSlots(db->lookaside.pSmallFree);
#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */
  if( pHighwater ) *pHighwater = db->lookaside.nSlot - nInit;
  return db->lookaside.nSlot - (nInit+nFree);
}

// Assembly:
movq 0x190(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x27235f
movq (%rcx), %rcx
incl %eax
jmp 0x272353
movq 0x198(%rdi), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testq %rdx, %rdx
je 0x272377
movq (%rdx), %rdx
incl %ecx
jmp 0x27236b
movq 0x1a0(%rdi), %r8
xorl %edx, %edx
testq %r8, %r8
je 0x27238c
movq (%r8), %r8
incl %edx
jmp 0x272380
movq 0x1a8(%rdi), %r9
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
testq %r9, %r9
je 0x2723a6
movq (%r9), %r9
incl %r8d
jmp 0x272399
addl %eax, %edx
testq %rsi, %rsi
je 0x2723b7
movl 0x17c(%rdi), %eax
subl %edx, %eax
movl %eax, (%rsi)
movl 0x17c(%rdi), %eax
addl %edx, %ecx
addl %r8d, %ecx
subl %ecx, %eax
addl $-0x2, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3VdbeClearObject
SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){
  SubProgram *pSub, *pNext;
  assert( p->db==0 || p->db==db );
  releaseMemArray(p->aColName, p->nResColumn*COLNAME_N);
  for(pSub=p->pProgram; pSub; pSub=pNext){
    pNext = pSub->pNext;
    vdbeFreeOpArray(db, pSub->aOp, pSub->nOp);
    sqlite3DbFree(db, pSub);
  }
  if( p->magic!=VDBE_MAGIC_INIT ){
    releaseMemArray(p->aVar, p->nVar);
    sqlite3DbFree(db, p->pVList);
    sqlite3DbFree(db, p->pFree);
  }
  vdbeFreeOpArray(db, p->aOp, p->nOp);
  sqlite3DbFree(db, p->aColName);
  sqlite3DbFree(db, p->zSql);
#ifdef SQLITE_ENABLE_NORMALIZE
  sqlite3DbFree(db, p->zNormSql);
  {
    DblquoteStr *pThis, *pNext;
    for(pThis=p->pDblStr; pThis; pThis=pNext){
      pNext = pThis->pNextStr;
      sqlite3DbFree(db, pThis);
    }
  }
#endif
#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
  {
    int i;
    for(i=0; i<p->nScan; i++){
      sqlite3DbFree(db, p->aScan[i].zName);
    }
    sqlite3DbFree(db, p->aScan);
  }
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x98(%rsi), %rdi
movzwl 0xc0(%rsi), %esi
addl %esi, %esi
callq 0x28fa89
movq 0x118(%r14), %r15
testq %r15, %r15
je 0x2724be
movq 0x28(%r15), %r12
movq (%r15), %rsi
movl 0x8(%r15), %edx
movq %rbx, %rdi
callq 0x28fb18
movq %rbx, %rdi
movq %r15, %rsi
callq 0x282904
movq %r12, %r15
testq %r12, %r12
jne 0x272498
cmpl $0x16bceaa5, 0x24(%r14) # imm = 0x16BCEAA5
je 0x272501
movq 0x80(%r14), %rdi
movswl 0x20(%r14), %esi
callq 0x28fa89
movq 0xb0(%r14), %rsi
testq %rsi, %rsi
je 0x2724ed
movq %rbx, %rdi
callq 0x282904
movq 0xf8(%r14), %rsi
testq %rsi, %rsi
je 0x272501
movq %rbx, %rdi
callq 0x282904
movq 0x88(%r14), %rsi
movl 0x90(%r14), %edx
movq %rbx, %rdi
callq 0x28fb18
movq 0x98(%r14), %rsi
testq %rsi, %rsi
je 0x27252b
movq %rbx, %rdi
callq 0x282904
movq 0xf0(%r14), %rsi
testq %rsi, %rsi
je 0x27254a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x282904
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_vfs_find
SQLITE_API sqlite3_vfs *sqlite3_vfs_find(const char *zVfs){
  sqlite3_vfs *pVfs = 0;
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex;
#endif
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return 0;
#endif
#if SQLITE_THREADSAFE
  mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN);
#endif
  sqlite3_mutex_enter(mutex);
  for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
    if( zVfs==0 ) break;
    if( strcmp(zVfs, pVfs->zName)==0 ) break;
  }
  sqlite3_mutex_leave(mutex);
  return pVfs;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x2725a7
testl %eax, %eax
je 0x27256a
xorl %ebx, %ebx
jmp 0x272581
testq %r14, %r14
sete %al
movq 0x24c621(%rip), %rbx    # 0x4beb98
testq %rbx, %rbx
sete %cl
orb %al, %cl
je 0x27258c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x17a40
testl %eax, %eax
je 0x272581
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x27258c
jmp 0x272566
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_vfs_register
SQLITE_API int sqlite3_vfs_register(sqlite3_vfs *pVfs, int makeDflt){
  MUTEX_LOGIC(sqlite3_mutex *mutex;)
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return rc;
#endif
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pVfs==0 ) return SQLITE_MISUSE_BKPT;
#endif

  MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); )
  sqlite3_mutex_enter(mutex);
  vfsUnlink(pVfs);
  if( makeDflt || vfsList==0 ){
    pVfs->pNext = vfsList;
    vfsList = pVfs;
  }else{
    pVfs->pNext = vfsList->pNext;
    vfsList->pNext = pVfs;
  }
  assert(vfsList);
  sqlite3_mutex_leave(mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x2725a7
testl %eax, %eax
jne 0x272989
movq 0x24c289(%rip), %rax    # 0x4beb98
testq %rbx, %rbx
je 0x272952
cmpq %rbx, %rax
je 0x27293d
testq %rax, %rax
je 0x272977
movq %rax, %rdx
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
je 0x272932
cmpq %rbx, %rdx
jne 0x272921
cmpq %rbx, %rdx
jne 0x272952
addq $0x10, %rcx
jmp 0x272944
leaq 0x24c254(%rip), %rcx    # 0x4beb98
movq 0x10(%rbx), %rax
movq %rax, (%rcx)
movq 0x24c246(%rip), %rax    # 0x4beb98
testl %ebp, %ebp
setne %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0x27296a
leaq 0x24c230(%rip), %rcx    # 0x4beb98
jmp 0x272980
movq %rax, %rcx
movq 0x10(%rax), %rax
addq $0x10, %rcx
jmp 0x272980
leaq 0x24c21a(%rip), %rcx    # 0x4beb98
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq %rbx, (%rcx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_vfs_unregister
SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){
  MUTEX_LOGIC(sqlite3_mutex *mutex;)
#ifndef SQLITE_OMIT_AUTOINIT
  int rc = sqlite3_initialize();
  if( rc ) return rc;
#endif
  MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); )
  sqlite3_mutex_enter(mutex);
  vfsUnlink(pVfs);
  sqlite3_mutex_leave(mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2725a7
testl %eax, %eax
je 0x27299f
popq %rbx
retq
xorl %eax, %eax
testq %rbx, %rbx
je 0x27299d
movq 0x24c1eb(%rip), %rdx    # 0x4beb98
cmpq %rbx, %rdx
je 0x2729d3
testq %rdx, %rdx
je 0x27299d
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
je 0x2729c8
cmpq %rbx, %rdx
jne 0x2729b7
cmpq %rbx, %rdx
jne 0x27299d
addq $0x10, %rcx
jmp 0x2729da
leaq 0x24c1be(%rip), %rcx    # 0x4beb98
movq 0x10(%rbx), %rdx
movq %rdx, (%rcx)
jmp 0x27299d
// File: /workspace/github_c_makefile_star2_O3/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 0x2725a7
movl %eax, %ecx
movq $-0x1, %rax
testl %ecx, %ecx
jne 0x272a4c
movq 0x24c1a2(%rip), %rax    # 0x4beba8
testq %rbx, %rbx
js 0x272a4c
movq 0x24c19e(%rip), %rcx    # 0x4bebb0
cmpq %rbx, %rcx
movq %rbx, %rdx
cmovlq %rcx, %rdx
testq %rbx, %rbx
cmoveq %rcx, %rdx
testq %rcx, %rcx
cmovleq %rbx, %rdx
movq %rdx, 0x24c177(%rip)    # 0x4beba8
testq %rdx, %rdx
setg %cl
cmpq 0x24c0ba(%rip), %rdx    # 0x4beaf8
setle %dl
andb %cl, %dl
movzbl %dl, %ecx
movl %ecx, 0x24c16c(%rip)    # 0x4bebb8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2725a7
movl %eax, %ecx
movq $-0x1, %rax
testl %ecx, %ecx
je 0x272a7a
popq %rbx
retq
movq 0x24c12f(%rip), %rax    # 0x4bebb0
testq %rbx, %rbx
js 0x272a78
movq %rbx, 0x24c123(%rip)    # 0x4bebb0
movq 0x24c114(%rip), %rcx    # 0x4beba8
cmpq %rbx, %rcx
setle %dl
testq %rcx, %rcx
setne %cl
testb %cl, %dl
jne 0x272a78
movq %rbx, 0x24c0fd(%rip)    # 0x4beba8
jmp 0x272a78
// File: /workspace/github_c_makefile_star2_O3/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 0x272afd
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
movq %rdi, %rbx
cmpl $0x0, 0x248b59(%rip)    # 0x4bb660
je 0x272b4b
movl %ebx, %edi
callq *0x248b8f(%rip)         # 0x4bb6a0
cmpq %rbx, 0x24c058(%rip)    # 0x4beb70
jge 0x272b21
movq %rbx, 0x24c04f(%rip)    # 0x4beb70
movq 0x24c080(%rip), %rsi    # 0x4beba8
testq %rsi, %rsi
jle 0x272b7e
movq 0x24bfc4(%rip), %rcx    # 0x4beaf8
movslq %eax, %rdx
subq %rdx, %rsi
cmpq %rsi, %rcx
jge 0x272b54
movl $0x0, 0x24c06f(%rip)    # 0x4bebb8
jmp 0x272b7e
movl %ebx, %edi
popq %rbx
jmpq *0x248b2c(%rip)         # 0x4bb680
movl $0x1, 0x24c05a(%rip)    # 0x4bebb8
movq 0x24c04b(%rip), %rsi    # 0x4bebb0
testq %rsi, %rsi
sete %dil
subq %rdx, %rsi
cmpq %rsi, %rcx
setl %cl
orb %dil, %cl
je 0x272af6
movl %eax, %edi
callq *0x248afa(%rip)         # 0x4bb680
testq %rax, %rax
je 0x272af6
movq %rax, %rbx
movq %rax, %rdi
callq *0x248afd(%rip)         # 0x4bb698
cltq
addq 0x24bf54(%rip), %rax    # 0x4beaf8
movq %rax, 0x24bf4d(%rip)    # 0x4beaf8
cmpq 0x24bf96(%rip), %rax    # 0x4beb48
jle 0x272bbb
movq %rax, 0x24bf8d(%rip)    # 0x4beb48
movq 0x24bf7e(%rip), %rcx    # 0x4beb40
leaq 0x1(%rcx), %rax
movq %rax, 0x24bf73(%rip)    # 0x4beb40
cmpq 0x24bfbc(%rip), %rcx    # 0x4beb90
jl 0x272af8
movq %rax, 0x24bfaf(%rip)    # 0x4beb90
jmp 0x272af8
// File: /workspace/github_c_makefile_star2_O3/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 0x272c35
movq %rdi, %rbx
cmpl $0x0, 0x248a50(%rip)    # 0x4bb660
je 0x272c2b
movq %rbx, %rdi
callq *0x248a7d(%rip)         # 0x4bb698
cltq
subq %rax, 0x24bed4(%rip)    # 0x4beaf8
decq 0x24bf15(%rip)          # 0x4beb40
movq %rbx, %rdi
popq %rbx
jmpq *0x248a53(%rip)         # 0x4bb688
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2725a7
testl %eax, %eax
je 0x272c51
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 0x272c63
// File: /workspace/github_c_makefile_star2_O3/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 0x272d05
movq %rdi, %rbx
testq %r14, %r14
je 0x272d11
cmpq $0x7ffffeff, %r14       # imm = 0x7FFFFEFF
ja 0x272d3c
movq %rbx, %rdi
callq *0x248a03(%rip)         # 0x4bb698
movl %eax, %ebp
movl %r14d, %edi
callq *0x248a00(%rip)         # 0x4bb6a0
cmpl %eax, %ebp
je 0x272d3e
cmpl $0x0, 0x2489b1(%rip)    # 0x4bb660
je 0x272d46
cmpq %r14, 0x24beb4(%rip)    # 0x4beb70
jge 0x272cc5
movq %r14, 0x24beab(%rip)    # 0x4beb70
movq %rbx, %rdi
movl %eax, %esi
callq *0x2489c0(%rip)         # 0x4bb690
testq %rax, %rax
je 0x272d3c
movq %rax, %rbx
movq %rax, %rdi
callq *0x2489b7(%rip)         # 0x4bb698
subl %ebp, %eax
cltq
addq 0x24be0c(%rip), %rax    # 0x4beaf8
movq %rax, 0x24be05(%rip)    # 0x4beaf8
cmpq 0x24be4e(%rip), %rax    # 0x4beb48
jle 0x272d3e
movq %rax, 0x24be45(%rip)    # 0x4beb48
jmp 0x272d3e
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x272ae6
cmpl $0x0, 0x248948(%rip)    # 0x4bb660
je 0x272d33
movq %rbx, %rdi
callq *0x248975(%rip)         # 0x4bb698
cltq
subq %rax, 0x24bdcc(%rip)    # 0x4beaf8
decq 0x24be0d(%rip)          # 0x4beb40
movq %rbx, %rdi
callq *0x24894c(%rip)         # 0x4bb688
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x248943(%rip), %rcx    # 0x4bb690
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
popq %r14
popq %rbp
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/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 0x274743
testl %edx, %edx
je 0x274748
movl %ecx, 0x18(%rdi)
addq 0x8(%rdi), %rax
movslq %edx, %rdx
movq %rax, %rdi
jmp 0x17660
jmp 0x274968
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpb $0x0, 0x1c(%rdi)
je 0x274752
xorl %eax, %eax
retq
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %eax
cmpq %rsi, %rax
jge 0x274775
movl 0x14(%rbx), %eax
cmpq %rsi, %rax
jae 0x274775
movq %rbx, %rdi
movl $0x12, %esi
callq 0x2829a0
jmp 0x2747a3
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x274784
callq 0x282a35
jmp 0x27478c
movq %rsi, %rdi
callq 0x272ae6
testq %rax, %rax
jne 0x2747a5
movb $0x7, 0x1c(%rbx)
cmpl $0x0, 0x14(%rbx)
je 0x2747a3
movq %rbx, %rdi
callq 0x274a57
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_str_appendchar
SQLITE_API void sqlite3_str_appendchar(sqlite3_str *p, int N, char c){
  testcase( p->nChar + (i64)N > 0x7fffffff );
  if( p->nChar+(i64)N >= p->nAlloc && (N = sqlite3StrAccumEnlarge(p, N))<=0 ){
    return;
  }
  while( (N--)>0 ) p->zText[p->nChar++] = c;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movl 0x10(%rdi), %eax
movl 0x18(%rdi), %ecx
movslq %esi, %rdx
addq %rcx, %rdx
cmpq %rax, %rdx
jge 0x2747c7
testl %esi, %esi
jg 0x2747d5
jmp 0x2747f0
movq %r14, %rdi
callq 0x27482e
movl %eax, %esi
testl %eax, %eax
jle 0x2747f0
incl %esi
movq 0x8(%r14), %rax
movl 0x18(%r14), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x18(%r14)
movb %bl, (%rax,%rcx)
decl %esi
cmpl $0x1, %esi
ja 0x2747d7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x274843
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %rbx
movl 0x14(%rdi), %eax
testq %rax, %rax
je 0x27485a
movl %esi, %ebp
testb $0x4, 0x1d(%rbx)
jne 0x274874
xorl %esi, %esi
jmp 0x274878
movq %rbx, %rdi
movl $0x12, %esi
callq 0x2829a0
movl 0x18(%rbx), %r14d
notl %r14d
addl 0x10(%rbx), %r14d
jmp 0x27483b
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 0x2748b4
movq %rbx, %rdi
callq 0x274a57
movq %rbx, %rdi
movl $0x12, %esi
callq 0x2829a0
xorl %r14d, %r14d
jmp 0x27483b
movl %ecx, 0x10(%rbx)
movq (%rbx), %rdi
movl %ecx, %edx
testq %rdi, %rdi
je 0x2748c8
callq 0x2829e5
jmp 0x2748d3
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x272c63
movq %rax, %r14
testq %rax, %rax
je 0x274939
testb $0x4, 0x1d(%rbx)
jne 0x2748f5
movl 0x18(%rbx), %edx
testq %rdx, %rdx
je 0x2748f5
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x17660
movq %r14, 0x8(%rbx)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x274921
cmpq %r14, 0x1c0(%rcx)
jbe 0x274921
movl $0x80, %eax
cmpq %r14, 0x1b0(%rcx)
jbe 0x27492a
cmpq %r14, 0x1b8(%rcx)
jbe 0x27495f
movq %r14, %rdi
callq *0x246d6e(%rip)         # 0x4bb698
movl %eax, 0x10(%rbx)
orb $0x4, 0x1d(%rbx)
movl %ebp, %r14d
jmp 0x27483b
movq %rbx, %rdi
callq 0x274a57
movb $0x7, 0x1c(%rbx)
xorl %r14d, %r14d
cmpl $0x0, 0x14(%rbx)
je 0x27483b
movq %rbx, %rdi
callq 0x274a57
jmp 0x27483b
movzwl 0x176(%rcx), %eax
jmp 0x27492a
// File: /workspace/github_c_makefile_star2_O3/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 0x27482e
testl %eax, %eax
jle 0x274993
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_O3/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:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
leaq 0x246e57(%rip), %rcx    # 0x4bb800
cmpq %rcx, %rdi
sete %cl
orb %al, %cl
jne 0x2749eb
movq %rdi, %rbx
callq 0x2749f9
movq %rax, %r14
cmpl $0x0, 0x246c9b(%rip)    # 0x4bb660
je 0x2749e0
movq %rbx, %rdi
callq *0x246cc8(%rip)         # 0x4bb698
cltq
subq %rax, 0x24a11f(%rip)    # 0x4beaf8
decq 0x24a160(%rip)          # 0x4beb40
movq %rbx, %rdi
callq *0x246c9f(%rip)         # 0x4bb688
jmp 0x2749ee
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x274a19
movl 0x18(%rdi), %ecx
movb $0x0, (%rax,%rcx)
cmpl $0x0, 0x14(%rdi)
je 0x274a19
testb $0x4, 0x1d(%rdi)
je 0x282b99
movq 0x8(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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
movb 0x1d(%rdi), %al
testb $0x4, %al
je 0x274a7b
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x274a76
movq (%rbx), %rdi
callq 0x282904
movb 0x1d(%rbx), %al
andb $-0x5, %al
movb %al, 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_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2725a7
leaq 0x246d60(%rip), %r14    # 0x4bb800
testl %eax, %eax
jne 0x274adc
movl $0x20, %edi
callq 0x272ae6
testq %rax, %rax
je 0x274adc
testq %rbx, %rbx
je 0x274abd
movl 0x7c(%rbx), %ecx
jmp 0x274ac2
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)
movq %rax, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2725a7
testl %eax, %eax
je 0x274b03
xorl %eax, %eax
jmp 0x274b49
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 0x272d87
movq %r15, %rdi
callq 0x2749f9
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x274c36
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 0x272d87
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_O3/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 0x275022
testq %rsi, %rsi
je 0x27502a
xorl %ecx, %ecx
leaq 0x15c2e6(%rip), %rdx    # 0x3d12e0
movzbl (%rdi,%rcx), %eax
movzbl (%rsi,%rcx), %r8d
cmpb %r8b, %al
jne 0x27500f
testq %rax, %rax
jne 0x27501d
jmp 0x275030
movzbl (%rax,%rdx), %eax
movzbl (%r8,%rdx), %r8d
subl %r8d, %eax
jne 0x275029
incq %rcx
jmp 0x274ffa
xorl %eax, %eax
negq %rsi
sbbl %eax, %eax
retq
movl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x275073
testq %rsi, %rsi
je 0x27507b
testl %edx, %edx
jle 0x275070
incl %edx
xorl %r8d, %r8d
leaq 0x15c293(%rip), %rcx    # 0x3d12e0
movzbl (%rdi,%r8), %eax
testq %rax, %rax
je 0x275081
movzbl (%rax,%rcx), %eax
movzbl (%rsi,%r8), %r9d
cmpb (%r9,%rcx), %al
jne 0x275083
decl %edx
incq %r8
cmpl $0x1, %edx
ja 0x27504d
xorl %eax, %eax
retq
xorl %eax, %eax
negq %rsi
sbbl %eax, %eax
retq
movl $0x1, %eax
retq
xorl %eax, %eax
movzbl (%rsi,%r8), %edx
movzbl (%rdx,%rcx), %ecx
subl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 *0x24630d(%rip)         # 0x4bbc58
cmpl $-0x1, %eax
je 0x27599d
xorl %ebx, %ebx
testb $0x1, %bpl
je 0x2759ef
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq *0x246306(%rip)         # 0x4bbc70
xorl %ebx, %ebx
testl %eax, %eax
jne 0x2759ef
movl 0xc(%rsp), %edi
callq 0x176c0
testl %eax, %eax
je 0x2759c7
leaq 0x160265(%rip), %rsi    # 0x3d5be9
movl $0x50a, %ebx            # imm = 0x50A
movl $0x50a, %edi            # imm = 0x50A
movq %r14, %rdx
movl $0x9b7c, %ecx           # imm = 0x9B7C
callq 0x2842dc
jmp 0x2759c9
callq 0x17060
movl $0x170a, %ebx           # imm = 0x170A
cmpl $0x2, (%rax)
je 0x2759ef
leaq 0x160171(%rip), %rsi    # 0x3d5b24
movl $0xa0a, %ebx            # imm = 0xA0A
movl $0xa0a, %edi            # imm = 0xA0A
movq %r14, %rdx
movl $0x9b72, %ecx           # imm = 0x9B72
jmp 0x2759ea
xorl %ebx, %ebx
movl 0xc(%rsp), %edi
callq *0x24611d(%rip)         # 0x4bbaf0
testl %eax, %eax
je 0x2759ef
leaq 0x152efe(%rip), %rsi    # 0x3c88dc
movl $0x100a, %edi           # imm = 0x100A
xorl %edx, %edx
movl $0x9b7e, %ecx           # imm = 0x9B7E
callq 0x2842dc
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x275a20
movl $0x6, %esi
callq *0x2460f1(%rip)         # 0x4bbb08
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
jmp 0x275a4e
movq %rsp, %rsi
callq *0x24610f(%rip)         # 0x4bbb38
xorl %ecx, %ecx
testl %eax, %eax
jne 0x275a4e
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_O3/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, 0x248f07(%rip)    # 0x4beda8
leaq 0x15fd8e(%rip), %rdi    # 0x3d5c36
xorl %esi, %esi
xorl %edx, %edx
callq 0x284201
testl %eax, %eax
js 0x275ef9
movl %eax, %ebp
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq *0x245cd3(%rip)         # 0x4bbb98
testl %eax, %eax
jns 0x275ed3
callq 0x17060
cmpl $0x4, (%rax)
je 0x275eb7
movl %ebp, %edi
callq *0x245c15(%rip)         # 0x4bbaf0
testl %eax, %eax
je 0x275f19
leaq 0x1529f6(%rip), %rsi    # 0x3c88dc
movl $0x100a, %edi           # imm = 0x100A
xorl %edx, %edx
movl $0x9c84, %ecx           # imm = 0x9C84
callq 0x2842dc
jmp 0x275f19
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x17740
movq (%rbx), %rax
movq %rax, (%r14)
movl 0x248e98(%rip), %eax    # 0x4beda8
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_O3/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 0x276337
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 0x276371
movq (%rbx), %rdi
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x27636c
xorl %esi, %esi
xorl %edx, %edx
callq *%rax
jmp 0x27636e
xorl %eax, %eax
movl %eax, 0x58(%rbx)
testq %r14, %r14
je 0x276402
cmpq $0x0, 0x160(%rbx)
jne 0x2763ab
movl $0x38, %esi
movq %rbx, %rdi
callq 0x279b27
testq %rax, %rax
je 0x276428
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 0x284ab7
movq 0x160(%rbx), %rdi
testq %rdi, %rdi
je 0x276433
leaq 0x272e(%rip), %r8       # 0x278b1c
movq %rax, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
callq 0x278594
jmp 0x276433
movl %ebp, 0x50(%rbx)
testl %ebp, %ebp
jne 0x276413
cmpq $0x0, 0x160(%rbx)
je 0x276433
movq %rbx, %rdi
movl %ebp, %esi
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x284b1f
movq $0x0, 0x160(%rbx)
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x280170
movl %eax, %ebp
cmpl $0x1, %eax
jne 0x2764c5
leaq 0x8(%rsp), %r15
movl $0x1a0, %edx            # imm = 0x1A0
movq %r15, %rdi
xorl %esi, %esi
callq 0x173a0
movq %r14, -0x8(%r15)
movq %rsp, %rdi
callq 0x284b82
testl %eax, %eax
je 0x2764e7
movl 0x18(%rsp), %esi
movq 0x8(%rsp), %r14
leaq 0x15260e(%rip), %rdx    # 0x3c8aa9
movq %rbx, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x2762da
testq %r14, %r14
je 0x2764b8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x282904
movq %rsp, %rdi
callq 0x27bd9d
xorl %r14d, %r14d
jmp 0x276510
testl %ebp, %ebp
jns 0x276501
leaq 0x15f773(%rip), %rdx    # 0x3d5c43
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x1, %esi
movq %r15, %rcx
xorl %eax, %eax
callq 0x2762da
jmp 0x276510
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x2764f9
movq %rbx, %rdi
callq 0x282904
movq %rsp, %rdi
callq 0x27bd9d
movq 0x20(%r14), %rax
movl %ebp, %ecx
shlq $0x5, %rcx
movq 0x8(%rax,%rcx), %r14
movq %r14, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq