LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_7/exercise_7_07/find.c
// Function: parse_arg_list
boolean parse_arg_list(int argc, char *argv[])
{
  program_name = argv[0];

  if (argc < 3)
  {
    fprintf(stderr, "Usage: %s [-xn]... PATTERN [FILE]...\n", program_name);
    return false;
  }

  while (--argc > 0 && (*++argv)[0] == '-')
  {
    int c;
    while ((c = *++argv[0]))
    {
      switch (c)
      {
      case 'x':
        except = true;
        break;

      case 'n':
        number = true;
        break;

      default:
        fprintf(stderr, "%s: illegal option %c.\n", program_name, c);
        return false;
        break;
      }
    }

    ++pattern_arg_pos;
  }

  return true;
}

// Assembly:
pushq %rbx
movq (%rsi), %rdx
movq %rdx, 0x2dde(%rip)      # 0x4088
cmpl $0x3, %edi
jl 0x1337
movl 0x2db7(%rip), %eax      # 0x4070
pushq $0x1
popq %rbx
leaq 0x2dbd(%rip), %rcx      # 0x4080
leaq 0x2dba(%rip), %r8       # 0x4084
cmpl $0x2, %edi
jl 0x1333
movq 0x8(%rsi), %r9
cmpb $0x2d, (%r9)
jne 0x1333
decl %edi
addq $0x8, %rsi
incq %r9
movq %r9, (%rsi)
movzbl (%r9), %r10d
cmpl $0x6e, %r10d
je 0x12fa
movq %rcx, %r11
cmpl $0x78, %r10d
je 0x12fd
jmp 0x1306
movq %r8, %r11
movl $0x1, (%r11)
jmp 0x12df
testl %r10d, %r10d
jne 0x1315
incl %eax
movl %eax, 0x2d5d(%rip)      # 0x4070
jmp 0x12ca
movsbl %r10b, %ecx
movq 0x2cd8(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd16(%rip), %rsi       # 0x2040
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1080
movl %ebx, %eax
popq %rbx
retq
movq 0x2cba(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xcd2(%rip), %rsi       # 0x201a
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1080
jmp 0x1333
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_7/exercise_7_07/find.c
// Function: find_pattern
void find_pattern(char *pattern, FILE *file_p)
{
  size_t line_number = 1;
  char line[MAX_LINE_LEN];
  while (fgets(line, MAX_LINE_LEN, file_p) != NULL)
  {
    if ((strstr(line, pattern) != NULL) != except)
    {
      if (number)
      {
        printf("%ld: ", line_number);
      }
      printf("%s", line);
    }
    ++line_number;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3e8, %rsp            # imm = 0x3E8
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %r15
movq %rsp, %r12
leaq 0xce6(%rip), %r13       # 0x205e
leaq 0xcd9(%rip), %rbp       # 0x2058
movq %r12, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
movq %rbx, %rdx
callq 0x1060
testq %rax, %rax
je 0x13d7
movq %r12, %rdi
movq %r14, %rsi
callq 0x10b0
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
cmpl %ecx, 0x2cd3(%rip)      # 0x4080
je 0x13d2
cmpl $0x0, 0x2cce(%rip)      # 0x4084
je 0x13c5
movq %rbp, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1050
movq %r13, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1050
incq %r15
jmp 0x137f
addq $0x3e8, %rsp            # imm = 0x3E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x789ba(%rip), %r15     # 0x7ffe0
movq (%r15), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %edx, %edx
callq 0x7170
movl 0x4(%rbx), %esi
addl $0x4, %esi
leaq 0x579ee(%rip), %rdx     # 0x5f030
xorl %edi, %edi
xorl %eax, %eax
callq 0x73b0
movq (%r15), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %edx, %edx
callq 0x7390
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x8bd0
movq (%r15), %r13
movq 0x8(%r15), %r12
pushq $0x1
popq %rbp
leaq 0x5bdf3(%rip), %r14     # 0x6346c
leaq 0x57ac6(%rip), %r15     # 0x5f146
cmpq %r12, %r13
je 0x76c7
movl 0x4(%rbx), %esi
incl %esi
movq (%r13), %rcx
movl %ebp, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x73b0
movq 0x7893f(%rip), %rax     # 0x7ffe0
movq (%rax), %rdi
callq 0x72f0
movl 0x4(%rbx), %esi
addl $0x18, %esi
movl 0x20(%r13), %ecx
movl %ebp, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x73b0
incl %ebp
addq $0x28, %r13
jmp 0x7680
movq %rsp, %rdi
callq 0x795a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x795a
movq %rbx, %rdi
callq 0x74e0
// File: /workspace/github_c_makefile_star2_O2/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 0x7440
callq 0x7070
callq 0x70d0
movq 0x78642(%rip), %r14     # 0x7ffe0
movq (%r14), %rdi
xorl %esi, %esi
callq 0x7320
callq 0x7310
xorl %edi, %edi
callq 0x7230
movq (%r14), %rdi
pushq $0x1
popq %rsi
callq 0x7100
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7e06
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7300
xorl %ebp, %ebp
movq 0x781c2(%rip), %r15     # 0x7ffe0
pushq $0x7c
popq %r14
cmpl (%rbx), %ebp
jge 0x7e65
movq (%r15), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x72e0
cmpl $-0x1, %eax
je 0x7e42
movq (%r15), %rdi
movl %r14d, %esi
callq 0x70b0
movq (%r15), %rdi
movl 0x4(%rbx), %edx
decl %edx
movl %ebp, %esi
callq 0x72e0
cmpl $-0x1, %eax
je 0x7e61
movq (%r15), %rdi
movl %r14d, %esi
callq 0x70b0
incl %ebp
jmp 0x7e22
xorl %ebp, %ebp
pushq $0x2d
popq %r14
movq (%r15), %rdi
cmpl 0x4(%rbx), %ebp
jge 0x7eae
xorl %esi, %esi
movl %ebp, %edx
callq 0x72e0
cmpl $-0x1, %eax
je 0x7e8c
movq (%r15), %rdi
movl %r14d, %esi
callq 0x70b0
movq (%r15), %rdi
movl (%rbx), %esi
decl %esi
movl %ebp, %edx
callq 0x72e0
cmpl $-0x1, %eax
je 0x7eaa
movq (%r15), %rdi
movl %r14d, %esi
callq 0x70b0
incl %ebp
jmp 0x7e6b
xorl %esi, %esi
xorl %edx, %edx
callq 0x72e0
cmpl $-0x1, %eax
je 0x7ec7
movq (%r15), %rdi
pushq $0x2f
popq %rsi
callq 0x70b0
movq (%r15), %rdi
movl (%rbx), %esi
decl %esi
xorl %edx, %edx
callq 0x72e0
cmpl $-0x1, %eax
je 0x7ee5
movq (%r15), %rdi
pushq $0x5c
popq %rsi
callq 0x70b0
movq (%r15), %rdi
movl 0x4(%rbx), %edx
decl %edx
xorl %esi, %esi
callq 0x72e0
cmpl $-0x1, %eax
je 0x7f04
movq (%r15), %rdi
pushq $0x5c
popq %rsi
callq 0x70b0
movq (%r15), %rdi
movl (%rbx), %esi
movl 0x4(%rbx), %edx
decl %esi
decl %edx
callq 0x72e0
cmpl $-0x1, %eax
je 0x7f2f
movq (%r15), %rdi
pushq $0x2f
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x70b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x3
popq %rsi
xorl %edx, %edx
callq 0x7050
movq 0x77b4b(%rip), %r14     # 0x7ffe0
movq (%r14), %rdi
movl $0x200100, %esi         # imm = 0x200100
xorl %edx, %edx
callq 0x7170
pushq $0x40
popq %rsi
movq %rbx, %rdi
callq 0x87d2
movq (%r14), %rdi
movl $0x200100, %esi         # imm = 0x200100
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x852e
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cvtsi2sdl (%rax), %xmm1
ucomisd %xmm1, %xmm0
jae 0x8532
movl 0x4(%rax), %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
decl %eax
cltq
addq $0x10, %rsi
movq %rsi, %rdi
movq %rax, %rsi
callq 0x8838
movl (%rax), %eax
testl %eax, %eax
je 0x8536
leal -0x2(%rax), %ecx
cvtsi2sd %ecx, %xmm0
movsd (%rbx), %xmm1
addl $0x2, %eax
cvtsi2sd %eax, %xmm2
cmpltpd %xmm1, %xmm0
cmpltpd %xmm2, %xmm1
andpd %xmm0, %xmm1
movd %xmm1, %eax
jmp 0x8538
xorl %eax, %eax
jmp 0x8539
xorl %eax, %eax
jmp 0x8538
movb $0x1, %al
popq %rbx
andb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movl 0x58(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x58(%rdi)
testb $0x1, %al
je 0x85b6
movq %rdi, %rbx
callq 0x88d6
movl 0x58(%rbx), %eax
pushq $0x14
popq %rcx
cltd
idivl %ecx
cmpl $0x4, %edx
je 0x857e
cmpl $0x2, %edx
je 0x857e
testl %edx, %edx
jne 0x85a6
movq %rbx, %rdi
callq 0x88f4
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
jmp 0x85ae
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
jne 0x8595
movq 0x48(%rbx), %rax
movl $0x200, %esi            # imm = 0x200
addq -0x8(%rax), %rsi
addq $-0x4, %rsi
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x891a
leaq 0x8(%rsp), %rsi
andl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x81ac
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x98fb
leaq 0x8(%rbx), %rsi
pushq $0x6
popq %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x1552d
movq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rcx
leaq 0x566c6(%rip), %rsi     # 0x5f149
pushq $0x1b
popq %rdx
xorl %r8d, %r8d
callq 0x11e1a
movq 0x18(%rbx), %rdi
callq 0xecb0
movq 0x18(%rbx), %rdi
callq 0xe2a4
movq 0x8(%rbx), %rdi
leaq 0x10(%rbx), %rcx
leaq 0x566b6(%rip), %rsi     # 0x5f165
pushq $0x3e
popq %rdx
xorl %r8d, %r8d
callq 0x11e1a
movq 0x10(%rbx), %rdi
callq 0xecb0
movq 0x10(%rbx), %rdi
callq 0xe2a4
movq 0x8(%rbx), %rdi
leaq 0x20(%rbx), %rcx
leaq 0x566c9(%rip), %rsi     # 0x5f1a4
pushq $0x3a
popq %rdx
xorl %r8d, %r8d
callq 0x11e1a
movq 0x20(%rbx), %rdi
pushq $0x1
popq %rsi
movl %ebp, %edx
callq 0x10071
movq 0x8(%rbx), %rdi
leaq 0x28(%rbx), %rcx
leaq 0x566dc(%rip), %rsi     # 0x5f1df
pushq $0x2c
popq %rdx
xorl %r8d, %r8d
callq 0x11e1a
movq 0x8(%rbx), %rdi
addq $0x30, %rbx
leaq 0x566ef(%rip), %rsi     # 0x5f20c
pushq $0x20
popq %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
popq %rbx
popq %r14
popq %rbp
jmp 0x11e1a
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x10071
movq 0x28(%rbx), %rdi
callq 0xecb0
movq 0x28(%rbx), %rdi
xorl %esi, %esi
callq 0xfc54
movl %eax, %ebp
movq 0x28(%rbx), %rdi
callq 0xe3a2
cmpl (%rbx), %ebp
setl %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
pushq $-0x1
popq %rcx
pushq $-0x1
popq %r8
callq 0x100fb
movq 0x30(%r14), %rdi
pushq $0x2
popq %rsi
movl %ebx, %edx
callq 0x10071
movq 0x30(%r14), %rdi
callq 0xecb0
movq 0x30(%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe3a2
// File: /workspace/github_c_makefile_star2_O2/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 $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x20(%rsi), %rdi
movl (%rsi), %edx
pushq $0x1
popq %rsi
callq 0x10071
leaq 0x28(%rsp), %r15
movq %rsp, %r12
pushq $0x1
popq %rbp
movq 0x20(%r14), %rdi
callq 0xecb0
cmpl $0x64, %eax
jne 0x8c9c
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
andq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0xfca8
movq %rax, %r13
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0xfbd9
movslq %eax, %rdx
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
addq %r13, %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x8d0a
movq %r12, %rdi
movq %r15, %rsi
callq 0x7380
movq %r15, %rdi
callq 0x7150
movq 0x20(%r14), %rdi
movl %ebp, %esi
callq 0xfc54
movl %eax, 0x20(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8cde
movq %r12, %rdi
callq 0x7150
jmp 0x8c08
movq 0x20(%r14), %rdi
callq 0xe3a2
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8cbd
jmp 0x8cc2
jmp 0x8cc2
movq %rax, %r14
jmp 0x8ccd
movq %rax, %r14
movq %rsp, %rdi
callq 0x7150
movq %rbx, %rdi
callq 0x795a
movq %r14, %rdi
callq 0x74e0
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x8
popq %r14
xorl %r15d, %r15d
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jge 0x94c6
movq 0x20(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x94bd
callq 0xca44
incq %r15
addq $0x20, %r14
jmp 0x94a2
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x8
popq %r14
xorl %r15d, %r15d
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jge 0x94ff
movq 0x20(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x94f6
callq 0xde91
incq %r15
addq $0x20, %r14
jmp 0x94db
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, %bpl
cmpl $0x0, 0x76407(%rip)     # 0x802a4
je 0x9ebd
pushq $0x2
popq %rdi
callq *0x76470(%rip)          # 0x80318
testq %rax, %rax
je 0x9ebd
movq %rax, %r14
movq %rax, %rdi
callq *0x7646f(%rip)          # 0x80328
xorl %ebp, %ebp
jmp 0x9ec0
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x9e4a
testb %bpl, %bpl
jne 0x9ed6
movq %r14, %rdi
callq *0x76462(%rip)          # 0x80338
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x77de6(%rip), %rdi     # 0x81d18
testq %rdi, %rdi
je 0x9f46
callq *0x763eb(%rip)          # 0x80328
movq 0x77dd4(%rip), %rdi     # 0x81d18
jmp 0x9f48
xorl %edi, %edi
movq %r15, 0x77dd9(%rip)     # 0x81d28
movq %r14, 0x77dda(%rip)     # 0x81d30
movq %rbx, 0x77dc3(%rip)     # 0x81d20
testq %rbx, %rbx
setg %al
movslq 0x77d56(%rip), %rcx     # 0x81cc0
cmpq %rbx, %rcx
setge %cl
andb %al, %cl
movzbl %cl, %eax
movl %eax, 0x77dd1(%rip)     # 0x81d4c
testq %rdi, %rdi
je 0x9f8b
popq %rbx
popq %r14
popq %r15
jmpq *0x763ad(%rip)          # 0x80338
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x17d9a
callq 0x7290
testq %rax, %rax
je 0xbf4d
leaq 0x5752e(%rip), %rdx     # 0x6346c
movl %ebp, %edi
movq %rbx, %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0xb40d
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x17e08
// File: /workspace/github_c_makefile_star2_O2/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 0xfbd7
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x94(%rbx), %esi
callq 0xe358
movl %eax, 0x94(%rbx)
movq (%rbx), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0xfbd7
popq %rbx
jmpq *0x70761(%rip)          # 0x80338
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]flappy/sqlite3.c
// Function: columnName
static const void *columnName(
  sqlite3_stmt *pStmt,
  int N,
  const void *(*xFunc)(Mem*),
  int useType
){
  const void *ret = 0;
  Vdbe *p = (Vdbe *)pStmt;
  int n;
  sqlite3 *db = p->db;
  
  assert( db!=0 );
  n = sqlite3_column_count(pStmt);
  if( N<n && N>=0 ){
    N += useType*n;
    sqlite3_mutex_enter(db->mutex);
    assert( db->mallocFailed==0 );
    ret = xFunc(&p->aColName[N]);
     /* A malloc may have failed inside of the xFunc() call. If this
    ** is the case, clear the mallocFailed flag and return NULL.
    */
    if( db->mallocFailed ){
      db->mallocFailed = 0;
      ret = 0;
    }
    sqlite3_mutex_leave(db->mutex);
  }
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movzwl 0x48(%rdi), %ebp
cmpl %esi, %ebp
jbe 0xfda9
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdi), %r15
imull %ecx, %ebp
addl %esi, %ebp
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0xfd8d
callq *0x7059b(%rip)          # 0x80328
movl %ebp, %eax
imulq $0x38, %rax, %rdi
addq 0x20(%r14), %rdi
callq *%rbx
cmpb $0x0, 0x50(%r15)
je 0xfdad
movb $0x0, 0x50(%r15)
xorl %ebx, %ebx
jmp 0xfdb0
xorl %ebx, %ebx
jmp 0xfdbf
movq %rax, %rbx
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0xfdbf
callq *0x70579(%rip)          # 0x80338
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xff2f
movl %eax, %ebx
testl %eax, %eax
jne 0x100f1
movq (%r14), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x100f1
callq *0x70247(%rip)          # 0x80338
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x103e4
callq *0x6ff4a(%rip)          # 0x80328
movq 0x18(%rbx), %rdi
jmp 0x103e6
xorl %edi, %edi
addq $0x8, %rbx
leaq 0x68(%r14), %rax
testq %r14, %r14
cmoveq %rbx, %rax
movq (%rax), %rbx
testq %rdi, %rdi
je 0x10403
callq *0x6ff35(%rip)          # 0x80338
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rax
shll %cl, %eax
orl %eax, 0xa0(%rdi)
cmpl $0x1, %esi
je 0x10de2
movq (%rdi), %rdx
movq 0x20(%rdx), %rdx
movslq %ecx, %rcx
shlq $0x5, %rcx
movq 0x8(%rdx,%rcx), %rcx
cmpb $0x0, 0x11(%rcx)
je 0x10de2
orl %eax, 0xa4(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x10e08
cmpb $0x0, 0x50(%rdi)
je 0x10e29
cmpl $-0xa, %ebp
je 0x10ec3
movl %ebp, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20ddd
testl %esi, %esi
jns 0x10e33
movl 0x34(%r14), %esi
decl %esi
movslq %esi, %rax
imulq $0x18, %rax, %r13
leaq (%r12,%r13), %r15
movsbl 0x1(%r12,%r13), %esi
movq 0x10(%r12,%r13), %rdx
callq 0x20ddd
andq $0x0, 0x10(%r12,%r13)
cmpl $-0xe, %ebp
jne 0x10e64
movl %ebx, 0x10(%r15)
movb $-0xe, 0x1(%r15)
jmp 0x10ec3
testq %rbx, %rbx
je 0x10e7e
cmpl $-0xa, %ebp
je 0x10e85
cmpl $-0x6, %ebp
jne 0x10e93
movq %rbx, 0x10(%r15)
movb $-0x6, 0x1(%r15)
jmp 0x10ec3
movb $0x0, 0x1(%r15)
jmp 0x10ec3
movq %rbx, 0x10(%r15)
movb $-0xa, 0x1(%r15)
incl 0x18(%rbx)
jmp 0x10ec3
testl %ebp, %ebp
js 0x10ebb
jne 0x10ea3
movq %rbx, %rdi
callq 0x90a2
movl %eax, %ebp
movq (%r14), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x32017
movq %rax, 0x10(%r15)
movb $-0x1, 0x1(%r15)
jmp 0x10ec3
movq %rbx, 0x10(%r15)
movb %bpl, 0x1(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x10f25
movl %esi, %ebx
movq %rdi, %r14
movslq %esi, %r12
imulq $0x18, %r12, %r13
movq (%rdi), %rdi
movsbl 0x1(%r15,%r13), %esi
movq 0x10(%r15,%r13), %rdx
callq 0x20ddd
xorps %xmm0, %xmm0
movups %xmm0, (%r15,%r13)
andq $0x0, 0x10(%r15,%r13)
movb $-0x69, (%r15,%r13)
movl 0x34(%r14), %eax
decl %eax
cmpl %r12d, %eax
jne 0x10f25
movl %ebx, 0x34(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_set_authorizer
SQLITE_API int sqlite3_set_authorizer(
  sqlite3 *db,
  int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
  void *pArg
){
  sqlite3_mutex_enter(db->mutex);
  db->xAuth = xAuth;
  db->pAuthArg = pArg;
  sqlite3ExpirePreparedStatements(db);
  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 0x1173a
callq *0x6ebee(%rip)          # 0x80328
movq %r15, 0x170(%rbx)
movq %r14, 0x178(%rbx)
movq %rbx, %rdi
callq 0x11767
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1175f
callq *0x6ebd9(%rip)          # 0x80338
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12310
callq *0x6e018(%rip)          # 0x80328
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 0x12336
callq *0x6e002(%rip)          # 0x80338
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
callq 0x98fb
testl %eax, %eax
jne 0x124ec
movb $0x1, %bpl
cmpl $0x0, 0x6ddfa(%rip)     # 0x802a4
je 0x124ca
pushq $0x2
popq %rdi
callq *0x6de63(%rip)          # 0x80318
testq %rax, %rax
je 0x124ca
movq %rax, %rbx
movq %rax, %rdi
callq *0x6de62(%rip)          # 0x80328
xorl %ebp, %ebp
jmp 0x124cc
xorl %ebx, %ebx
movq 0x6f98d(%rip), %rdi     # 0x81e60
callq 0xa0b5
andq $0x0, 0x6f980(%rip)     # 0x81e60
andl $0x0, 0x6f971(%rip)     # 0x81e58
testb %bpl, %bpl
je 0x124f3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x6de36(%rip)          # 0x80338
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]flappy/sqlite3.c
// Function: sqlite3_shutdown
SQLITE_API int sqlite3_shutdown(void){
  if( sqlite3GlobalConfig.isInit ){
#ifdef SQLITE_EXTRA_SHUTDOWN
    void SQLITE_EXTRA_SHUTDOWN(void);
    SQLITE_EXTRA_SHUTDOWN();
#endif
    sqlite3_os_end();
    sqlite3_reset_auto_extension();
    sqlite3GlobalConfig.isInit = 0;
  }
  if( sqlite3GlobalConfig.isPCacheInit ){
    sqlite3PcacheShutdown();
    sqlite3GlobalConfig.isPCacheInit = 0;
  }
  if( sqlite3GlobalConfig.isMallocInit ){
    sqlite3MallocEnd();
    sqlite3GlobalConfig.isMallocInit = 0;

#ifndef SQLITE_OMIT_SHUTDOWN_DIRECTORIES
    /* The heap subsystem has now been shutdown and these values are supposed
    ** to be NULL or point to memory that was obtained from sqlite3_malloc(),
    ** which would rely on that heap subsystem; therefore, make sure these
    ** values cannot refer to heap memory that was just invalidated when the
    ** heap subsystem was shutdown.  This is only done if the current call to
    ** this function resulted in the heap subsystem actually being shutdown.
    */
    sqlite3_data_directory = 0;
    sqlite3_temp_directory = 0;
#endif
  }
  if( sqlite3GlobalConfig.isMutexInit ){
    sqlite3MutexEnd();
    sqlite3GlobalConfig.isMutexInit = 0;
  }

  return SQLITE_OK;
}

// Assembly:
pushq %rax
cmpl $0x0, 0x6cd68(%rip)     # 0x80408
je 0x136ae
callq 0x12494
andl $0x0, 0x6cd5a(%rip)     # 0x80408
cmpl $0x0, 0x6cd63(%rip)     # 0x80418
je 0x136d3
movq 0x6ccaa(%rip), %rax     # 0x80368
testq %rax, %rax
je 0x136cc
movq 0x6cc8e(%rip), %rdi     # 0x80358
callq *%rax
andl $0x0, 0x6cd45(%rip)     # 0x80418
cmpl $0x0, 0x6cd3a(%rip)     # 0x80414
je 0x13728
movq 0x6cc15(%rip), %rax     # 0x802f8
testq %rax, %rax
je 0x136f1
movq 0x6cc11(%rip), %rdi     # 0x80300
callq *%rax
xorps %xmm0, %xmm0
andq $0x0, 0x6e64c(%rip)     # 0x81d48
movups %xmm0, 0x6e635(%rip)    # 0x81d38
andl $0x0, 0x6cd0a(%rip)     # 0x80414
movups %xmm0, 0x6e617(%rip)    # 0x81d28
andq $0x0, 0x6e757(%rip)     # 0x81e70
movups %xmm0, 0x6e5f8(%rip)    # 0x81d18
andq $0x0, 0x6e740(%rip)     # 0x81e68
cmpl $0x0, 0x6cce1(%rip)     # 0x80410
je 0x13746
movq 0x6cbd8(%rip), %rax     # 0x80310
testq %rax, %rax
je 0x1373f
callq *%rax
andl $0x0, 0x6ccca(%rip)     # 0x80410
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14279
callq *0x6c0b5(%rip)          # 0x80328
movq 0x18(%rbx), %rdi
jmp 0x1427b
xorl %edi, %edi
movq %r15, 0x298(%rbx)
movq %r14, 0x2a0(%rbx)
andl $0x0, 0x2a8(%rbx)
andl $0x0, 0x2f8(%rbx)
testq %rdi, %rdi
je 0x142a2
callq *0x6c096(%rip)          # 0x80338
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x142cb
callq *0x6c05d(%rip)          # 0x80328
xorl %eax, %eax
testl %ebp, %ebp
cmovleq %rax, %r15
movl $0x0, %ecx
cmovgl %ebp, %ecx
cmovleq %rax, %rbx
movq %r15, 0x180(%r14)
movl %ecx, 0x190(%r14)
movq %rbx, 0x188(%r14)
movq 0x18(%r14), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x1430d
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *0x6c02b(%rip)          # 0x80338
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x149e9
callq *0x6b945(%rip)          # 0x80328
movq 0x18(%r14), %rdi
jmp 0x149eb
xorl %edi, %edi
movq 0xc0(%r14), %r12
movq %r15, 0xb8(%r14)
movq %rbx, 0xc0(%r14)
testq %rdi, %rdi
je 0x14a0b
callq *0x6b92d(%rip)          # 0x80338
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14a40
callq *0x6b8ee(%rip)          # 0x80328
movq 0x18(%r14), %rdi
jmp 0x14a42
xorl %edi, %edi
movq 0xd0(%r14), %r12
movq %r15, 0xc8(%r14)
movq %rbx, 0xd0(%r14)
testq %rdi, %rdi
je 0x14a62
callq *0x6b8d6(%rip)          # 0x80338
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14a97
callq *0x6b897(%rip)          # 0x80328
movq 0x18(%r14), %rdi
jmp 0x14a99
xorl %edi, %edi
movq 0xd8(%r14), %r12
movq %r15, 0xe0(%r14)
movq %rbx, 0xd8(%r14)
testq %rdi, %rdi
je 0x14ab9
callq *0x6b87f(%rip)          # 0x80338
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14aee
callq *0x6b840(%rip)          # 0x80328
movq 0x18(%r14), %rdi
jmp 0x14af0
xorl %edi, %edi
movq 0xf8(%r14), %r12
movq %r15, 0x100(%r14)
movq %rbx, 0xf8(%r14)
testq %rdi, %rdi
je 0x14b10
callq *0x6b828(%rip)          # 0x80338
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14b45
callq *0x6b7e9(%rip)          # 0x80328
movq 0x18(%r14), %rdi
jmp 0x14b47
xorl %edi, %edi
movq 0xe8(%r14), %r12
movq %r15, 0xf0(%r14)
movq %rbx, 0xe8(%r14)
testq %rdi, %rdi
je 0x14b67
callq *0x6b7d1(%rip)          # 0x80338
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14bb9
callq *0x6b775(%rip)          # 0x80328
movq 0x18(%r14), %rdi
jmp 0x14bbb
xorl %edi, %edi
movq 0x110(%r14), %r12
movq %r15, 0x108(%r14)
movq %rbx, 0x110(%r14)
testq %rdi, %rdi
je 0x14bdb
callq *0x6b75d(%rip)          # 0x80338
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x155e8
callq *0x6ad40(%rip)          # 0x80328
movzbl %bpl, %edx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rcx
movq %r14, %r8
xorl %r9d, %r9d
callq 0x15626
movq %rbx, %rdi
movl %eax, %esi
callq 0xe358
movl %eax, %ebp
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1561b
callq *0x6ad1d(%rip)          # 0x80338
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x15845
callq *0x6aae3(%rip)          # 0x80328
movzbl %bpl, %edx
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
callq 0x15626
movq %rbx, %rdi
movl %eax, %esi
callq 0xe358
movl %eax, %ebp
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x15878
callq *0x6aac0(%rip)          # 0x80338
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_O2/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, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x15936
callq *0x6a9f8(%rip)          # 0x80328
movq 0x18(%r14), %rdi
jmp 0x15938
xorl %edi, %edi
movq %r15, 0x118(%r14)
andq $0x0, 0x120(%r14)
movq %rbx, 0x128(%r14)
testq %rdi, %rdi
je 0x15959
callq *0x6a9df(%rip)          # 0x80338
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x15984
callq *0x6a9aa(%rip)          # 0x80328
movq 0x18(%r15), %rdi
jmp 0x15986
xorl %edi, %edi
andq $0x0, 0x118(%r15)
movq %r14, 0x120(%r15)
movq %rbx, 0x128(%r15)
testq %rdi, %rdi
je 0x159a7
callq *0x6a991(%rip)          # 0x80338
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
xorl %r14d, %r14d
testq %rdi, %rdi
je 0x15a0b
callq *0x6a923(%rip)          # 0x80328
movq 0x18(%rbx), %rdi
jmp 0x15a0d
xorl %edi, %edi
negl %ebp
sbbl %r14d, %r14d
orl $0xff, %r14d
movl %r14d, 0x48(%rbx)
testq %rdi, %rdi
je 0x15a28
callq *0x6a910(%rip)          # 0x80338
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x17c7f
movl %esi, %ebp
movq %rdi, %rbx
movq (%r14), %r15
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x17c1c
callq *0x6870c(%rip)          # 0x80328
leaq 0x38(%r15), %rcx
movq %rcx, %rax
movq (%rcx), %rdx
leaq 0x8(%rdx), %rcx
cmpq %r14, %rdx
jne 0x17c20
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
movq %r14, %rdi
callq 0xa0b5
andq $0x0, 0x40(%rbx)
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x17c52
callq *0x686e6(%rip)          # 0x80338
callq 0x17d9a
decl 0x30(%r15)
jne 0x17c7a
testl %ebp, %ebp
je 0x17c72
cmpl $0x0, 0x18(%r15)
js 0x17c72
movq 0x10(%r15), %rdi
callq *0x68c16(%rip)          # 0x80888
movq %rbx, %rdi
callq 0x185c8
callq 0x17e08
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq