LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_scanComment
static int PTRCALL
PREFIX(scanComment)(const ENCODING *enc, const char *ptr,
                    const char *end, const char **nextTokPtr)
{
  if (ptr != end) {
    if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
      *nextTokPtr = ptr;
      return XML_TOK_INVALID;
    }
    ptr += MINBPC(enc);
    while (ptr != end) {
      switch (BYTE_TYPE(enc, ptr)) {
      INVALID_CASES(ptr, nextTokPtr)
      case BT_MINUS:
        if ((ptr += MINBPC(enc)) == end)
          return XML_TOK_PARTIAL;
        if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
          if ((ptr += MINBPC(enc)) == end)
            return XML_TOK_PARTIAL;
          if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
            *nextTokPtr = ptr;
            return XML_TOK_INVALID;
          }
          *nextTokPtr = ptr + MINBPC(enc);
          return XML_TOK_COMMENT;
        }
        break;
      default:
        ptr += MINBPC(enc);
        break;
      }
    }
  }
  return XML_TOK_PARTIAL;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rdx, %rsi
je 0x209133
pushq %rbx
xorl %r8d, %r8d
cmpb $0x0, 0x1(%rsi)
jne 0x20912c
cmpb $0x2d, (%rsi)
jne 0x20912c
addq $0x2, %rsi
movl $0xfffffffe, %r9d       # imm = 0xFFFFFFFE
leaq 0x163b45(%rip), %r10    # 0x36cb84
movq %rsi, %r11
cmpq %rdx, %r11
je 0x209132
movq %r11, %rsi
movzbl 0x1(%r11), %r11d
leal -0xd8(%r11), %ebx
cmpl $0x4, %ebx
jb 0x2090d3
testl %r11d, %r11d
jne 0x209098
movzbl (%rsi), %r11d
movzbl 0x88(%rdi,%r11), %r11d
cmpq $0x8, %r11
jbe 0x2090bb
cmpl $0x1b, %r11d
jne 0x2090b5
leaq 0x2(%rsi), %r11
cmpq %rdx, %r11
je 0x209132
cmpb $0x0, 0x3(%rsi)
jne 0x209042
cmpb $0x2d, (%r11)
jne 0x209042
jmp 0x209102
cmpl $0xff, %r11d
je 0x2090b0
addl $0xffffff24, %r11d      # imm = 0xFFFFFF24
cmpl $0x4, %r11d
jae 0x2090b5
jmp 0x20912c
cmpb $-0x3, (%rsi)
ja 0x20912c
addq $0x2, %rsi
jmp 0x20903f
movslq (%r10,%r11,4), %r11
addq %r10, %r11
jmpq *%r11
movq %rdx, %r11
subq %rsi, %r11
cmpq $0x2, %r11
jge 0x2090b5
jmp 0x2090fd
movq %rdx, %r11
subq %rsi, %r11
cmpq $0x4, %r11
jl 0x2090fd
addq $0x4, %rsi
jmp 0x20903f
movq %rdx, %r11
subq %rsi, %r11
cmpq $0x3, %r11
jl 0x2090fd
addq $0x3, %rsi
jmp 0x20903f
movl %r9d, %eax
jmp 0x209132
leaq 0x4(%rsi), %rdi
cmpq %rdx, %rdi
je 0x209132
cmpb $0x0, 0x5(%rsi)
jne 0x209129
leaq 0x6(%rsi), %rax
xorl %edx, %edx
cmpb $0x3e, 0x4(%rsi)
cmoveq %rax, %rdi
movl $0xd, %r8d
cmovnel %edx, %r8d
movq %rdi, %rsi
movq %rsi, (%rcx)
movl %r8d, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: utf8_toUtf8
static void PTRCALL
utf8_toUtf8(__attribute__ ((unused)) const ENCODING *enc,
            const char **fromP, const char *fromLim,
            char **toP, const char *toLim)
{
  char *to;
  const char *from;
  if (fromLim - *fromP > toLim - *toP) {
    /* Avoid copying partial characters. */
    for (fromLim = *fromP + (toLim - *toP); fromLim > *fromP; fromLim--)
      if (((unsigned char)fromLim[-1] & 0xc0) != 0x80)
        break;
  }
  for (to = *toP, from = *fromP; from != fromLim; from++, to++)
    *to = *from;
  *fromP = from;
  *toP = to;
}

// Assembly:
movq (%rsi), %rax
movq %rdx, %r9
subq %rax, %r9
movq (%rcx), %rdi
subq %rdi, %r8
cmpq %r8, %r9
jle 0x206413
addq %rax, %r8
movq %r8, %rdx
cmpq %rax, %r8
jbe 0x206413
leaq -0x1(%rdx), %r8
movb -0x1(%rdx), %r9b
andb $-0x40, %r9b
negb %r9b
jo 0x2063ec
jmp 0x206413
movb (%rax), %r8b
movb %r8b, (%rdi)
incq %rax
incq %rdi
cmpq %rdx, %rax
jne 0x206407
movq %rax, (%rsi)
movq %rdi, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok.c
// Function: utf8_toUtf16
static void PTRCALL
utf8_toUtf16(const ENCODING *enc,
             const char **fromP, const char *fromLim,
             unsigned short **toP, const unsigned short *toLim)
{
  unsigned short *to = *toP;
  const char *from = *fromP;
  while (from != fromLim && to != toLim) {
    switch (((struct normal_encoding *)enc)->type[(unsigned char)*from]) {
    case BT_LEAD2:
      *to++ = (unsigned short)(((from[0] & 0x1f) << 6) | (from[1] & 0x3f));
      from += 2;
      break;
    case BT_LEAD3:
      *to++ = (unsigned short)(((from[0] & 0xf) << 12)
                               | ((from[1] & 0x3f) << 6) | (from[2] & 0x3f));
      from += 3;
      break;
    case BT_LEAD4:
      {
        unsigned long n;
        if (to + 1 == toLim)
          goto after;
        n = ((from[0] & 0x7) << 18) | ((from[1] & 0x3f) << 12)
            | ((from[2] & 0x3f) << 6) | (from[3] & 0x3f);
        n -= 0x10000;
        to[0] = (unsigned short)((n >> 10) | 0xD800);
        to[1] = (unsigned short)((n & 0x3FF) | 0xDC00);
        to += 2;
        from += 4;
      }
      break;
    default:
      *to++ = *from++;
      break;
    }
  }
after:
  *fromP = from;
  *toP = to;
}

// Assembly:
pushq %rbx
movq (%rcx), %rax
movq (%rsi), %r9
cmpq %rdx, %r9
je 0x20652f
cmpq %r8, %rax
je 0x20652f
movzbl (%r9), %r10d
movzwl %r10w, %r10d
movzbl 0x88(%rdi,%r10), %r11d
cmpl $0x7, %r11d
je 0x2064b2
cmpl $0x6, %r11d
je 0x206481
cmpl $0x5, %r11d
jne 0x20651b
andl $0x1f, %r10d
shll $0x6, %r10d
movzbl 0x1(%r9), %r11d
andl $0x3f, %r11d
orl %r10d, %r11d
movw %r11w, (%rax)
addq $0x2, %rax
addq $0x2, %r9
jmp 0x206426
shll $0xc, %r10d
movzbl 0x1(%r9), %r11d
andl $0x3f, %r11d
shll $0x6, %r11d
orl %r10d, %r11d
movzbl 0x2(%r9), %r10d
andl $0x3f, %r10d
orl %r11d, %r10d
movw %r10w, (%rax)
addq $0x2, %rax
addq $0x3, %r9
jmp 0x206426
leaq 0x2(%rax), %r11
cmpq %r8, %r11
je 0x20652f
andl $0x7, %r10d
shll $0x12, %r10d
movzbl 0x1(%r9), %r11d
andl $0x3f, %r11d
shll $0xc, %r11d
orl %r10d, %r11d
movzbl 0x2(%r9), %r10d
andl $0x3f, %r10d
shll $0x6, %r10d
movzbl 0x3(%r9), %ebx
andl $0x3f, %ebx
addl %r10d, %r11d
addl $0xff0000, %r11d        # imm = 0xFF0000
shrl $0xa, %r11d
orl $0xd800, %r11d          # imm = 0xD800
movw %r11w, (%rax)
orl %r10d, %ebx
orl $0xdc00, %ebx           # imm = 0xDC00
movw %bx, 0x2(%rax)
addq $0x4, %rax
addq $0x4, %r9
jmp 0x206426
incq %r9
movsbl %r10b, %r10d
movw %r10w, (%rax)
addq $0x2, %rax
jmp 0x206426
movq %r9, (%rsi)
movq %rax, (%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
leal -0xd8(%rax), %r9d
cmpl $0x4, %r9d
jae 0x208088
movb (%rsi), %al
cmpb (%rdx), %al
jne 0x2080fe
incq %rsi
incq %rdx
movb (%rsi), %al
cmpb (%rdx), %al
jne 0x2080fe
incq %rsi
incq %rdx
movb (%rsi), %r8b
xorl %eax, %eax
cmpb (%rdx), %r8b
jne 0x208100
movb 0x1(%rsi), %r8b
cmpb 0x1(%rdx), %r8b
je 0x2080cb
jmp 0x208100
testl %eax, %eax
je 0x2080a6
cmpl $0xff, %eax
je 0x20809f
addl $0xffffff24, %eax       # imm = 0xFFFFFF24
cmpl $0x4, %eax
jae 0x2080bb
jmp 0x2080eb
cmpb $-0x3, (%rsi)
jbe 0x2080bb
jmp 0x2080eb
movzbl (%rsi), %eax
movzbl 0x88(%rdi,%rax), %eax
cmpl $0x1d, %eax
ja 0x2080e6
btl %eax, %ecx
jae 0x2080d8
movb (%rdx), %r9b
xorl %eax, %eax
cmpb (%rsi), %r9b
jne 0x208100
cmpb %r8b, 0x1(%rdx)
jne 0x208100
addq $0x2, %rdx
addq $0x2, %rsi
jmp 0x208039
cmpl $0x6, %eax
je 0x20805e
cmpl $0x7, %eax
je 0x20804e
cmpl $0x5, %eax
je 0x20806e
movzbl 0x1(%rdx), %ecx
leal -0xdc(%rcx), %eax
cmpl $0x4, %eax
jae 0x208101
pushq $0x1
popq %rax
retq
xorl %eax, %eax
retq
xorl %eax, %eax
testl %ecx, %ecx
je 0x208116
cmpl $0xff, %ecx
jne 0x208100
cmpb $-0x3, (%rdx)
ja 0x2080fa
jmp 0x208100
movzbl (%rdx), %ecx
movzbl 0x88(%rdi,%rcx), %ecx
cmpl $0x1d, %ecx
ja 0x2080fa
movl $0x2f4000e0, %edx       # imm = 0x2F4000E0
btl %ecx, %edx
jb 0x208100
jmp 0x2080fa
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rsi, %rax
movl $0x200600, %ecx         # imm = 0x200600
cmpb $0x0, 0x1(%rax)
jne 0x208210
movzbl (%rax), %edx
movzbl 0x88(%rdi,%rdx), %edx
cmpl $0x15, %edx
ja 0x208210
btl %edx, %ecx
jae 0x208210
addq $0x2, %rax
jmp 0x2081ef
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/expat-2.0.1/lib/xmltok_impl.c
// Function: little2_checkPiTarget
static int PTRCALL
PREFIX(checkPiTarget)(__attribute__ ((unused)) const ENCODING *enc, const char *ptr,
                      const char *end, int *tokPtr)
{
  int upper = 0;
  *tokPtr = XML_TOK_PI;
  if (end - ptr != MINBPC(enc)*3)
    return 1;
  switch (BYTE_TO_ASCII(enc, ptr)) {
  case ASCII_x:
    break;
  case ASCII_X:
    upper = 1;
    break;
  default:
    return 1;
  }
  ptr += MINBPC(enc);
  switch (BYTE_TO_ASCII(enc, ptr)) {
  case ASCII_m:
    break;
  case ASCII_M:
    upper = 1;
    break;
  default:
    return 1;
  }
  ptr += MINBPC(enc);
  switch (BYTE_TO_ASCII(enc, ptr)) {
  case ASCII_l:
    break;
  case ASCII_L:
    upper = 1;
    break;
  default:
    return 1;
  }
  if (upper)
    return 0;
  *tokPtr = XML_TOK_XML_DECL;
  return 1;
}

// Assembly:
movl $0xb, (%rdx)
subq %rdi, %rsi
pushq $0x1
popq %rcx
cmpq $0x6, %rsi
jne 0x20914c
cmpb $0x0, 0x1(%rdi)
je 0x20914f
movl %ecx, %eax
retq
movzbl (%rdi), %eax
cmpl $0x78, %eax
je 0x209161
cmpl $0x58, %eax
jne 0x20914c
pushq $0x1
popq %rsi
jmp 0x209163
xorl %esi, %esi
cmpb $0x0, 0x3(%rdi)
jne 0x20914c
movzbl 0x2(%rdi), %eax
cmpl $0x6d, %eax
je 0x20917a
cmpl $0x4d, %eax
jne 0x20914c
pushq $0x1
popq %rsi
cmpb $0x0, 0x5(%rdi)
jne 0x20914c
movzbl 0x4(%rdi), %edi
cmpl $0x6c, %edi
je 0x209193
movl %ecx, %eax
cmpl $0x4c, %edi
jne 0x20914e
xorl %eax, %eax
retq
xorl %eax, %eax
testl %esi, %esi
jne 0x20914e
movl $0xc, (%rdx)
jmp 0x20914c
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_status
SQLITE_API int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){
  sqlite3_int64 iCur = 0, iHwtr = 0;
  int rc;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pCurrent==0 || pHighwater==0 ) return SQLITE_MISUSE_BKPT;
#endif
  rc = sqlite3_status64(op, &iCur, &iHwtr, resetFlag);
  if( rc==0 ){
    *pCurrent = (int)iCur;
    *pHighwater = (int)iHwtr;
  }
  return rc;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
callq 0x21ec0c
testl %eax, %eax
jne 0x21ec82
movl 0x10(%rsp), %ecx
movl %ecx, (%r14)
movl 0x8(%rsp), %ecx
movl %ecx, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x190(%rdi), %rdi
callq 0x22d0ed
movl %eax, %r12d
movq 0x198(%rbx), %rdi
callq 0x22d0ed
movl %eax, %ebp
movq 0x1a0(%rbx), %rdi
callq 0x22d0ed
movl %eax, %r15d
addl %r12d, %r15d
movq 0x1a8(%rbx), %rdi
callq 0x22d0ed
testq %r14, %r14
je 0x21f0c8
movl 0x17c(%rbx), %ecx
subl %r15d, %ecx
movl %ecx, (%r14)
movl 0x17c(%rbx), %ecx
addl %ebp, %r15d
addl %eax, %r15d
subl %r15d, %ecx
movl %ecx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x238689
movq 0x118(%r14), %r15
testq %r15, %r15
je 0x21f1f6
movq 0x28(%r15), %r12
movq (%r15), %rsi
movl 0x8(%r15), %edx
movq %rbx, %rdi
callq 0x238710
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22d0fc
movq %r12, %r15
jmp 0x21f1ce
cmpl $0x16bceaa5, 0x24(%r14) # imm = 0x16BCEAA5
je 0x21f22f
movq 0x80(%r14), %rdi
movswl 0x20(%r14), %esi
callq 0x238689
movq 0xb0(%r14), %rsi
movq %rbx, %rdi
callq 0x21f26b
movq 0xf8(%r14), %rsi
movq %rbx, %rdi
callq 0x21f26b
movq 0x88(%r14), %rsi
movl 0x90(%r14), %edx
movq %rbx, %rdi
callq 0x238710
movq 0x98(%r14), %rsi
movq %rbx, %rdi
callq 0x21f26b
movq 0xf0(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21f26b
// File: /workspace/github_c_makefile_star2_O2/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 0x21f2bc
testl %eax, %eax
je 0x21f292
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x21e8af(%rip), %rbx    # 0x43db48
movq (%rbx), %rbx
testq %r14, %r14
je 0x21f287
testq %rbx, %rbx
je 0x21f287
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x179e0
testl %eax, %eax
je 0x21f287
addq $0x10, %rbx
jmp 0x21f299
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
callq 0x21f2bc
movl %eax, %ebp
testl %eax, %eax
jne 0x21f579
movq %rbx, %rdi
callq 0x21f580
testl %r14d, %r14d
setne %cl
movq 0x21e5f4(%rip), %rax    # 0x43db48
testq %rax, %rax
sete %dl
orb %cl, %dl
je 0x21f567
leaq 0x21e5e3(%rip), %rcx    # 0x43db48
jmp 0x21f572
movq %rax, %rcx
addq $0x10, %rcx
movq 0x10(%rax), %rax
movq %rax, 0x10(%rbx)
movq %rbx, (%rcx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: vfsUnlink
static void vfsUnlink(sqlite3_vfs *pVfs){
  assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN)) );
  if( pVfs==0 ){
    /* No-op */
  }else if( vfsList==pVfs ){
    vfsList = pVfs->pNext;
  }else if( vfsList ){
    sqlite3_vfs *p = vfsList;
    while( p->pNext && p->pNext!=pVfs ){
      p = p->pNext;
    }
    if( p->pNext==pVfs ){
      p->pNext = pVfs->pNext;
    }
  }
}

// Assembly:
testq %rdi, %rdi
je 0x21f5ac
movq 0x21e5bc(%rip), %rcx    # 0x43db48
cmpq %rdi, %rcx
je 0x21f5ad
testq %rcx, %rcx
je 0x21f5ac
movq %rcx, %rax
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x21f5a7
cmpq %rdi, %rcx
jne 0x21f596
cmpq %rdi, %rcx
je 0x21f5b6
retq
leaq 0x21e594(%rip), %rax    # 0x43db48
jmp 0x21f5ba
addq $0x10, %rax
movq 0x10(%rdi), %rcx
movq %rcx, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x21f2bc
movl %eax, %ebx
testl %eax, %eax
jne 0x21f5dc
movq %r14, %rdi
callq 0x21f580
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x21f2bc
testl %eax, %eax
je 0x21f5fe
pushq $-0x1
popq %rax
jmp 0x21f64b
movq 0x21e553(%rip), %rax    # 0x43db58
testq %rbx, %rbx
js 0x21f64b
movq 0x21e54f(%rip), %rcx    # 0x43db60
cmpq %rbx, %rcx
movq %rbx, %rdx
cmovlq %rcx, %rdx
testq %rbx, %rbx
cmoveq %rcx, %rdx
testq %rcx, %rcx
cmovleq %rbx, %rdx
movq %rdx, 0x21e528(%rip)    # 0x43db58
testq %rdx, %rdx
setg %cl
cmpq 0x21e46b(%rip), %rdx    # 0x43daa8
setle %dl
andb %cl, %dl
movzbl %dl, %ecx
movl %ecx, 0x21e51d(%rip)    # 0x43db68
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x21f2bc
testl %eax, %eax
je 0x21f673
pushq $-0x1
popq %rax
popq %rbx
retq
movq 0x21e4e6(%rip), %rax    # 0x43db60
testq %rbx, %rbx
js 0x21f671
movq %rbx, 0x21e4da(%rip)    # 0x43db60
movq 0x21e4cb(%rip), %rcx    # 0x43db58
cmpq %rbx, %rcx
setle %dl
testq %rcx, %rcx
setne %cl
testb %cl, %dl
jne 0x21f671
movq %rbx, 0x21e4b4(%rip)    # 0x43db58
jmp 0x21f671
// File: /workspace/github_c_makefile_star2_O2/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 0x21f6f6
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
movq %rdi, %rbx
cmpl $0x0, 0x21af10(%rip)    # 0x43a610
je 0x21f744
movl %ebx, %edi
callq *0x21af46(%rip)         # 0x43a650
cmpq %rbx, 0x21e40f(%rip)    # 0x43db20
jge 0x21f71a
movq %rbx, 0x21e406(%rip)    # 0x43db20
movq 0x21e437(%rip), %rsi    # 0x43db58
testq %rsi, %rsi
jle 0x21f777
movq 0x21e37b(%rip), %rcx    # 0x43daa8
movslq %eax, %rdx
subq %rdx, %rsi
cmpq %rsi, %rcx
jge 0x21f74d
movl $0x0, 0x21e426(%rip)    # 0x43db68
jmp 0x21f777
movl %ebx, %edi
popq %rbx
jmpq *0x21aee3(%rip)         # 0x43a630
movl $0x1, 0x21e411(%rip)    # 0x43db68
movq 0x21e402(%rip), %rsi    # 0x43db60
testq %rsi, %rsi
sete %dil
subq %rdx, %rsi
cmpq %rsi, %rcx
setl %cl
orb %dil, %cl
je 0x21f6ef
movl %eax, %edi
callq *0x21aeb1(%rip)         # 0x43a630
testq %rax, %rax
je 0x21f6ef
movq %rax, %rbx
movq %rax, %rdi
callq *0x21aeb4(%rip)         # 0x43a648
cltq
addq 0x21e30b(%rip), %rax    # 0x43daa8
movq %rax, 0x21e304(%rip)    # 0x43daa8
cmpq 0x21e34d(%rip), %rax    # 0x43daf8
jle 0x21f7b4
movq %rax, 0x21e344(%rip)    # 0x43daf8
movq 0x21e335(%rip), %rcx    # 0x43daf0
leaq 0x1(%rcx), %rax
movq %rax, 0x21e32a(%rip)    # 0x43daf0
cmpq 0x21e373(%rip), %rcx    # 0x43db40
jl 0x21f6f1
movq %rax, 0x21e366(%rip)    # 0x43db40
jmp 0x21f6f1
// File: /workspace/github_c_makefile_star2_O2/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 0x21f82e
movq %rdi, %rbx
cmpl $0x0, 0x21ae07(%rip)    # 0x43a610
je 0x21f824
movq %rbx, %rdi
callq *0x21ae34(%rip)         # 0x43a648
cltq
subq %rax, 0x21e28b(%rip)    # 0x43daa8
decq 0x21e2cc(%rip)          # 0x43daf0
movq %rbx, %rdi
popq %rbx
jmpq *0x21ae0a(%rip)         # 0x43a638
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x21f2bc
testl %eax, %eax
je 0x21f84a
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 0x21f85c
// File: /workspace/github_c_makefile_star2_O2/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 0x21f8f6
movq %rdi, %rbx
testq %r14, %r14
je 0x21f902
cmpq $0x7ffffeff, %r14       # imm = 0x7FFFFEFF
ja 0x21f90a
movq %rbx, %rdi
callq *0x21adba(%rip)         # 0x43a648
movl %eax, %ebp
movl %r14d, %edi
callq *0x21adb7(%rip)         # 0x43a650
cmpl %eax, %ebp
je 0x21f90c
cmpl $0x0, 0x21ad6c(%rip)    # 0x43a610
je 0x21f914
cmpq %r14, 0x21e273(%rip)    # 0x43db20
jge 0x21f8b6
movq %r14, 0x21e26a(%rip)    # 0x43db20
movq %rbx, %rdi
movl %eax, %esi
callq *0x21ad7f(%rip)         # 0x43a640
testq %rax, %rax
je 0x21f90a
movq %rax, %rbx
movq %rax, %rdi
callq *0x21ad76(%rip)         # 0x43a648
subl %ebp, %eax
cltq
addq 0x21e1cb(%rip), %rax    # 0x43daa8
movq %rax, 0x21e1c4(%rip)    # 0x43daa8
cmpq 0x21e20d(%rip), %rax    # 0x43daf8
jle 0x21f90c
movq %rax, 0x21e204(%rip)    # 0x43daf8
jmp 0x21f90c
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x21f6df
movq %rbx, %rdi
callq 0x21f7f9
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x21ad25(%rip), %rcx    # 0x43a640
movq %rbx, %rdi
movl %eax, %esi
popq %rbx
popq %r14
popq %rbp
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O2/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 0x220f74
testl %edx, %edx
je 0x220f79
movl %ecx, 0x18(%rdi)
addq 0x8(%rdi), %rax
movslq %edx, %rdx
movq %rax, %rdi
jmp 0x17630
jmp 0x22117c
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x220fa1
xorl %eax, %eax
retq
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %eax
cmpq %rsi, %rax
jge 0x220fb7
movl 0x14(%rbx), %ecx
movb $0x12, %al
cmpq %rsi, %rcx
jb 0x220fc6
movq (%rbx), %rdi
callq 0x22809f
testq %rax, %rax
jne 0x220fd3
movb $0x7, %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0x22d166
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
cmpb $0x0, 0x1c(%rdi)
je 0x2210a2
retq
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x14(%rdi), %eax
testq %rax, %rax
je 0x2210bd
movl %esi, %ebp
testb $0x4, 0x1d(%rbx)
jne 0x2210d5
xorl %esi, %esi
jmp 0x2210d9
pushq $0x12
popq %rsi
movq %rbx, %rdi
callq 0x22d166
movl 0x18(%rbx), %eax
notl %eax
addl 0x10(%rbx), %eax
jmp 0x221177
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 0x221107
movq %rbx, %rdi
callq 0x22125c
pushq $0x12
jmp 0x22116c
movl %ecx, 0x10(%rbx)
movq (%rbx), %rdi
movl %ecx, %edx
testq %rdi, %rdi
je 0x22111b
callq 0x22d1b5
jmp 0x221126
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x21f85c
movq %rax, %r14
testq %rax, %rax
je 0x221162
testb $0x4, 0x1d(%rbx)
jne 0x221148
movl 0x18(%rbx), %edx
testq %rdx, %rdx
je 0x221148
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x17630
movq %r14, 0x8(%rbx)
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x22103d
movl %eax, 0x10(%rbx)
orb $0x4, 0x1d(%rbx)
movl %ebp, %eax
jmp 0x221177
movq %rbx, %rdi
callq 0x22125c
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x22d166
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x221099
testl %eax, %eax
jle 0x2211a7
movl %eax, %ebp
movl 0x18(%rbx), %edi
addq 0x8(%rbx), %rdi
movl %eax, %edx
movq %r14, %rsi
callq 0x17630
addl %ebp, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2195df(%rip), %rcx    # 0x43a7b0
cmpq %rcx, %rdi
sete %cl
orb %al, %cl
jne 0x2211fd
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x221200
movq %rax, %r14
movq %rbx, %rdi
callq 0x21f7f9
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x221220
movl 0x18(%rdi), %ecx
movb $0x0, (%rax,%rcx)
cmpl $0x0, 0x14(%rdi)
je 0x221220
testb $0x4, 0x1d(%rdi)
je 0x22d364
movq 0x8(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x221276
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x21f26b
andb $-0x5, 0x1d(%rbx)
andl $0x0, 0x10(%rbx)
andl $0x0, 0x18(%rbx)
andq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x21f7df
testq %rax, %rax
je 0x2212a0
testq %rbx, %rbx
je 0x2212a9
movl 0x7c(%rbx), %ecx
jmp 0x2212ae
leaq 0x219509(%rip), %rax    # 0x43a7b0
jmp 0x2212c4
movl $0x3b9aca00, %ecx       # imm = 0x3B9ACA00
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andl $0x0, 0x10(%rax)
movl %ecx, 0x14(%rax)
andl $0x0, 0x18(%rax)
andw $0x0, 0x1c(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x21f2bc
testl %eax, %eax
je 0x2212e2
xorl %eax, %eax
jmp 0x221321
leaq 0x20(%rsp), %rax
movq %rsp, %r15
movq %rax, 0x8(%r15)
andq $0x0, (%r15)
movabsq $0x3b9aca0000000046, %rax # imm = 0x3B9ACA0000000046
movq %rax, 0x10(%r15)
andl $0x0, 0x18(%r15)
andw $0x0, 0x1c(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x21f955
movq %r15, %rdi
callq 0x221200
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x22140d
leaq 0x8(%rsp), %r14
movq %rbx, 0x8(%r14)
andq $0x0, (%r14)
movl %edi, 0x10(%r14)
andq $0x0, 0x14(%r14)
andw $0x0, 0x1c(%r14)
movq %r14, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x21f955
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_O2/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 0x2217e8
testq %rsi, %rsi
je 0x2217f0
xorl %eax, %eax
leaq 0x14ff30(%rip), %rcx    # 0x3716f0
xorl %r8d, %r8d
testl %edx, %edx
jle 0x2217ef
movzbl (%rdi,%r8), %r9d
testq %r9, %r9
je 0x2217f4
movzbl (%r9,%rcx), %r9d
movzbl (%rsi,%r8), %r10d
cmpb (%r10,%rcx), %r9b
jne 0x2217f7
incq %r8
decl %edx
jmp 0x2217c3
xorl %eax, %eax
negq %rsi
sbbl %eax, %eax
retq
pushq $0x1
popq %rax
retq
xorl %r9d, %r9d
movzbl (%rsi,%r8), %eax
movzbl (%rax,%rcx), %eax
subl %eax, %r9d
movl %r9d, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14d
movq %rsi, %rbx
movq %rsi, %rdi
callq *0x218ccd(%rip)         # 0x43ac08
cmpl $-0x1, %eax
je 0x221f8d
xorl %ebp, %ebp
testb $0x1, %r14b
je 0x221fce
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq *0x218cc6(%rip)         # 0x43ac20
xorl %ebp, %ebp
testl %eax, %eax
jne 0x221fce
movl 0xc(%rsp), %edi
callq 0x17690
testl %eax, %eax
je 0x221fbc
leaq 0x154095(%rip), %rsi    # 0x376009
movl $0x50a, %ebp            # imm = 0x50A
movl $0x50a, %edi            # imm = 0x50A
movq %rbx, %rdx
movl $0x9b7c, %ecx           # imm = 0x9B7C
callq 0x22e701
jmp 0x221fbe
callq 0x17060
movl $0x170a, %ebp           # imm = 0x170A
cmpl $0x2, (%rax)
je 0x221fce
leaq 0x153fa1(%rip), %rsi    # 0x375f44
movl $0xa0a, %ebp            # imm = 0xA0A
movl $0xa0a, %edi            # imm = 0xA0A
movq %rbx, %rdx
movl $0x9b72, %ecx           # imm = 0x9B72
callq 0x22e701
jmp 0x221fce
xorl %ebp, %ebp
movl 0xc(%rsp), %esi
xorl %edi, %edi
movl $0x9b7e, %edx           # imm = 0x9B7E
callq 0x22e7d6
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x221ffd
pushq $0x6
popq %rsi
callq *0x218ac4(%rip)         # 0x43aab8
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
jmp 0x22202b
movq %rsp, %rsi
callq *0x218ae2(%rip)         # 0x43aae8
xorl %ecx, %ecx
testl %eax, %eax
jne 0x22202b
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_O2/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 0x17380
callq 0x17a90
movl %eax, 0x21b9c9(%rip)    # 0x43dd58
leaq 0x153cc0(%rip), %rdi    # 0x376056
xorl %esi, %esi
xorl %edx, %edx
callq 0x22e62a
testl %eax, %eax
js 0x2223d1
movl %eax, %ebp
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq *0x218795(%rip)         # 0x43ab48
testl %eax, %eax
jns 0x2223c1
callq 0x17060
cmpl $0x4, (%rax)
je 0x2223a5
xorl %edi, %edi
movl %ebp, %esi
movl $0x9c84, %edx           # imm = 0x9C84
callq 0x22e7d6
jmp 0x2223ef
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x17710
movq (%rbx), %rax
movq %rax, (%r14)
movl 0x21b970(%rip), %eax    # 0x43dd58
movl %eax, 0x8(%r14)
pushq $0xc
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x222750
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)
callq 0x22ef6f
testq %r14, %r14
je 0x2227d0
cmpq $0x0, 0x160(%rbx)
jne 0x22277b
movq %rbx, %rdi
callq 0x22998f
movq %rax, 0x160(%rbx)
testq %rax, %rax
je 0x2227c4
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 0x22efaa
movq 0x160(%rbx), %rdi
leaq 0x23f8(%rip), %rcx      # 0x224bb1
pushq $0x1
popq %rdx
movq %rax, %rsi
callq 0x2299ac
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movl %ebp, %esi
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x222800
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3MallocZero
SQLITE_PRIVATE void *sqlite3MallocZero(u64 n){
  void *p = sqlite3Malloc(n);
  if( p ){
    memset(p, 0, (size_t)n);
  }
  return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x21f6df
testq %rax, %rax
je 0x2227fe
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x17380
popq %rbx
retq