LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/flappy.cc
// Function: Bird::is_alive(World&)
bool is_alive(World &world) {
    if (y <= 0 || y >= display->height) {
      return false;
    }
    int wall = world.walls[display->width / 2 - 1];
    if (wall != 0) {
      return y > wall - World::kVGap && y < wall + World::kVGap;
    }
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
ucomisd (%rax), %xmm0
jae 0x9b27
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movq 0x10(%rax), %rax
cvtsi2sdl (%rax), %xmm1
ucomisd %xmm1, %xmm0
jb 0x9b2d
movb $0x0, -0x1(%rbp)
jmp 0x9ba1
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x10(%rax), %rax
movl 0x4(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
subl $0x1, %eax
movslq %eax, %rsi
callq 0xa100
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x9b9d
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movl -0x1c(%rbp), %eax
subl $0x2, %eax
cvtsi2sd %eax, %xmm1
xorl %eax, %eax
ucomisd %xmm1, %xmm0
movb %al, -0x29(%rbp)
jbe 0x9b93
movq -0x28(%rbp), %rax
movsd (%rax), %xmm1
movl -0x1c(%rbp), %eax
addl $0x2, %eax
cvtsi2sd %eax, %xmm0
ucomisd %xmm1, %xmm0
seta %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9ba1
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/flappy.cc
// Function: World::step()
void step() {
    steps++;
    if (steps % kRate == 0) {
      walls.pop_front();
      switch (steps % (kRate * kHGap)) {
        case 0:
          walls.push_back(rand_wall());
          break;
        case kRate * 1:
        case kRate * 2:
          walls.push_back(walls.back());
          break;
        default:
          walls.push_back(0);
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x58(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x58(%rax)
movl 0x58(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x9c95
movq -0x18(%rbp), %rdi
callq 0xa2d0
movq -0x18(%rbp), %rax
movslq 0x58(%rax), %rcx
movl %ecx, %eax
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rcx
shrq $0x3f, %rcx
sarq $0x23, %rdx
addl %ecx, %edx
shll $0x2, %edx
movl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
je 0x9c4d
jmp 0x9c39
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x9c68
jmp 0x9c43
movl -0x1c(%rbp), %eax
subl $0x4, %eax
je 0x9c68
jmp 0x9c7f
movq -0x18(%rbp), %rdi
callq 0xa340
movq -0x18(%rbp), %rdi
movl %eax, -0xc(%rbp)
leaq -0xc(%rbp), %rsi
callq 0x8600
jmp 0x9c93
movq -0x18(%rbp), %rdi
callq 0x9110
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0xa390
jmp 0x9c93
movq -0x18(%rbp), %rdi
movl $0x0, -0x10(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x8600
jmp 0x9c95
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/highscores.cc
// Function: HighScores::HighScores(char const*, int)
HighScores::HighScores(const char *file, int size) {
  size_ = size;
  sqlite3_initialize();
  int flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
  sqlite3_open_v2(file, &db, flags, nullptr);

  REGISTER(timeout);
  sqlite3_step(stmt_timeout);
  sqlite3_finalize(stmt_timeout);

  REGISTER(table);
  sqlite3_step(stmt_table);
  sqlite3_finalize(stmt_table);

  REGISTER(top);
  sqlite3_bind_int(stmt_top, 1, size);
  REGISTER(place);
  REGISTER(insert);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
callq 0xc950
movq -0x30(%rbp), %rsi
movl $0x6, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rsi
movl -0x18(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x1da90
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
movq 0xa7631(%rip), %rax     # 0xb22a8
movq %rax, -0x68(%rbp)
movq 0xa7626(%rip), %rdi     # 0xb22a8
callq 0x7150
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x30(%rbp), %rcx
movl %eax, %edx
addq $0x18, %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x18650
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x141e0
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x12d20
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
movq 0xa75e0(%rip), %rax     # 0xb22b0
movq %rax, -0x58(%rbp)
movq 0xa75d5(%rip), %rdi     # 0xb22b0
callq 0x7150
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x30(%rbp), %rcx
movl %eax, %edx
addq $0x10, %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x18650
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x141e0
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x12d20
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq 0xa758f(%rip), %rax     # 0xb22b8
movq %rax, -0x48(%rbp)
movq 0xa7584(%rip), %rdi     # 0xb22b8
callq 0x7150
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rcx
movl %eax, %edx
addq $0x20, %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x18650
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0x14(%rbp), %edx
movl $0x1, %esi
callq 0x156e0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq 0xa7543(%rip), %rax     # 0xb22c0
movq %rax, -0x38(%rbp)
movq 0xa7538(%rip), %rdi     # 0xb22c0
callq 0x7150
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rcx
movl %eax, %edx
addq $0x28, %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x18650
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq 0xa750c(%rip), %rax     # 0xb22c8
movq %rax, -0x20(%rbp)
movq 0xa7501(%rip), %rdi     # 0xb22c8
callq 0x7150
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl %eax, %edx
addq $0x30, %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x18650
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/highscores.cc
// Function: HighScores::is_best(int)
bool HighScores::is_best(int score) {
  sqlite3_bind_int(stmt_place, 1, score);
  sqlite3_step(stmt_place);
  int count = sqlite3_column_int(stmt_place, 0);
  sqlite3_reset(stmt_place);
  return count < size_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x28(%rax), %rdi
movl -0xc(%rbp), %edx
movl $0x1, %esi
callq 0x156e0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x141e0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
xorl %esi, %esi
callq 0x15020
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0x10(%rbp)
movq 0x28(%rax), %rdi
callq 0x12ed0
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl (%rcx), %eax
setl %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/highscores.cc
// Function: HighScores::insert_score(char const*, int)
void HighScores::insert_score(const char *name, int score) {
  sqlite3_bind_text(stmt_insert, 1, name, -1, SQLITE_TRANSIENT);
  sqlite3_bind_int(stmt_insert, 2, score);
  sqlite3_step(stmt_insert);
  sqlite3_reset(stmt_insert);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rdx
movl $0x1, %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq $-0x1, %r8
callq 0x157d0
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
movl -0x14(%rbp), %edx
movl $0x2, %esi
callq 0x156e0
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x141e0
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x12ed0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/highscores.cc
// Function: HighScores::top_scores()
std::vector<listing> HighScores::top_scores() {
  std::vector<listing> scores;
  sqlite3_bind_int(stmt_top, 1, size_);
  while (sqlite3_step(stmt_top) == SQLITE_ROW) {
    listing line;
    const char *name = (const char *)sqlite3_column_text(stmt_top, 0);
    size_t length = sqlite3_column_bytes(stmt_top, 0);
    line.name = std::string{name, length};
    line.score = sqlite3_column_int(stmt_top, 1);
    scores.push_back(line);
  }
  sqlite3_reset(stmt_top);
  return scores;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xb120
movq -0x90(%rbp), %rax
movq 0x20(%rax), %rdi
movl (%rax), %edx
movl $0x1, %esi
callq 0x156e0
jmp 0xaf51
jmp 0xaf53
movq -0x90(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x141e0
movl %eax, -0xa4(%rbp)
jmp 0xaf6b
movl -0xa4(%rbp), %eax
cmpl $0x64, %eax
jne 0xb0c9
leaq -0x50(%rbp), %rdi
callq 0xb140
movq -0x90(%rbp), %rax
movq 0x20(%rax), %rdi
xorl %esi, %esi
callq 0x150a0
movq %rax, -0xb0(%rbp)
jmp 0xaf9e
movq -0x90(%rbp), %rax
movq -0xb0(%rbp), %rcx
movq %rcx, -0x58(%rbp)
movq 0x20(%rax), %rdi
xorl %esi, %esi
callq 0x14f60
movl %eax, -0xb4(%rbp)
jmp 0xafc3
movl -0xb4(%rbp), %eax
cltq
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x7510
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
movq -0xc0(%rbp), %rcx
leaq -0x80(%rbp), %rdi
callq 0x7330
jmp 0xb018
leaq -0x50(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movq %rsi, -0xe0(%rbp)
callq 0x73b0
movq -0xe0(%rbp), %rdi
callq 0x71d0
leaq -0x81(%rbp), %rdi
callq 0x7320
movq -0x90(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x1, %esi
callq 0x15020
movl %eax, -0xd4(%rbp)
jmp 0xb061
movq -0xa0(%rbp), %rdi
movl -0xd4(%rbp), %eax
movl %eax, -0x30(%rbp)
leaq -0x50(%rbp), %rsi
callq 0xb160
jmp 0xb07c
leaq -0x50(%rbp), %rdi
callq 0xaae0
jmp 0xaf53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xb101
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xb0be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x81(%rbp), %rdi
callq 0x7320
leaq -0x50(%rbp), %rdi
callq 0xaae0
jmp 0xb101
movq -0x90(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x12ed0
jmp 0xb0db
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xb0f1
movq -0xa0(%rbp), %rdi
callq 0x7c50
movq -0x98(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x7c50
movq -0x20(%rbp), %rdi
callq 0x7500
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3BtreeEnterAll
SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){
  int i;
  Btree *p;
  assert( sqlite3_mutex_held(db->mutex) );
  for(i=0; i<db->nDb; i++){
    p = db->aDb[i].pBt;
    if( p ) sqlite3BtreeEnter(p);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0xc317
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc30a
movq -0x18(%rbp), %rdi
callq 0x10f50
jmp 0xc30c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc2d3
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3BtreeLeaveAll
SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3 *db){
  int i;
  Btree *p;
  assert( sqlite3_mutex_held(db->mutex) );
  for(i=0; i<db->nDb; i++){
    p = db->aDb[i].pBt;
    if( p ) sqlite3BtreeLeave(p);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0xc417
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc40a
movq -0x18(%rbp), %rdi
callq 0x12630
jmp 0xc40c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc3d3
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3MutexAlloc
SQLITE_PRIVATE sqlite3_mutex *sqlite3MutexAlloc(int id){
  if( !sqlite3GlobalConfig.bCoreMutex ){
    return 0;
  }
  assert( GLOBAL(int, mutexIsInit) );
  return sqlite3GlobalConfig.mutex.xMutexAlloc(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, 0xa5782(%rip)     # 0xb22d4
jne 0xcb5e
movq $0x0, -0x8(%rbp)
jmp 0xcb6e
movq 0xa57e3(%rip), %rax     # 0xb2348
movl -0xc(%rbp), %edi
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_vfs_unregister
SQLITE_API int sqlite3_vfs_unregister(sqlite3_vfs *pVfs){
#if SQLITE_THREADSAFE
  sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
#endif
  sqlite3_mutex_enter(mutex);
  vfsUnlink(pVfs);
  sqlite3_mutex_leave(mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x2, %edi
callq 0xcb40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc290
movq -0x8(%rbp), %rdi
callq 0xcc30
movq -0x10(%rbp), %rdi
callq 0xc870
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_mutex_try
SQLITE_API int sqlite3_mutex_try(sqlite3_mutex *p){
  int rc = SQLITE_OK;
  if( p ){
    return sqlite3GlobalConfig.mutex.xMutexTry(p);
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcdbc
movq 0xa55af(%rip), %rax     # 0xb2360
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0xcdc2
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: unixDlError
static void unixDlError(sqlite3_vfs *NotUsed, int nBuf, char *zBufOut){
  const char *zErr;
  UNUSED_PARAMETER(NotUsed);
  unixEnterMutex();
  zErr = dlerror();
  if( zErr ){
    sqlite3_snprintf(nBuf, zBufOut, "%s", zErr);
  }
  unixLeaveMutex();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x214c0
callq 0x72b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xfe71
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq 0x890e9(%rip), %rdx     # 0x98f53
movb $0x0, %al
callq 0xf220
callq 0x21650
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3BtreeLeave
SQLITE_PRIVATE void sqlite3BtreeLeave(Btree *p){
  if( p->sharable ){
    assert( p->wantToLock>0 );
    p->wantToLock--;
    if( p->wantToLock==0 ){
      unlockBtreeMutex(p);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x11(%rax)
je 0x12668
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x12666
movq -0x8(%rbp), %rdi
callq 0x2d310
jmp 0x12668
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: columnMallocFailure
static void columnMallocFailure(sqlite3_stmt *pStmt)
{
  /* If malloc() failed during an encoding conversion within an
  ** sqlite3_column_XXX API, then set the return code of the statement to
  ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
  ** and _finalize() will return NOMEM.
  */
  Vdbe *p = (Vdbe *)pStmt;
  if( p ){
    p->rc = sqlite3ApiExit(p->db, p->rc);
    sqlite3_mutex_leave(p->db->mutex);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x14f4d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x94(%rax), %esi
callq 0x12e50
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x94(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdi
callq 0xc870
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3VdbeChangeToNoop
SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe *p, int addr){
  if( p->aOp ){
    VdbeOp *pOp = &p->aOp[addr];
    sqlite3 *db = p->db;
    freeP4(db, pOp->p4type, pOp->p4.p);
    memset(pOp, 0, sizeof(pOp[0]));
    pOp->opcode = OP_Noop;
    if( addr==p->nOp-1 ) p->nOp--;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1705c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %esi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x327e0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x71a0
movq -0x18(%rbp), %rax
movb $-0x69, (%rax)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x34(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1705a
movq -0x8(%rbp), %rax
movl 0x34(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x34(%rax)
jmp 0x1705c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_load_extension
SQLITE_API int sqlite3_load_extension(
  sqlite3 *db,          /* Load the extension into this database connection */
  const char *zFile,    /* Name of the shared library containing extension */
  const char *zProc,    /* Entry point.  Use "sqlite3_extension_init" if 0 */
  char **pzErrMsg       /* Put error message here if not 0 */
){
  int rc;
  sqlite3_mutex_enter(db->mutex);
  rc = sqlite3LoadExtension(db, zFile, zProc, pzErrMsg);
  rc = sqlite3ApiExit(db, rc);
  sqlite3_mutex_leave(db->mutex);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xc290
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x18840
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x12e50
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xc870
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_enable_load_extension
SQLITE_API int sqlite3_enable_load_extension(sqlite3 *db, int onoff){
  sqlite3_mutex_enter(db->mutex);
  if( onoff ){
    db->flags |= SQLITE_LoadExtension;
  }else{
    db->flags &= ~SQLITE_LoadExtension;
  }
  sqlite3_mutex_leave(db->mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xc290
cmpl $0x0, -0xc(%rbp)
je 0x18db4
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
orl $0x400000, %ecx         # imm = 0x400000
movl %ecx, 0x2c(%rax)
jmp 0x18dc4
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
andl $0xffbfffff, %ecx       # imm = 0xFFBFFFFF
movl %ecx, 0x2c(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xc870
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_reset_auto_extension
SQLITE_API void sqlite3_reset_auto_extension(void){
#ifndef SQLITE_OMIT_AUTOINIT
  if( sqlite3_initialize()==SQLITE_OK )
#endif
  {
#if SQLITE_THREADSAFE
    sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
#endif
    wsdAutoextInit;
    sqlite3_mutex_enter(mutex);
    sqlite3_free(wsdAutoext.aExt);
    wsdAutoext.aExt = 0;
    wsdAutoext.nExt = 0;
    sqlite3_mutex_leave(mutex);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xc950
cmpl $0x0, %eax
jne 0x18ff3
movl $0x2, %edi
callq 0xcb40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc290
movq 0x9af60(%rip), %rdi     # 0xb3f30
callq 0xd0d0
movq $0x0, 0x9af50(%rip) # 0xb3f30
movl $0x0, 0x9af3e(%rip)     # 0xb3f28
movq -0x8(%rbp), %rdi
callq 0xc870
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3MutexInit
SQLITE_PRIVATE int sqlite3MutexInit(void){ 
  int rc = SQLITE_OK;
  if( !sqlite3GlobalConfig.mutex.xMutexAlloc ){
    /* If the xMutexAlloc method has not been set, then the user did not
    ** install a mutex implementation via sqlite3_config() prior to 
    ** sqlite3_initialize() being called. This block copies pointers to
    ** the default implementation into the sqlite3GlobalConfig structure.
    */
    sqlite3_mutex_methods const *pFrom;
    sqlite3_mutex_methods *pTo = &sqlite3GlobalConfig.mutex;

    if( sqlite3GlobalConfig.bCoreMutex ){
      pFrom = sqlite3DefaultMutex();
    }else{
      pFrom = sqlite3NoopMutex();
    }
    memcpy(pTo, pFrom, offsetof(sqlite3_mutex_methods, xMutexAlloc));
    memcpy(&pTo->xMutexFree, &pFrom->xMutexFree,
           sizeof(*pTo) - offsetof(sqlite3_mutex_methods, xMutexFree));
    pTo->xMutexAlloc = pFrom->xMutexAlloc;
  }
  rc = sqlite3GlobalConfig.mutex.xMutexInit();

#ifdef SQLITE_DEBUG
  GLOBAL(int, mutexIsInit) = 1;
#endif

  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
cmpq $0x0, 0x97931(%rip)     # 0xb2348
jne 0x1aa85
leaq 0x978b0(%rip), %rax     # 0xb22d0
addq $0x68, %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x978a5(%rip)     # 0xb22d4
je 0x1aa3c
callq 0x8cba0
movq %rax, -0x10(%rbp)
jmp 0x1aa45
callq 0x8cbb0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl $0x30, %edx
callq 0x7260
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
callq *0x978ad(%rip)          # 0xb2338
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3MutexEnd
SQLITE_PRIVATE int sqlite3MutexEnd(void){
  int rc = SQLITE_OK;
  if( sqlite3GlobalConfig.mutex.xMutexEnd ){
    rc = sqlite3GlobalConfig.mutex.xMutexEnd();
  }

#ifdef SQLITE_DEBUG
  GLOBAL(int, mutexIsInit) = 0;
#endif

  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpq $0x0, 0x97469(%rip)     # 0xb2340
je 0x1aee2
callq *0x97461(%rip)          # 0xb2340
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_create_collation
SQLITE_API int sqlite3_create_collation(
  sqlite3* db, 
  const char *zName, 
  int enc, 
  void* pCtx,
  int(*xCompare)(void*,int,const void*,int,const void*)
){
  int rc;
  sqlite3_mutex_enter(db->mutex);
  assert( !db->mallocFailed );
  rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, 0);
  rc = sqlite3ApiExit(db, rc);
  sqlite3_mutex_leave(db->mutex);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xc290
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
xorl %edx, %edx
movl %edx, %r9d
movzbl %al, %edx
callq 0x1dc30
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x12e50
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xc870
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_create_collation_v2
SQLITE_API int sqlite3_create_collation_v2(
  sqlite3* db, 
  const char *zName, 
  int enc, 
  void* pCtx,
  int(*xCompare)(void*,int,const void*,int,const void*),
  void(*xDel)(void*)
){
  int rc;
  sqlite3_mutex_enter(db->mutex);
  assert( !db->mallocFailed );
  rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
  rc = sqlite3ApiExit(db, rc);
  sqlite3_mutex_leave(db->mutex);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xc290
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movzbl %al, %edx
callq 0x1dc30
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x12e50
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xc870
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_extended_result_codes
SQLITE_API int sqlite3_extended_result_codes(sqlite3 *db, int onoff){
  sqlite3_mutex_enter(db->mutex);
  db->errMask = onoff ? 0xffffffff : 0xff;
  sqlite3_mutex_leave(db->mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xc290
movl -0xc(%rbp), %edx
movl $0xff, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xc870
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: robust_open
static int robust_open(const char *z, int f, mode_t m){
  int fd;
  mode_t m2 = m ? m : SQLITE_DEFAULT_FILE_PERMISSIONS;
  while(1){
#if defined(O_CLOEXEC)
    fd = osOpen(z,f|O_CLOEXEC,m2);
#else
    fd = osOpen(z,f,m2);
#endif
    if( fd<0 ){
      if( errno==EINTR ) continue;
      break;
    }
    if( fd>=SQLITE_MINIMUM_FILE_DESCRIPTOR ) break;
    osClose(fd);
    sqlite3_log(SQLITE_WARNING, 
                "attempt to open \"%s\" as file descriptor %d", z, fd);
    fd = -1;
    if( osOpen("/dev/null", f, m)<0 ) break;
  }
  if( fd>=0 ){
    if( m!=0 ){
      struct stat statbuf;
      if( osFstat(fd, &statbuf)==0 
       && statbuf.st_size==0
       && (statbuf.st_mode&0777)!=m 
      ){
        osFchmod(fd, m);
      }
    }
#if defined(FD_CLOEXEC) && (!defined(O_CLOEXEC) || O_CLOEXEC==0)
    osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
#endif
  }
  return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x21816
movl -0x10(%rbp), %eax
movl %eax, -0xac(%rbp)
jmp 0x21823
movl $0x1a4, %eax            # imm = 0x1A4
movl %eax, -0xac(%rbp)
jmp 0x21823
movl -0xac(%rbp), %eax
movl %eax, -0x18(%rbp)
movq 0x90f05(%rip), %rax     # 0xb2738
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
orl $0x80000, %esi          # imm = 0x80000
movl -0x18(%rbp), %edx
callq *%rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x2185c
callq 0x7030
cmpl $0x4, (%rax)
jne 0x2185a
jmp 0x2182c
jmp 0x218b3
cmpl $0x3, -0x14(%rbp)
jl 0x21864
jmp 0x218b3
movq 0x90ee5(%rip), %rax     # 0xb2750
movl -0x14(%rbp), %edi
callq *%rax
movq -0x8(%rbp), %rdx
movl -0x14(%rbp), %ecx
movl $0x1c, %edi
leaq 0x7767f(%rip), %rsi     # 0x98f02
movb $0x0, %al
callq 0xf2d0
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq 0x90ea0(%rip), %rax     # 0xb2738
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0x77688(%rip), %rdi     # 0x98f2d
callq *%rax
cmpl $0x0, %eax
jge 0x218ae
jmp 0x218b3
jmp 0x2182c
cmpl $0x0, -0x14(%rbp)
jl 0x21901
cmpl $0x0, -0x10(%rbp)
je 0x218ff
movq 0x90eea(%rip), %rax     # 0xb27b0
movl -0x14(%rbp), %edi
leaq -0xa8(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x218fd
cmpq $0x0, -0x78(%rbp)
jne 0x218fd
movl -0x90(%rbp), %eax
andl $0x1ff, %eax            # imm = 0x1FF
cmpl -0x10(%rbp), %eax
je 0x218fd
movq 0x90f93(%rip), %rax     # 0xb2888
movl -0x14(%rbp), %edi
movl -0x10(%rbp), %esi
callq *%rax
jmp 0x218ff
jmp 0x21901
movl -0x14(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: unixUnmapfile
static void unixUnmapfile(unixFile *pFd){
  assert( pFd->nFetchOut==0 );
  if( pFd->pMapRegion ){
    osMunmap(pFd->pMapRegion, pFd->mmapSizeActual);
    pFd->pMapRegion = 0;
    pFd->mmapSize = 0;
    pFd->mmapSizeActual = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x21ae4
movq 0x90e9a(%rip), %rax     # 0xb2948
movq -0x8(%rbp), %rcx
movq 0x68(%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rsi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: unixTempFileDir
static const char *unixTempFileDir(void){
  static const char *azDirs[] = {
     0,
     0,
     0,
     "/var/tmp",
     "/usr/tmp",
     "/tmp",
     0        /* List terminator */
  };
  unsigned int i;
  struct stat buf;
  const char *zDir = 0;

  azDirs[0] = sqlite3_temp_directory;
  if( !azDirs[1] ) azDirs[1] = getenv("SQLITE_TMPDIR");
  if( !azDirs[2] ) azDirs[2] = getenv("TMPDIR");
  for(i=0; i<sizeof(azDirs)/sizeof(azDirs[0]); zDir=azDirs[i++]){
    if( zDir==0 ) continue;
    if( osStat(zDir, &buf) ) continue;
    if( !S_ISDIR(buf.st_mode) ) continue;
    if( osAccess(zDir, 07) ) continue;
    break;
  }
  return zDir;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq $0x0, -0xa0(%rbp)
movq 0x9197b(%rip), %rax     # 0xb3f38
movq %rax, 0x903ac(%rip)     # 0xb2970
cmpq $0x0, 0x903ac(%rip)     # 0xb2978
jne 0x225e1
leaq 0x769d0(%rip), %rdi     # 0x98fa5
callq 0x73a0
movq %rax, 0x90397(%rip)     # 0xb2978
cmpq $0x0, 0x90397(%rip)     # 0xb2980
jne 0x225fe
leaq 0x769ba(%rip), %rdi     # 0x98fac
callq 0x73a0
movq %rax, 0x90382(%rip)     # 0xb2980
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpq $0x7, %rax
jae 0x2268d
cmpq $0x0, -0xa0(%rbp)
jne 0x2261a
jmp 0x22667
movq 0x90177(%rip), %rax     # 0xb2798
movq -0xa0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0x22638
jmp 0x22667
movl -0x80(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
je 0x22649
jmp 0x22667
movq 0x90118(%rip), %rax     # 0xb2768
movq -0xa0(%rbp), %rdi
movl $0x7, %esi
callq *%rax
cmpl $0x0, %eax
je 0x22665
jmp 0x22667
jmp 0x2268d
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x4(%rbp)
movl %eax, %eax
movl %eax, %ecx
leaq 0x902f3(%rip), %rax     # 0xb2970
movq (%rax,%rcx,8), %rax
movq %rax, -0xa0(%rbp)
jmp 0x22605
movq -0xa0(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: unlockBtreeMutex
static void unlockBtreeMutex(Btree *p){
  BtShared *pBt = p->pBt;
  assert( p->locked==1 );
  assert( sqlite3_mutex_held(pBt->mutex) );
  assert( sqlite3_mutex_held(p->db->mutex) );
  assert( p->db==pBt->db );

  sqlite3_mutex_leave(pBt->mutex);
  p->locked = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xc870
movq -0x8(%rbp), %rax
movb $0x0, 0x12(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: lockBtreeMutex
static void lockBtreeMutex(Btree *p){
  assert( p->locked==0 );
  assert( sqlite3_mutex_notheld(p->pBt->mutex) );
  assert( sqlite3_mutex_held(p->db->mutex) );

  sqlite3_mutex_enter(p->pBt->mutex);
  p->pBt->db = p->db;
  p->locked = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rdi
callq 0xc290
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0x12(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: vdbeFreeOpArray
static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){
  if( aOp ){
    Op *pOp;
    for(pOp=aOp; pOp<&aOp[nOp]; pOp++){
      freeP4(db, pOp->p4type, pOp->p4.p);
#ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
      sqlite3DbFree(db, pOp->zComment);
#endif     
    }
  }
  sqlite3DbFree(db, aOp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x327c3
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x327c1
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %esi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x327e0
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0x32782
jmp 0x327c3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc760
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3KeyInfoUnref
SQLITE_PRIVATE void sqlite3KeyInfoUnref(KeyInfo *p){
  if( p ){
    assert( p->nRef>0 );
    p->nRef--;
    if( p->nRef==0 ) sqlite3DbFree(0, p);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x32916
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x32914
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xc760
jmp 0x32916
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3VdbeEnter
SQLITE_PRIVATE void sqlite3VdbeEnter(Vdbe *p){
  int i;
  yDbMask mask;
  sqlite3 *db;
  Db *aDb;
  int nDb;
  if( p->lockMask==0 ) return;  /* The common case */
  db = p->db;
  aDb = db->aDb;
  nDb = db->nDb;
  for(i=0, mask=1; i<nDb; i++, mask += mask){
    if( i!=1 && (mask & p->lockMask)!=0 && ALWAYS(aDb[i].pBt!=0) ){
      sqlite3BtreeEnter(aDb[i].pBt);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xa4(%rax)
jne 0x3323e
jmp 0x332d1
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x332d1
cmpl $0x1, -0xc(%rbp)
je 0x332bb
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
andl 0xa4(%rcx), %eax
cmpl $0x0, %eax
je 0x332bb
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x332bb
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x10f50
jmp 0x332bd
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x3326d
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3VdbeCheckFk
SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *p, int deferred){
  sqlite3 *db = p->db;
  if( (deferred && (db->nDeferredCons+db->nDeferredImmCons)>0) 
   || (!deferred && p->nFkConstraint>0) 
  ){
    p->rc = SQLITE_CONSTRAINT_FOREIGNKEY;
    p->errorAction = OE_Abort;
    sqlite3SetString(&p->zErrMsg, db, "FOREIGN KEY constraint failed");
    return SQLITE_ERROR;
  }
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x334dc
movq -0x20(%rbp), %rax
movq 0x308(%rax), %rax
movq -0x20(%rbp), %rcx
addq 0x310(%rcx), %rax
cmpq $0x0, %rax
jg 0x334f0
cmpl $0x0, -0x14(%rbp)
jne 0x3352c
movq -0x10(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
jle 0x3352c
movq -0x10(%rbp), %rax
movl $0x313, 0x94(%rax)      # imm = 0x313
movq -0x10(%rbp), %rax
movb $0x2, 0x98(%rax)
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
movq -0x20(%rbp), %rsi
leaq 0x65bef(%rip), %rdx     # 0x9910b
movb $0x0, %al
callq 0x347d0
movl $0x1, -0x4(%rbp)
jmp 0x33533
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3VdbeLeave
SQLITE_PRIVATE void sqlite3VdbeLeave(Vdbe *p){
  int i;
  yDbMask mask;
  sqlite3 *db;
  Db *aDb;
  int nDb;
  if( p->lockMask==0 ) return;  /* The common case */
  db = p->db;
  aDb = db->aDb;
  nDb = db->nDb;
  for(i=0, mask=1; i<nDb; i++, mask += mask){
    if( i!=1 && (mask & p->lockMask)!=0 && ALWAYS(aDb[i].pBt!=0) ){
      sqlite3BtreeLeave(aDb[i].pBt);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xa4(%rax)
jne 0x3355e
jmp 0x335f1
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x335f1
cmpl $0x1, -0xc(%rbp)
je 0x335db
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
andl 0xa4(%rcx), %eax
cmpl $0x0, %eax
je 0x335db
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x335db
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x12630
jmp 0x335dd
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x3358d
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3VdbeIntegerAffinity
SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){
  assert( pMem->flags & MEM_Real );
  assert( (pMem->flags & MEM_RowSet)==0 );
  assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  assert( EIGHT_BYTE_ALIGNMENT(pMem) );

  pMem->u.i = doubleToInt64(pMem->r);

  /* Only mark the value as an integer if
  **
  **    (1) the round-trip conversion real->int->real is a no-op, and
  **    (2) The integer is neither the largest nor the smallest
  **        possible integer (ticket #3922)
  **
  ** The second and third terms in the following conditional enforces
  ** the second condition under the assumption that addition overflow causes
  ** values to wrap around.
  */
  if( pMem->r==(double)pMem->u.i
   && pMem->u.i>SMALLEST_INT64
   && pMem->u.i<LARGEST_INT64
  ){
    pMem->flags |= MEM_Int;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
callq 0x356d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rbp), %rax
cvtsi2sdq 0x18(%rax), %xmm1
ucomisd %xmm1, %xmm0
jne 0x3f2b7
jp 0x3f2b7
movq -0x8(%rbp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, 0x18(%rax)
jle 0x3f2b7
movq -0x8(%rbp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, 0x18(%rax)
jge 0x3f2b7
movq -0x8(%rbp), %rax
movzwl 0x24(%rax), %ecx
orl $0x4, %ecx
movw %cx, 0x24(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3BtreeKeyFetch
SQLITE_PRIVATE const void *sqlite3BtreeKeyFetch(BtCursor *pCur, u32 *pAmt){
  const void *p = 0;
  assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
  assert( cursorHoldsMutex(pCur) );
  if( ALWAYS(pCur->eState==CURSOR_VALID) ){
    p = (const void*)fetchPayload(pCur, pAmt, 0);
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x77(%rax), %eax
cmpl $0x1, %eax
jne 0x3f9a8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x44b00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3BtreeDataFetch
SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor *pCur, u32 *pAmt){
  const void *p = 0;
  assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
  assert( cursorHoldsMutex(pCur) );
  if( ALWAYS(pCur->eState==CURSOR_VALID) ){
    p = (const void*)fetchPayload(pCur, pAmt, 1);
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x77(%rax), %eax
cmpl $0x1, %eax
jne 0x3fa7b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x44b00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3BtreeCursor
SQLITE_PRIVATE int sqlite3BtreeCursor(
  Btree *p,                                   /* The btree */
  int iTable,                                 /* Root page of table to open */
  int wrFlag,                                 /* 1 to write. 0 read-only */
  struct KeyInfo *pKeyInfo,                   /* First arg to xCompare() */
  BtCursor *pCur                              /* Write new cursor here */
){
  int rc;
  sqlite3BtreeEnter(p);
  rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
  sqlite3BtreeLeave(p);
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10f50
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x45390
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12630
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3VdbeSorterCompare
SQLITE_PRIVATE int sqlite3VdbeSorterCompare(
  const VdbeCursor *pCsr,         /* Sorter cursor */
  Mem *pVal,                      /* Value to compare to current sorter key */
  int nIgnore,                    /* Ignore this many fields at the end */
  int *pRes                       /* OUT: Result of comparison */
){
  VdbeSorter *pSorter = pCsr->pSorter;
  void *pKey; int nKey;           /* Sorter key to compare pVal with */

  pKey = vdbeSorterRowkey(pSorter, &nKey);
  vdbeSorterCompare(pCsr, nIgnore, pVal->z, pVal->n, pKey, nKey, pRes);
  return SQLITE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x493e0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x30(%rbp), %r8
movl -0x34(%rbp), %r9d
movq -0x20(%rbp), %rax
movq %rax, (%rsp)
callq 0x49460
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/sqlite3.c
// Function: sqlite3AnalysisLoad
SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
  analysisInfo sInfo;
  HashElem *i;
  char *zSql;
  int rc;

  assert( iDb>=0 && iDb<db->nDb );
  assert( db->aDb[iDb].pBt!=0 );

  /* Clear any prior statistics */
  assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
  for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){
    Index *pIdx = sqliteHashData(i);
    sqlite3DefaultRowEst(pIdx);
#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
    sqlite3DeleteIndexSamples(db, pIdx);
    pIdx->aSample = 0;
#endif
  }

  /* Check to make sure the sqlite_stat1 table exists */
  sInfo.db = db;
  sInfo.zDatabase = db->aDb[iDb].zName;
  if( sqlite3FindTable(db, "sqlite_stat1", sInfo.zDatabase)==0 ){
    return SQLITE_ERROR;
  }

  /* Load new statistics out of the sqlite_stat1 table */
  zSql = sqlite3MPrintf(db, 
      "SELECT tbl,idx,stat FROM %Q.sqlite_stat1", sInfo.zDatabase);
  if( zSql==0 ){
    rc = SQLITE_NOMEM;
  }else{
    rc = sqlite3_exec(db, zSql, analysisLoader, &sInfo, 0);
    sqlite3DbFree(db, zSql);
  }


  /* Load the statistics from the sqlite_stat4 table. */
#ifdef SQLITE_ENABLE_STAT3_OR_STAT4
  if( rc==SQLITE_OK ){
    int lookasideEnabled = db->lookaside.bEnabled;
    db->lookaside.bEnabled = 0;
    rc = loadStat4(db, sInfo.zDatabase);
    db->lookaside.bEnabled = lookasideEnabled;
  }
#endif

  if( rc==SQLITE_NOMEM ){
    db->mallocFailed = 1;
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x42bd7
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x4ae80
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x42bae
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x56d29(%rip), %rsi     # 0x99931
callq 0x4af30
cmpq $0x0, %rax
jne 0x42c1c
movl $0x1, -0x4(%rbp)
jmp 0x42c87
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x56cea(%rip), %rsi     # 0x99915
movb $0x0, %al
callq 0x16a10
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x42c46
movl $0x7, -0x3c(%rbp)
jmp 0x42c73
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq 0x83bb(%rip), %rdx      # 0x4b010
leaq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x181e0
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xc760
cmpl $0x7, -0x3c(%rbp)
jne 0x42c81
movq -0x10(%rbp), %rax
movb $0x1, 0x50(%rax)
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq