LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
leaq 0x3ba48(%rip), %rdi     # 0xd24f8
callq 0x8190
movq %rax, %rdi
callq 0x8830
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x1bf0e(%rip), %rsi     # 0xb29dc
callq 0x8400
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x8790
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x8400
callq 0x97eb0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x97f40
testb $0x1, %al
jne 0x96b09
jmp 0x96b0e
jmp 0x96ba9
movq 0x30(%rsp), %rdi
leaq 0x1becb(%rip), %rsi     # 0xb29e5
callq 0x8400
movq 0x20(%rsp), %rdi
callq 0x97f60
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x97fb0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x97f90
testb $0x1, %al
jne 0x96b52
jmp 0x96b89
movq 0x30(%rsp), %rdi
leaq 0x1c296(%rip), %rsi     # 0xb2df4
callq 0x8400
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x97fe0
movq (%rsp), %rdi
movq (%rax), %rsi
callq 0x96bb0
leaq 0x18(%rsp), %rdi
callq 0x98000
jmp 0x96b2e
movq 0x30(%rsp), %rdi
leaq 0x1c25f(%rip), %rsi     # 0xb2df4
callq 0x8400
movq %rax, %rdi
movq 0x393e4(%rip), %rsi     # 0xcff88
callq 0x8470
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x8(%rsp)
movb %al, 0x3(%rsp)
je 0x97177
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x97181
jmp 0x971af
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x8390
cmpl $0x0, %eax
jne 0x971a0
movb $0x0, 0x17(%rsp)
jmp 0x971b4
jmp 0x971a2
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x97151
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x48(%rsp)
cmpb $0x0, 0x10(%rax)
je 0x97681
movq 0xb8(%rsp), %rdi
leaq 0x1b419(%rip), %rsi     # 0xb2a82
callq 0x8400
movq %rax, %rdi
movq 0x48(%rsp), %rax
movsbl 0x10(%rax), %esi
callq 0x8500
jmp 0x97695
movq 0xb8(%rsp), %rdi
leaq 0x1b3f6(%rip), %rsi     # 0xb2a86
callq 0x8400
movq 0x48(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x97880
movq 0x48(%rsp), %rax
movl 0x3ae9c(%rip), %ecx     # 0xd254c
addl $0x2, %ecx
movq %rcx, 0x30(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x87f0
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0x90(%rsp), %rdi
callq 0x85b0
jmp 0x976ec
leaq 0x90(%rsp), %rdi
callq 0x8670
movq %rax, 0x28(%rsp)
jmp 0x97700
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
subl %ecx, %eax
movl %eax, 0x24(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x88f8
jmp 0x9771f
leaq 0x8f(%rsp), %rdi
callq 0x84a0
movl 0x24(%rsp), %eax
movl %eax, 0xb4(%rsp)
movq 0xb8(%rsp), %rdi
leaq 0x1b345(%rip), %rsi     # 0xb2a8b
callq 0x8400
movq %rax, %rdi
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x8400
movq 0x48(%rsp), %rax
testb $0x1, 0x20(%rax)
je 0x977d5
movq 0xb8(%rsp), %rdi
leaq 0x1b2e0(%rip), %rsi     # 0xb2a56
callq 0x8400
movl 0xb4(%rsp), %eax
subl $0x6, %eax
movl %eax, 0xb4(%rsp)
jmp 0x977d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x977c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x88f8
jmp 0x977c1
jmp 0x977c3
leaq 0x8f(%rsp), %rdi
callq 0x84a0
jmp 0x978b2
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0xb4(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x87f0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rcx
leaq 0x58(%rsp), %rdi
movl $0x20, %edx
callq 0x8250
jmp 0x97819
movq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x8350
jmp 0x9782a
leaq 0x58(%rsp), %rdi
callq 0x88f8
jmp 0x97836
leaq 0x57(%rsp), %rdi
callq 0x84a0
jmp 0x97880
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x97874
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x88f8
jmp 0x97872
jmp 0x97874
leaq 0x57(%rsp), %rdi
callq 0x84a0
jmp 0x978b2
movq 0x48(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x978a2
movq 0x48(%rsp), %rax
movq 0xb8(%rsp), %rdi
movq 0x18(%rax), %rsi
callq 0x8400
movq 0xb8(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x80(%rsp), %rdi
callq 0x87d0
movq %rax, %rdi
callq 0x8cf60
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x97630
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x979ec
movq (%rsp), %rax
movq 0x28(%rax), %rax
cmpl $0x0, (%rax)
je 0x979ec
movq 0x8(%rsp), %rdi
leaq 0x1b0bb(%rip), %rsi     # 0xb2a90
callq 0x8400
movq %rax, %rdi
movq (%rsp), %rax
movq 0x28(%rax), %rax
movl (%rax), %esi
callq 0x8780
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x97b58
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x87f0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x85b0
jmp 0x97af3
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0x38(%rsp), %rsi
callq 0x8050
jmp 0x97b08
leaq 0x38(%rsp), %rdi
callq 0x88f8
jmp 0x97b14
leaq 0x37(%rsp), %rdi
callq 0x84a0
jmp 0x97b66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x97b4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x88f8
jmp 0x97b4a
jmp 0x97b4c
leaq 0x37(%rsp), %rdi
callq 0x84a0
jmp 0x97b6b
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x8580
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x87d0
movq %rax, %rdi
callq 0x8cf60
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x97630
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x8730
testb $0x1, %al
jne 0x97be2
movq 0x8(%rsp), %rdi
leaq 0x1aede(%rip), %rsi     # 0xb2a9c
callq 0x8400
movq %rax, %rdi
movq (%rsp), %rax
movq 0x28(%rax), %rsi
callq 0x8350
movq %rax, %rdi
leaq 0x1b209(%rip), %rsi     # 0xb2de6
callq 0x8400
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x78(%rsp)
je 0x97e0e
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x87f0
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x58(%rsp), %rdi
callq 0x85b0
jmp 0x97cfc
leaq 0x57(%rsp), %rdi
callq 0x84a0
leaq 0x1a700(%rip), %rsi     # 0xb240d
leaq 0x58(%rsp), %rdi
callq 0x8d0c0
movb %al, 0x27(%rsp)
jmp 0x97d1d
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x97d27
jmp 0x97d72
movq 0x38(%rsp), %rax
movq 0x28(%rax), %rax
movb $0x1, (%rax)
jmp 0x97e00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x57(%rsp), %rdi
callq 0x84a0
jmp 0x97e22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x88f8
jmp 0x97e0c
leaq 0x1ad30(%rip), %rsi     # 0xb2aa9
leaq 0x58(%rsp), %rdi
callq 0x8d0c0
movb %al, 0x26(%rsp)
jmp 0x97d89
movb 0x26(%rsp), %al
testb $0x1, %al
jne 0x97d93
jmp 0x97da1
movq 0x38(%rsp), %rax
movq 0x28(%rax), %rax
movb $0x0, (%rax)
jmp 0x97dfe
movq 0x38248(%rip), %rdi     # 0xcfff0
leaq 0x1ad00(%rip), %rsi     # 0xb2aaf
callq 0x8400
movq %rax, 0x18(%rsp)
jmp 0x97dbb
movq 0x18(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x8400
movq %rax, 0x10(%rsp)
jmp 0x97dd1
movq 0x10(%rsp), %rdi
leaq 0x1b009(%rip), %rsi     # 0xb2de6
callq 0x8400
movq %rax, 0x8(%rsp)
jmp 0x97de9
movq 0x8(%rsp), %rdi
movq 0x38193(%rip), %rsi     # 0xcff88
callq 0x8470
jmp 0x97dfc
jmp 0x97dfe
jmp 0x97e00
leaq 0x58(%rsp), %rdi
callq 0x88f8
jmp 0x97e1a
jmp 0x97e22
movq 0x38(%rsp), %rax
movq 0x28(%rax), %rax
movb $0x1, (%rax)
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x87d0
movq %rax, %rdi
callq 0x8cf60
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x97630
movq (%rsp), %rax
testb $0x1, 0x20(%rax)
je 0x97ea3
movq 0x8(%rsp), %rdi
leaq 0x1ac19(%rip), %rsi     # 0xb2a90
callq 0x8400
movq %rax, %rdi
movq (%rsp), %rax
movq 0x28(%rax), %rax
movb (%rax), %cl
leaq 0x1ac19(%rip), %rsi     # 0xb2aa9
leaq 0x1a576(%rip), %rax     # 0xb240d
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x8400
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x2f(%rsp), %rsi
callq 0x984c0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x984f0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x9b670
testb $0x1, %al
jne 0x986a0
jmp 0x9872a
movq 0x37949(%rip), %rdi     # 0xcfff0
leaq 0x1a43b(%rip), %rsi     # 0xb2ae9
callq 0x8400
movq %rax, %rdi
leaq 0x1a729(%rip), %rsi     # 0xb2de6
callq 0x8400
movq %rax, %rdi
movsbl 0x2f(%rsp), %esi
callq 0x8500
movq %rax, %rdi
leaq 0x1a217(%rip), %rsi     # 0xb28f0
callq 0x8400
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x2f(%rsp), %rsi
callq 0x98520
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
callq 0x96bb0
movq %rax, %rdi
leaq 0x1a6eb(%rip), %rsi     # 0xb2df4
callq 0x8400
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x96bb0
movq %rax, %rdi
movq 0x37863(%rip), %rsi     # 0xcff88
callq 0x8470
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
leaq 0x2f(%rsp), %rsi
callq 0x98520
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x98, %rsp
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x90(%rsp)
movb $0x0, 0x8f(%rsp)
callq 0x90dc0
leaq 0x80(%rsp), %rdi
callq 0x9e0e0
jmp 0x9baa8
leaq 0x68(%rsp), %rdi
callq 0x9e0e0
jmp 0x9bab4
leaq 0x36b75(%rip), %rdi     # 0xd2630
callq 0x9e100
movq %rax, 0x40(%rsp)
jmp 0x9bac7
movq 0x40(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x80(%rsp)
leaq 0x36b4b(%rip), %rdi     # 0xd2630
callq 0x9df40
movq %rax, 0x38(%rsp)
jmp 0x9baf1
movq 0x38(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x9e130
movb %al, 0x37(%rsp)
jmp 0x9bb1d
movb 0x37(%rsp), %al
testb $0x1, %al
jne 0x9bb2a
jmp 0x9bbdd
leaq 0x80(%rsp), %rdi
callq 0x9e150
movq %rax, 0x28(%rsp)
jmp 0x9bb3e
movq 0x28(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x9bbc7
leaq 0x80(%rsp), %rdi
callq 0x9e150
movq %rax, 0x20(%rsp)
jmp 0x9bb5e
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
addq $0x28, %rax
movq %rax, 0x10(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x9e150
movq %rax, 0x18(%rsp)
jmp 0x9bb84
movq 0x18(%rsp), %rsi
movq 0x48(%rsp), %rdi
callq 0x8f470
movq %rax, 0x8(%rsp)
jmp 0x9bb9a
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x8050
jmp 0x9bbab
jmp 0x9bbc7
movq 0x48(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
callq 0x8d0f0
jmp 0x9bc06
jmp 0x9bbc9
leaq 0x80(%rsp), %rdi
callq 0x9e170
jmp 0x9bbd8
jmp 0x9bb05
movb $0x1, 0x8f(%rsp)
testb $0x1, 0x8f(%rsp)
jne 0x9bbf9
movq 0x48(%rsp), %rdi
callq 0x8d0f0
movq 0x50(%rsp), %rax
addq $0x98, %rsp
retq
jmp 0x9bc08
movq 0x78(%rsp), %rdi
callq 0x87d0
movq %rax, %rdi
callq 0x8cf60
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x1210d(%rip), %rsi     # 0xb2d02
callq 0x8d0c0
testb $0x1, %al
jne 0xa0c00
jmp 0xa0c0d
movl $0x0, 0x14(%rsp)
jmp 0xa0c99
movq 0x8(%rsp), %rdi
leaq 0x120ef(%rip), %rsi     # 0xb2d08
callq 0x8d0c0
testb $0x1, %al
jne 0xa0c24
jmp 0xa0c2e
movl $0x1, 0x14(%rsp)
jmp 0xa0c99
movq 0x8(%rsp), %rdi
leaq 0x120d3(%rip), %rsi     # 0xb2d0d
callq 0x8d0c0
testb $0x1, %al
jne 0xa0c45
jmp 0xa0c4f
movl $0x2, 0x14(%rsp)
jmp 0xa0c99
movq 0x8(%rsp), %rdi
leaq 0x120ba(%rip), %rsi     # 0xb2d15
callq 0x8d0c0
testb $0x1, %al
jne 0xa0c66
jmp 0xa0c70
movl $0x3, 0x14(%rsp)
jmp 0xa0c99
movq 0x8(%rsp), %rdi
leaq 0x1209f(%rip), %rsi     # 0xb2d1b
callq 0x8d0c0
testb $0x1, %al
jne 0xa0c87
jmp 0xa0c91
movl $0x4, 0x14(%rsp)
jmp 0xa0c99
movl $0x5, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/logger.cpp
// Function: to_str(ash::Severity)
const char * to_str(const Severity level) {
  switch (level) {
    case DEBUG: return "DEBUG";
    case INFO: return "INFO";
    case WARNING: return "WARNING";
    case ERROR: return "ERROR";
    case FATAL: return "FATAL";
    case UNKNOWN:  // fallthrough.
    default: return "UNKNOWN";
  }
}

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x5, %rax
ja 0xa0d20
movq -0x18(%rsp), %rax
leaq 0x1200d(%rip), %rcx     # 0xb2cdc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x12023(%rip), %rax     # 0xb2d02
movq %rax, -0x8(%rsp)
jmp 0xa0d2c
leaq 0x1201b(%rip), %rax     # 0xb2d08
movq %rax, -0x8(%rsp)
jmp 0xa0d2c
leaq 0x12012(%rip), %rax     # 0xb2d0d
movq %rax, -0x8(%rsp)
jmp 0xa0d2c
leaq 0x1200c(%rip), %rax     # 0xb2d15
movq %rax, -0x8(%rsp)
jmp 0xa0d2c
leaq 0x12004(%rip), %rax     # 0xb2d1b
movq %rax, -0x8(%rsp)
jmp 0xa0d2c
jmp 0xa0d20
leaq 0x11ffa(%rip), %rax     # 0xb2d21
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x268, %rsp            # imm = 0x268
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x82a0
leaq 0xe0(%rsp), %rdi
leaq 0xf9d6(%rip), %rsi      # 0xb3066
callq 0x8400
movq %rax, 0x58(%rsp)
jmp 0xa369c
movq 0x58(%rsp), %rdi
leaq 0xf9d0(%rip), %rsi      # 0xb3078
callq 0x8400
movq %rax, 0x40(%rsp)
jmp 0xa36b4
movq 0x40(%rsp), %rdi
leaq 0xf9be(%rip), %rsi      # 0xb307e
callq 0x8400
movq %rax, 0x38(%rsp)
jmp 0xa36cc
leaq 0xa0(%rsp), %rdi
callq 0xa8040
jmp 0xa36db
movq 0x38(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x8350
movq %rax, 0x30(%rsp)
jmp 0xa36f4
movq 0x30(%rsp), %rdi
leaq 0xf750(%rip), %rsi      # 0xb2e50
callq 0x8400
movq %rax, 0x28(%rsp)
jmp 0xa370c
movq 0x28(%rsp), %rdi
leaq 0xf974(%rip), %rsi      # 0xb308c
callq 0x8400
movq %rax, 0x20(%rsp)
jmp 0xa3724
leaq 0x80(%rsp), %rdi
callq 0xa8040
jmp 0xa3733
movq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x8350
movq %rax, 0x18(%rsp)
jmp 0xa374c
movq 0x18(%rsp), %rdi
leaq 0xf942(%rip), %rsi      # 0xb309a
callq 0x8400
movq %rax, 0x10(%rsp)
jmp 0xa3764
movq 0x10(%rsp), %rdi
leaq 0xf93a(%rip), %rsi      # 0xb30aa
callq 0x8400
movq %rax, 0x8(%rsp)
jmp 0xa377c
leaq 0xebf3(%rip), %rsi      # 0xb2376
leaq 0x60(%rsp), %rdi
callq 0xa8cb0
jmp 0xa378f
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x8350
movq %rax, (%rsp)
jmp 0xa37a4
movq (%rsp), %rdi
leaq 0xf1eb(%rip), %rsi      # 0xb299a
callq 0x8400
jmp 0xa37b6
leaq 0x60(%rsp), %rdi
callq 0x88f8
jmp 0xa37c2
leaq 0x80(%rsp), %rdi
callq 0x88f8
jmp 0xa37d1
leaq 0xa0(%rsp), %rdi
callq 0x88f8
jmp 0xa37e0
movq 0x48(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x83e0
jmp 0xa37f4
leaq 0xd0(%rsp), %rdi
callq 0x8900
movq 0x50(%rsp), %rax
addq $0x268, %rsp            # imm = 0x268
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
jmp 0xa3894
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
jmp 0xa3883
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
jmp 0xa3872
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x88f8
jmp 0xa3870
jmp 0xa3872
leaq 0x80(%rsp), %rdi
callq 0x88f8
jmp 0xa3881
jmp 0xa3883
leaq 0xa0(%rsp), %rdi
callq 0x88f8
jmp 0xa3892
jmp 0xa3894
leaq 0xd0(%rsp), %rdi
callq 0x8900
jmp 0xa38a3
jmp 0xa38a5
movq 0xc8(%rsp), %rdi
callq 0x87d0
movq %rax, %rdi
callq 0x8cf60
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
cmpq $0x0, 0x2d3f7(%rip)     # 0xd28c0
jne 0xa5531
movl $0x1, 0x4(%rsp)
movslq 0x4(%rsp), %rdi
shlq $0x3, %rdi
callq 0xa61f0
movq %rax, 0x2d3d8(%rip)     # 0xd28c0
cmpq $0x0, 0x2d3d0(%rip)     # 0xd28c0
jne 0xa54fe
leaq 0xed9a(%rip), %rdi      # 0xb4293
callq 0xa5fd0
movq 0x2d3bb(%rip), %rdi     # 0xd28c0
movslq 0x4(%rsp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x8200
movslq 0x4(%rsp), %rax
movq %rax, 0x2d3cf(%rip)     # 0xd28f0
movq $0x0, 0x2d39c(%rip) # 0xd28c8
jmp 0xa55c3
movq 0x2d390(%rip), %rax     # 0xd28c8
movq 0x2d3b1(%rip), %rcx     # 0xd28f0
subq $0x1, %rcx
cmpq %rcx, %rax
jb 0xa55c3
movl $0x8, (%rsp)
movq 0x2d39a(%rip), %rax     # 0xd28f0
movslq (%rsp), %rcx
addq %rcx, %rax
movl %eax, 0x4(%rsp)
movq 0x2d358(%rip), %rdi     # 0xd28c0
movslq 0x4(%rsp), %rsi
shlq $0x3, %rsi
callq 0xa6990
movq %rax, 0x2d343(%rip)     # 0xd28c0
cmpq $0x0, 0x2d33b(%rip)     # 0xd28c0
jne 0xa5593
leaq 0xed05(%rip), %rdi      # 0xb4293
callq 0xa5fd0
movq 0x2d326(%rip), %rdi     # 0xd28c0
movq 0x2d34f(%rip), %rax     # 0xd28f0
shlq $0x3, %rax
addq %rax, %rdi
movslq (%rsp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x8200
movslq 0x4(%rsp), %rax
movq %rax, 0x2d32d(%rip)     # 0xd28f0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x40, %edi
callq 0xa61f0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xa55fe
leaq 0xeb18(%rip), %rdi      # 0xb4111
callq 0xa5fd0
movslq 0xc(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movq 0x18(%rax), %rdi
addq $0x2, %rdi
callq 0xa61f0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xa563e
leaq 0xead8(%rip), %rdi      # 0xb4111
callq 0xa5fd0
movq (%rsp), %rax
movl $0x1, 0x24(%rax)
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa6000
movq (%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/queries.cpp
// Function: yy_load_buffer_state()
static void yy_load_buffer_state  (void)
{
    	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
	yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
	(yy_hold_char) = *(yy_c_buf_p);
}

// Assembly:
movq 0x2d259(%rip), %rax     # 0xd28c0
movq 0x2d25a(%rip), %rcx     # 0xd28c8
movq (%rax,%rcx,8), %rax
movl 0x20(%rax), %eax
movl %eax, 0x2d26d(%rip)     # 0xd28e8
movq 0x2d23e(%rip), %rax     # 0xd28c0
movq 0x2d23f(%rip), %rcx     # 0xd28c8
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq %rax, 0x2d238(%rip)     # 0xd28d0
movq %rax, 0x2d141(%rip)     # 0xd27e0
movq 0x2d21a(%rip), %rax     # 0xd28c0
movq 0x2d21b(%rip), %rcx     # 0xd28c8
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x2d10d(%rip)     # 0xd27c8
movq 0x2d20e(%rip), %rax     # 0xd28d0
movb (%rax), %al
movb %al, 0x2d20e(%rip)      # 0xd28d8
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x2d1e2(%rip), %eax     # 0xd28b8
movl %eax, -0x4(%rsp)
movq 0x2d0ff(%rip), %rax     # 0xd27e0
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpq 0x2d1de(%rip), %rax     # 0xd28d0
jae 0xa57f8
movq -0x10(%rsp), %rax
cmpb $0x0, (%rax)
je 0xa571e
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xda8b(%rip), %rax      # 0xb31a0
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rsp)
jmp 0xa5729
movl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0xa5729
movl -0x18(%rsp), %eax
movb %al, -0x11(%rsp)
movslq -0x4(%rsp), %rcx
leaq 0xde63(%rip), %rax      # 0xb35a0
cmpw $0x0, (%rax,%rcx,2)
je 0xa575a
movl -0x4(%rsp), %eax
movl %eax, 0x2d18e(%rip)     # 0xd28dc
movq -0x10(%rsp), %rax
movq %rax, 0x2d186(%rip)     # 0xd28e0
jmp 0xa575c
movslq -0x4(%rsp), %rcx
leaq 0xe1a8(%rip), %rax      # 0xb3910
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rsp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0xdef3(%rip), %rax      # 0xb3670
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rsp), %eax
je 0xa57bb
movslq -0x4(%rsp), %rcx
leaq 0xe27d(%rip), %rax      # 0xb3a10
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rsp)
cmpl $0x65, -0x4(%rsp)
jl 0xa57b9
movzbl -0x11(%rsp), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xe35e(%rip), %rax      # 0xb3b10
movl (%rax,%rcx,4), %eax
movb %al, -0x11(%rsp)
jmp 0xa575c
movslq -0x4(%rsp), %rcx
leaq 0xe149(%rip), %rax      # 0xb3910
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rsp), %ecx
addl %ecx, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xe393(%rip), %rax      # 0xb3b70
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rsp)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0xa56e6
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/queries.cpp
// Function: yy_try_NUL_trans(int)
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	register int yy_is_jam;
    	register char *yy_cp = (yy_c_buf_p);

	register YY_CHAR yy_c = 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];
	yy_is_jam = (yy_current_state == 100);

	return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq 0x2d0c5(%rip), %rax     # 0xd28d0
movq %rax, -0x10(%rsp)
movb $0x1, -0x11(%rsp)
movslq -0x4(%rsp), %rcx
leaq 0xdd7f(%rip), %rax      # 0xb35a0
cmpw $0x0, (%rax,%rcx,2)
je 0xa583e
movl -0x4(%rsp), %eax
movl %eax, 0x2d0aa(%rip)     # 0xd28dc
movq -0x10(%rsp), %rax
movq %rax, 0x2d0a2(%rip)     # 0xd28e0
jmp 0xa5840
movslq -0x4(%rsp), %rcx
leaq 0xe0c4(%rip), %rax      # 0xb3910
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rsp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0xde0f(%rip), %rax      # 0xb3670
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rsp), %eax
je 0xa589f
movslq -0x4(%rsp), %rcx
leaq 0xe199(%rip), %rax      # 0xb3a10
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rsp)
cmpl $0x65, -0x4(%rsp)
jl 0xa589d
movzbl -0x11(%rsp), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xe27a(%rip), %rax      # 0xb3b10
movl (%rax,%rcx,4), %eax
movb %al, -0x11(%rsp)
jmp 0xa5840
movslq -0x4(%rsp), %rcx
leaq 0xe065(%rip), %rax      # 0xb3910
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rsp), %ecx
addl %ecx, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xe2af(%rip), %rax      # 0xb3b70
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rsp)
cmpl $0x64, -0x4(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rsp)
cmpl $0x0, -0x8(%rsp)
je 0xa58e9
xorl %eax, %eax
movl %eax, -0x18(%rsp)
jmp 0xa58f1
movl -0x4(%rsp), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x2c98f(%rip)     # 0xd28c0
je 0xa5f4c
movq 0x2c986(%rip), %rax     # 0xd28c0
movq 0x2c987(%rip), %rcx     # 0xd28c8
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0xa5f55
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xa5f55
movq 0x8(%rsp), %rax
cmpq $0x0, %rax
jne 0xa5f8b
callq 0xa54c0
movq 0x2c85c(%rip), %rdi     # 0xd27c8
movl $0x4000, %esi           # imm = 0x4000
callq 0xa55d0
movq %rax, %rdx
movq 0x2c940(%rip), %rax     # 0xd28c0
movq 0x2c941(%rip), %rcx     # 0xd28c8
movq %rdx, (%rax,%rcx,8)
cmpq $0x0, 0x2c92d(%rip)     # 0xd28c0
je 0xa5fad
movq 0x2c924(%rip), %rax     # 0xd28c0
movq 0x2c925(%rip), %rcx     # 0xd28c8
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0xa5fb5
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0xa5fb5
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa6000
callq 0xa5660
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
callq 0x8060
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rdi
callq 0xa62b0
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movl $0x1, 0x38(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x2c872(%rip)     # 0xd28c0
je 0xa6069
movq 0x2c869(%rip), %rax     # 0xd28c0
movq 0x2c86a(%rip), %rcx     # 0xd28c8
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0xa6072
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0xa6072
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq %rcx, %rax
je 0xa6099
movq 0x30(%rsp), %rax
movl $0x1, 0x30(%rax)
movq 0x30(%rsp), %rax
movl $0x0, 0x34(%rax)
cmpq $0x0, 0x28(%rsp)
je 0xa60c3
movq 0x28(%rsp), %rdi
callq 0x8490
movl %eax, %edi
callq 0x87b0
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
jmp 0xa60cb
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0xa60cb
movl 0xc(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x28(%rax)
movl 0x24(%rsp), %eax
movl %eax, 0x8(%rsp)
callq 0x8060
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0xa54c0
cmpq $0x0, 0x2c7ba(%rip)     # 0xd28c0
je 0xa6121
movq 0x2c7b1(%rip), %rax     # 0xd28c0
movq 0x2c7b2(%rip), %rcx     # 0xd28c8
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0xa612a
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xa612a
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0xa613b
jmp 0xa61dc
cmpq $0x0, 0x2c77d(%rip)     # 0xd28c0
je 0xa615d
movq 0x2c774(%rip), %rax     # 0xd28c0
movq 0x2c775(%rip), %rcx     # 0xd28c8
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0xa6165
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0xa6165
movq (%rsp), %rax
cmpq $0x0, %rax
je 0xa61b6
movb 0x2c763(%rip), %cl      # 0xd28d8
movq 0x2c754(%rip), %rax     # 0xd28d0
movb %cl, (%rax)
movq 0x2c74b(%rip), %rcx     # 0xd28d0
movq 0x2c734(%rip), %rax     # 0xd28c0
movq 0x2c735(%rip), %rdx     # 0xd28c8
movq (%rax,%rdx,8), %rax
movq %rcx, 0x10(%rax)
movl 0x2c747(%rip), %ecx     # 0xd28e8
movq 0x2c718(%rip), %rax     # 0xd28c0
movq 0x2c719(%rip), %rdx     # 0xd28c8
movq (%rax,%rdx,8), %rax
movl %ecx, 0x20(%rax)
movq 0x10(%rsp), %rdx
movq 0x2c6fe(%rip), %rax     # 0xd28c0
movq 0x2c6ff(%rip), %rcx     # 0xd28c8
movq %rdx, (%rax,%rcx,8)
callq 0xa5660
movl $0x1, 0x2c710(%rip)     # 0xd28ec
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xa6213
jmp 0xa628e
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x2c69b(%rip)     # 0xd28c0
je 0xa623f
movq 0x2c692(%rip), %rax     # 0xd28c0
movq 0x2c693(%rip), %rcx     # 0xd28c8
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0xa6247
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0xa6247
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
cmpq %rcx, %rax
jne 0xa626b
movq 0x2c664(%rip), %rax     # 0xd28c0
movq 0x2c665(%rip), %rcx     # 0xd28c8
movq $0x0, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x24(%rax)
je 0xa6284
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xa62a0
movq 0x10(%rsp), %rdi
callq 0xa62a0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xa62c6
jmp 0xa635c
movq 0x10(%rsp), %rax
movl $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x1(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movl $0x1, 0x2c(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x3c(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x2c599(%rip)     # 0xd28c0
je 0xa6341
movq 0x2c590(%rip), %rax     # 0xd28c0
movq 0x2c591(%rip), %rcx     # 0xd28c8
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0xa6349
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0xa6349
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
cmpq %rcx, %rax
jne 0xa635c
callq 0xa5660
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xa6386
jmp 0xa6475
callq 0xa54c0
cmpq $0x0, 0x2c52d(%rip)     # 0xd28c0
je 0xa63ae
movq 0x2c524(%rip), %rax     # 0xd28c0
movq 0x2c525(%rip), %rcx     # 0xd28c8
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0xa63b7
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xa63b7
movq 0x8(%rsp), %rax
cmpq $0x0, %rax
je 0xa6409
movb 0x2c510(%rip), %cl      # 0xd28d8
movq 0x2c501(%rip), %rax     # 0xd28d0
movb %cl, (%rax)
movq 0x2c4f8(%rip), %rcx     # 0xd28d0
movq 0x2c4e1(%rip), %rax     # 0xd28c0
movq 0x2c4e2(%rip), %rdx     # 0xd28c8
movq (%rax,%rdx,8), %rax
movq %rcx, 0x10(%rax)
movl 0x2c4f4(%rip), %ecx     # 0xd28e8
movq 0x2c4c5(%rip), %rax     # 0xd28c0
movq 0x2c4c6(%rip), %rdx     # 0xd28c8
movq (%rax,%rdx,8), %rax
movl %ecx, 0x20(%rax)
cmpq $0x0, 0x2c4af(%rip)     # 0xd28c0
je 0xa642b
movq 0x2c4a6(%rip), %rax     # 0xd28c0
movq 0x2c4a7(%rip), %rcx     # 0xd28c8
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0xa6433
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0xa6433
movq (%rsp), %rax
cmpq $0x0, %rax
je 0xa644f
movq 0x2c484(%rip), %rax     # 0xd28c8
addq $0x1, %rax
movq %rax, 0x2c479(%rip)     # 0xd28c8
movq 0x10(%rsp), %rdx
movq 0x2c465(%rip), %rax     # 0xd28c0
movq 0x2c466(%rip), %rcx     # 0xd28c8
movq %rdx, (%rax,%rcx,8)
callq 0xa5660
movl $0x1, 0x2c477(%rip)     # 0xd28ec
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
cmpq $0x0, 0x2c434(%rip)     # 0xd28c0
je 0xa64a7
movq 0x2c42b(%rip), %rax     # 0xd28c0
movq 0x2c42c(%rip), %rcx     # 0xd28c8
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0xa64b0
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0xa64b0
movq 0x10(%rsp), %rax
cmpq $0x0, %rax
jne 0xa64c0
jmp 0xa656b
cmpq $0x0, 0x2c3f8(%rip)     # 0xd28c0
je 0xa64e3
movq 0x2c3ef(%rip), %rax     # 0xd28c0
movq 0x2c3f0(%rip), %rcx     # 0xd28c8
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0xa64ec
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xa64ec
movq 0x8(%rsp), %rdi
callq 0xa6200
movq 0x2c3c3(%rip), %rax     # 0xd28c0
movq 0x2c3c4(%rip), %rcx     # 0xd28c8
movq $0x0, (%rax,%rcx,8)
cmpq $0x0, 0x2c3b4(%rip)     # 0xd28c8
jbe 0xa6528
movq 0x2c3ab(%rip), %rax     # 0xd28c8
addq $-0x1, %rax
movq %rax, 0x2c3a0(%rip)     # 0xd28c8
cmpq $0x0, 0x2c390(%rip)     # 0xd28c0
je 0xa654a
movq 0x2c387(%rip), %rax     # 0xd28c0
movq 0x2c388(%rip), %rcx     # 0xd28c8
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0xa6552
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0xa6552
movq (%rsp), %rax
cmpq $0x0, %rax
je 0xa656b
callq 0xa5660
movl $0x1, 0x2c381(%rip)     # 0xd28ec
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/queries.cpp
// Function: yy_scan_buffer(char*, unsigned long)
YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
{
	YY_BUFFER_STATE b;
    
	if ( size < 2 ||
	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
	     base[size-1] != YY_END_OF_BUFFER_CHAR )
		/* They forgot to leave room for the EOB's. */
		return 0;

	b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );

	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
	b->yy_buf_pos = b->yy_ch_buf = base;
	b->yy_is_our_buffer = 0;
	b->yy_input_file = 0;
	b->yy_n_chars = b->yy_buf_size;
	b->yy_is_interactive = 0;
	b->yy_at_bol = 1;
	b->yy_fill_buffer = 0;
	b->yy_buffer_status = YY_BUFFER_NEW;

	yy_switch_to_buffer(b  );

	return b;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x2, 0x10(%rsp)
jb 0xa65b4
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
subq $0x2, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xa65b4
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xa65c2
movq $0x0, 0x20(%rsp)
jmp 0xa667d
movl $0x40, %edi
callq 0xa61f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xa65e5
leaq 0xdb5d(%rip), %rdi      # 0xb413d
callq 0xa5fd0
movq 0x10(%rsp), %rcx
subq $0x2, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x24(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
movl $0x1, 0x2c(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x38(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x3c(%rax)
movq 0x8(%rsp), %rdi
callq 0xa60f0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/queries.cpp
// Function: yy_scan_bytes(char const*, int)
YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
{
	YY_BUFFER_STATE b;
	char *buf;
	yy_size_t n;
	int i;
    
	/* Get memory for full buffer, including space for trailing EOB's. */
	n = _yybytes_len + 2;
	buf = (char *) yyalloc(n  );
	if ( ! buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );

	for ( i = 0; i < _yybytes_len; ++i )
		buf[i] = yybytes[i];

	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;

	b = yy_scan_buffer(buf,n );
	if ( ! b )
		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );

	/* It's okay to grow etc. this buffer, and we should throw it
	 * away when we're done.
	 */
	b->yy_is_our_buffer = 1;

	return b;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
addl $0x2, %eax
cltq
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xa61f0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xa66fe
leaq 0xda6e(%rip), %rdi      # 0xb4167
callq 0xa5fd0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0xa6737
movq 0x30(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xa6706
movq 0x18(%rsp), %rax
movl 0x2c(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq 0x18(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa6570
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xa6780
leaq 0xda15(%rip), %rdi      # 0xb4190
callq 0xa5fd0
movq 0x20(%rsp), %rax
movl $0x1, 0x24(%rax)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)