LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/database.cpp
// Function: ash::DBObject::quote(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const string DBObject::quote(const string & in) {
  if (in.empty()) return "null";
  string out = "'";
  char c;
  for (string::const_iterator i = in.begin(), e = in.end(); i != e; ++i) {
    c = *i;
    switch (c) {
      case '\n':  // fallthrough
      case '\t':
        out.push_back(c);
        break;
      case '\'':
        out.push_back(c); // fallthrough
      default:
        if (isprint(c)) out.push_back(c);
    }
  }
  out.push_back('\'');
  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
cmpq $0x0, 0x8(%rsi)
movq %r15, (%rdi)
je 0x6a74d
movq %rsi, %r14
leaq 0x13c5f(%rip), %rsi     # 0x7e343
leaq 0x13c59(%rip), %rdx     # 0x7e344
movq %rbx, %rdi
callq 0x68de4
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x6a73e
movq (%r14), %r14
xorl %r13d, %r13d
movzbl (%r14,%r13), %eax
movsbl %al, %ebp
leal -0x9(%rax), %ecx
cmpl $0x2, %ecx
jb 0x6a72c
cmpl $0x27, %eax
jne 0x6a721
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8310
movl %ebp, %edi
callq 0x8730
testl %eax, %eax
je 0x6a736
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8310
incq %r13
cmpq %r13, %r12
jne 0x6a702
movq %rbx, %rdi
movl $0x27, %esi
callq 0x8310
jmp 0x6a763
leaq 0x13b41(%rip), %rsi     # 0x7e295
leaq 0x13b3e(%rip), %rdx     # 0x7e299
movq %rbx, %rdi
callq 0x68de4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6a777
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6a787
callq 0x8390
movq %r14, %rdi
callq 0x8720
nop
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/database.cpp
// Function: ash::Database::init_db()
void Database::init_db() {
  const string & create_tables = DBObject::get_create_tables();
  char * error = 0;
  if (sqlite3_exec(db, create_tables.c_str(), NOOPCallback, 0, &error)) {
    cerr << "Failed to create tables:\n"
         << create_tables
         << "Error:\n"
         << error << endl;
    sqlite3_free(error);
    error = 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6b1c0
movq %rsp, %r8
movq $0x0, (%r8)
movq 0x28(%rbx), %rdi
movq (%r14), %rsi
leaq 0x18f(%rip), %rdx       # 0x6b1bc
xorl %ecx, %ecx
callq 0x12763
testl %eax, %eax
je 0x6b0f3
movq 0x28fa5(%rip), %rdi     # 0x93fe8
leaq 0x12a44(%rip), %rsi     # 0x7da8e
movl $0x19, %edx
callq 0x8470
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x28f83(%rip), %rdi     # 0x93fe8
callq 0x8470
movq %rax, %rbx
leaq 0x12e0c(%rip), %rsi     # 0x7de80
movl $0x7, %edx
movq %rax, %rdi
callq 0x8470
movq (%rsp), %r14
testq %r14, %r14
je 0x6b0a2
movq %r14, %rdi
callq 0x8190
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8470
jmp 0x6b0bb
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq %rbx, %rdi
addq %rax, %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x86b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x83c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8250
movq (%rsp), %rdi
callq 0xa2e8
movq $0x0, (%rsp)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b106
callq 0x8390
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b124
callq 0x8390
movq %rbx, %rdi
callq 0x8720
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/database.cpp
// Function: ash::DBObject::get_create_tables[abi:cxx11]()
const string DBObject::get_create_tables() {
  stringstream ss;
  ss << "PRAGMA foreign_keys=OFF;"
     << "BEGIN TRANSACTION;";
  typedef list<string>::iterator it;
  for (it i = create_tables.begin(), e = create_tables.end(); i != e; ++i) {
    ss << *i << "; ";
  }
  ss << "COMMIT;";
  return ss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8290
leaq 0x18(%rsp), %r14
leaq 0x12c9f(%rip), %rsi     # 0x7de88
movl $0x18, %edx
movq %r14, %rdi
callq 0x8470
leaq 0x12ca4(%rip), %rsi     # 0x7dea1
movl $0x12, %edx
movq %r14, %rdi
callq 0x8470
leaq 0x2b1a7(%rip), %r12     # 0x963b8
leaq 0x12cbd(%rip), %r15     # 0x7ded5
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x6b246
movq 0x10(%r13), %rsi
movq 0x18(%r13), %rdx
movq %r14, %rdi
callq 0x8470
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x8470
jmp 0x6b21b
leaq 0x12c67(%rip), %rsi     # 0x7deb4
movl $0x7, %edx
movq %r14, %rdi
callq 0x8470
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x8630
leaq 0x8(%rsp), %rdi
callq 0x87e8
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x6b287
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x87e8
movq %rbx, %rdi
callq 0x8720
movq %rax, %rdi
callq 0x68c53
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/database.cpp
// Function: ash::DBObject::get_sql[abi:cxx11]() const
const string DBObject::get_sql() const {
  typedef map<string, string>::const_iterator c_iter;

  stringstream ss;
  ss << "INSERT INTO " << get_name() << " (";

  // Insert the column names.
  for (c_iter i = values.begin(), e = values.end(); i != e; ) {
    ss << (i -> first);
    if (++i == e) break;
    ss << ", ";
  }

  ss << ") VALUES (";
  // Insert the values.
  for (c_iter i = values.begin(), e = values.end(); i != e; ) {
    ss << (i -> second);
    if (++i == e) break;
    ss << ", ";
  }

  ss << "); ";

  return ss.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8290
leaq 0x30(%rsp), %r14
leaq 0x11fdb(%rip), %rsi     # 0x7debc
movl $0xc, %edx
movq %r14, %rdi
callq 0x8470
movq (%r15), %rax
movq %rsp, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x8470
leaq 0x11fbf(%rip), %rsi     # 0x7ded1
movl $0x2, %edx
movq %rax, %rdi
callq 0x8470
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6bf32
callq 0x8390
movq 0x20(%r15), %r13
leaq 0x10(%r15), %rbp
leaq 0xff10(%rip), %r12      # 0x7be51
cmpq %rbp, %r13
je 0x6bf78
movq 0x20(%r13), %rsi
movq 0x28(%r13), %rdx
movq %r14, %rdi
callq 0x8470
movq %r13, %rdi
callq 0x8480
cmpq %rbp, %rax
je 0x6bf78
movq %rax, %r13
movl $0x2, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x8470
jmp 0x6bf41
leaq 0x11f4a(%rip), %rsi     # 0x7dec9
movl $0xa, %edx
movq %r14, %rdi
callq 0x8470
movq 0x20(%r15), %r12
leaq 0xfeba(%rip), %r15      # 0x7be51
cmpq %rbp, %r12
je 0x6bfd0
movq 0x40(%r12), %rsi
movq 0x48(%r12), %rdx
movq %r14, %rdi
callq 0x8470
movq %r12, %rdi
callq 0x8480
cmpq %rbp, %rax
je 0x6bfd0
movq %rax, %r12
movl $0x2, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x8470
jmp 0x6bf97
leaq 0x11efd(%rip), %rsi     # 0x7ded4
movl $0x3, %edx
movq %r14, %rdi
callq 0x8470
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x8630
leaq 0x20(%rsp), %rdi
callq 0x87e8
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6c02e
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c031
callq 0x8390
jmp 0x6c031
jmp 0x6c02e
jmp 0x6c02e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x87e8
movq %rbx, %rdi
callq 0x8720
movq %rax, %rdi
callq 0x68c53
nop
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/flags.cpp
// Function: flag::Flag::show_help(std::ostream&)
void Flag::show_help(ostream & out) {
  char * program_name = strdup(prog_name.c_str());
  out << "\nUsage: " << basename(program_name);

  list<Flag *> & flags = Flag::instances();
  if (flags.empty()) return;

  out << " [options]";
  for (list<Flag *>::iterator i = flags.begin(); i != flags.end(); ++i) {
    out << "\n" << **i;
  }
  out << "\n" << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x29b02(%rip), %rdi     # 0x963d8
callq 0x8760
movq %rax, %r14
leaq 0x11652(%rip), %rsi     # 0x7df37
movl $0x8, %edx
movq %rbx, %rdi
callq 0x8470
movq %r14, %rdi
callq 0x86e0
testq %rax, %rax
je 0x6c91a
movq %rax, %r14
movq %rax, %rdi
callq 0x8190
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8470
jmp 0x6c931
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x86b0
callq 0x6d550
cmpq %rax, (%rax)
je 0x6c9d2
movq %rax, %r14
leaq 0x115f7(%rip), %rsi     # 0x7df40
movl $0xa, %edx
movq %rbx, %rdi
callq 0x8470
movq (%r14), %r12
cmpq %r14, %r12
je 0x6c98c
leaq 0x119fa(%rip), %r15     # 0x7e35f
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8470
movq 0x10(%r12), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
movq (%r12), %r12
cmpq %r14, %r12
jne 0x6c965
leaq 0x119cc(%rip), %rsi     # 0x7e35f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8470
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x83c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x8250
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/flags.cpp
// Function: flag::all_isgraph(char const*)
bool all_isgraph(const char * input) {
  for (int i = 0; input && input[i] != '\0'; ++i) {
    if (!isgraph(input[i]))
      return false;
  }
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movb $0x1, %bl
testq %rdi, %rdi
je 0x6cd3f
movq %rdi, %r14
movq %rdi, %r15
movsbl (%r15), %edi
testl %edi, %edi
je 0x6cd3f
callq 0x8380
testl %eax, %eax
je 0x6cd3d
incq %r15
testq %r14, %r14
jne 0x6cd22
jmp 0x6cd3f
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/flags.cpp
// Function: flag::Flag::insert(std::ostream&) const
ostream & Flag::insert(ostream & out) const {
  if (short_name)
    out << "  -" << short_name;
  else
    out << "    ";

  if (long_name) {
    int padding = 2 + longest_long_name - string(long_name).length();
    out << "  --" << long_name;
    if (has_arg) {
      out << "=VALUE";
      padding -= 6;
    }
    out << string(padding, ' ');
  }

  if (description) out << description;
  return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x10(%rdi)
je 0x6d086
leaq 0x10f76(%rip), %rsi     # 0x7dfdd
movl $0x3, %edx
movq %rbx, %rdi
callq 0x8470
movb 0x10(%r14), %al
leaq 0x8(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
jmp 0x6d092
leaq 0x10f54(%rip), %rsi     # 0x7dfe1
movl $0x4, %edx
movq %rbx, %rdi
callq 0x8470
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x6d17e
movl 0x2937e(%rip), %r13d    # 0x9642c
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0x8170
movl 0x8(%r15), %ebp
negl %ebp
movq (%r15), %rdi
leaq 0x18(%rsp), %r12
cmpq %r12, %rdi
je 0x6d0d8
callq 0x8390
leaq 0x10f07(%rip), %rsi     # 0x7dfe6
movl $0x4, %edx
movq %rbx, %rdi
callq 0x8470
movq 0x8(%r14), %r15
testq %r15, %r15
je 0x6d10d
movq %r15, %rdi
callq 0x8190
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x8470
jmp 0x6d124
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x86b0
addl %r13d, %ebp
addl $0x2, %ebp
cmpb $0x1, 0x20(%r14)
jne 0x6d148
leaq 0x10e79(%rip), %rsi     # 0x7dfb1
movl $0x6, %edx
movq %rbx, %rdi
callq 0x8470
addl $-0x6, %ebp
movslq %ebp, %rsi
leaq 0x8(%rsp), %r15
movq %r12, (%r15)
movq %r15, %rdi
movl $0x20, %edx
callq 0x8490
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x8470
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6d17e
callq 0x8390
movq 0x18(%r14), %r14
testq %r14, %r14
je 0x6d19d
movq %r14, %rdi
callq 0x8190
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8470
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6d1c1
callq 0x8390
movq %rbx, %rdi
callq 0x8720
nop
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/flags.cpp
// Function: flag::IntFlag::insert(std::ostream&) const
ostream & IntFlag::insert(ostream & out) const {
  Flag::insert(out);
  if (value && *value) {
    out << "  Default: " << *value;
  }
  return out;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6d046
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x6d251
cmpl $0x0, (%rax)
je 0x6d251
leaq 0x10db5(%rip), %rsi     # 0x7dfeb
movl $0xb, %edx
movq %rbx, %rdi
callq 0x8470
movq 0x28(%r14), %rax
movl (%rax), %esi
movq %rbx, %rdi
callq 0x86d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/flags.cpp
// Function: flag::StringFlag::set(char const*)
void StringFlag::set(const char * optarg) {
  if (optarg) {
    *value = string(optarg);
  } else {
    value -> clear();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x6d2ef
movq %rsi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rsi, %rdi
callq 0x8190
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x68de4
movq 0x28(%rbx), %rdi
movq %r15, %rsi
callq 0x81f0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6d301
callq 0x8390
jmp 0x6d301
movq 0x28(%rbx), %rax
movq $0x0, 0x8(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6d31f
callq 0x8390
movq %rbx, %rdi
callq 0x8720
nop
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/flags.cpp
// Function: flag::StringFlag::insert(std::ostream&) const
ostream & StringFlag::insert(ostream & out) const {
  Flag::insert(out);
  if (!value -> empty()) {
    out << "  Default: '" << *value << "'";
  }
  return out;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6d046
movq 0x28(%r14), %rax
cmpq $0x0, 0x8(%rax)
je 0x6d37d
leaq 0x10cae(%rip), %rsi     # 0x7dff7
movl $0xc, %edx
movq %rbx, %rdi
callq 0x8470
movq 0x28(%r14), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x8470
leaq 0x10fd3(%rip), %rsi     # 0x7e343
movl $0x1, %edx
movq %rax, %rdi
callq 0x8470
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/flags.cpp
// Function: flag::BoolFlag::set(char const*)
void BoolFlag::set(const char * optarg) {
  if (optarg) {
    string opt(optarg);
    if (opt == "true") {
      *value = true;
    } else if (opt == "false") {
      *value = false;
    } else {
      cerr << "ERROR: boolean flags must be either true or false.  Got '"
           << optarg << "'" << endl;
    }
  } else {
    *value = true;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
testq %rsi, %rsi
je 0x6d4a6
movq %rsi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rsi, %rdi
callq 0x8190
leaq (%rax,%rbx), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x68de4
leaq 0x105c7(%rip), %rsi     # 0x7d9ca
movq %r15, %rdi
callq 0x80f0
testl %eax, %eax
je 0x6d4af
leaq 0x10bea(%rip), %rsi     # 0x7e004
leaq 0x8(%rsp), %rdi
callq 0x80f0
testl %eax, %eax
je 0x6d4b3
movq 0x26bb5(%rip), %rdi     # 0x93fe8
leaq 0x10bd0(%rip), %rsi     # 0x7e00a
movl $0x39, %edx
callq 0x8470
movq %rbx, %rdi
callq 0x8190
movq 0x26b95(%rip), %rdi     # 0x93fe8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x8470
movq 0x26b83(%rip), %rbx     # 0x93fe8
leaq 0x10ed7(%rip), %rsi     # 0x7e343
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8470
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x83c0
movsbl %al, %esi
movq 0x26b51(%rip), %rdi     # 0x93fe8
callq 0x8040
movq %rax, %rdi
callq 0x8250
jmp 0x6d4bb
movq 0x28(%r14), %rax
movb $0x1, (%rax)
jmp 0x6d4ca
movb $0x1, %al
jmp 0x6d4b5
xorl %eax, %eax
movq 0x28(%r14), %rcx
movb %al, (%rcx)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6d4ca
callq 0x8390
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6d4e8
callq 0x8390
movq %rbx, %rdi
callq 0x8720
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/flags.cpp
// Function: flag::BoolFlag::insert(std::ostream&) const
ostream & BoolFlag::insert(ostream & out) const {
  Flag::insert(out);
  if (has_arg) {
    out << "  Default: " << (*value ? "true" : "false");
  }
  return out;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6d046
cmpb $0x1, 0x20(%r14)
jne 0x6d542
leaq 0x10ade(%rip), %rsi     # 0x7dfeb
movl $0xb, %edx
movq %rbx, %rdi
callq 0x8470
movq 0x28(%r14), %rax
movzbl (%rax), %edx
leaq 0x104a2(%rip), %rax     # 0x7d9ca
leaq 0x10ad5(%rip), %rsi     # 0x7e004
testq %rdx, %rdx
cmovneq %rax, %rsi
xorq $0x5, %rdx
movq %rbx, %rdi
callq 0x8470
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/flags.cpp
// Function: void flag::safe_add<char>(std::map<char const, flag::Flag*, std::less<char const>, std::allocator<std::pair<char const, flag::Flag*>>>&, char, flag::Flag*)
void safe_add(map<const T, Flag *> & known, const T key, Flag * value) {
  if (known.find(key) != known.end()) {
    cerr << "ERROR: ambiguous flags defined: duplicate key: "
         << "'" << key << "'\n" << *known[key] << "\n" << *value << endl;
  }
  known[key] = value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movb %sil, 0x6(%rsp)
movq 0x10(%rdi), %rdx
leaq 0x8(%rdi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x6d763
movq %rax, %rcx
xorl %edi, %edi
cmpb %sil, 0x20(%rdx)
setl %dil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x6d74b
movq %rax, %rdx
cmpq %rax, %rcx
je 0x6d776
cmpb %sil, 0x20(%rcx)
cmovgq %rax, %rcx
movq %rcx, %rdx
cmpq %rax, %rdx
je 0x6d846
movq 0x26862(%rip), %r15     # 0x93fe8
leaq 0x108b7(%rip), %rsi     # 0x7e044
movl $0x2f, %edx
movq %r15, %rdi
callq 0x8470
leaq 0x10ba2(%rip), %rsi     # 0x7e343
movl $0x1, %edx
movq %r15, %rdi
callq 0x8470
leaq 0x6(%rsp), %r12
movb (%r12), %al
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x8470
movq %rax, %r15
leaq 0x10656(%rip), %rsi     # 0x7de2b
movl $0x2, %edx
movq %rax, %rdi
callq 0x8470
movq %r14, %rdi
movq %r12, %rsi
callq 0x6d6be
movq (%rax), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x10(%rax)
movq %rax, %r15
leaq 0x10b5c(%rip), %rsi     # 0x7e35f
movl $0x1, %edx
movq %rax, %rdi
callq 0x8470
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x83c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8250
leaq 0x6(%rsp), %rsi
movq %r14, %rdi
callq 0x6d6be
movq %rbx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/formatter.cpp
// Function: ash::Formatter::get_desc[abi:cxx11]()
map<string, string> Formatter::get_desc() {
  map<string, string> rval;
  map<string, Formatter *>::iterator i, e;

  for (i = instances.begin(), e = instances.end(); i != e; ++i) {
    if (i -> second)
      rval[i -> first] = i -> second -> description;
  }
  return rval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq 0x285a1(%rip), %r14     # 0x96528
leaq 0x2858a(%rip), %r12     # 0x96518
cmpq %r12, %r14
je 0x6dfc7
movq 0x40(%r14), %r15
testq %r15, %r15
je 0x6dfb7
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x697fa
addq $0x28, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x81f0
movq %r14, %rdi
callq 0x8270
movq %rax, %r14
cmpq %r12, %rax
jne 0x6df93
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x68c98
movq %r14, %rdi
callq 0x8720
movq %rax, %rdi
callq 0x68c53
nop
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/formatter.cpp
// Function: get_widths(ash::ResultSet const*, bool)
vector<size_t> get_widths(const ResultSet * rs, bool do_show_headings) {
  vector<size_t> widths;
  const size_t XX = 4;  // The number of spaces between columns.

  // Initialize with the widths of the headings.
  size_t c = 0;
  ResultSet::HeadersType::const_iterator i, e;
  for (i = (rs -> headers).begin(), e = (rs -> headers).end(); i != e; ++i, ++c)
    if (do_show_headings)
      widths.push_back(XX + i -> size());
    else
      widths.push_back(XX);

  // Limit the width of columns containing very wide elements.
  size_t max_w = 80;  // TODO(cpa): make this a flag or configurable.

  // Loop ofer the rs.data looking for max column widths.
  for (size_t r = 0; r < rs -> rows; ++r) {
    for (size_t c = 0; c < rs -> columns; ++c) {
      widths[c] = max(widths[c], min(max_w, XX + (rs -> data[r][c]).size()));
    }
  }

  return widths;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq $0x4, 0x8(%rsp)
movq (%rsi), %r13
cmpq %rsi, %r13
je 0x6e2c3
movl %edx, %ebp
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r12
testb %bpl, %bpl
je 0x6e293
movq 0x18(%r13), %rax
addq $0x4, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
jne 0x6e2a2
movq %rbx, %rdi
movq %r15, %rdx
callq 0x6f8f2
jmp 0x6e2ba
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6e2af
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x6e2ba
movq %rbx, %rdi
movq %r12, %rdx
callq 0x6f8f2
movq (%r13), %r13
cmpq %r14, %r13
jne 0x6e26a
cmpq $0x0, 0x30(%r14)
je 0x6e321
movq (%rbx), %rax
xorl %ecx, %ecx
movl $0x50, %edx
cmpq $0x0, 0x38(%r14)
je 0x6e318
movq 0x18(%r14), %rsi
leaq (%rcx,%rcx,2), %rdi
movq (%rsi,%rdi,8), %rsi
addq $0x8, %rsi
xorl %edi, %edi
movq (%rsi), %r8
addq $0x4, %r8
movq (%rax,%rdi,8), %r9
cmpq $0x50, %r8
cmovaeq %rdx, %r8
cmpq %r8, %r9
cmovaq %r9, %r8
movq %r8, (%rax,%rdi,8)
incq %rdi
addq $0x20, %rsi
cmpq 0x38(%r14), %rdi
jb 0x6e2ed
incq %rcx
cmpq 0x30(%r14), %rcx
jb 0x6e2d4
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e335
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6e345
callq 0x8390
movq %r14, %rdi
callq 0x8720
nop
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/formatter.cpp
// Function: ash::SpacedFormatter::insert(ash::ResultSet const*, std::ostream&) const
void SpacedFormatter::insert(const ResultSet * rs, ostream & out) const {
  if (!rs) return;  // Sanity check.

  vector<size_t> widths = get_widths(rs, do_show_headings);

  // Print the headings, if not suppressed.
  if (do_show_headings) {
    size_t c = 0, cols = widths.size();
    ResultSet::HeadersType::const_iterator i, e;
    for (i = (rs -> headers).begin(), e = (rs -> headers).end(); i != e; ++i) {
      if (c < cols - 1) out << left << setw(widths[c++]);
      out << *i;
    }
    out << endl;
  }

  // Iterate over the data once more, printing.
  for (size_t r = 0; r < rs -> rows; ++r) {
    for (size_t c = 0; c < rs -> columns; ++c) {
      if (c < rs -> columns - 1) out << left << setw(widths[c]);
      out << (rs -> data)[r][c];
    }
    out << endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x6e4cf
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movzbl 0x48(%rdi), %edx
movq %rsp, %rdi
callq 0x6e22b
cmpb $0x1, 0x48(%r15)
jne 0x6e40f
movq 0x8(%rsp), %r15
subq (%rsp), %r15
sarq $0x3, %r15
decq %r15
xorl %r12d, %r12d
movl $0xffffff4f, %ebp       # imm = 0xFFFFFF4F
movq %r14, %r13
movq (%r13), %r13
cmpq %r14, %r13
je 0x6e3e8
cmpq %r15, %r12
jae 0x6e3d6
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl %ebp, %edx
orl $0x20, %edx
movl %edx, 0x18(%rbx,%rcx)
movq (%rsp), %rcx
movslq (%rcx,%r12,8), %rcx
incq %r12
movq -0x18(%rax), %rax
movq %rcx, 0x10(%rbx,%rax)
movq 0x10(%r13), %rsi
movq 0x18(%r13), %rdx
movq %rbx, %rdi
callq 0x8470
jmp 0x6e3a0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x83c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8250
cmpq $0x0, 0x30(%r14)
je 0x6e4c1
xorl %r15d, %r15d
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x6e48d
movl $0x8, %r12d
leaq (%r15,%r15,2), %r13
xorl %ebp, %ebp
decq %rax
cmpq %rax, %rbp
jae 0x6e464
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
movl $0xffffff4f, %esi       # imm = 0xFFFFFF4F
andl %esi, %edx
orl $0x20, %edx
movl %edx, 0x18(%rbx,%rcx)
movq (%rsp), %rcx
movslq (%rcx,%rbp,8), %rcx
movq -0x18(%rax), %rax
movq %rcx, 0x10(%rbx,%rax)
movq 0x18(%r14), %rax
movq (%rax,%r13,8), %rax
movq -0x8(%rax,%r12), %rsi
movq (%rax,%r12), %rdx
movq %rbx, %rdi
callq 0x8470
incq %rbp
movq 0x38(%r14), %rax
addq $0x20, %r12
cmpq %rax, %rbp
jb 0x6e432
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x83c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8250
incq %r15
cmpq 0x30(%r14), %r15
jb 0x6e41d
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6e4cf
callq 0x8390
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e4e4
jmp 0x6e4e4
jmp 0x6e4e4
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6e4f5
callq 0x8390
movq %rbx, %rdi
callq 0x8720
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/logger.cpp
// Function: parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const Severity parse(const string & input) {
  if (input == "DEBUG") return DEBUG;
  if (input == "INFO") return INFO;
  if (input == "WARNING") return WARNING;
  if (input == "ERROR") return ERROR;
  if (input == "FATAL") return FATAL;
  return UNKNOWN;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xe790(%rip), %rsi      # 0x7e25f
callq 0x80f0
testl %eax, %eax
je 0x6fb2d
leaq 0xe786(%rip), %rsi      # 0x7e265
movq %rbx, %rdi
callq 0x80f0
testl %eax, %eax
je 0x6fb31
leaq 0xe778(%rip), %rsi      # 0x7e26a
movq %rbx, %rdi
callq 0x80f0
testl %eax, %eax
je 0x6fb38
leaq 0xe76d(%rip), %rsi      # 0x7e272
movq %rbx, %rdi
callq 0x80f0
testl %eax, %eax
je 0x6fb3f
leaq 0xe760(%rip), %rsi      # 0x7e278
movq %rbx, %rdi
callq 0x80f0
cmpl $0x1, %eax
movl $0x5, %eax
sbbl $0x0, %eax
jmp 0x6fb44
xorl %eax, %eax
jmp 0x6fb44
movl $0x1, %eax
jmp 0x6fb44
movl $0x2, %eax
jmp 0x6fb44
movl $0x3, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/logger.cpp
// Function: get_target[abi:cxx11](ash::Severity)
string get_target(const Severity level) {
  Config & config = Config::instance();

  // Default to /dev/null if the visibility is too low for this Logger.
  const Severity visible = parse(config.get_string("LOG_LEVEL", "DEBUG"));
  if (level < visible) return "/dev/null";
  // Use the configured target file.
  return config.get_string("LOG_FILE", "/dev/null");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebp
movq %rdi, %rbx
callq 0x69ef2
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0xe6fa(%rip), %rsi      # 0x7e286
leaq 0xe6fc(%rip), %rdx      # 0x7e28f
leaq 0x8(%rsp), %rdi
callq 0x68de4
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xe6b1(%rip), %rsi      # 0x7e25f
leaq 0xe6af(%rip), %rdx      # 0x7e264
leaq 0x48(%rsp), %rdi
callq 0x68de4
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x48(%rsp), %rcx
movq %r14, %rsi
callq 0x69e9a
leaq 0x28(%rsp), %rdi
callq 0x6fac4
movl %eax, %r15d
leaq 0x38(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x6fbf6
callq 0x8390
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x6fc05
callq 0x8390
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %r12
cmpq %r12, %rdi
je 0x6fc19
callq 0x8390
cmpl %ebp, %r15d
jle 0x6fc3d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xe664(%rip), %rsi      # 0x7e290
leaq 0xe666(%rip), %rdx      # 0x7e299
movq %rbx, %rdi
callq 0x68de4
jmp 0x6fca6
leaq 0x28(%rsp), %rdi
movq %r13, (%rdi)
leaq 0xe64e(%rip), %rsi      # 0x7e29a
leaq 0xe64f(%rip), %rdx      # 0x7e2a2
callq 0x68de4
leaq 0x8(%rsp), %rdi
movq %r12, (%rdi)
leaq 0xe629(%rip), %rsi      # 0x7e290
leaq 0xe62b(%rip), %rdx      # 0x7e299
callq 0x68de4
leaq 0x28(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x69e9a
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6fc97
callq 0x8390
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x6fca6
callq 0x8390
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6fccf
callq 0x8390
jmp 0x6fccf
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
jne 0x6fd1b
jmp 0x6fd25
jmp 0x6fd22
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6fcf8
callq 0x8390
jmp 0x6fcf8
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x6fd0c
callq 0x8390
jmp 0x6fd0c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6fd25
callq 0x8390
jmp 0x6fd25
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8720
nop
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/session.cpp
// Function: ash::Session::get_close_session_sql[abi:cxx11]() const
const string Session::get_close_session_sql() const {
  stringstream ss;
  ss << "UPDATE sessions \n"
     << "SET \n"
     << "  end_time = " << unix::time() << ", \n"
     << "  duration = " << unix::time() << " - start_time \n"
     << "WHERE id == " << unix::env("ASH_SESSION_ID") << "; ";
  return ss.str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, %rbx
leaq 0x60(%rsp), %rdi
callq 0x8290
leaq 0x70(%rsp), %r14
leaq 0xd504(%rip), %rsi      # 0x7e5d1
movl $0x11, %edx
movq %r14, %rdi
callq 0x8470
leaq 0xd502(%rip), %rsi      # 0x7e5e3
movl $0x5, %edx
movq %r14, %rdi
callq 0x8470
leaq 0xd4f4(%rip), %rsi      # 0x7e5e9
movl $0xd, %edx
movq %r14, %rdi
callq 0x8470
leaq 0x40(%rsp), %rdi
callq 0x73bd0
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq %r14, %rdi
callq 0x8470
movq %rax, %r14
leaq 0xd293(%rip), %rsi      # 0x7e3bb
movl $0x3, %edx
movq %rax, %rdi
callq 0x8470
leaq 0xd4bb(%rip), %rsi      # 0x7e5f7
movl $0xd, %edx
movq %r14, %rdi
callq 0x8470
leaq 0x20(%rsp), %rdi
callq 0x73bd0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r14, %rdi
callq 0x8470
movq %rax, %r14
leaq 0xd496(%rip), %rsi      # 0x7e605
movl $0xf, %edx
movq %rax, %rdi
callq 0x8470
leaq 0xd492(%rip), %rsi      # 0x7e615
movl $0xc, %edx
movq %r14, %rdi
callq 0x8470
leaq 0xc79c(%rip), %rsi      # 0x7d933
movq %rsp, %rdi
callq 0x7436f
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x8470
leaq 0xcd1e(%rip), %rsi      # 0x7ded5
movl $0x2, %edx
movq %rax, %rdi
callq 0x8470
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x711d7
callq 0x8390
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x711ea
callq 0x8390
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x711fd
callq 0x8390
leaq 0x78(%rsp), %rsi
movq %rbx, %rdi
callq 0x8630
leaq 0x60(%rsp), %rdi
callq 0x87e8
movq %rbx, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r14
retq
jmp 0x71240
jmp 0x71258
jmp 0x71270
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x71243
callq 0x8390
jmp 0x71243
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7125b
callq 0x8390
jmp 0x7125b
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x71273
callq 0x8390
jmp 0x71273
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x87e8
movq %rbx, %rdi
callq 0x8720
movq %rax, %rdi
callq 0x68c53
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/queries.cpp
// Function: yyensure_buffer_stack()
static void yyensure_buffer_stack (void)
{
	int num_to_alloc;
    
	if (!(yy_buffer_stack)) {

		/* First allocation is just for 2 elements, since we don't know if this
		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
		 * immediate realloc on the next call.
         */
		num_to_alloc = 1;
		(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
								(num_to_alloc * sizeof(struct yy_buffer_state*)
								);
		if ( ! (yy_buffer_stack) )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
								  
		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
				
		(yy_buffer_stack_max) = num_to_alloc;
		(yy_buffer_stack_top) = 0;
		return;
	}

	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){

		/* Increase the buffer to prepare for a possible push. */
		int grow_size = 8 /* arbitrary grow size */;

		num_to_alloc = (yy_buffer_stack_max) + grow_size;
		(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
								((yy_buffer_stack),
								num_to_alloc * sizeof(struct yy_buffer_state*)
								);
		if ( ! (yy_buffer_stack) )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		/* zero only the new slots.*/
		memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
		(yy_buffer_stack_max) = num_to_alloc;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x23e48(%rip), %rdi     # 0x967a0
testq %rdi, %rdi
je 0x729c0
movq 0x23e6c(%rip), %rbx     # 0x967d0
leaq -0x1(%rbx), %rax
cmpq %rax, 0x23e39(%rip)     # 0x967a8
jb 0x729ed
movq %rbx, %rax
shlq $0x20, %rax
movabsq $0x800000000, %r14      # imm = 0x800000000
addq %rax, %r14
movq %r14, %rsi
sarq $0x1d, %rsi
callq 0x8680
movq %rax, 0x23e08(%rip)     # 0x967a0
testq %rax, %rax
je 0x729fa
sarq $0x20, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax,%rbx,8)
movups %xmm0, 0x20(%rax,%rbx,8)
movups %xmm0, 0x10(%rax,%rbx,8)
movups %xmm0, (%rax,%rbx,8)
movq %r14, 0x23e12(%rip)     # 0x967d0
jmp 0x729ed
movl $0x8, %edi
callq 0x8510
movq %rax, 0x23dcf(%rip)     # 0x967a0
testq %rax, %rax
je 0x729f5
xorl %ecx, %ecx
movq %rcx, (%rax)
movq $0x1, 0x23dea(%rip) # 0x967d0
movq %rcx, 0x23dbb(%rip)     # 0x967a8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x8b85
callq 0x8b5d
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/queries.cpp
// Function: yy_create_buffer(_IO_FILE*, int)
YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
{
	YY_BUFFER_STATE b;
    
	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_buf_size = size;

	/* yy_ch_buf has to be 2 characters longer than the size given because
	 * we need to put in 2 end-of-buffer characters.
	 */
	b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
	if ( ! b->yy_ch_buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_is_our_buffer = 1;

	yy_init_buffer(b,file );

	return b;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl $0x40, %edi
callq 0x8510
testq %rax, %rax
je 0x72a4e
movq %rax, %r14
movslq %ebp, %rdi
movq %rdi, 0x18(%rax)
addq $0x2, %rdi
callq 0x8510
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x72a53
movl $0x1, 0x24(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x72bdb
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x8bd5
callq 0x8bad
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/queries.cpp
// Function: yy_get_previous_state()
static yy_state_type yy_get_previous_state (void)
{
	register yy_state_type yy_current_state;
	register char *yy_cp;
    
	yy_current_state = (yy_start);

	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
		{
		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
		if ( yy_accept[yy_current_state] )
			{
			(yy_last_accepting_state) = yy_current_state;
			(yy_last_accepting_cpos) = yy_cp;
			}
		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
			{
			yy_current_state = (int) yy_def[yy_current_state];
			if ( yy_current_state >= 101 )
				yy_c = yy_meta[(unsigned int) yy_c];
			}
		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
		}

	return yy_current_state;
}

// Assembly:
movl 0x23d3a(%rip), %eax     # 0x96798
movq 0x23c5b(%rip), %rcx     # 0x966c0
movq 0x23d44(%rip), %rdx     # 0x967b0
cmpq %rdx, %rcx
jae 0x72b2c
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0xc08c(%rip), %rsi      # 0x7eb10
leaq 0xc3f5(%rip), %rdi      # 0x7ee80
leaq 0xc14e(%rip), %r8       # 0x7ebe0
leaq 0xc647(%rip), %r9       # 0x7f0e0
leaq 0xc4e0(%rip), %r10      # 0x7ef80
leaq 0xc5d9(%rip), %r11      # 0x7f080
leaq 0xbc62(%rip), %rbx      # 0x7e710
movzbl (%rcx), %r14d
testq %r14, %r14
je 0x72abd
movb (%rbx,%r14,4), %bpl
jmp 0x72ac0
movb $0x1, %bpl
movslq %eax, %r14
cmpw $0x0, (%rsi,%r14,2)
je 0x72ad8
movl %eax, 0x23ceb(%rip)     # 0x967bc
movq %rcx, 0x23ce8(%rip)     # 0x967c0
movswq (%rdi,%r14,2), %r12
movzbl %bpl, %r15d
addq %r12, %r15
movswl (%r8,%r15,2), %r12d
cmpl %r12d, %eax
je 0x72b14
movswq (%r10,%r14,2), %r14
cmpq $0x65, %r14
jl 0x72b01
movzbl %bpl, %eax
movb (%r11,%rax,4), %bpl
movswq (%rdi,%r14,2), %rax
movzbl %bpl, %r15d
addq %rax, %r15
cmpw (%r8,%r15,2), %r14w
jne 0x72aee
movl %r15d, %eax
movswl (%r9,%rax,2), %eax
incq %rcx
cmpq %rdx, %rcx
jne 0x72aae
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/queries.cpp
// Function: yyrestart(_IO_FILE*)
void yyrestart  (FILE * input_file )
{
    
	if ( ! YY_CURRENT_BUFFER ){
        yyensure_buffer_stack ();
		YY_CURRENT_BUFFER_LVALUE =
            yy_create_buffer(yyin,YY_BUF_SIZE );
	}

	yy_init_buffer(YY_CURRENT_BUFFER,input_file );
	yy_load_buffer_state( );
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x23c68(%rip), %rax     # 0x967a0
testq %rax, %rax
je 0x72b4b
movq 0x23c64(%rip), %rcx     # 0x967a8
cmpq $0x0, (%rax,%rcx,8)
jne 0x72b73
callq 0x7294d
movq 0x23b51(%rip), %rdi     # 0x966a8
movl $0x4000, %esi           # imm = 0x4000
callq 0x729ff
movq 0x23c38(%rip), %rcx     # 0x967a0
movq 0x23c39(%rip), %rdx     # 0x967a8
movq %rax, (%rcx,%rdx,8)
movq 0x23c26(%rip), %rax     # 0x967a0
testq %rax, %rax
je 0x72b8c
movq 0x23c22(%rip), %rcx     # 0x967a8
movq (%rax,%rcx,8), %rdi
jmp 0x72b8e
xorl %edi, %edi
movq %rbx, %rsi
callq 0x72bdb
movq 0x23c03(%rip), %rax     # 0x967a0
movq 0x23c04(%rip), %rcx     # 0x967a8
movq (%rax,%rcx,8), %rdx
movl 0x20(%rdx), %esi
movl %esi, 0x23c17(%rip)     # 0x967c8
movq 0x10(%rdx), %rdx
movq %rdx, 0x23bf4(%rip)     # 0x967b0
movq %rdx, 0x23afd(%rip)     # 0x966c0
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x23ad7(%rip)     # 0x966a8
movb (%rdx), %al
movb %al, 0x23bdf(%rip)      # 0x967b8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/queries.cpp
// Function: yy_init_buffer(yy_buffer_state*, _IO_FILE*)
static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )

{
	int oerrno = errno;
    
	yy_flush_buffer(b );

	b->yy_input_file = file;
	b->yy_fill_buffer = 1;

    /* If b is the current buffer, then yy_init_buffer was _probably_
     * called from yyrestart() or through yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->yy_bs_lineno = 1;
        b->yy_bs_column = 0;
    }

        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    
	errno = oerrno;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x8060
movq %rax, %r14
movl (%rax), %ebp
movq %rbx, %rdi
callq 0x72d5c
movq %r15, (%rbx)
movl $0x1, 0x38(%rbx)
movq 0x23b95(%rip), %rax     # 0x967a0
testq %rax, %rax
je 0x72c1d
movq 0x23b91(%rip), %rcx     # 0x967a8
movq (%rax,%rcx,8), %rax
jmp 0x72c1f
xorl %eax, %eax
cmpq %rbx, %rax
je 0x72c2c
movq $0x1, 0x30(%rbx)
testq %r15, %r15
je 0x72c49
movq %r15, %rdi
callq 0x8450
movl %eax, %edi
callq 0x8700
xorl %ecx, %ecx
testl %eax, %eax
setg %cl
jmp 0x72c4b
xorl %ecx, %ecx
movl %ecx, 0x28(%rbx)
movl %ebp, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/queries.cpp
// Function: yy_switch_to_buffer(yy_buffer_state*)
void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
{
    
	/* TODO. We should be able to replace this entire function body
	 * with
	 *		yypop_buffer_state();
	 *		yypush_buffer_state(new_buffer);
     */
	yyensure_buffer_stack ();
	if ( YY_CURRENT_BUFFER == new_buffer )
		return;

	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*(yy_c_buf_p) = (yy_hold_char);
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
		}

	YY_CURRENT_BUFFER_LVALUE = new_buffer;
	yy_load_buffer_state( );

	/* We don't actually know whether we did this switch during
	 * EOF (yywrap()) processing, but the only time this flag
	 * is looked at is after yywrap() is called, so it's safe
	 * to go ahead and always set it.
	 */
	(yy_did_buffer_switch_on_eof) = 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x7294d
movq 0x23b34(%rip), %rax     # 0x967a0
testq %rax, %rax
je 0x72c7e
movq 0x23b30(%rip), %rcx     # 0x967a8
movq (%rax,%rcx,8), %rcx
jmp 0x72c80
xorl %ecx, %ecx
cmpq %rbx, %rcx
je 0x72cff
testq %rax, %rax
je 0x72cbc
movq 0x23b17(%rip), %rcx     # 0x967a8
cmpq $0x0, (%rax,%rcx,8)
je 0x72cbc
movb 0x23b1a(%rip), %dl      # 0x967b8
movq 0x23b0b(%rip), %rsi     # 0x967b0
movb %dl, (%rsi)
movq (%rax,%rcx,8), %rdx
movq %rsi, 0x10(%rdx)
movl 0x23b13(%rip), %edx     # 0x967c8
movq (%rax,%rcx,8), %rcx
movl %edx, 0x20(%rcx)
movq 0x23ae5(%rip), %rcx     # 0x967a8
movq %rbx, (%rax,%rcx,8)
movl 0x20(%rbx), %edx
movl %edx, 0x23af8(%rip)     # 0x967c8
movq 0x10(%rbx), %rdx
movq %rdx, 0x23ad5(%rip)     # 0x967b0
movq %rdx, 0x239de(%rip)     # 0x966c0
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x239b8(%rip)     # 0x966a8
movb (%rdx), %al
movb %al, 0x23ac0(%rip)      # 0x967b8
movb $0x1, 0x23acd(%rip)     # 0x967cc
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/queries.cpp
// Function: yy_delete_buffer(yy_buffer_state*)
void yy_delete_buffer (YY_BUFFER_STATE  b )
{
    
	if ( ! b )
		return;

	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

	if ( b->yy_is_our_buffer )
		yyfree((void *) b->yy_ch_buf  );

	yyfree((void *) b  );
}

// Assembly:
testq %rdi, %rdi
je 0x72d28
pushq %rbx
movq %rdi, %rbx
movq 0x23a8a(%rip), %rax     # 0x967a0
testq %rax, %rax
je 0x72d29
movq 0x23a86(%rip), %rcx     # 0x967a8
movq (%rax,%rcx,8), %rcx
jmp 0x72d2b
retq
xorl %ecx, %ecx
cmpq %rbx, %rcx
jne 0x72d3f
movq 0x23a71(%rip), %rcx     # 0x967a8
movq $0x0, (%rax,%rcx,8)
cmpl $0x0, 0x24(%rbx)
je 0x72d4e
movq 0x8(%rbx), %rdi
callq 0x84b0
movq %rbx, %rdi
popq %rbx
jmp 0x84b0
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/queries.cpp
// Function: yy_flush_buffer(yy_buffer_state*)
void yy_flush_buffer (YY_BUFFER_STATE  b )
{
    	if ( ! b )
		return;

	b->yy_n_chars = 0;

	/* We always need two end-of-buffer characters.  The first causes
	 * a transition to the end-of-buffer state.  The second causes
	 * a jam in that state.
	 */
	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

	b->yy_buf_pos = &b->yy_ch_buf[0];

	b->yy_at_bol = 1;
	b->yy_buffer_status = YY_BUFFER_NEW;

	if ( b == YY_CURRENT_BUFFER )
		yy_load_buffer_state( );
}

// Assembly:
testq %rdi, %rdi
je 0x72da1
xorl %ecx, %ecx
movl %ecx, 0x20(%rdi)
movq 0x8(%rdi), %rax
movb %cl, (%rax)
movq 0x8(%rdi), %rax
movb %cl, 0x1(%rax)
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rdi)
movl $0x1, 0x2c(%rdi)
movl %ecx, 0x3c(%rdi)
movq 0x23a14(%rip), %rax     # 0x967a0
testq %rax, %rax
je 0x72d9c
movq 0x23a10(%rip), %rcx     # 0x967a8
movq (%rax,%rcx,8), %rcx
cmpq %rdi, %rcx
je 0x72da2
retq
movq 0x239ff(%rip), %rcx     # 0x967a8
movq (%rax,%rcx,8), %rdx
movl 0x20(%rdx), %esi
movl %esi, 0x23a12(%rip)     # 0x967c8
movq 0x10(%rdx), %rdx
movq %rdx, 0x239ef(%rip)     # 0x967b0
movq %rdx, 0x238f8(%rip)     # 0x966c0
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x238d2(%rip)     # 0x966a8
movb (%rdx), %al
movb %al, 0x239da(%rip)      # 0x967b8
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/queries.cpp
// Function: yypush_buffer_state(yy_buffer_state*)
void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
{
    	if (new_buffer == NULL)
		return;

	yyensure_buffer_stack();

	/* This block is copied from yy_switch_to_buffer. */
	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*(yy_c_buf_p) = (yy_hold_char);
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
		}

	/* Only push if top exists. Otherwise, replace top. */
	if (YY_CURRENT_BUFFER)
		(yy_buffer_stack_top)++;
	YY_CURRENT_BUFFER_LVALUE = new_buffer;

	/* copied from yy_switch_to_buffer. */
	yy_load_buffer_state( );
	(yy_did_buffer_switch_on_eof) = 1;
}

// Assembly:
testq %rdi, %rdi
je 0x72e90
pushq %rbx
movq %rdi, %rbx
callq 0x7294d
movq 0x239a8(%rip), %rax     # 0x967a0
testq %rax, %rax
je 0x72e4c
movq 0x239a4(%rip), %rcx     # 0x967a8
cmpq $0x0, (%rax,%rcx,8)
je 0x72e2f
movb 0x239a7(%rip), %dl      # 0x967b8
movq 0x23998(%rip), %rsi     # 0x967b0
movb %dl, (%rsi)
movq (%rax,%rcx,8), %rdx
movq %rsi, 0x10(%rdx)
movl 0x239a0(%rip), %edx     # 0x967c8
movq (%rax,%rcx,8), %rcx
movl %edx, 0x20(%rcx)
testq %rax, %rax
je 0x72e4c
movq 0x2396d(%rip), %rcx     # 0x967a8
cmpq $0x0, (%rax,%rcx,8)
je 0x72e4c
incq %rcx
movq %rcx, 0x2395c(%rip)     # 0x967a8
movq 0x23955(%rip), %rcx     # 0x967a8
movq %rbx, (%rax,%rcx,8)
movl 0x20(%rbx), %edx
movl %edx, 0x23968(%rip)     # 0x967c8
movq 0x10(%rbx), %rdx
movq %rdx, 0x23945(%rip)     # 0x967b0
movq %rdx, 0x2384e(%rip)     # 0x966c0
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x23828(%rip)     # 0x966a8
movb (%rdx), %al
movb %al, 0x23930(%rip)      # 0x967b8
movb $0x1, 0x2393d(%rip)     # 0x967cc
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/barabo[P]advanced-shell-history/src/queries.cpp
// Function: yypop_buffer_state()
void yypop_buffer_state (void)
{
    	if (!YY_CURRENT_BUFFER)
		return;

	yy_delete_buffer(YY_CURRENT_BUFFER );
	YY_CURRENT_BUFFER_LVALUE = NULL;
	if ((yy_buffer_stack_top) > 0)
		--(yy_buffer_stack_top);

	if (YY_CURRENT_BUFFER) {
		yy_load_buffer_state( );
		(yy_did_buffer_switch_on_eof) = 1;
	}
}

// Assembly:
movq 0x23908(%rip), %rax     # 0x967a0
testq %rax, %rax
je 0x72f2d
pushq %rax
movq 0x238ff(%rip), %rcx     # 0x967a8
movq (%rax,%rcx,8), %rdi
testq %rdi, %rdi
je 0x72f29
callq 0x72d06
movq 0x238e2(%rip), %rax     # 0x967a0
movq 0x238e3(%rip), %rcx     # 0x967a8
movq $0x0, (%rax,%rcx,8)
testq %rcx, %rcx
je 0x72edc
decq %rcx
movq %rcx, 0x238cc(%rip)     # 0x967a8
testq %rax, %rax
je 0x72f29
movq 0x238c0(%rip), %rcx     # 0x967a8
movq (%rax,%rcx,8), %rdx
testq %rdx, %rdx
je 0x72f29
movl 0x20(%rdx), %esi
movl %esi, 0x238ce(%rip)     # 0x967c8
movq 0x10(%rdx), %rdx
movq %rdx, 0x238ab(%rip)     # 0x967b0
movq %rdx, 0x237b4(%rip)     # 0x966c0
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x2378e(%rip)     # 0x966a8
movb (%rdx), %al
movb %al, 0x23896(%rip)      # 0x967b8
movb $0x1, 0x238a3(%rip)     # 0x967cc
addq $0x8, %rsp
retq