LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/flappy.cc
// Function: print_scores(Display&, HighScores&)
void print_scores(Display &display, HighScores &scores) {
  attron(A_BOLD);
  mvprintw(0, display.width + 4, "== High Scores ==");
  attroff(A_BOLD);
  int i = 1;
  for (auto &line : scores.top_scores()) {
    mvprintw(i, display.width + 1, "%s", line.name.c_str());
    clrtoeol();
    mvprintw(i, display.width + 24, "%d", line.score);
    i++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x819ba(%rip), %r15     # 0x88fe0
movq (%r15), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %edx, %edx
callq 0x7160
movl 0x4(%rbx), %esi
addl $0x4, %esi
leaq 0x649ee(%rip), %rdx     # 0x6c030
xorl %edi, %edi
xorl %eax, %eax
callq 0x7390
movq (%r15), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %edx, %edx
callq 0x7380
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x8c8a
movq (%r15), %r13
movq 0x8(%r15), %r12
cmpq %r12, %r13
je 0x76cc
movl $0x1, %ebp
leaq 0x68dcc(%rip), %r14     # 0x7044c
leaq 0x64abf(%rip), %r15     # 0x6c146
movl 0x4(%rbx), %esi
incl %esi
movq (%r13), %rcx
movl %ebp, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x7390
movq 0x8193d(%rip), %rax     # 0x88fe0
movq (%rax), %rdi
callq 0x72e0
movl 0x4(%rbx), %esi
addl $0x18, %esi
movl 0x20(%r13), %ecx
movl %ebp, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x7390
incl %ebp
addq $0x28, %r13
cmpq %r12, %r13
jne 0x7687
movq %rsp, %rdi
callq 0x79dc
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x79dc
movq %rbx, %rdi
callq 0x74b0
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/flappy.cc
// Function: Display::Display(int, int)
Display(int width = 40, int height = 20) : height{height}, width{width} {
    initscr();
    start_color();
    raw();
    timeout(0);
    noecho();
    curs_set(0);
    keypad(stdscr, TRUE);
    erase();
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %edx, (%rdi)
movl %esi, 0x4(%rdi)
callq 0x7410
callq 0x7070
callq 0x70d0
movq 0x81586(%rip), %r14     # 0x88fe0
movq (%r14), %rdi
xorl %esi, %esi
callq 0x7310
callq 0x7300
xorl %edi, %edi
callq 0x7220
movq (%r14), %rdi
movl $0x1, %esi
callq 0x7100
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7eec
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/flappy.cc
// Function: Display::erase()
void erase() {
    ::erase();
    for (int y = 0; y < height; y++) {
      mvaddch(y, 0, '|');
      mvaddch(y, width - 1, '|');
    }
    for (int x = 0; x < width; x++) {
      mvaddch(0, x, '-');
      mvaddch(height - 1, x, '-');
    }
    mvaddch(0, 0, '/');
    mvaddch(height - 1, 0, '\\');
    mvaddch(0, width - 1, '\\');
    mvaddch(height - 1, width - 1, '/');
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x72f0
cmpl $0x0, (%rbx)
jle 0x7f4b
xorl %ebp, %ebp
movq 0x810da(%rip), %r14     # 0x88fe0
movq (%r14), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x72d0
cmpl $-0x1, %eax
je 0x7f24
movq (%r14), %rdi
movl $0x7c, %esi
callq 0x70b0
movq (%r14), %rdi
movl 0x4(%rbx), %edx
decl %edx
movl %ebp, %esi
callq 0x72d0
cmpl $-0x1, %eax
je 0x7f45
movq (%r14), %rdi
movl $0x7c, %esi
callq 0x70b0
incl %ebp
cmpl (%rbx), %ebp
jl 0x7f06
cmpl $0x0, 0x4(%rbx)
jle 0x7f9f
xorl %ebp, %ebp
movq 0x81086(%rip), %r14     # 0x88fe0
movq (%r14), %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x72d0
cmpl $-0x1, %eax
je 0x7f78
movq (%r14), %rdi
movl $0x2d, %esi
callq 0x70b0
movq (%r14), %rdi
movl (%rbx), %esi
decl %esi
movl %ebp, %edx
callq 0x72d0
cmpl $-0x1, %eax
je 0x7f98
movq (%r14), %rdi
movl $0x2d, %esi
callq 0x70b0
incl %ebp
cmpl 0x4(%rbx), %ebp
jl 0x7f5a
movq 0x8103a(%rip), %r14     # 0x88fe0
movq (%r14), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x72d0
cmpl $-0x1, %eax
je 0x7fc4
movq (%r14), %rdi
movl $0x2f, %esi
callq 0x70b0
movq (%r14), %rdi
movl (%rbx), %esi
decl %esi
xorl %edx, %edx
callq 0x72d0
cmpl $-0x1, %eax
je 0x7fe4
movq (%r14), %rdi
movl $0x5c, %esi
callq 0x70b0
movq (%r14), %rdi
movl 0x4(%rbx), %edx
decl %edx
xorl %esi, %esi
callq 0x72d0
cmpl $-0x1, %eax
je 0x8005
movq (%r14), %rdi
movl $0x5c, %esi
callq 0x70b0
movq (%r14), %rdi
movl (%rbx), %esi
movl 0x4(%rbx), %edx
decl %esi
decl %edx
callq 0x72d0
cmpl $-0x1, %eax
je 0x802c
movq (%r14), %rdi
movl $0x2f, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x70b0
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/flappy.cc
// Function: Bird::draw()
void draw() {
    init_pair(1, COLOR_YELLOW, COLOR_BLACK);
    attron(COLOR_PAIR(1) | A_BOLD);
    draw('@');
    attroff(COLOR_PAIR(1) | A_BOLD);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x3, %esi
xorl %edx, %edx
callq 0x7050
movq 0x80a93(%rip), %r14     # 0x88fe0
movq (%r14), %rdi
movl $0x200100, %esi         # imm = 0x200100
xorl %edx, %edx
callq 0x7160
movq %rbx, %rdi
movl $0x40, %esi
callq 0x8972
movq (%r14), %rdi
movl $0x200100, %esi         # imm = 0x200100
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7380
nop
// File: /workspace/github_c_makefile_star2_O1/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:
movsd (%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0x85d2
movq 0x10(%rdi), %rax
xorps %xmm1, %xmm1
cvtsi2sdl (%rax), %xmm1
ucomisd %xmm1, %xmm0
jae 0x85d2
movl 0x4(%rax), %eax
movl %eax, %edx
shrl $0x1f, %edx
addl %eax, %edx
sarl %edx
movq 0x10(%rsi), %rcx
movq %rcx, %rax
subq 0x18(%rsi), %rax
movslq %edx, %rdx
sarq $0x2, %rax
addq %rdx, %rax
decq %rax
cmpq $0x7f, %rax
ja 0x85d7
decq %rdx
leaq (%rcx,%rdx,4), %rax
jmp 0x8608
xorl %eax, %eax
andb $0x1, %al
retq
movq 0x28(%rsi), %rcx
movq %rax, %rdx
shrq $0x7, %rdx
movabsq $-0x200000000000000, %rsi # imm = 0xFE00000000000000
orq %rdx, %rsi
testq %rax, %rax
cmovgq %rdx, %rsi
movq %rsi, %rdx
shlq $0x7, %rdx
subq %rdx, %rax
shlq $0x2, %rax
addq (%rcx,%rsi,8), %rax
movl (%rax), %eax
testl %eax, %eax
je 0x8633
leal -0x2(%rax), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
addl $0x2, %eax
cvtsi2sd %eax, %xmm2
cmpltpd %xmm0, %xmm1
cmpltpd %xmm2, %xmm0
andpd %xmm1, %xmm0
movd %xmm0, %eax
jmp 0x85d4
movb $0x1, %al
jmp 0x85d4
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl 0x58(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x58(%rdi)
testb $0x1, %al
je 0x86ff
movq %rdi, %rbx
callq 0x89da
movslq 0x58(%rbx), %rax
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x23, %rcx
addl %edx, %ecx
shll $0x2, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
cmpl $0x4, %eax
je 0x86b5
cmpl $0x2, %eax
je 0x86b5
testl %eax, %eax
jne 0x86ee
movq 0x50(%rbx), %rax
movl (%rax), %r14d
callq 0x7090
cltd
idivl %r14d
movl %edx, %eax
shrl $0x1f, %eax
addl %edx, %eax
sarl %eax
leal 0x3(%r14), %ecx
testl %r14d, %r14d
cmovnsl %r14d, %ecx
sarl $0x2, %ecx
addl %eax, %ecx
leaq 0x4(%rsp), %rsi
movl %ecx, (%rsi)
jmp 0x86f7
movq 0x30(%rbx), %rax
movq %rax, %rsi
cmpq 0x38(%rbx), %rax
jne 0x86cf
movq 0x48(%rbx), %rcx
movl $0x200, %esi            # imm = 0x200
addq -0x8(%rcx), %rsi
addq $-0x4, %rsi
movq 0x40(%rbx), %rcx
addq $-0x4, %rcx
cmpq %rcx, %rax
je 0x8707
movl (%rsi), %ecx
movl %ecx, (%rax)
addq $0x4, %rax
movq %rax, 0x30(%rbx)
jmp 0x86ff
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x8236
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8a28
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, (%rdi)
callq 0x9c6c
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
movl $0x6, %edx
xorl %ecx, %ecx
callq 0x1714d
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rcx
leaq 0x63624(%rip), %rsi     # 0x6c149
movl $0x1b, %edx
xorl %r8d, %r8d
callq 0x13148
movq 0x18(%rbx), %rdi
callq 0xf8a2
movq 0x18(%rbx), %rdi
callq 0xed8f
movq 0x8(%rbx), %rdi
leaq 0x10(%rbx), %rcx
leaq 0x63612(%rip), %rsi     # 0x6c165
movl $0x3e, %edx
xorl %r8d, %r8d
callq 0x13148
movq 0x10(%rbx), %rdi
callq 0xf8a2
movq 0x10(%rbx), %rdi
callq 0xed8f
movq 0x8(%rbx), %rdi
leaq 0x20(%rbx), %rcx
leaq 0x63623(%rip), %rsi     # 0x6c1a4
movl $0x3a, %edx
xorl %r8d, %r8d
callq 0x13148
movq 0x20(%rbx), %rdi
movl $0x1, %esi
movl %ebp, %edx
callq 0x10ec8
movq 0x8(%rbx), %rdi
leaq 0x28(%rbx), %rcx
leaq 0x63632(%rip), %rsi     # 0x6c1df
movl $0x2c, %edx
xorl %r8d, %r8d
callq 0x13148
movq 0x8(%rbx), %rdi
addq $0x30, %rbx
leaq 0x63643(%rip), %rsi     # 0x6c20c
movl $0x20, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x13148
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl %esi, %edx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movl $0x1, %esi
callq 0x10ec8
movq 0x28(%rbx), %rdi
callq 0xf8a2
movq 0x28(%rbx), %rdi
xorl %esi, %esi
callq 0x1097b
movl %eax, %ebp
movq 0x28(%rbx), %rdi
callq 0xee9a
cmpl (%rbx), %ebp
setl %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %rdx
movq %rdi, %r14
movq 0x30(%rdi), %rdi
movl $0x1, %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq $-0x1, %r8
callq 0x10f64
movq 0x30(%r14), %rdi
movl $0x2, %esi
movl %ebx, %edx
callq 0x10ec8
movq 0x30(%r14), %rdi
callq 0xf8a2
movq 0x30(%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xee9a
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x8(%rsp)
movq $0x0, 0x10(%rdi)
movq 0x20(%rsi), %rdi
movl (%rsi), %edx
movl $0x1, %esi
callq 0x10ec8
leaq 0x20(%rsp), %rbp
leaq 0x48(%rsp), %rbx
leaq 0x38(%rsp), %r15
leaq 0x10(%rsp), %r12
movq 0x20(%r14), %rdi
callq 0xf8a2
cmpl $0x64, %eax
jne 0x8d87
movq %rbp, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x109cf
movq %rax, %r13
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x108f6
movslq %eax, %rdx
movq %rbx, 0x38(%rsp)
addq %r13, %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x8e30
movq %r12, %rdi
movq %r15, %rsi
callq 0x7370
movq 0x38(%rsp), %rdi
cmpq %rbx, %rdi
je 0x8d48
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x72b0
movq 0x20(%r14), %rdi
movl $0x1, %esi
callq 0x1097b
movl %eax, 0x30(%rsp)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x8ddc
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x8cd2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x72b0
jmp 0x8cd2
movq 0x20(%r14), %rdi
callq 0xee9a
movq 0x8(%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8daa
jmp 0x8daf
jmp 0x8daf
movq %rax, %r14
jmp 0x8dc9
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x8dc9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x72b0
movq 0x8(%rsp), %rdi
callq 0x79dc
movq %r14, %rdi
callq 0x74b0
nop
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x0, 0x28(%rdi)
jle 0x9787
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x9772
callq 0xd284
incq %r15
movslq 0x28(%rbx), %rax
addq $0x20, %r14
cmpq %rax, %r15
jl 0x9760
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $0x0, 0x28(%rdi)
jle 0x97f3
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movq (%rax,%r14), %r12
testq %r12, %r12
je 0x97d8
cmpb $0x0, 0x11(%r12)
je 0x97d8
decl 0x14(%r12)
jne 0x97d8
movq 0x8(%r12), %rax
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x97d2
callq *0x7fb56(%rip)          # 0x89328
movb $0x0, 0x12(%r12)
incq %r15
movslq 0x28(%rbx), %rax
addq $0x20, %r14
cmpq %rax, %r15
jl 0x97a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x7f123(%rip)     # 0x89294
je 0xa183
movl $0x2, %edi
callq *0x7f18a(%rip)          # 0x89308
movq %rax, %r14
jmp 0xa186
xorl %r14d, %r14d
testq %r14, %r14
je 0xa1a7
movq %r14, %rdi
callq *0x7f184(%rip)          # 0x89318
movq %rbx, %rdi
callq 0xa121
movq %r14, %rdi
callq *0x7f183(%rip)          # 0x89328
jmp 0xa1af
movq %rbx, %rdi
callq 0xa121
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3MemoryAlarm
static int sqlite3MemoryAlarm(
  void(*xCallback)(void *pArg, sqlite3_int64 used,int N),
  void *pArg,
  sqlite3_int64 iThreshold
){
  int nUsed;
  sqlite3_mutex_enter(mem0.mutex);
  mem0.alarmCallback = xCallback;
  mem0.alarmArg = pArg;
  mem0.alarmThreshold = iThreshold;
  nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
  mem0.nearlyFull = (iThreshold>0 && iThreshold<=nUsed);
  sqlite3_mutex_leave(mem0.mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x80afa(%rip), %rdi     # 0x8ad08
testq %rdi, %rdi
je 0xa219
callq *0x7f0ff(%rip)          # 0x89318
movq %r15, 0x80af8(%rip)     # 0x8ad18
movq %r14, 0x80af9(%rip)     # 0x8ad20
movq %rbx, 0x80ae2(%rip)     # 0x8ad10
testq %rbx, %rbx
setg %al
movslq 0x80a75(%rip), %rcx     # 0x8acb0
cmpq %rbx, %rcx
setge %cl
andb %al, %cl
movzbl %cl, %eax
movl %eax, 0x80af0(%rip)     # 0x8ad3c
movq 0x80ab5(%rip), %rdi     # 0x8ad08
testq %rdi, %rdi
je 0xa263
popq %rbx
popq %r14
popq %r15
jmpq *0x7f0c5(%rip)          # 0x89328
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
cmpl $0x0, 0x7ccd9(%rip)     # 0x89294
je 0xc5ca
movl $0x2, %edi
callq *0x7cd40(%rip)          # 0x89308
jmp 0xc5cc
xorl %eax, %eax
testq %rax, %rax
je 0xc5da
movq %rax, %rdi
callq *0x7cd3e(%rip)          # 0x89318
callq 0x7280
testq %rax, %rax
je 0xc5fa
leaq 0x63e61(%rip), %rdx     # 0x7044c
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0xb8ca
cmpl $0x0, 0x7cc93(%rip)     # 0x89294
je 0xc610
movl $0x2, %edi
callq *0x7ccfa(%rip)          # 0x89308
jmp 0xc612
xorl %eax, %eax
testq %rax, %rax
je 0xc626
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x7cd02(%rip)          # 0x89328
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3BtreeGetMeta
SQLITE_PRIVATE void sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){
  BtShared *pBt = p->pBt;

  sqlite3BtreeEnter(p);
  assert( p->inTrans>TRANS_NONE );
  assert( SQLITE_OK==querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK) );
  assert( pBt->pPage1 );
  assert( idx>=0 && idx<=15 );

  *pMeta = get4byte(&pBt->pPage1->aData[36 + idx*4]);

  /* If auto-vacuum is disabled in this build and this is an auto-vacuum
  ** database, mark the database as read-only.  */
#ifdef SQLITE_OMIT_AUTOVACUUM
  if( idx==BTREE_LARGEST_ROOT_PAGE && *pMeta>0 ){
    pBt->btsFlags |= BTS_READ_ONLY;
  }
#endif

  sqlite3BtreeLeave(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %r15
callq 0xd284
movq 0x18(%r15), %rax
movq 0x50(%rax), %rax
movslq %ebp, %rcx
movl 0x24(%rax,%rcx,4), %eax
bswapl %eax
movl %eax, (%r14)
cmpb $0x0, 0x11(%rbx)
je 0xdb45
decl 0x14(%rbx)
jne 0xdb45
movq 0x8(%rbx), %rax
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0xdb41
callq *0x7b7e7(%rip)          # 0x89328
movb $0x0, 0x12(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
testq %rdi, %rdi
je 0x108f4
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x94(%rbx), %esi
callq 0xee48
movl %eax, 0x94(%rbx)
movq (%rbx), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x108f4
popq %rbx
jmpq *0x78a34(%rip)          # 0x89328
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_bind_null
SQLITE_API int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
  int rc;
  Vdbe *p = (Vdbe*)pStmt;
  rc = vdbeUnbind(p, i);
  if( rc==SQLITE_OK ){
    sqlite3_mutex_leave(p->db->mutex);
  }
  return rc;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x10d54
movl %eax, %ebx
testl %eax, %eax
jne 0x10f5a
movq (%r14), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x10f5a
callq *0x783ce(%rip)          # 0x89328
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_next_stmt
SQLITE_API sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){
  sqlite3_stmt *pNext;
  sqlite3_mutex_enter(pDb->mutex);
  if( pStmt==0 ){
    pNext = (sqlite3_stmt*)pDb->pVdbe;
  }else{
    pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;
  }
  sqlite3_mutex_leave(pDb->mutex);
  return pNext;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x11323
callq *0x77ff5(%rip)          # 0x89318
leaq 0x8(%rbx), %rax
leaq 0x68(%r14), %rcx
testq %r14, %r14
cmoveq %rax, %rcx
movq (%rcx), %r14
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x11344
callq *0x77fe4(%rip)          # 0x89328
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3VdbeUsesBtree
SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe *p, int i){
  assert( i>=0 && i<p->db->nDb && i<(int)sizeof(yDbMask)*8 );
  assert( i<(int)sizeof(p->btreeMask)*8 );
  p->btreeMask |= ((yDbMask)1)<<i;
  if( i!=1 && sqlite3BtreeSharable(p->db->aDb[i].pBt) ){
    p->lockMask |= ((yDbMask)1)<<i;
  }
}

// Assembly:
movl %esi, %ecx
movl $0x1, %eax
shll %cl, %eax
orl %eax, 0xa0(%rdi)
cmpl $0x1, %esi
je 0x11ea2
movq (%rdi), %rdx
movq 0x20(%rdx), %rdx
movslq %ecx, %rcx
shlq $0x5, %rcx
movq 0x8(%rdx,%rcx), %rcx
cmpb $0x0, 0x11(%rcx)
je 0x11ea2
orl %eax, 0xa4(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3VdbeChangeP4
SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){
  Op *pOp;
  sqlite3 *db;
  assert( p!=0 );
  db = p->db;
  assert( p->magic==VDBE_MAGIC_INIT );
  if( p->aOp==0 || db->mallocFailed ){
    if( n!=P4_VTAB ){
      freeP4(db, n, (void*)*(char**)&zP4);
    }
    return;
  }
  assert( p->nOp>0 );
  assert( addr<p->nOp );
  if( addr<0 ){
    addr = p->nOp - 1;
  }
  pOp = &p->aOp[addr];
  assert( pOp->p4type==P4_NOTUSED || pOp->p4type==P4_INT32 );
  freeP4(db, pOp->p4type, pOp->p4.p);
  pOp->p4.p = 0;
  if( n==P4_INT32 ){
    /* Note: this cast is safe, because the origin data point was an int
    ** that was cast to a (const char *). */
    pOp->p4.i = SQLITE_PTR_TO_INT(zP4);
    pOp->p4type = P4_INT32;
  }else if( zP4==0 ){
    pOp->p4.p = 0;
    pOp->p4type = P4_NOTUSED;
  }else if( n==P4_KEYINFO ){
    pOp->p4.p = (void*)zP4;
    pOp->p4type = P4_KEYINFO;
  }else if( n==P4_VTAB ){
    pOp->p4.p = (void*)zP4;
    pOp->p4type = P4_VTAB;
    sqlite3VtabLock((VTable *)zP4);
    assert( ((VTable *)zP4)->db==p->db );
  }else if( n<0 ){
    pOp->p4.p = (void*)zP4;
    pOp->p4type = (signed char)n;
  }else{
    if( n==0 ) n = sqlite3Strlen30(zP4);
    pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n);
    pOp->p4type = P4_DYNAMIC;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movq %rdx, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x11ec6
cmpb $0x0, 0x50(%rdi)
je 0x11ee6
cmpl $-0xa, %r14d
je 0x11fd0
movl %r14d, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2475b
testl %esi, %esi
jns 0x11ef0
movl 0x34(%r15), %esi
decl %esi
movslq %esi, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %r12
movsbl 0x1(%r12), %esi
movq 0x10(%r12), %rdx
callq 0x2475b
movq $0x0, 0x10(%r12)
cmpl $-0xe, %r14d
jne 0x11f2a
movl %ebx, 0x10(%r12)
movb $-0xe, 0x1(%r12)
jmp 0x11fd0
testq %rbx, %rbx
je 0x11f4b
cmpl $-0xa, %r14d
je 0x11f5c
cmpl $-0x6, %r14d
jne 0x11f6c
movq %rbx, 0x10(%r12)
movb $-0x6, 0x1(%r12)
jmp 0x11fd0
movq $0x0, 0x10(%r12)
movb $0x0, 0x1(%r12)
jmp 0x11fd0
movq %rbx, 0x10(%r12)
movb $-0xa, 0x1(%r12)
incl 0x18(%rbx)
jmp 0x11fd0
testl %r14d, %r14d
js 0x11fc6
jne 0x11f8f
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movq %rbx, %rax
incl %r14d
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x11f7c
andl $0x3fffffff, %r14d      # imm = 0x3FFFFFFF
movq (%r15), %rdi
leal 0x1(%r14), %esi
callq 0x11af4
movq %rax, %r15
testq %rax, %rax
je 0x11fb9
movl %r14d, %r14d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7230
movb $0x0, (%r15,%r14)
movq %r15, 0x10(%r12)
movb $-0x1, 0x1(%r12)
jmp 0x11fd0
movq %rbx, 0x10(%r12)
movb %r14b, 0x1(%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x1202d
movq %rdi, %rbx
movslq %esi, %r15
leaq (%r15,%r15,2), %r12
movq (%rdi), %rdi
movsbl 0x1(%r14,%r12,8), %esi
movq 0x10(%r14,%r12,8), %rdx
callq 0x2475b
xorps %xmm0, %xmm0
movups %xmm0, (%r14,%r12,8)
movq $0x0, 0x10(%r14,%r12,8)
movb $-0x69, (%r14,%r12,8)
movl 0x34(%rbx), %eax
decl %eax
cmpl %r15d, %eax
jne 0x1202d
movl %eax, 0x34(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x13792
callq *0x75b86(%rip)          # 0x89318
xorl %eax, %eax
testl %ebp, %ebp
setne %al
movl $0xffbfffff, %ecx       # imm = 0xFFBFFFFF
andl 0x2c(%rbx), %ecx
shll $0x16, %eax
orl %ecx, %eax
movl %eax, 0x2c(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x137b8
callq *0x75b70(%rip)          # 0x89328
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
callq 0x9c6c
testl %eax, %eax
je 0x1392e
popq %rbx
retq
cmpl $0x0, 0x7595f(%rip)     # 0x89294
je 0x13947
movl $0x2, %edi
callq *0x759c6(%rip)          # 0x89308
movq %rax, %rbx
jmp 0x13949
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x13982
movq %rbx, %rdi
callq *0x759c1(%rip)          # 0x89318
movq 0x774f2(%rip), %rdi     # 0x8ae50
callq 0xa3cf
movq $0x0, 0x774e2(%rip) # 0x8ae50
movl $0x0, 0x774d0(%rip)     # 0x8ae48
movq %rbx, %rdi
popq %rbx
jmpq *0x759a6(%rip)          # 0x89328
movq 0x774c7(%rip), %rdi     # 0x8ae50
callq 0xa3cf
movq $0x0, 0x774b7(%rip) # 0x8ae50
movl $0x0, 0x774a5(%rip)     # 0x8ae48
jmp 0x1392c
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3OsInit
SQLITE_PRIVATE int sqlite3OsInit(void){
  void *p = sqlite3_malloc(10);
  if( p==0 ) return SQLITE_NOMEM;
  sqlite3_free(p);
  return sqlite3_os_init();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x9c6c
testl %eax, %eax
je 0x14f34
xorl %edi, %edi
jmp 0x14f41
movl $0xa, %edi
callq 0xa35e
movq %rax, %rdi
testq %rdi, %rdi
je 0x14f7b
callq 0xa3cf
xorl %ebx, %ebx
leaq 0x744ec(%rip), %r14     # 0x89440
xorl %r15d, %r15d
leaq (%r14,%r15), %rdi
xorl %esi, %esi
testq %r15, %r15
sete %sil
callq 0xa087
addq $0xa8, %r15
cmpq $0x2a0, %r15            # imm = 0x2A0
jne 0x14f57
jmp 0x14f80
movl $0x7, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3PCacheBufferSetup
SQLITE_PRIVATE void sqlite3PCacheBufferSetup(void *pBuf, int sz, int n){
  if( pcache1.isInit ){
    PgFreeslot *p;
    sz = ROUNDDOWN8(sz);
    pcache1.szSlot = sz;
    pcache1.nSlot = pcache1.nFreeSlot = n;
    pcache1.nReserve = n>90 ? 10 : (n/10 + 1);
    pcache1.pStart = pBuf;
    pcache1.pFree = 0;
    pcache1.bUnderPressure = 0;
    while( n-- ){
      p = (PgFreeslot*)pBuf;
      p->pNext = pcache1.pFree;
      pcache1.pFree = p;
      pBuf = (void*)&((char*)pBuf)[sz];
    }
    pcache1.pEnd = pBuf;
  }
}

// Assembly:
cmpl $0x0, 0x75fd9(%rip)     # 0x8af68
je 0x1501e
andl $-0x8, %esi
movl %esi, 0x75fce(%rip)     # 0x8af6c
movl %edx, 0x75ff4(%rip)     # 0x8af98
movl %edx, 0x75fc6(%rip)     # 0x8af70
movl $0xa, %eax
cmpl $0x5a, %edx
jg 0x14fcd
movslq %edx, %rax
imulq $0x66666667, %rax, %rax # imm = 0x66666667
movq %rax, %rcx
sarq $0x22, %rcx
shrq $0x3f, %rax
addl %ecx, %eax
incl %eax
movl %eax, 0x75fa1(%rip)     # 0x8af74
movq %rdi, 0x75f9e(%rip)     # 0x8af78
movq $0x0, 0x75fab(%rip) # 0x8af90
movl $0x0, 0x75fad(%rip)     # 0x8af9c
testl %edx, %edx
je 0x15017
movq 0x75f96(%rip), %rcx     # 0x8af90
movslq %esi, %rax
movq %rcx, (%rdi)
movq %rdi, %rcx
addq %rax, %rdi
decl %edx
jne 0x14ffd
movq %rdi, %rcx
subq %rax, %rcx
movq %rcx, 0x75f79(%rip)     # 0x8af90
movq %rdi, 0x75f62(%rip)     # 0x8af80
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_busy_handler
SQLITE_API int sqlite3_busy_handler(
  sqlite3 *db,
  int (*xBusy)(void*,int),
  void *pArg
){
  sqlite3_mutex_enter(db->mutex);
  db->busyHandler.xFunc = xBusy;
  db->busyHandler.pArg = pArg;
  db->busyHandler.nBusy = 0;
  db->busyTimeout = 0;
  sqlite3_mutex_leave(db->mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x15c52
callq *0x736c6(%rip)          # 0x89318
movq %r15, 0x298(%rbx)
movq %r14, 0x2a0(%rbx)
xorl %eax, %eax
movl %eax, 0x2a8(%rbx)
movl %eax, 0x2f8(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x15c7d
callq *0x736ab(%rip)          # 0x89328
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_progress_handler
SQLITE_API void sqlite3_progress_handler(
  sqlite3 *db, 
  int nOps,
  int (*xProgress)(void*), 
  void *pArg
){
  sqlite3_mutex_enter(db->mutex);
  if( nOps>0 ){
    db->xProgress = xProgress;
    db->nProgressOps = (unsigned)nOps;
    db->pProgressArg = pArg;
  }else{
    db->xProgress = 0;
    db->nProgressOps = 0;
    db->pProgressArg = 0;
  }
  sqlite3_mutex_leave(db->mutex);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x15ca6
callq *0x73672(%rip)          # 0x89318
testl %ebp, %ebp
jle 0x15cc0
movq %r15, 0x180(%rbx)
movl %ebp, 0x190(%rbx)
movq %r14, 0x188(%rbx)
jmp 0x15cd4
leaq 0x180(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x15ced
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *0x7363b(%rip)          # 0x89328
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_trace
SQLITE_API void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
  void *pOld;
  sqlite3_mutex_enter(db->mutex);
  pOld = db->pTraceArg;
  db->xTrace = xTrace;
  db->pTraceArg = pArg;
  sqlite3_mutex_leave(db->mutex);
  return pOld;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x164f7
callq *0x72e21(%rip)          # 0x89318
movq 0x18(%r14), %rdi
movq 0xc0(%r14), %r12
movq %r15, 0xb8(%r14)
movq %rbx, 0xc0(%r14)
testq %rdi, %rdi
je 0x1651b
callq *0x72e0d(%rip)          # 0x89328
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_profile
SQLITE_API void *sqlite3_profile(
  sqlite3 *db,
  void (*xProfile)(void*,const char*,sqlite_uint64),
  void *pArg
){
  void *pOld;
  sqlite3_mutex_enter(db->mutex);
  pOld = db->pProfileArg;
  db->xProfile = xProfile;
  db->pProfileArg = pArg;
  sqlite3_mutex_leave(db->mutex);
  return pOld;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1654a
callq *0x72dce(%rip)          # 0x89318
movq 0x18(%r14), %rdi
movq 0xd0(%r14), %r12
movq %r15, 0xc8(%r14)
movq %rbx, 0xd0(%r14)
testq %rdi, %rdi
je 0x1656e
callq *0x72dba(%rip)          # 0x89328
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_commit_hook
SQLITE_API void *sqlite3_commit_hook(
  sqlite3 *db,              /* Attach the hook to this database */
  int (*xCallback)(void*),  /* Function to invoke on each commit */
  void *pArg                /* Argument to the function */
){
  void *pOld;
  sqlite3_mutex_enter(db->mutex);
  pOld = db->pCommitArg;
  db->xCommitCallback = xCallback;
  db->pCommitArg = pArg;
  sqlite3_mutex_leave(db->mutex);
  return pOld;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1659d
callq *0x72d7b(%rip)          # 0x89318
movq 0x18(%r14), %rdi
movq 0xd8(%r14), %r12
movq %r15, 0xe0(%r14)
movq %rbx, 0xd8(%r14)
testq %rdi, %rdi
je 0x165c1
callq *0x72d67(%rip)          # 0x89328
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_update_hook
SQLITE_API void *sqlite3_update_hook(
  sqlite3 *db,              /* Attach the hook to this database */
  void (*xCallback)(void*,int,char const *,char const *,sqlite_int64),
  void *pArg                /* Argument to the function */
){
  void *pRet;
  sqlite3_mutex_enter(db->mutex);
  pRet = db->pUpdateArg;
  db->xUpdateCallback = xCallback;
  db->pUpdateArg = pArg;
  sqlite3_mutex_leave(db->mutex);
  return pRet;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x165f0
callq *0x72d28(%rip)          # 0x89318
movq 0x18(%r14), %rdi
movq 0xf8(%r14), %r12
movq %r15, 0x100(%r14)
movq %rbx, 0xf8(%r14)
testq %rdi, %rdi
je 0x16614
callq *0x72d14(%rip)          # 0x89328
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_rollback_hook
SQLITE_API void *sqlite3_rollback_hook(
  sqlite3 *db,              /* Attach the hook to this database */
  void (*xCallback)(void*), /* Callback function */
  void *pArg                /* Argument to the function */
){
  void *pRet;
  sqlite3_mutex_enter(db->mutex);
  pRet = db->pRollbackArg;
  db->xRollbackCallback = xCallback;
  db->pRollbackArg = pArg;
  sqlite3_mutex_leave(db->mutex);
  return pRet;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x16643
callq *0x72cd5(%rip)          # 0x89318
movq 0x18(%r14), %rdi
movq 0xe8(%r14), %r12
movq %r15, 0xf0(%r14)
movq %rbx, 0xe8(%r14)
testq %rdi, %rdi
je 0x16667
callq *0x72cc1(%rip)          # 0x89328
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_wal_hook
SQLITE_API void *sqlite3_wal_hook(
  sqlite3 *db,                    /* Attach the hook to this db handle */
  int(*xCallback)(void *, sqlite3*, const char*, int),
  void *pArg                      /* First argument passed to xCallback() */
){
#ifndef SQLITE_OMIT_WAL
  void *pRet;
  sqlite3_mutex_enter(db->mutex);
  pRet = db->pWalArg;
  db->xWalCallback = xCallback;
  db->pWalArg = pArg;
  sqlite3_mutex_leave(db->mutex);
  return pRet;
#else
  return 0;
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x166fc
callq *0x72c1c(%rip)          # 0x89318
movq 0x18(%r14), %rdi
movq 0x110(%r14), %r12
movq %r15, 0x108(%r14)
movq %rbx, 0x110(%r14)
testq %rdi, %rdi
je 0x16720
callq *0x72c08(%rip)          # 0x89328
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x17242
callq *0x720d6(%rip)          # 0x89318
movzbl %bpl, %edx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rcx
movq %r14, %r8
xorl %r9d, %r9d
callq 0x17280
movq %rbx, %rdi
movl %eax, %esi
callq 0xee48
movl %eax, %ebp
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x17275
callq *0x720b3(%rip)          # 0x89328
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x17523
callq *0x71df5(%rip)          # 0x89318
movzbl %bpl, %edx
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x17280
movq %rbx, %rdi
movl %eax, %esi
callq 0xee48
movl %eax, %ebp
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x17556
callq *0x71dd2(%rip)          # 0x89328
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_collation_needed
SQLITE_API int sqlite3_collation_needed(
  sqlite3 *db, 
  void *pCollNeededArg, 
  void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*)
){
  sqlite3_mutex_enter(db->mutex);
  db->xCollNeeded = xCollNeeded;
  db->xCollNeeded16 = 0;
  db->pCollNeededArg = pCollNeededArg;
  sqlite3_mutex_leave(db->mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x17610
callq *0x71d08(%rip)          # 0x89318
movq %r15, 0x118(%rbx)
movq $0x0, 0x120(%rbx)
movq %r14, 0x128(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x17638
callq *0x71cf0(%rip)          # 0x89328
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_collation_needed16
SQLITE_API int sqlite3_collation_needed16(
  sqlite3 *db, 
  void *pCollNeededArg, 
  void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)
){
  sqlite3_mutex_enter(db->mutex);
  db->xCollNeeded = 0;
  db->xCollNeeded16 = xCollNeeded16;
  db->pCollNeededArg = pCollNeededArg;
  sqlite3_mutex_leave(db->mutex);
  return SQLITE_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1765d
callq *0x71cbb(%rip)          # 0x89318
movq $0x0, 0x118(%rbx)
movq %r15, 0x120(%rbx)
movq %r14, 0x128(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x17685
callq *0x71ca3(%rip)          # 0x89328
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x176eb
callq *0x71c2d(%rip)          # 0x89318
xorl %eax, %eax
negl %ebp
sbbl %eax, %eax
orl $0xff, %eax
movl %eax, 0x48(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x17708
callq *0x71c20(%rip)          # 0x89328
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: sqlite3MallocAlarm
static void sqlite3MallocAlarm(int nByte){
  void (*xCallback)(void*,sqlite3_int64,int);
  sqlite3_int64 nowUsed;
  void *pArg;
  if( mem0.alarmCallback==0 ) return;
  xCallback = mem0.alarmCallback;
  nowUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
  pArg = mem0.alarmArg;
  mem0.alarmCallback = 0;
  sqlite3_mutex_leave(mem0.mutex);
  xCallback(pArg, nowUsed, nByte);
  sqlite3_mutex_enter(mem0.mutex);
  mem0.alarmCallback = xCallback;
  mem0.alarmArg = pArg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x72698(%rip), %r15     # 0x8ad18
testq %r15, %r15
je 0x186dd
movl %edi, %ebp
movslq 0x72622(%rip), %r14     # 0x8acb0
movq 0x7268b(%rip), %rbx     # 0x8ad20
movq $0x0, 0x72678(%rip) # 0x8ad18
movq 0x72661(%rip), %rdi     # 0x8ad08
testq %rdi, %rdi
je 0x186b2
callq *0x70c76(%rip)          # 0x89328
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq *%r15
movq 0x72644(%rip), %rdi     # 0x8ad08
testq %rdi, %rdi
je 0x186cf
callq *0x70c49(%rip)          # 0x89318
movq %r15, 0x72642(%rip)     # 0x8ad18
movq %rbx, 0x72643(%rip)     # 0x8ad20
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]flappy/sqlite3.c
// Function: unixShmUnmap
static int unixShmUnmap(
  sqlite3_file *fd,               /* The underlying database file */
  int deleteFlag                  /* Delete shared-memory if true */
){
  unixShm *p;                     /* The connection to be closed */
  unixShmNode *pShmNode;          /* The underlying shared-memory file */
  unixShm **pp;                   /* For looping over sibling connections */
  unixFile *pDbFd;                /* The underlying database file */

  pDbFd = (unixFile*)fd;
  p = pDbFd->pShm;
  if( p==0 ) return SQLITE_OK;
  pShmNode = p->pShmNode;

  assert( pShmNode==pDbFd->pInode->pShmNode );
  assert( pShmNode->pInode==pDbFd->pInode );

  /* Remove connection p from the set of connections associated
  ** with pShmNode */
  sqlite3_mutex_enter(pShmNode->mutex);
  for(pp=&pShmNode->pFirst; (*pp)!=p; pp = &(*pp)->pNext){}
  *pp = p->pNext;

  /* Free the connection p */
  sqlite3_free(p);
  pDbFd->pShm = 0;
  sqlite3_mutex_leave(pShmNode->mutex);

  /* If pShmNode->nRef has reached 0, then close the underlying
  ** shared-memory file, too */
  unixEnterMutex();
  assert( pShmNode->nRef>0 );
  pShmNode->nRef--;
  if( pShmNode->nRef==0 ){
    if( deleteFlag && pShmNode->h>=0 ) osUnlink(pShmNode->zFilename);
    unixShmPurge(pDbFd);
  }
  unixLeaveMutex();

  return SQLITE_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x40(%rdi), %r14
testq %r14, %r14
je 0x1a16f
movl %esi, %ebp
movq %rdi, %rbx
movq (%r14), %r15
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x1a0c7
callq *0x6f251(%rip)          # 0x89318
leaq 0x38(%r15), %rcx
movq %rcx, %rax
movq (%rcx), %rdx
leaq 0x8(%rdx), %rcx
cmpq %r14, %rdx
jne 0x1a0cb
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
movq %r14, %rdi
callq 0xa3cf
movq $0x0, 0x40(%rbx)
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x1a100
callq *0x6f228(%rip)          # 0x89328
cmpl $0x0, 0x6f18d(%rip)     # 0x89294
je 0x1a116
movl $0x2, %edi
callq *0x6f1f4(%rip)          # 0x89308
jmp 0x1a118
xorl %eax, %eax
testq %rax, %rax
je 0x1a126
movq %rax, %rdi
callq *0x6f1f2(%rip)          # 0x89318
decl 0x30(%r15)
jne 0x1a149
testl %ebp, %ebp
je 0x1a141
cmpl $0x0, 0x18(%r15)
js 0x1a141
movq 0x10(%r15), %rdi
callq *0x6f737(%rip)          # 0x89878
movq %rbx, %rdi
callq 0x1aab6
cmpl $0x0, 0x6f144(%rip)     # 0x89294
je 0x1a15f
movl $0x2, %edi
callq *0x6f1ab(%rip)          # 0x89308
jmp 0x1a161
xorl %eax, %eax
testq %rax, %rax
je 0x1a16f
movq %rax, %rdi
callq *0x6f1b9(%rip)          # 0x89328
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
testl %edx, %edx
movl $0x1a4, %r12d           # imm = 0x1A4
cmovnel %edx, %r12d
movl %esi, %r13d
orl $0x80000, %r13d         # imm = 0x80000
movq %r15, %rdi
movl %r13d, %esi
movl %r12d, %edx
callq *0x6f28f(%rip)          # 0x896f8
movl %eax, %ebp
testl %eax, %eax
js 0x1a4ac
cmpl $0x2, %ebp
jg 0x1a4bd
movl %ebp, %edi
callq *0x6f294(%rip)          # 0x89710
movl $0x1c, %edi
leaq 0x55f73(%rip), %rsi     # 0x703fb
movq %r15, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0xb94a
leaq 0x55f8b(%rip), %rdi     # 0x70426
movl %r14d, %esi
movl %ebx, %edx
callq *0x6f252(%rip)          # 0x896f8
testl %eax, %eax
jns 0x1a45a
jmp 0x1a4b8
callq 0x7030
cmpl $0x4, (%rax)
je 0x1a45a
jmp 0x1a4bd
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %ebx, %ebx
sete %al
testl %ebp, %ebp
sets %cl
orb %al, %cl
jne 0x1a4fb
leaq 0x8(%rsp), %rsi
movl %ebp, %edi
callq *0x6f298(%rip)          # 0x89770
testl %eax, %eax
jne 0x1a4fb
cmpq $0x0, 0x38(%rsp)
jne 0x1a4fb
movl $0x1ff, %eax            # imm = 0x1FF
andl 0x20(%rsp), %eax
cmpl %ebx, %eax
je 0x1a4fb
movl %ebp, %edi
movl %ebx, %esi
callq *0x6f34d(%rip)          # 0x89848
movl %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq