LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3BtreeSetPageSize
SQLITE_PRIVATE int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve, int iFix){
  int rc = SQLITE_OK;
  int x;
  BtShared *pBt = p->pBt;
  assert( nReserve>=0 && nReserve<=255 );
  sqlite3BtreeEnter(p);
  pBt->nReserveWanted = nReserve;
  x = pBt->pageSize - pBt->usableSize;
  if( nReserve<x ) nReserve = x;
  if( pBt->btsFlags & BTS_PAGESIZE_FIXED ){
    sqlite3BtreeLeave(p);
    return SQLITE_READONLY;
  }
  assert( nReserve>=0 && nReserve<=255 );
  if( pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE &&
        ((pageSize-1)&pageSize)==0 ){
    assert( (pageSize & 7)==0 );
    assert( !pBt->pCursor );
    pBt->pageSize = (u32)pageSize;
    freeTempSpace(pBt);
  }
  rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize, nReserve);
  pBt->usableSize = pBt->pageSize - (u16)nReserve;
  if( iFix ) pBt->btsFlags |= BTS_PAGESIZE_FIXED;
  sqlite3BtreeLeave(p);
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, 0x8(%rsi)
movb %cl, 0x26(%rsi)
movl 0x34(%rsi), %r14d
subl 0x38(%rsi), %r14d
cmpl %ecx, %r14d
cmovlel %ecx, %r14d
movl $0x8, %eax
testb $0x2, 0x28(%rsi)
jne 0x2817dc
movq %rsi, %rbx
movl %r8d, %ebp
leaq 0x34(%rsi), %r15
leal -0x200(%rdx), %eax
cmpl $0xfe00, %eax           # imm = 0xFE00
ja 0x2817ba
leal 0x1ffff(%rdx), %eax
testl %edx, %eax
jne 0x2817ba
movl %edx, 0x34(%rbx)
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x2817ba
addq $-0x4, %rdi
movq %rdi, 0x88(%rbx)
callq 0x288d1d
movq $0x0, 0x88(%rbx)
movq (%rbx), %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x285a0f
movl 0x34(%rbx), %ecx
movzwl %r14w, %edx
subl %edx, %ecx
movl %ecx, 0x38(%rbx)
testl %ebp, %ebp
je 0x2817dc
orb $0x2, 0x28(%rbx)
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: sqlite3_create_filename
SQLITE_API char *sqlite3_create_filename(
  const char *zDatabase,
  const char *zJournal,
  const char *zWal,
  int nParam,
  const char **azParam
){
  sqlite3_int64 nByte;
  int i;
  char *pResult, *p;
  nByte = strlen(zDatabase) + strlen(zJournal) + strlen(zWal) + 10;
  for(i=0; i<nParam*2; i++){
    nByte += strlen(azParam[i])+1;
  }
  pResult = p = sqlite3_malloc64( nByte );
  if( p==0 ) return 0;
  memset(p, 0, 4);
  p += 4;
  p = appendText(p, zDatabase);
  for(i=0; i<nParam*2; i++){
    p = appendText(p, azParam[i]);
  }
  *(p++) = 0;
  p = appendText(p, zJournal);
  p = appendText(p, zWal);
  *(p++) = 0;
  *(p++) = 0;
  assert( (sqlite3_int64)(p - pResult)==nByte );
  return pResult + 4;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movl %ecx, %r13d
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
callq 0x172f0
movq %rax, %rbx
movq %r14, 0x18(%rsp)
movq %r14, %rdi
callq 0x172f0
movq %rax, %r14
movq %r12, 0x20(%rsp)
movq %r12, %rdi
callq 0x172f0
addq %rbx, %r14
leaq (%rax,%r14), %r12
addq $0xa, %r12
leal (,%r13,2), %r14d
testl %r13d, %r13d
jle 0x28212b
cmpl $0x2, %r14d
movl $0x1, %ebx
cmovgel %r14d, %ebx
xorl %ebp, %ebp
movq (%r15,%rbp,8), %rdi
callq 0x172f0
addq %rax, %r12
incq %r12
incq %rbp
cmpq %rbp, %rbx
jne 0x282114
callq 0x2725a7
testl %eax, %eax
je 0x28213b
xorl %ebp, %ebp
jmp 0x28223a
movq %r12, %rdi
callq 0x272ae6
testq %rax, %rax
je 0x282134
movq %rax, %rbx
movl $0x0, (%rax)
leaq 0x4(%rax), %rbp
movq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x172f0
movq %rax, 0x10(%rsp)
leaq 0x1(%rax), %rdx
movq %rbp, %rdi
movq %r12, %rsi
callq 0x17660
testl %r13d, %r13d
jle 0x2821d6
movq %rbp, 0x8(%rsp)
movq 0x10(%rsp), %rax
addq %rbx, %rax
addq $0x5, %rax
cmpl $0x2, %r14d
movl $0x1, %r12d
cmovgel %r14d, %r12d
xorl %ebp, %ebp
movq %rax, %r13
movq (%r15,%rbp,8), %r14
movq %r14, %rdi
callq 0x172f0
movq %rax, %rbx
leaq 0x1(%rax), %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0x17660
incq %rbp
leaq (%rbx,%r13), %rax
incq %rax
cmpq %rbp, %r12
jne 0x28219c
addq %rbx, %r13
movq 0x8(%rsp), %rbp
jmp 0x2821e3
movq 0x10(%rsp), %rax
leaq (%rbx,%rax), %r13
addq $0x4, %r13
leaq 0x2(%r13), %rbx
movb $0x0, 0x1(%r13)
movq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x172f0
movq %rax, %r14
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x17660
leaq (%r14,%r13), %rbx
addq $0x3, %rbx
movq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x172f0
movq %rax, %r14
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x17660
movw $0x0, 0x1(%r14,%rbx)
movq %rbp, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
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: sqlite3_uri_key
SQLITE_API const char *sqlite3_uri_key(const char *zFilename, int N){
  if( zFilename==0 || N<0 ) return 0;
  zFilename = databaseName(zFilename);
  zFilename += sqlite3Strlen30(zFilename) + 1;
  while( zFilename[0] && (N--)>0 ){
    zFilename += sqlite3Strlen30(zFilename) + 1;
    zFilename += sqlite3Strlen30(zFilename) + 1;
  }
  return zFilename[0] ? zFilename : 0;
}

// Assembly:
testq %rdi, %rdi
sete %al
testl %esi, %esi
sets %cl
orb %al, %cl
je 0x282351
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
decq %rdi
cmpb $0x0, -0x1(%r14)
jne 0x28235b
cmpb $0x0, -0x2(%r14)
jne 0x28235b
cmpb $0x0, -0x3(%r14)
jne 0x28235b
cmpb $0x0, -0x4(%r14)
jne 0x28235b
movq %r14, %rdi
callq 0x172f0
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
addq %rax, %r14
incq %r14
movb (%r14), %cl
testb %cl, %cl
sete %al
testl %ebx, %ebx
setle %dl
orb %al, %dl
jne 0x2823de
movl $0x3fffffff, %r15d      # imm = 0x3FFFFFFF
movq %r14, %rdi
callq 0x172f0
andq %r15, %rax
leaq (%r14,%rax), %r12
leaq (%r14,%rax), %rdi
incq %rdi
callq 0x172f0
andq %r15, %rax
leaq (%rax,%r12), %r14
addq $0x2, %r14
movb (%r14), %cl
testb %cl, %cl
je 0x2823de
leal -0x1(%rbx), %eax
cmpl $0x1, %ebx
movl %eax, %ebx
ja 0x2823a7
xorl %eax, %eax
testb %cl, %cl
cmovneq %r14, %rax
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_uri_int64
SQLITE_API sqlite3_int64 sqlite3_uri_int64(
  const char *zFilename,    /* Filename as passed to xOpen */
  const char *zParam,       /* URI parameter sought */
  sqlite3_int64 bDflt       /* return if parameter is missing */
){
  const char *z = sqlite3_uri_parameter(zFilename, zParam);
  sqlite3_int64 v;
  if( z && sqlite3DecOrHexToI64(z, &v)==0 ){
    bDflt = v;
  }
  return bDflt;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
callq 0x2822a3
testq %rax, %rax
je 0x28244a
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x282453
testl %eax, %eax
jne 0x28244a
movq 0x8(%rsp), %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3DecOrHexToI64
SQLITE_PRIVATE int sqlite3DecOrHexToI64(const char *z, i64 *pOut){
#ifndef SQLITE_OMIT_HEX_INTEGER
  if( z[0]=='0'
   && (z[1]=='x' || z[1]=='X')
  ){
    u64 u = 0;
    int i, k;
    for(i=2; z[i]=='0'; i++){}
    for(k=i; sqlite3Isxdigit(z[k]); k++){
      u = u*16 + sqlite3HexToInt(z[k]);
    }
    memcpy(pOut, &u, 8);
    return (z[k]==0 && k-i<=16) ? 0 : 2;
  }else
#endif /* SQLITE_OMIT_HEX_INTEGER */
  {
    return sqlite3Atoi64(z, pOut, sqlite3Strlen30(z), SQLITE_UTF8);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x30, (%rdi)
jne 0x28249a
movzbl 0x1(%r14), %eax
orl $0x20, %eax
cmpl $0x78, %eax
jne 0x28249a
movl $0x1, %eax
cmpb $0x30, 0x1(%r14,%rax)
leaq 0x1(%rax), %rax
je 0x282474
movl %eax, %ecx
movzbl (%r14,%rcx), %edi
leaq 0x14efb2(%rip), %rdx    # 0x3d1440
testb $0x8, (%rdi,%rdx)
jne 0x2824c0
xorl %esi, %esi
movl %eax, %edx
jmp 0x2824f6
movq %r14, %rdi
callq 0x172f0
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
movl $0x1, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2927e4
xorl %esi, %esi
movq %rax, %rcx
movq %rsi, %r8
shlq $0x4, %r8
leal (%rdi,%rdi), %esi
sarb $0x7, %sil
andb $0x9, %sil
addb %dil, %sil
andb $0xf, %sil
movzbl %sil, %esi
orq %r8, %rsi
movzbl 0x1(%r14,%rcx), %edi
incq %rcx
testb $0x8, (%rdi,%rdx)
jne 0x2824c5
movl %ecx, %edx
movq %rsi, (%rbx)
cmpb $0x0, (%r14,%rcx)
setne %cl
subl %eax, %edx
cmpl $0x11, %edx
setge %al
orb %cl, %al
movzbl %al, %eax
addl %eax, %eax
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_filename_journal
SQLITE_API const char *sqlite3_filename_journal(const char *zFilename){
  zFilename = databaseName(zFilename);
  zFilename += sqlite3Strlen30(zFilename) + 1;
  while( zFilename[0] ){
    zFilename += sqlite3Strlen30(zFilename) + 1;
    zFilename += sqlite3Strlen30(zFilename) + 1;
  }
  return zFilename + 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
decq %rdi
cmpb $0x0, -0x1(%rbx)
jne 0x28253c
cmpb $0x0, -0x2(%rbx)
jne 0x28253c
cmpb $0x0, -0x3(%rbx)
jne 0x28253c
cmpb $0x0, -0x4(%rbx)
jne 0x28253c
movq %rbx, %rdi
callq 0x172f0
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
cmpb $0x0, 0x1(%rbx,%rax)
je 0x2825ae
addq %rax, %rbx
incq %rbx
movl $0x3fffffff, %r14d      # imm = 0x3FFFFFFF
movq %rbx, %rdi
callq 0x172f0
andq %r14, %rax
leaq (%rbx,%rax), %r15
leaq (%rbx,%rax), %rdi
incq %rdi
callq 0x172f0
andq %r14, %rax
leaq (%rax,%r15), %rbx
addq $0x2, %rbx
cmpb $0x0, (%rbx)
jne 0x28257a
leaq (%rax,%r15), %rbx
incq %rbx
jmp 0x2825b1
addq %rax, %rbx
addq $0x2, %rbx
movq %rbx, %rax
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_filename_wal
SQLITE_API const char *sqlite3_filename_wal(const char *zFilename){
#ifdef SQLITE_OMIT_WAL
  return 0;
#else
  zFilename = sqlite3_filename_journal(zFilename);
  zFilename += sqlite3Strlen30(zFilename) + 1;
  return zFilename;
#endif
}

// Assembly:
pushq %rbx
callq 0x282537
movq %rax, %rbx
movq %rax, %rdi
callq 0x172f0
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
addq %rbx, %rax
incq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_db_filename
SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName){
  Btree *pBt;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  pBt = sqlite3DbNameToBtree(db, zDbName);
  return pBt ? sqlite3BtreeGetFilename(pBt) : 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x2825f3
movq %rbx, %rdi
callq 0x280170
testl %eax, %eax
jns 0x2825f5
jmp 0x28261f
xorl %eax, %eax
movq 0x20(%rbx), %rcx
movl %eax, %eax
shlq $0x5, %rax
movq 0x8(%rcx,%rax), %rax
testq %rax, %rax
je 0x28261f
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpb $0x0, 0x13(%rax)
je 0x282623
leaq 0x14f4be(%rip), %rax    # 0x3d1adb
jmp 0x28262a
xorl %eax, %eax
jmp 0x28262a
movq 0xd0(%rax), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_db_readonly
SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName){
  Btree *pBt;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return -1;
  }
#endif
  pBt = sqlite3DbNameToBtree(db, zDbName);
  return pBt ? sqlite3BtreeIsReadonly(pBt) : -1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x282643
movq %rbx, %rdi
callq 0x280170
testl %eax, %eax
jns 0x282645
jmp 0x282666
xorl %eax, %eax
movq 0x20(%rbx), %rcx
movl %eax, %eax
shlq $0x5, %rax
movq 0x8(%rcx,%rax), %rax
testq %rax, %rax
je 0x282666
movq 0x8(%rax), %rax
movzwl 0x28(%rax), %eax
andl $0x1, %eax
jmp 0x28266b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: sqlite3_compileoption_used
SQLITE_API int sqlite3_compileoption_used(const char *zOptName){
  int i, n;
  int nOpt;
  const char **azCompileOpt;

#if SQLITE_ENABLE_API_ARMOR
  if( zOptName==0 ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif

  azCompileOpt = sqlite3CompileOptions(&nOpt);

  if( sqlite3StrNICmp(zOptName, "SQLITE_", 7)==0 ) zOptName += 7;
  n = sqlite3Strlen30(zOptName);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2826ba
movq %rdi, %rbx
xorl %ecx, %ecx
leaq 0x14ec57(%rip), %rax    # 0x3d12e0
leaq 0x15336e(%rip), %rdx    # 0x3d59fe
movzbl (%rbx,%rcx), %esi
testq %rsi, %rsi
je 0x2826c0
movzbl (%rsi,%rax), %esi
movzbl (%rcx,%rdx), %edi
movb (%rdi,%rax), %dil
cmpb %dil, %sil
jne 0x2826ca
incq %rcx
cmpq $0x7, %rcx
jne 0x282690
movl $0x7, %eax
jmp 0x2826db
xorl %ebx, %ebx
xorl %eax, %eax
jmp 0x2826eb
movzbl (%rcx,%rdx), %ecx
movb (%rcx,%rax), %dil
xorl %esi, %esi
movzbl %dil, %eax
xorl %ecx, %ecx
cmpl %eax, %esi
movl $0x7, %eax
cmovneq %rcx, %rax
addq %rax, %rbx
movq %rbx, %rdi
callq 0x172f0
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl %eax, %r14d
xorl %r12d, %r12d
leaq 0x235bd8(%rip), %r13    # 0x4b82d0
leaq 0x14ed41(%rip), %rbp    # 0x3d1440
movq (%r12,%r13), %r15
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x275033
testl %eax, %eax
jne 0x282720
movzbl (%r15,%r14), %eax
testb $0x46, (%rax,%rbp)
je 0x28272e
addq $0x8, %r12
cmpq $0x18, %r12
jne 0x2826ff
xorl %eax, %eax
jmp 0x282733
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
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: setStrAccumError
static void setStrAccumError(StrAccum *p, u8 eError){
  assert( eError==SQLITE_NOMEM || eError==SQLITE_TOOBIG );
  p->accError = eError;
  if( p->mxAlloc ) sqlite3_str_reset(p);
  if( eError==SQLITE_TOOBIG ) sqlite3ErrorToParser(p->db, eError);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movb %bpl, 0x1c(%rdi)
cmpl $0x0, 0x14(%rdi)
je 0x2829ba
movq %rbx, %rdi
callq 0x274a57
cmpb $0x12, %bpl
jne 0x2829de
movq (%rbx), %rax
testq %rax, %rax
je 0x2829de
movq 0x130(%rax), %rax
testq %rax, %rax
je 0x2829de
movl $0x12, 0x18(%rax)
incl 0x30(%rax)
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: sqlite3DbRealloc
SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *db, void *p, u64 n){
  assert( db!=0 );
  if( p==0 ) return sqlite3DbMallocRawNN(db, n);
  assert( sqlite3_mutex_held(db->mutex) );
  if( ((uptr)p)<(uptr)db->lookaside.pEnd ){
#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
    if( ((uptr)p)>=(uptr)db->lookaside.pMiddle ){
      if( n<=LOOKASIDE_SMALL ) return p;
    }else
#endif
    if( ((uptr)p)>=(uptr)db->lookaside.pStart ){
      if( n<=db->lookaside.szTrue ) return p;
    }
  }
  return dbReallocFinish(db, p, n);
}

// Assembly:
testq %rsi, %rsi
je 0x282a21
cmpq %rsi, 0x1c0(%rdi)
jbe 0x282adb
cmpq %rsi, 0x1b0(%rdi)
jbe 0x282a26
cmpq %rsi, 0x1b8(%rdi)
ja 0x282adb
movzwl 0x176(%rdi), %eax
cmpq %rdx, %rax
jb 0x282adb
movq %rsi, %rax
retq
movq %rdx, %rsi
jmp 0x282a35
cmpq $0x81, %rdx
jae 0x282adb
jmp 0x282a1d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: dbReallocFinish
static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n){
  void *pNew = 0;
  assert( db!=0 );
  assert( p!=0 );
  if( db->mallocFailed==0 ){
    if( isLookaside(db, p) ){
      pNew = sqlite3DbMallocRawNN(db, n);
      if( pNew ){
        memcpy(pNew, p, lookasideMallocSize(db, p));
        sqlite3DbFree(db, p);
      }
    }else{
      assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
      assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
      sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
      pNew = sqlite3Realloc(p, n);
      if( !pNew ){
        sqlite3OomFault(db);
      }
      sqlite3MemdebugSetType(pNew,
            (db->lookaside.bDisable==0 ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
    }
  }
  return pNew;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpb $0x0, 0x61(%rdi)
je 0x282af2
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rsi, 0x1b8(%rdi)
ja 0x282b4f
cmpq %r15, 0x1c0(%rbx)
jbe 0x282b4f
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x282a35
testq %rax, %rax
je 0x282ae6
movq %rax, %r14
movl $0x80, %edx
cmpq %r15, 0x1b0(%rbx)
jbe 0x282b32
movzwl 0x176(%rbx), %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x17660
testq %r15, %r15
je 0x282ae9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x282904
jmp 0x282ae9
movq %r15, %rdi
movq %rdx, %rsi
callq 0x272c63
movq %rax, %r14
testq %rax, %rax
jne 0x282ae9
movq %rbx, %rdi
callq 0x278b1c
jmp 0x282ae6
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: dbMallocRawFinish
static SQLITE_NOINLINE void *dbMallocRawFinish(sqlite3 *db, u64 n){
  void *p;
  assert( db!=0 );
  p = sqlite3Malloc(n);
  if( !p ) sqlite3OomFault(db);
  sqlite3MemdebugSetType(p,
         (db->lookaside.bDisable==0) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP);
  return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x272ae6
movq %rax, %r14
testq %rax, %rax
jne 0x282b8e
movq %rbx, %rdi
callq 0x278b1c
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: strAccumFinishRealloc
static SQLITE_NOINLINE char *strAccumFinishRealloc(StrAccum *p){
  char *zText;
  assert( p->mxAlloc>0 && !isMalloced(p) );
  zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
  if( zText ){
    memcpy(zText, p->zText, p->nChar+1);
    p->printfFlags |= SQLITE_PRINTF_MALLOCED;
  }else{
    setStrAccumError(p, SQLITE_NOMEM);
  }
  p->zText = zText;
  return zText;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x18(%rbx), %esi
incl %esi
testq %rdi, %rdi
je 0x282bb4
callq 0x282a35
jmp 0x282bbc
movq %rsi, %rdi
callq 0x272ae6
movq %rax, %r14
testq %rax, %rax
je 0x282bdb
movq 0x8(%rbx), %rsi
movl 0x18(%rbx), %edx
incl %edx
movq %r14, %rdi
callq 0x17660
orb $0x4, 0x1d(%rbx)
jmp 0x282bed
movb $0x7, 0x1c(%rbx)
cmpl $0x0, 0x14(%rbx)
je 0x282bed
movq %rbx, %rdi
callq 0x274a57
movq %r14, 0x8(%rbx)
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: unixClose
static int unixClose(sqlite3_file *id){
  int rc = SQLITE_OK;
  unixFile *pFile = (unixFile *)id;
  unixInodeInfo *pInode = pFile->pInode;

  assert( pInode!=0 );
  verifyDbFile(pFile);
  unixUnlock(id, NO_LOCK);
  assert( unixFileMutexNotheld(pFile) );
  unixEnterMutex();

  /* unixFile.pInode is always valid here. Otherwise, a different close
  ** routine (e.g. nolockClose()) would be called instead.
  */
  assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
  sqlite3_mutex_enter(pInode->pLockMutex);
  if( pInode->nLock ){
    /* If there are outstanding locks, do not actually close the file just
    ** yet because that would clear those locks.  Instead, add the file
    ** descriptor to pInode->pUnused list.  It will be automatically closed
    ** when the last lock is cleared.
    */
    setPendingFd(pFile);
  }
  sqlite3_mutex_leave(pInode->pLockMutex);
  releaseInodeInfo(pFile);
  rc = closeUnixFile(id);
  unixLeaveMutex();
  return rc;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
callq 0x283ffc
movq %rbx, %rdi
xorl %esi, %esi
callq 0x283287
cmpl $0x0, 0x1c(%r14)
movq 0x10(%rbx), %r14
je 0x282c4a
movq 0x30(%rbx), %rax
movq 0x28(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x28(%r14)
movl $0xffffffff, 0x18(%rbx) # imm = 0xFFFFFFFF
movq $0x0, 0x30(%rbx)
jmp 0x282c4f
testq %r14, %r14
je 0x282cae
decl 0x30(%r14)
jne 0x282cae
movq %rbx, %rdi
callq 0x28433b
movq 0x40(%r14), %rax
movq 0x48(%r14), %rcx
leaq 0x40(%rcx), %rdx
testq %rcx, %rcx
leaq 0x23c12d(%rip), %rsi    # 0x4beda0
cmovneq %rdx, %rsi
movq %rax, (%rsi)
testq %rax, %rax
je 0x282c83
movq %rcx, 0x48(%rax)
cmpl $0x0, 0x2389d6(%rip)    # 0x4bb660
je 0x282ca5
movq %r14, %rdi
callq *0x238a03(%rip)         # 0x4bb698
cltq
subq %rax, 0x23be5a(%rip)    # 0x4beaf8
decq 0x23be9b(%rip)          # 0x4beb40
movq %r14, %rdi
callq *0x2389da(%rip)         # 0x4bb688
movq %rbx, %rdi
callq 0x2840a3
xorl %eax, %eax
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: unixFileSize
static int unixFileSize(sqlite3_file *id, i64 *pSize){
  int rc;
  struct stat buf;
  assert( id );
  rc = osFstat(((unixFile*)id)->h, &buf);
  SimulateIOError( rc=1 );
  if( rc!=0 ){
    storeLastErrno((unixFile*)id, errno);
    return SQLITE_IOERR_FSTAT;
  }
  *pSize = buf.st_size;

  /* When opening a zero-size database, the findInodeInfo() procedure
  ** writes a single byte into that file in order to work around a bug
  ** in the OS-X msdos filesystem.  In order to avoid problems with upper
  ** layers, we need to report this file size as zero even though it is
  ** really 1.   Ticket #3260.
  */
  if( *pSize==1 ) *pSize = 0;


  return SQLITE_OK;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x18(%rdi), %edi
leaq 0x8(%rsp), %rsi
callq *0x238b5c(%rip)         # 0x4bbb50
testl %eax, %eax
je 0x28300a
callq 0x17060
movl (%rax), %eax
movl %eax, 0x20(%r14)
movl $0x70a, %eax            # imm = 0x70A
jmp 0x283021
movq 0x38(%rsp), %rcx
xorl %eax, %eax
cmpq $0x1, %rcx
movl $0x0, %edx
cmovneq %rcx, %rdx
movq %rdx, (%rbx)
addq $0x98, %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: unixCheckReservedLock
static int unixCheckReservedLock(sqlite3_file *id, int *pResOut){
  int rc = SQLITE_OK;
  int reserved = 0;
  unixFile *pFile = (unixFile*)id;

  SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );

  assert( pFile );
  assert( pFile->eFileLock<=SHARED_LOCK );
  sqlite3_mutex_enter(pFile->pInode->pLockMutex);

  /* Check if a thread in this process holds such a lock */
  if( pFile->pInode->eFileLock>SHARED_LOCK ){
    reserved = 1;
  }

  /* Otherwise see if some other process holds it.
  */
#ifndef __DJGPP__
  if( !reserved && !pFile->pInode->bProcessLock ){
    struct flock lock;
    lock.l_whence = SEEK_SET;
    lock.l_start = RESERVED_BYTE;
    lock.l_len = 1;
    lock.l_type = F_WRLCK;
    if( osFcntl(pFile->h, F_GETLK, &lock) ){
      rc = SQLITE_IOERR_CHECKRESERVEDLOCK;
      storeLastErrno(pFile, errno);
    } else if( lock.l_type!=F_UNLCK ){
      reserved = 1;
    }
  }
#endif

  sqlite3_mutex_leave(pFile->pInode->pLockMutex);
  OSTRACE(("TEST WR-LOCK %d %d %d (unix)\n", pFile->h, rc, reserved));

  *pResOut = reserved;
  return rc;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq 0x10(%rdi), %rax
cmpb $0x1, 0x20(%rax)
ja 0x28341c
xorl %ebp, %ebp
cmpb $0x0, 0x21(%rax)
movl $0x0, %eax
jne 0x283423
movq %rdi, %r14
movslq 0x2386e4(%rip), %rax    # 0x4bbac0
incq %rax
movq %rsp, %rdx
movq %rax, 0x8(%rdx)
movq $0x1, 0x10(%rdx)
movl $0x1, (%rdx)
movl 0x18(%rdi), %edi
xorl %ebp, %ebp
movl $0x5, %esi
xorl %eax, %eax
callq *0x23877a(%rip)         # 0x4bbb80
testl %eax, %eax
je 0x28342e
callq 0x17060
movl (%rax), %eax
movl %eax, 0x20(%r14)
movl $0xe0a, %eax            # imm = 0xE0A
jmp 0x283423
xorl %eax, %eax
movl $0x1, %ebp
movl %ebp, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebp, %ebp
cmpw $0x2, (%rsp)
setne %bpl
xorl %eax, %eax
jmp 0x283423
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: verifyDbFile
static void verifyDbFile(unixFile *pFile){
  struct stat buf;
  int rc;

  /* These verifications occurs for the main database only */
  if( pFile->ctrlFlags & UNIXFILE_NOLOCK ) return;

  rc = osFstat(pFile->h, &buf);
  if( rc!=0 ){
    sqlite3_log(SQLITE_WARNING, "cannot fstat db file %s", pFile->zPath);
    return;
  }
  if( buf.st_nlink==0 ){
    sqlite3_log(SQLITE_WARNING, "file unlinked while open: %s", pFile->zPath);
    return;
  }
  if( buf.st_nlink>1 ){
    sqlite3_log(SQLITE_WARNING, "multiple links to file: %s", pFile->zPath);
    return;
  }
  if( fileHasMoved(pFile) ){
    sqlite3_log(SQLITE_WARNING, "file renamed while open: %s", pFile->zPath);
    return;
  }
}

// Assembly:
testb $-0x80, 0x1e(%rdi)
jne 0x28403c
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdi, %rbx
movl 0x18(%rdi), %edi
movq %rsp, %rsi
callq *0x237b37(%rip)         # 0x4bbb50
testl %eax, %eax
je 0x28403d
movq 0x38(%rbx), %rdx
leaq 0x151a4a(%rip), %rsi    # 0x3d5a72
movl $0x1c, %edi
xorl %eax, %eax
callq 0x274d08
addq $0x120, %rsp            # imm = 0x120
popq %rbx
retq
movq 0x10(%rsp), %rax
cmpq $0x1, %rax
je 0x28405a
testq %rax, %rax
jne 0x284096
movq 0x38(%rbx), %rdx
leaq 0x151a32(%rip), %rsi    # 0x3d5a8a
jmp 0x284028
cmpq $0x0, 0x10(%rbx)
je 0x284034
movq 0x38(%rbx), %rdi
leaq 0x90(%rsp), %rsi
callq *0x237ac5(%rip)         # 0x4bbb38
testl %eax, %eax
jne 0x284089
movq 0x98(%rsp), %rax
movq 0x10(%rbx), %rcx
cmpq 0x8(%rcx), %rax
je 0x284034
movq 0x38(%rbx), %rdx
leaq 0x151a2e(%rip), %rsi    # 0x3d5ac2
jmp 0x284028
movq 0x38(%rbx), %rdx
leaq 0x151a06(%rip), %rsi    # 0x3d5aa7
jmp 0x284028
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: closeUnixFile
static int closeUnixFile(sqlite3_file *id){
  unixFile *pFile = (unixFile*)id;
#if SQLITE_MAX_MMAP_SIZE>0
  unixUnmapfile(pFile);
#endif
  if( pFile->h>=0 ){
    robust_close(pFile, pFile->h, __LINE__);
    pFile->h = -1;
  }
#if OS_VXWORKS
  if( pFile->pId ){
    if( pFile->ctrlFlags & UNIXFILE_DELETE ){
      osUnlink(pFile->pId->zCanonicalName);
    }
    vxworksReleaseFileId(pFile->pId);
    pFile->pId = 0;
  }
#endif
#ifdef SQLITE_UNLINK_AFTER_CLOSE
  if( pFile->ctrlFlags & UNIXFILE_DELETE ){
    osUnlink(pFile->zPath);
    sqlite3_free(*(char**)&pFile->zPath);
    pFile->zPath = 0;
  }
#endif
  OSTRACE(("CLOSE   %-3d\n", pFile->h));
  OpenCounter(-1);
  sqlite3_free(pFile->pPreallocatedUnused);
  memset(pFile, 0, sizeof(unixFile));
  return SQLITE_OK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
testq %rdi, %rdi
je 0x2840c9
movq 0x58(%rbx), %rsi
callq *0x237c46(%rip)         # 0x4bbd00
movq $0x0, 0x68(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movl 0x18(%rbx), %edi
testl %edi, %edi
js 0x2840fb
callq *0x237a1a(%rip)         # 0x4bbaf0
testl %eax, %eax
je 0x2840f4
movq 0x38(%rbx), %rdx
leaq 0x1447f7(%rip), %rsi    # 0x3c88dc
movl $0x100a, %edi           # imm = 0x100A
movl $0x8b38, %ecx           # imm = 0x8B38
callq 0x2842dc
movl $0xffffffff, 0x18(%rbx) # imm = 0xFFFFFFFF
movq 0x30(%rbx), %rdi
callq 0x272c00
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq $0x0, 0x70(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: openDirectory
static int openDirectory(const char *zFilename, int *pFd){
  int ii;
  int fd = -1;
  char zDirname[MAX_PATHNAME+1];

  sqlite3_snprintf(MAX_PATHNAME, zDirname, "%s", zFilename);
  for(ii=(int)strlen(zDirname); ii>0 && zDirname[ii]!='/'; ii--);
  if( ii>0 ){
    zDirname[ii] = '\0';
  }else{
    if( zDirname[0]!='/' ) zDirname[0] = '.';
    zDirname[1] = 0;
  }
  fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0);
  if( fd>=0 ){
    OSTRACE(("OPENDIR %-3d %s\n", fd, zDirname));
  }
  *pFd = fd;
  if( fd>=0 ) return SQLITE_OK;
  return unixLogError(SQLITE_CANTOPEN_BKPT, "openDirectory", zDirname);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %rbx
movq %rdi, %rcx
leaq 0x14495e(%rip), %rdx    # 0x3c8aa9
movq %rsp, %r14
movl $0x200, %edi            # imm = 0x200
movq %r14, %rsi
xorl %eax, %eax
callq 0x274c41
movq %r14, %rdi
callq 0x172f0
testl %eax, %eax
jle 0x284179
movl %eax, %ecx
cmpb $0x2f, (%rsp,%rcx)
je 0x28418a
leal -0x1(%rcx), %eax
cmpl $0x2, %ecx
jge 0x284169
cmpb $0x2f, (%rsp)
je 0x284183
movb $0x2e, (%rsp)
leaq 0x1(%rsp), %rax
jmp 0x28418e
leaq (%rsp,%rcx), %rax
movb $0x0, (%rax)
movq %rsp, %rdi
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x284201
movl %eax, (%rbx)
testl %eax, %eax
jns 0x2841e9
leaq 0x151a1f(%rip), %rsi    # 0x3d5bcb
leaq 0x151a07(%rip), %rdx    # 0x3d5bba
leaq 0x151877(%rip), %r8     # 0x3d5a31
movl $0xe, %ebp
movl $0xe, %edi
movl $0x917b, %ecx           # imm = 0x917B
xorl %eax, %eax
callq 0x274d08
leaq 0x151954(%rip), %rsi    # 0x3d5b2b
movq %rsp, %rdx
movl $0xe, %edi
movl $0x917b, %ecx           # imm = 0x917B
callq 0x2842dc
movl %ebp, %eax
addq $0x210, %rsp            # imm = 0x210
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: seekAndWriteFd
static int seekAndWriteFd(
  int fd,                         /* File descriptor to write to */
  i64 iOff,                       /* File offset to begin writing at */
  const void *pBuf,               /* Copy data from this buffer to the file */
  int nBuf,                       /* Size of buffer pBuf in bytes */
  int *piErrno                    /* OUT: Error number if error occurs */
){
  int rc = 0;                     /* Value returned by system call */

  assert( nBuf==(nBuf&0x1ffff) );
  assert( fd>2 );
  assert( piErrno!=0 );
  nBuf &= 0x1ffff;
  TIMER_START;

#if defined(USE_PREAD)
  do{ rc = (int)osPwrite(fd, pBuf, nBuf, iOff); }while( rc<0 && errno==EINTR );
#elif defined(USE_PREAD64)
  do{ rc = (int)osPwrite64(fd, pBuf, nBuf, iOff);}while( rc<0 && errno==EINTR);
#else
  do{
    i64 iSeek = lseek(fd, iOff, SEEK_SET);
    SimulateIOError( iSeek = -1 );
    if( iSeek<0 ){
      rc = -1;
      break;
    }
    rc = osWrite(fd, pBuf, nBuf);
  }while( rc<0 && errno==EINTR );
#endif

  TIMER_END;
  OSTRACE(("WRITE   %-3d %5d %7lld %llu\n", fd, rc, iOff, TIMER_ELAPSED));

  if( rc<0 ) *piErrno = errno;
  return rc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %ebp
andl $0x1ffff, %r14d         # imm = 0x1FFFF
movl %ebp, %edi
movq %r12, %rsi
xorl %edx, %edx
callq 0x176b0
testq %rax, %rax
js 0x28441c
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
callq *0x2377d8(%rip)         # 0x4bbbe0
movq %rax, %r13
testl %r13d, %r13d
jns 0x28442b
callq 0x17060
cmpl $0x4, (%rax)
je 0x2843e9
jmp 0x284427
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
callq 0x17060
movl (%rax), %eax
movl %eax, (%rbx)
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
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: unixFileLock
static int unixFileLock(unixFile *pFile, struct flock *pLock){
  int rc;
  unixInodeInfo *pInode = pFile->pInode;
  assert( pInode!=0 );
  assert( sqlite3_mutex_held(pInode->pLockMutex) );
  if( (pFile->ctrlFlags & (UNIXFILE_EXCL|UNIXFILE_RDONLY))==UNIXFILE_EXCL ){
    if( pInode->bProcessLock==0 ){
      struct flock lock;
      assert( pInode->nLock==0 );
      lock.l_whence = SEEK_SET;
      lock.l_start = SHARED_FIRST;
      lock.l_len = SHARED_SIZE;
      lock.l_type = F_WRLCK;
      rc = osSetPosixAdvisoryLock(pFile->h, &lock, pFile);
      if( rc<0 ) return rc;
      pInode->bProcessLock = 1;
      pInode->nLock++;
    }else{
      rc = 0;
    }
  }else{
    rc = osSetPosixAdvisoryLock(pFile->h, pLock, pFile);
  }
  return rc;
}

// Assembly:
movzwl 0x1e(%rdi), %eax
andl $0x3, %eax
cmpw $0x1, %ax
jne 0x28449c
pushq %rbx
subq $0x20, %rsp
movq 0x10(%rdi), %rbx
xorl %eax, %eax
cmpb $0x0, 0x21(%rbx)
jne 0x284496
movslq 0x23765e(%rip), %rax    # 0x4bbac0
addq $0x2, %rax
movq %rsp, %rdx
movq %rax, 0x8(%rdx)
movq $0x1fe, 0x10(%rdx)      # imm = 0x1FE
movl $0x1, (%rdx)
movl 0x18(%rdi), %edi
movl $0x6, %esi
xorl %eax, %eax
callq *0x2376f5(%rip)         # 0x4bbb80
testl %eax, %eax
js 0x284496
movb $0x1, 0x21(%rbx)
incl 0x1c(%rbx)
addq $0x20, %rsp
popq %rbx
retq
movq %rsi, %rdx
movq 0x2376da(%rip), %rcx    # 0x4bbb80
movl 0x18(%rdi), %edi
movl $0x6, %esi
xorl %eax, %eax
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: unixGetTempname
static int unixGetTempname(int nBuf, char *zBuf){
  const char *zDir;
  int iLimit = 0;

  /* It's odd to simulate an io-error here, but really this is just
  ** using the io-error infrastructure to test that SQLite handles this
  ** function failing.
  */
  zBuf[0] = 0;
  SimulateIOError( return SQLITE_IOERR );

  zDir = unixTempFileDir();
  if( zDir==0 ) return SQLITE_IOERR_GETTEMPPATH;
  do{
    u64 r;
    sqlite3_randomness(sizeof(r), &r);
    assert( nBuf>2 );
    zBuf[nBuf-2] = 0;
    sqlite3_snprintf(nBuf, zBuf, "%s/"SQLITE_TEMP_FILE_PREFIX"%llx%c",
                     zDir, r, 0);
    if( zBuf[nBuf-2]!=0 || (iLimit++)>10 ) return SQLITE_ERROR;
  }while( osAccess(zBuf,0)==0 );
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movl %edi, 0x4(%rsp)
movb $0x0, (%rsi)
leaq 0x23a7d0(%rip), %rax    # 0x4becd8
movq (%rax), %r14
cmpq $0x0, 0x23787d(%rip)    # 0x4bbd90
jne 0x284528
leaq 0x1516e4(%rip), %rdi    # 0x3d5c00
callq 0x17950
movq %rax, 0x237868(%rip)    # 0x4bbd90
cmpq $0x0, 0x237868(%rip)    # 0x4bbd98
jne 0x284545
leaq 0x1516ce(%rip), %rdi    # 0x3d5c07
callq 0x17950
movq %rax, 0x237853(%rip)    # 0x4bbd98
xorl %r12d, %r12d
leaq 0x237841(%rip), %r13    # 0x4bbd90
leaq 0x8(%rsp), %r15
movl $0xf000, %ebp           # imm = 0xF000
testq %r14, %r14
je 0x28458d
movq %r14, %rdi
movq %r15, %rsi
callq *0x2375ce(%rip)         # 0x4bbb38
testl %eax, %eax
jne 0x28458d
movl 0x20(%rsp), %eax
andl %ebp, %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x28458d
movq %r14, %rdi
movl $0x3, %esi
callq *0x23757f(%rip)         # 0x4bbb08
testl %eax, %eax
je 0x2845b6
cmpq $0x30, %r12
je 0x28459d
movq (%r12,%r13), %r14
addq $0x8, %r12
jmp 0x284559
movl $0x190a, %ebp           # imm = 0x190A
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq 0x4(%rsp), %r15
leaq 0x15162d(%rip), %r13    # 0x3d5bef
xorl %r12d, %r12d
movl $0x8, %edi
leaq 0x8(%rsp), %rsi
callq 0x274e7e
movb $0x0, -0x2(%rbx,%r15)
movq 0x8(%rsp), %r8
movl %r15d, %edi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x274c41
cmpb $0x0, -0x2(%rbx,%r15)
movl $0x1, %ebp
jne 0x2845a2
cmpl $0xa, %r12d
ja 0x2845a2
incl %r12d
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq *0x2374f0(%rip)         # 0x4bbb08
testl %eax, %eax
je 0x2845c5
jmp 0x2845a2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: unixMapfile
static int unixMapfile(unixFile *pFd, i64 nMap){
  assert( nMap>=0 || pFd->nFetchOut==0 );
  assert( nMap>0 || (pFd->mmapSize==0 && pFd->pMapRegion==0) );
  if( pFd->nFetchOut>0 ) return SQLITE_OK;

  if( nMap<0 ){
    struct stat statbuf;          /* Low-level file information */
    if( osFstat(pFd->h, &statbuf) ){
      return SQLITE_IOERR_FSTAT;
    }
    nMap = statbuf.st_size;
  }
  if( nMap>pFd->mmapSizeMax ){
    nMap = pFd->mmapSizeMax;
  }

  assert( nMap>0 || (pFd->mmapSize==0 && pFd->pMapRegion==0) );
  if( nMap!=pFd->mmapSize ){
    unixRemapfile(pFd, nMap);
  }

  return SQLITE_OK;
}

// Assembly:
cmpl $0x0, 0x4c(%rdi)
jle 0x284627
xorl %eax, %eax
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
js 0x2846b3
movq 0x50(%rbx), %r12
movq 0x60(%rbx), %r14
cmpq %r14, %rsi
cmovlq %rsi, %r14
cmpq %r12, %r14
je 0x284737
movl 0x18(%rbx), %ebp
movq 0x68(%rbx), %r13
testq %r13, %r13
je 0x2846d6
movq 0x58(%rbx), %rsi
subq %r12, %rsi
je 0x284677
leaq (%r12,%r13), %rdi
callq *0x237689(%rip)         # 0x4bbd00
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl $0x1, %ecx
xorl %eax, %eax
callq *0x23768b(%rip)         # 0x4bbd18
movq %rax, %r15
incq %rax
cmpq $0x1, %rax
ja 0x2846fd
movq %r13, %rdi
movq %r12, %rsi
callq *0x23765b(%rip)         # 0x4bbd00
leaq 0x15149c(%rip), %r12    # 0x3d5b48
testq %r15, %r15
jne 0x284704
jmp 0x2846dd
movl 0x18(%rbx), %edi
leaq 0x8(%rsp), %rsi
callq *0x23748f(%rip)         # 0x4bbb50
movl %eax, %ecx
movl $0x70a, %eax            # imm = 0x70A
testl %ecx, %ecx
jne 0x284739
movq 0x38(%rsp), %rsi
jmp 0x284640
leaq 0xefcb2(%rip), %r12     # 0x37438f
xorl %edi, %edi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq *0x2375f0(%rip)         # 0x4bbce8
movq %rax, %r15
jmp 0x284704
leaq 0x151444(%rip), %r12    # 0x3d5b48
cmpq $-0x1, %r15
jne 0x28472b
movq 0x38(%rbx), %rdx
xorl %r15d, %r15d
xorl %edi, %edi
movq %r12, %rsi
movl $0x96fd, %ecx           # imm = 0x96FD
callq 0x2842dc
movq $0x0, 0x60(%rbx)
xorl %r14d, %r14d
movq %r15, 0x68(%rbx)
movq %r14, 0x58(%rbx)
movq %r14, 0x50(%rbx)
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
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: unixShmPurge
static void unixShmPurge(unixFile *pFd){
  unixShmNode *p = pFd->pInode->pShmNode;
  assert( unixMutexHeld() );
  if( p && ALWAYS(p->nRef==0) ){
    int nShmPerMap = unixShmRegionPerMap();
    int i;
    assert( p->pInode==pFd->pInode );
    sqlite3_mutex_free(p->pShmMutex);
    for(i=0; i<p->nRegion; i+=nShmPerMap){
      if( p->hShm>=0 ){
        osMunmap(p->apRegion[i], p->szRegion);
      }else{
        sqlite3_free(p->apRegion[i]);
      }
    }
    sqlite3_free(p->apRegion);
    if( p->hShm>=0 ){
      robust_close(pFd, p->hShm, __LINE__);
      p->hShm = -1;
    }
    p->pInode->pShmNode = 0;
    sqlite3_free(p);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
movq 0x38(%rax), %rbx
testq %rbx, %rbx
je 0x2848ae
cmpl $0x0, 0x30(%rbx)
je 0x2848ba
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdi, %r14
callq *0x23746d(%rip)         # 0x4bbd30
cmpw $0x0, 0x20(%rbx)
je 0x284914
movl %eax, %ecx
shrl $0xf, %ecx
cmpl $0x8000, %eax           # imm = 0x8000
movl $0x1, %r15d
cmovgel %ecx, %r15d
xorl %r12d, %r12d
cmpl $0x0, 0x18(%rbx)
js 0x2848fb
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rdi
movslq 0x1c(%rbx), %rsi
callq *0x237407(%rip)         # 0x4bbd00
jmp 0x284908
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x272c00
addq %r15, %r12
movzwl 0x20(%rbx), %eax
cmpq %rax, %r12
jb 0x2848e1
movq 0x28(%rbx), %rdi
callq 0x272c00
movl 0x18(%rbx), %edi
testl %edi, %edi
js 0x284958
callq *0x2371c6(%rip)         # 0x4bbaf0
testl %eax, %eax
je 0x284951
testq %r14, %r14
je 0x284939
movq 0x38(%r14), %rdx
jmp 0x28493b
xorl %edx, %edx
leaq 0x143f9a(%rip), %rsi    # 0x3c88dc
movl $0x100a, %edi           # imm = 0x100A
movl $0x944a, %ecx           # imm = 0x944A
callq 0x2842dc
movl $0xffffffff, 0x18(%rbx) # imm = 0xFFFFFFFF
movq (%rbx), %rax
movq $0x0, 0x38(%rax)
cmpl $0x0, 0x236cf6(%rip)    # 0x4bb660
je 0x284985
movq %rbx, %rdi
callq *0x236d23(%rip)         # 0x4bb698
cltq
subq %rax, 0x23a17a(%rip)    # 0x4beaf8
decq 0x23a1bb(%rip)          # 0x4beb40
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *0x236cef(%rip)         # 0x4bb688
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/external/sqlite-3.33.0/sqlite3.c
// Function: dotlockClose
static int dotlockClose(sqlite3_file *id) {
  unixFile *pFile = (unixFile*)id;
  assert( id!=0 );
  dotlockUnlock(id, NO_LOCK);
  sqlite3_free(pFile->lockingContext);
  return closeUnixFile(id);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x284a39
movq 0x28(%rbx), %rdi
callq 0x272c00
movq %rbx, %rdi
callq 0x2840a3
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: dotlockCheckReservedLock
static int dotlockCheckReservedLock(sqlite3_file *id, int *pResOut) {
  int rc = SQLITE_OK;
  int reserved = 0;
  unixFile *pFile = (unixFile*)id;

  SimulateIOError( return SQLITE_IOERR_CHECKRESERVEDLOCK; );

  assert( pFile );
  reserved = osAccess((const char*)pFile->lockingContext, 0)==0;
  OSTRACE(("TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, rc, reserved));
  *pResOut = reserved;
  return rc;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x28(%rdi), %rdi
xorl %esi, %esi
callq *0x23706e(%rip)         # 0x4bbb08
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, (%rbx)
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: sqlite3VMPrintf
SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list ap){
  char *z;
  char zBase[SQLITE_PRINT_BUF_SIZE];
  StrAccum acc;
  assert( db!=0 );
  sqlite3StrAccumInit(&acc, db, zBase, sizeof(zBase),
                      db->aLimit[SQLITE_LIMIT_LENGTH]);
  acc.printfFlags = SQLITE_PRINTF_INTERNAL;
  sqlite3_str_vappendf(&acc, zFormat, ap);
  z = sqlite3StrAccumFinish(&acc);
  if( acc.accError==SQLITE_NOMEM ){
    sqlite3OomFault(db);
  }
  return z;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movl 0x7c(%rdi), %eax
leaq 0x20(%rsp), %rcx
movq %rsp, %r15
movq %rcx, 0x8(%r15)
movq %rdi, (%r15)
movl $0x46, 0x10(%r15)
movl %eax, 0x14(%r15)
movl $0x0, 0x18(%r15)
movw $0x100, 0x1c(%r15)      # imm = 0x100
movq %r15, %rdi
callq 0x272d87
movq %r15, %rdi
callq 0x2749f9
movq %rax, %r14
cmpb $0x7, 0x1c(%r15)
jne 0x284b12
movq %rbx, %rdi
callq 0x278b1c
movq %r14, %rax
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: sqlite3OpenTempDatabase
SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *pParse){
  sqlite3 *db = pParse->db;
  if( db->aDb[1].pBt==0 && !pParse->explain ){
    int rc;
    Btree *pBt;
    static const int flags =
          SQLITE_OPEN_READWRITE |
          SQLITE_OPEN_CREATE |
          SQLITE_OPEN_EXCLUSIVE |
          SQLITE_OPEN_DELETEONCLOSE |
          SQLITE_OPEN_TEMP_DB;

    rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pBt, 0, flags);
    if( rc!=SQLITE_OK ){
      sqlite3ErrorMsg(pParse, "unable to open a temporary database "
        "file for storing temporary tables");
      pParse->rc = rc;
      return 1;
    }
    db->aDb[1].pBt = pBt;
    assert( db->aDb[1].pSchema );
    if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, 0, 0) ){
      sqlite3OomFault(db);
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %rbx
movq 0x20(%rbx), %rax
xorl %ebp, %ebp
cmpq $0x0, 0x28(%rax)
jne 0x284c13
movq %rdi, %r14
cmpb $0x0, 0x11b(%rdi)
jne 0x284c13
movq (%rbx), %rdi
leaq 0x8(%rsp), %rcx
xorl %esi, %esi
movq %rbx, %rdx
xorl %r8d, %r8d
movl $0x21e, %r9d            # imm = 0x21E
callq 0x284c1e
testl %eax, %eax
je 0x284bde
movl %eax, %ebp
leaq 0x151089(%rip), %rsi    # 0x3d5c57
movq %r14, %rdi
xorl %eax, %eax
callq 0x27b48d
movl %ebp, 0x18(%r14)
jmp 0x284c0e
movq 0x8(%rsp), %rax
movq 0x20(%rbx), %rcx
movq %rax, 0x28(%rcx)
movl 0x6c(%rbx), %edx
movq (%rax), %rdi
movq 0x8(%rax), %rsi
xorl %ebp, %ebp
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x281747
cmpl $0x7, %eax
jne 0x284c13
movq %rbx, %rdi
callq 0x278b1c
movl $0x1, %ebp
movl %ebp, %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: sqlite3PcacheSetPageSize
SQLITE_PRIVATE int sqlite3PcacheSetPageSize(PCache *pCache, int szPage){
  assert( pCache->nRefSum==0 && pCache->pDirty==0 );
  if( pCache->szPage ){
    sqlite3_pcache *pNew;
    pNew = sqlite3GlobalConfig.pcache2.xCreate(
                szPage, pCache->szExtra + ROUND8(sizeof(PgHdr)),
                pCache->bPurgeable
    );
    if( pNew==0 ) return SQLITE_NOMEM_BKPT;
    sqlite3GlobalConfig.pcache2.xCachesize(pNew, numberOfCachePages(pCache));
    if( pCache->pCache ){
      sqlite3GlobalConfig.pcache2.xDestroy(pCache->pCache);
    }
    pCache->pCache = pNew;
    pCache->szPage = szPage;
    pcacheTrace(("%p.PAGESIZE %d\n",pCache,szPage));
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpl $0x0, 0x24(%rdi)
je 0x285e6a
movl %esi, %ebp
movq %rdi, %r14
movl 0x28(%rdi), %esi
addl $0x48, %esi
movzbl 0x2c(%rdi), %edx
movl %ebp, %edi
callq *0x235916(%rip)         # 0x4bb728
testq %rax, %rax
je 0x285e65
movq %rax, %r15
movq 0x23590f(%rip), %rcx    # 0x4bb730
movslq 0x1c(%r14), %rsi
testq %rsi, %rsi
jns 0x285e47
shlq $0xa, %rsi
negq %rsi
movslq 0x24(%r14), %rax
movslq 0x28(%r14), %rdi
addq %rax, %rdi
movq %rsi, %rax
cqto
idivq %rdi
movq %rax, %rsi
movq %r15, %rdi
callq *%rcx
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x285e5b
callq *0x235905(%rip)         # 0x4bb760
movq %r15, 0x40(%r14)
movl %ebp, 0x24(%r14)
jmp 0x285e6a
movl $0x7, %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: subjournalPageIfRequired
static int subjournalPageIfRequired(PgHdr *pPg){
  if( subjRequiresPage(pPg) ){
    return subjournalPage(pPg);
  }else{
    return SQLITE_OK;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rbx
movslq 0x80(%rbx), %rax
testq %rax, %rax
jle 0x285ec7
movq %rdi, %r14
movl 0x30(%rdi), %ebp
movq 0x78(%rbx), %r15
shlq $0x4, %rax
leaq (%rax,%rax,2), %r12
xorl %r13d, %r13d
cmpl %ebp, 0x18(%r15,%r13)
jb 0x285ebe
movq 0x10(%r15,%r13), %rdi
movl %ebp, %esi
callq 0x286b64
testl %eax, %eax
je 0x285ed8
addq $0x30, %r13
cmpq %r13, %r12
jne 0x285ea7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb 0x9(%rbx), %al
cmpb $0x2, %al
jne 0x285eee
incl 0x38(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x286bec
jmp 0x285ec9
movq 0x58(%rbx), %rdx
cmpq $0x0, (%rdx)
jne 0x285f4d
cmpb $0x4, %al
je 0x285f06
cmpb $0x0, 0x19(%rbx)
je 0x285fb5
movq (%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdx)
movups %xmm0, 0x20(%rdx)
movups %xmm0, 0x10(%rdx)
movq $0x0, 0x40(%rdx)
movl $0x3f8, %ecx            # imm = 0x3F8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %ecx, 0x8(%rdx)
leaq 0x230bdc(%rip), %rcx    # 0x4b6b10
movq %rcx, (%rdx)
movl %eax, 0xc(%rdx)
movl $0x201e, 0x40(%rdx)     # imm = 0x201E
movq $0x0, 0x50(%rdx)
movq %rdi, 0x48(%rdx)
movq 0x8(%r14), %r15
movl 0x38(%rbx), %eax
movslq 0xbc(%rbx), %r12
addq $0x4, %r12
imulq %rax, %r12
movq 0x58(%rbx), %rdi
movl 0x30(%r14), %eax
bswapl %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movq (%rdi), %rax
movl $0x4, %edx
movq %r12, %rcx
callq *0x18(%rax)
testl %eax, %eax
jne 0x285ec9
movq 0x58(%rbx), %rdi
movl 0xbc(%rbx), %edx
addq $0x4, %r12
movq (%rdi), %rax
movq %r15, %rsi
movq %r12, %rcx
callq *0x18(%rax)
testl %eax, %eax
jne 0x285ec9
movl 0x30(%r14), %ebp
jmp 0x285edf
movl 0x2356c1(%rip), %eax    # 0x4bb67c
movq (%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdx)
movups %xmm0, 0x30(%rdx)
movups %xmm0, 0x20(%rdx)
movups %xmm0, 0x10(%rdx)
movups %xmm0, (%rdx)
movq $0x0, 0x50(%rdx)
testl %eax, %eax
je 0x285fed
movl $0x3f8, %ecx            # imm = 0x3F8
cmovgl %eax, %ecx
jmp 0x285f2a
xorl %esi, %esi
movl $0x201e, %ecx           # imm = 0x201E
xorl %r8d, %r8d
callq *0x28(%rdi)
testl %eax, %eax
jne 0x285ec9
jmp 0x285f4d