LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Overv[P]pqpp/./pq.hpp
// Function: pq::connection::prepare(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
prepared_statement prepare(const string& name, const string& query, int parameters) {
            auto tmp = PQprepare(conn.get(), name.c_str(), query.c_str(), parameters, nullptr);
            auto res = unique_ptr<PGresult, function<void(PGresult*)>>(tmp, [=](PGresult* res) {
                PQclear(res);
            });

            if (PQresultStatus(res.get()) == PGRES_COMMAND_OK) {
                return prepared_statement(name, parameters);
            } else {
                throw runtime_error(PQerrorMessage(conn.get()));
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x4980
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2060
movq %rax, -0xb0(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2060
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq %rax, %rdx
movl -0x24(%rbp), %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x20c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x79(%rbp), %rsi
callq 0x54c0
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x58(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x5550
movq -0xa0(%rbp), %rdi
callq 0x5590
movq -0x98(%rbp), %rdi
callq 0x55b0
movq %rax, %rdi
callq 0x2390
movl %eax, -0x90(%rbp)
jmp 0x3537
movl -0x90(%rbp), %eax
cmpl $0x1, %eax
jne 0x3584
movq -0xd0(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x55e0
jmp 0x3557
leaq -0x58(%rbp), %rdi
callq 0x5620
movq -0xc8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x3601
movl $0x10, %edi
callq 0x2150
movq -0xc0(%rbp), %rdi
movq %rax, -0xe0(%rbp)
callq 0x4980
movq %rax, %rdi
callq 0x22c0
movq %rax, -0xd8(%rbp)
jmp 0x35b2
movq -0xd8(%rbp), %rsi
movq -0xe0(%rbp), %rdi
callq 0x20d0
jmp 0x35c7
movq -0xe0(%rbp), %rdi
movq 0x12a03(%rip), %rsi     # 0x15fd8
movq 0x129e4(%rip), %rdx     # 0x15fc0
callq 0x21f0
jmp 0x3616
movq -0xe0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
callq 0x22b0
leaq -0x58(%rbp), %rdi
callq 0x5620
movq -0x88(%rbp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
// File: Overv[P]pqpp/./pq.hpp
// Function: pq::connection::make_pq_args(std::vector<pq::value, std::allocator<pq::value>> const&)
vector<const char*> make_pq_args(const vector<value>& arguments) {
            vector<const char*> pq_args;

            for (auto& val : arguments) {
                if (val.is_null()) {
                    pq_args.push_back(nullptr);
                } else {
                    pq_args.push_back(val.str().c_str());
                }
            }

            return pq_args;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x6e30
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6e50
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6e80
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6eb0
testb $0x1, %al
jne 0x6653
jmp 0x66dc
leaq -0x30(%rbp), %rdi
callq 0x6ef0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3be0
testb $0x1, %al
jne 0x666f
jmp 0x669f
movq -0x70(%rbp), %rdi
movq $0x0, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x6f10
jmp 0x6686
jmp 0x66cc
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x6c90
jmp 0x66fc
movq -0x40(%rbp), %rdi
callq 0x6f40
movq %rax, -0x78(%rbp)
jmp 0x66ae
movq -0x78(%rbp), %rdi
callq 0x2060
movq -0x70(%rbp), %rdi
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x6f10
jmp 0x66ca
jmp 0x66cc
jmp 0x66ce
leaq -0x30(%rbp), %rdi
callq 0x6f50
jmp 0x663d
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x66ef
movq -0x70(%rbp), %rdi
callq 0x6c90
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
nop
// File: mattn[P]minijson/./minijson.h
// Function: minijson::errstr(minijson::error)
inline const char*
errstr(error e) {
  switch (e) {
  case no_error: return "no error";
  case undefined_error: return "undefined";
  case invalid_token_error: return "invalid token";
  case unknown_type_error: return "unknown type";
  case memory_allocation_error: return "memory allocation error";
  default: return "unknown error";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x2b29
movq -0x18(%rbp), %rax
leaq 0x7525(%rip), %rcx      # 0xa004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x75f0(%rip), %rax      # 0xa0df
movq %rax, -0x8(%rbp)
jmp 0x2b34
leaq 0x75ec(%rip), %rax      # 0xa0e8
movq %rax, -0x8(%rbp)
jmp 0x2b34
leaq 0x75e9(%rip), %rax      # 0xa0f2
movq %rax, -0x8(%rbp)
jmp 0x2b34
leaq 0x75ea(%rip), %rax      # 0xa100
movq %rax, -0x8(%rbp)
jmp 0x2b34
leaq 0x75ea(%rip), %rax      # 0xa10d
movq %rax, -0x8(%rbp)
jmp 0x2b34
leaq 0x75f5(%rip), %rax      # 0xa125
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: mattn[P]minijson/./minijson.h
// Function: std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, minijson::value, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, minijson::value>>>& minijson::value::get<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, minijson::value, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, minijson::value>>>>() const
T& get() const {
    if (t == array_type) return *(T*)(void*)u.a;
    if (t == object_type) return *(T*)(void*)u.o;
    if (t == string_type) return *(T*)(void*)u.s;
    return *(T*)(void*)(&u.d);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x5, (%rax)
jne 0x2b63
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b9d
movq -0x18(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x2b7a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b9d
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x2b91
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2b9d
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mattn[P]minijson/./minijson.h
// Function: minijson::value::str[abi:cxx11](char const*) const
std::string str(const char* p) const {
    std::stringstream ss;
    ss << '"';
    while (*p) {
      if (*p == '\n') ss << "\\n";
      if (*p == '\r') ss << "\\r";
      if (*p == '\t') ss << "\\t";
      else if (strchr("\"", *p)) ss << "\\" << *p;
      else ss << *p;
      p++;
    }
    ss << '"';
    return ss.str();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x2150
leaq -0x190(%rbp), %rdi
movl $0x22, %esi
callq 0x2290
jmp 0x3cd7
jmp 0x3cd9
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x3de8
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x3d2c
leaq -0x190(%rbp), %rdi
leaq 0x644e(%rip), %rsi      # 0xa14e
callq 0x21f0
jmp 0x3d07
jmp 0x3d2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x2170
jmp 0x3e2c
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0x3d4f
leaq -0x190(%rbp), %rdi
leaq 0x640b(%rip), %rsi      # 0xa151
callq 0x21f0
jmp 0x3d4d
jmp 0x3d4f
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
jne 0x3d72
leaq -0x190(%rbp), %rdi
leaq 0x63eb(%rip), %rsi      # 0xa154
callq 0x21f0
jmp 0x3d70
jmp 0x3dd7
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
leaq 0x63d7(%rip), %rdi      # 0xa157
callq 0x2090
cmpq $0x0, %rax
je 0x3dbe
leaq -0x190(%rbp), %rdi
leaq 0x63c0(%rip), %rsi      # 0xa159
callq 0x21f0
movq %rax, -0x1c8(%rbp)
jmp 0x3da7
movq -0x1c8(%rbp), %rdi
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
callq 0x2290
jmp 0x3dbc
jmp 0x3dd5
leaq -0x190(%rbp), %rdi
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
callq 0x2290
jmp 0x3dd3
jmp 0x3dd5
jmp 0x3dd7
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3cd9
leaq -0x190(%rbp), %rdi
movl $0x22, %esi
callq 0x2290
jmp 0x3dfb
movq -0x1c0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x21e0
jmp 0x3e10
leaq -0x1a0(%rbp), %rdi
callq 0x2170
movq -0x1b8(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x2310
nopl (%rax,%rax)
// File: mattn[P]minijson/./minijson.h
// Function: minijson::value::value(minijson::value const&)
value(const value& v) : t(v.t), u() {
    if (t == array_type) {
      u.a = new array();
      *u.a = *v.u.a;
    } else if (t == object_type) {
      u.o = new object();
      *u.o = *v.u.o;
    } else if (t == string_type) {
      u.s = new string();
      *u.s = *v.u.s;
    } else
      u.d = v.u.d;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x20f0
movq -0x18(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x4781
movl $0x18, %edi
callq 0x2200
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x20f0
movq -0x20(%rbp), %rdi
callq 0x4830
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq 0x8(%rax), %rdi
callq 0x4850
jmp 0x4823
movq -0x18(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x47cf
movl $0x30, %edi
callq 0x2200
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x20f0
movq -0x28(%rbp), %rdi
callq 0x4aa0
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq 0x8(%rax), %rdi
callq 0x4ac0
jmp 0x4821
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x480d
movl $0x20, %edi
callq 0x2200
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
callq 0x22c0
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq 0x8(%rax), %rdi
callq 0x2040
jmp 0x481f
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x4821
jmp 0x4823
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: mattn[P]minijson/./minijson.h
// Function: minijson::value::operator=(minijson::value const&)
const value& operator=(const value& v) {
    t = v.t;
    if (t == array_type) {
      u.a = new array(*v.u.a);
    } else if (t == object_type) {
      u.o = new object(*v.u.o);
    } else if (t == string_type) {
      u.s = new string(*v.u.s);
    } else u.d = v.u.d;
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
cmpl $0x5, (%rax)
jne 0x5138
movl $0x18, %edi
callq 0x2200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3e60
jmp 0x5108
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x51fd
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x18, %esi
callq 0x2210
jmp 0x5207
movq -0x28(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x5191
movl $0x30, %edi
callq 0x2200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4070
jmp 0x5164
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x51fb
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x30, %esi
callq 0x2210
jmp 0x5207
movq -0x28(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x51e7
movl $0x20, %edi
callq 0x2200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x20c0
jmp 0x51bd
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x51f9
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x20, %esi
callq 0x2210
jmp 0x5207
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rax)
jmp 0x51fb
jmp 0x51fd
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2310
// File: mattn[P]minijson/./minijson.h
// Function: minijson::error minijson::parse_any<char const*>(char const*&, minijson::value&)
inline error
parse_any(Iter& i, value& v) {
  _MINIJSON_SKIP(i);
  if (*i == '\x7b') return parse_object(i, v);
  if (*i == '[') return parse_array(i, v);
  if (*i == 't' || *i == 'f') return parse_boolean(i, v);
  if (*i == 'n') return parse_null(i, v);
  if ('0' <= *i && *i <= '9') return parse_number(i, v);
  if (*i == '"') return parse_string(i, v);
  return invalid_token_error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0x6791
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %esi
leaq 0x3937(%rip), %rdi      # 0xa0b9
callq 0x2090
cmpq $0x0, %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x679a
jmp 0x67aa
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x6760
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
jne 0x67ce
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x68b0
movl %eax, -0x4(%rbp)
jmp 0x689f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x5b, %eax
jne 0x67f2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6ca0
movl %eax, -0x4(%rbp)
jmp 0x689f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x74, %eax
je 0x6810
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x66, %eax
jne 0x6822
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6f40
movl %eax, -0x4(%rbp)
jmp 0x689f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x6e, %eax
jne 0x6843
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7080
movl %eax, -0x4(%rbp)
jmp 0x689f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x6877
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x6877
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7150
movl %eax, -0x4(%rbp)
jmp 0x689f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x6898
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x74c0
movl %eax, -0x4(%rbp)
jmp 0x689f
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mattn[P]minijson/./minijson.h
// Function: minijson::error minijson::parse_boolean<char const*>(char const*&, minijson::value&)
inline error
parse_boolean(Iter& i, value& v) {
  Iter p = i;
  if (*i == 't' && *(i+1) == 'r' && *(i+2) == 'u' && *(i+3) == 'e') {
    i += 4;
    v = (boolean) true;
  } else if (*i == 'f' && *(i+1) == 'a' && *(i+2) == 'l' && *(i+3) == 's' && *(i+4) == 'e') {
    i += 5;
    v = (boolean) false;
  }
  if (*i && nullptr == strchr(":,\x7d]\r\n ", *i)) {
    i = p;
    return undefined_error;
  }
  return no_error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x74, %eax
jne 0x6fb8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x72, %eax
jne 0x6fb8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x2(%rax), %eax
cmpl $0x75, %eax
jne 0x6fb8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x3(%rax), %eax
cmpl $0x65, %eax
jne 0x6fb8
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x8fc0
jmp 0x7022
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x66, %eax
jne 0x7020
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x61, %eax
jne 0x7020
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x2(%rax), %eax
cmpl $0x6c, %eax
jne 0x7020
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x3(%rax), %eax
cmpl $0x73, %eax
jne 0x7020
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x4(%rax), %eax
cmpl $0x65, %eax
jne 0x7020
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x5, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x8fc0
jmp 0x7022
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x7062
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %esi
leaq 0x3160(%rip), %rdi      # 0xa19f
callq 0x2090
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x7062
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x7069
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mattn[P]minijson/./minijson.h
// Function: minijson::error minijson::parse_null<char const*>(char const*&, minijson::value&)
inline error
parse_null(Iter& i, value& v) {
  Iter p = i;
  if (*i == 'n' && *(i+1) == 'u' && *(i+2) == 'l' && *(i+3) == 'l') {
    i += 4;
    v = null;
  }
  if (*i && nullptr == strchr(":,\x7d]\r\n ", *i)) {
    i = p;
    return undefined_error;
  }
  return no_error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x6e, %eax
jne 0x70f8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x75, %eax
jne 0x70f8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x2(%rax), %eax
cmpl $0x6c, %eax
jne 0x70f8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x3(%rax), %eax
cmpl $0x6c, %eax
jne 0x70f8
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
leaq 0x80df(%rip), %rsi      # 0xf1d2
callq 0x8ff0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x7138
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %esi
leaq 0x308a(%rip), %rdi      # 0xa19f
callq 0x2090
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x7138
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x713f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: tdv[P]boss/boss/examples/simple_object/main.cpp
// Function: main
int main()
{
  try
  {
    Boss::RefObjPtr<MyNs::ISimpleObject> Inst = Boss::Base<MyNs::SimpleObject>::Create();
    Inst->HelloWorld();
  }
  catch (std::exception const &e)
  {
    std::cerr << "Error: " << e.what() << std::endl;
  }
  return 0;
}

// Assembly:
subq $0x48, %rsp
movl $0x0, 0x44(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x16400
jmp 0x16228
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x164f0
jmp 0x16239
leaq 0x30(%rsp), %rdi
callq 0x16550
leaq 0x38(%rsp), %rdi
callq 0x16570
movq %rax, 0x10(%rsp)
jmp 0x16254
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
jmp 0x16264
leaq 0x38(%rsp), %rdi
callq 0x16580
jmp 0x16323
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x162b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x16550
jmp 0x162b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x16580
movl 0x24(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x16341
movq 0x28(%rsp), %rdi
callq 0x177a0
movq %rax, 0x18(%rsp)
leaq 0xe1008(%rip), %rdi     # 0xf72e0
leaq 0xa4d89(%rip), %rsi     # 0xbb068
callq 0x81770
movq %rax, 0x8(%rsp)
jmp 0x162eb
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x81770
movq %rax, (%rsp)
jmp 0x1630c
movq (%rsp), %rdi
leaq 0x6ad39(%rip), %rsi     # 0x81050
callq 0x80260
jmp 0x1631e
callq 0x17810
xorl %eax, %eax
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x17810
jmp 0x1633f
jmp 0x16341
movq 0x28(%rsp), %rdi
callq 0xb8120
movq %rax, %rdi
callq 0x165a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: haught[P]cws_plugin/cws_plugin.cpp
// Function: split[abi:cxx11](char const*, char const*)
std::vector<std::string> split(const char *s, const char *delim)
{
	std::vector<std::string> result;
	if (s && strlen(s))
	{
		int len = strlen(s);
		char *src = new char[len + 1];
		strcpy(src, s);
		src[len] = '\0';
		char *tokenptr = strtok(src, delim);
		while (tokenptr != NULL)
		{
			std::string tk = tokenptr;
			result.emplace_back(tk);
			tokenptr = strtok(NULL, delim);
		}
		delete[] src;
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x8ac0
cmpq $0x0, -0x10(%rbp)
je 0x37b8
movq -0x10(%rbp), %rdi
callq 0x3120
cmpq $0x0, %rax
je 0x37b8
movq -0x10(%rbp), %rdi
callq 0x3120
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
incl %eax
movslq %eax, %rdi
callq 0x3030
movq %rax, -0x80(%rbp)
jmp 0x36b8
movq -0x80(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3230
movq -0x28(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x33c0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x3799
movq -0x40(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3430
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x8ae0
jmp 0x3729
leaq -0x61(%rbp), %rdi
callq 0x32a0
movq -0x78(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x8b90
jmp 0x3741
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x33c0
movq %rax, -0x40(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3170
jmp 0x36ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x37d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x32a0
jmp 0x37d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3170
jmp 0x37d8
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
cmpq $0x0, %rax
je 0x37b6
movq -0x98(%rbp), %rdi
callq 0x3310
jmp 0x37b8
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x37cb
movq -0x78(%rbp), %rdi
callq 0x8c10
movq -0x70(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x8c10
movq -0x30(%rbp), %rdi
callq 0x3420
nopw (%rax,%rax)
// File: ambersun1234[P]AVL_Tree/src/avl.h
// Function: AVLTree<int>::findSmallestNodeHelper(node<int>*, int&)
node< itemType >* AVLTree< itemType >::findSmallestNodeHelper( node< itemType > *root , itemType &returnValue ) {
	root = root->getLeftChild();

	if ( root == nullptr ); // no smallest node found;
	else { // smallest node found
		itemType first = root->getData() , second = 0x3f3f3f3f;
		node< itemType > *temp = this->findSmallestNode( root->getRightChild() , second );

		root->setRightChild( temp );

		returnValue = first > second ? first : second;

		if ( root->unbalanced() ) this->doRotation( root );
		root->setHeight( root->getMaxHeight() );
	}
	return root;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f40
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3755
jmp 0x37e9
movq -0x10(%rbp), %rdi
callq 0x2ba0
movl %eax, -0x1c(%rbp)
movl $0x3f3f3f3f, -0x20(%rbp) # imm = 0x3F3F3F3F
movq -0x10(%rbp), %rdi
callq 0x2f60
movq -0x30(%rbp), %rdi
movq %rax, %rsi
leaq -0x20(%rbp), %rdx
callq 0x3820
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x30f0
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jle 0x37a2
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x37a8
movl -0x20(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3110
testb $0x1, %al
jne 0x37c0
jmp 0x37cd
movq -0x30(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x3160
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3330
movq -0x40(%rbp), %rdi
movl %eax, %esi
callq 0x3310
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ambersun1234[P]AVL_Tree/src/avl.h
// Function: AVLTree<int>::findSmallestNode(node<int>*, int&)
node< itemType >* AVLTree< itemType >::findSmallestNode( node< itemType > *root , itemType &returnValue ) {
	if ( root == nullptr ) return nullptr;

	if ( root->getRightChild() == nullptr ) {
		returnValue = root->getData();
		node< itemType > *temp = root->getLeftChild();

		delete root;
		root = nullptr;
		return temp;
	}
	root->setRightChild( this->findSmallestNode( root->getRightChild() , returnValue ) );
	if ( root != nullptr && root->unbalanced() ) this->doRotation( root );
	root->setHeight( root->getMaxHeight() );
	return root;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3850
movq $0x0, -0x8(%rbp)
jmp 0x391f
movq -0x18(%rbp), %rdi
callq 0x2f60
cmpq $0x0, %rax
jne 0x38ab
movq -0x18(%rbp), %rdi
callq 0x2ba0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x2f40
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x3899
movq -0x38(%rbp), %rdi
movl $0x20, %esi
callq 0x20f0
movq $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x391f
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2f60
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x3820
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x30f0
cmpq $0x0, -0x18(%rbp)
je 0x38fb
movq -0x18(%rbp), %rdi
callq 0x3110
testb $0x1, %al
jne 0x38ee
jmp 0x38fb
movq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3160
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3330
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0x3310
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: ambersun1234[P]AVL_Tree/src/avl.h
// Function: AVLTree<int>::findPredecessor(node<int>*, int) const
itemType AVLTree< itemType >::findPredecessor( node< itemType > *root , itemType target ) const {
	if ( root == nullptr ) return INT_MIN;

	if ( root->getData() > target ) {
		return max( INT_MIN , findPredecessor( root->getLeftChild() , target ) );
	}
	else {
		return max( root->getData() , findPredecessor( root->getRightChild() , target ) );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x395b
movl $0x80000000, -0x4(%rbp) # imm = 0x80000000
jmp 0x39d8
movq -0x18(%rbp), %rdi
callq 0x2ba0
cmpl -0x1c(%rbp), %eax
jle 0x399f
movl $0x80000000, -0x20(%rbp) # imm = 0x80000000
movq -0x18(%rbp), %rdi
callq 0x2f40
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movl -0x1c(%rbp), %edx
callq 0x3930
movl %eax, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x39f0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x39d8
movq -0x18(%rbp), %rdi
callq 0x2ba0
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2f60
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movl -0x1c(%rbp), %edx
callq 0x3930
movl %eax, -0x2c(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x39f0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ambersun1234[P]AVL_Tree/src/avl.h
// Function: AVLTree<int>::inorderTraversal(node<int>*, void (*)(node<int>&, std::ostream&))
void AVLTree< itemType >::inorderTraversal( node< itemType > *root , void visit( node< itemType > &record , ostream& os ) ) {
	if ( root == nullptr ) return;
	this->inorderTraversal( root->getLeftChild() , visit );
	visit( *root , cout );
	this->inorderTraversal( root->getRightChild() , visit );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3a55
jmp 0x3a98
movq -0x10(%rbp), %rdi
callq 0x2f40
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x3a30
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x5553(%rip), %rsi      # 0x8fd0
callq *%rax
movq -0x10(%rbp), %rdi
callq 0x2f60
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x3a30
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ambersun1234[P]AVL_Tree/src/avl.h
// Function: AVLTree<int>::preorderTraversal(node<int>*, void (*)(node<int>&, std::ostream&))
void AVLTree< itemType >::preorderTraversal( node< itemType > *root , void visit( node< itemType > &record , ostream& os ) ) {
	if ( root == nullptr ) return;
	visit( *root , cout );
	this->preorderTraversal( root->getLeftChild() , visit );
	this->preorderTraversal( root->getRightChild() , visit );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3ac5
jmp 0x3b08
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x54fc(%rip), %rsi      # 0x8fd0
callq *%rax
movq -0x10(%rbp), %rdi
callq 0x2f40
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x3aa0
movq -0x10(%rbp), %rdi
callq 0x2f60
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x3aa0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ambersun1234[P]AVL_Tree/src/avl.h
// Function: AVLTree<int>::postorderTraversal(node<int>*, void (*)(node<int>&, std::ostream&))
void AVLTree< itemType >::postorderTraversal( node< itemType > *root , void visit( node< itemType > &record , ostream& os ) ) {
	if ( root == nullptr ) return;
	this->postorderTraversal( root->getLeftChild() , visit );
	this->postorderTraversal( root->getRightChild() , visit );
	visit( *root , cout );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3b35
jmp 0x3b78
movq -0x10(%rbp), %rdi
callq 0x2f40
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x3b10
movq -0x10(%rbp), %rdi
callq 0x2f60
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x3b10
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x545a(%rip), %rsi      # 0x8fd0
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: JMMackenzie[P]binary_to_jass/bin_to_jass_disk.cpp
// Function: read_u32(_IO_FILE*)
uint32_t read_u32(FILE* f)
{
    uint32_t x;
    size_t ret = fread(&x, sizeof(uint32_t), 1, f);
    if (feof(f)) {
        return 0;
    }
    if (ret != 1) {
        exit(EXIT_FAILURE);
    }
    return x;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rcx
leaq 0x14(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x22b0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x22d0
cmpl $0x0, %eax
je 0x2570
movl $0x0, 0x24(%rsp)
jmp 0x258a
cmpq $0x1, 0x8(%rsp)
je 0x2582
movl $0x1, %edi
callq 0x2200
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: JMMackenzie[P]binary_to_jass/bin_to_jass_disk.cpp
// Function: read_uint32_list(std::vector<unsigned int, std::allocator<unsigned int>>&, _IO_FILE*)
void read_uint32_list(std::vector<uint32_t>& list, FILE* f)
{
    uint32_t list_len = read_u32(f);
    list.resize(list_len);
    if (list_len != 0) {
        read_u32s(f, list.data(), list_len);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2530
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x4b80
cmpl $0x0, 0x14(%rsp)
je 0x264a
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4c20
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl 0x14(%rsp), %eax
movl %eax, %edx
callq 0x25a0
addq $0x28, %rsp
retq
nop
// File: JMMackenzie[P]binary_to_jass/bin_to_jass_disk.cpp
// Function: usage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void usage(std::string program) {
  std::cerr << program << " <ds2i_prefix> <docid file> <lexicon file>"
            << "<max quantized score [256 = 8 bit quant, 512 = 9 bit quant]><q|G [QMX, EliasGammaSIMD]>\n";
  std::cerr << "e.g. " << program << " wsj wsj.documents wsj.terms 256 G\n";
  exit(EXIT_FAILURE);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, %rsi
movq %rsi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x305c80(%rip), %rdi    # 0x309fe8
callq 0x2170
movq %rax, %rdi
leaq 0x2fed94(%rip), %rsi    # 0x30310b
callq 0x2180
movq %rax, %rdi
leaq 0x2fedb0(%rip), %rsi    # 0x303136
callq 0x2180
movq 0x305c56(%rip), %rdi    # 0x309fe8
leaq 0x2fedf6(%rip), %rsi    # 0x30318f
callq 0x2180
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
leaq 0x2fede0(%rip), %rsi    # 0x303195
callq 0x2180
movl $0x1, %edi
callq 0x2200
nopw %cs:(%rax,%rax)
// File: JMMackenzie[P]binary_to_jass/bin_to_jass_disk.cpp
// Function: void delta<unsigned int>(unsigned int*, unsigned long)
static void delta(T * data, const size_t size) {
        if (size == 0)
            throw std::runtime_error("delta coding impossible with no value!");
        for (size_t i = size - 1; i > 0; --i) {
            data[i] -= data[i - 1];
        }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x4b1b
movl $0x10, %edi
callq 0x20e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x2fe74a(%rip), %rsi    # 0x30322c
callq 0x20a0
jmp 0x4ae9
movq 0x8(%rsp), %rdi
movq 0x3054fb(%rip), %rsi    # 0x309ff0
movq 0x3054cc(%rip), %rdx    # 0x309fc8
callq 0x2310
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x2130
jmp 0x4b69
movq 0x28(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jbe 0x4b64
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %esi
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %edx
subl %esi, %edx
movl %edx, (%rax,%rcx,4)
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4b29
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: JMMackenzie[P]binary_to_jass/compress_qmx.cpp
// Function: bits_needed_for(unsigned int)
static uint8_t bits_needed_for(uint32_t value)
{
if (value == 0x01)
	return 0;
else if (value <= 0x01)
	return 1;
else if (value <= 0x03)
	return 2;
else if (value <= 0x07)
	return 3;
else if (value <= 0x0F)
	return 4;
else if (value <= 0x1F)
	return 5;
else if (value <= 0x3F)
	return 6;
else if (value <= 0x7F)
	return 7;
else if (value <= 0xFF)
	return 8;
else if (value <= 0x1FF)
	return 9;
else if (value <= 0x3FF)
	return 10;
else if (value <= 0xFFF)
	return 12;
else if (value <= 0xFFFF)
	return 16;
else if (value <= 0x1FFFFF)
	return 21;
else
	return 32;
}

// Assembly:
movl %edi, -0x8(%rsp)
cmpl $0x1, -0x8(%rsp)
jne 0xa9e5
movb $0x0, -0x1(%rsp)
jmp 0xaac1
cmpl $0x1, -0x8(%rsp)
ja 0xa9f6
movb $0x1, -0x1(%rsp)
jmp 0xaac1
cmpl $0x3, -0x8(%rsp)
ja 0xaa07
movb $0x2, -0x1(%rsp)
jmp 0xaac1
cmpl $0x7, -0x8(%rsp)
ja 0xaa18
movb $0x3, -0x1(%rsp)
jmp 0xaac1
cmpl $0xf, -0x8(%rsp)
ja 0xaa29
movb $0x4, -0x1(%rsp)
jmp 0xaac1
cmpl $0x1f, -0x8(%rsp)
ja 0xaa3a
movb $0x5, -0x1(%rsp)
jmp 0xaac1
cmpl $0x3f, -0x8(%rsp)
ja 0xaa48
movb $0x6, -0x1(%rsp)
jmp 0xaac1
cmpl $0x7f, -0x8(%rsp)
ja 0xaa56
movb $0x7, -0x1(%rsp)
jmp 0xaac1
cmpl $0xff, -0x8(%rsp)
ja 0xaa67
movb $0x8, -0x1(%rsp)
jmp 0xaac1
cmpl $0x1ff, -0x8(%rsp)      # imm = 0x1FF
ja 0xaa78
movb $0x9, -0x1(%rsp)
jmp 0xaac1
cmpl $0x3ff, -0x8(%rsp)      # imm = 0x3FF
ja 0xaa89
movb $0xa, -0x1(%rsp)
jmp 0xaac1
cmpl $0xfff, -0x8(%rsp)      # imm = 0xFFF
ja 0xaa9a
movb $0xc, -0x1(%rsp)
jmp 0xaac1
cmpl $0xffff, -0x8(%rsp)     # imm = 0xFFFF
ja 0xaaab
movb $0x10, -0x1(%rsp)
jmp 0xaac1
cmpl $0x1fffff, -0x8(%rsp)   # imm = 0x1FFFFF
ja 0xaabc
movb $0x15, -0x1(%rsp)
jmp 0xaac1
movb $0x20, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopw %cs:(%rax,%rax)
// File: JMMackenzie[P]binary_to_jass/compress_integer_elias_gamma_simd.cpp
// Function: JASS::compress_integer_elias_gamma_simd::compute_selector(unsigned char const*)
uint32_t compress_integer_elias_gamma_simd::compute_selector(const uint8_t *encodings)
		{
		uint32_t value = 0;
		int current;

		for (current = 0; current < 32; current++)
			if (encodings[current] == 0)
				break;

		/*
			Compute the permutation number
		*/
		for (current--; current >=  0; current--)
			{
			size_t number_of_0s = encodings[current];
			value <<= number_of_0s;
			value |= 1 << (number_of_0s - 1);
			}

		return value;
		}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
cmpl $0x20, -0x10(%rsp)
jge 0x3000f0
movq -0x8(%rsp), %rax
movslq -0x10(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x3000e1
jmp 0x3000f0
jmp 0x3000e3
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x3000c5
movl -0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rsp)
cmpl $0x0, -0x10(%rsp)
jl 0x30014b
movq -0x8(%rsp), %rax
movslq -0x10(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rcx
movl -0xc(%rsp), %eax
shll %cl, %eax
movl %eax, -0xc(%rsp)
movq -0x18(%rsp), %rax
subq $0x1, %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
orl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x3000fb
movl -0xc(%rsp), %eax
retq
// File: JMMackenzie[P]binary_to_jass/./compress_integer_variable_byte.h
// Function: JASS::compress_integer_variable_byte::static_decode(unsigned int*, unsigned long, void const*, unsigned long)
static inline void static_decode(integer *decoded, size_t integers_to_decode, const void *source_as_void, size_t source_length)
				{
				const uint8_t *source = static_cast<const uint8_t *>(source_as_void);
				const uint8_t *end = source + source_length;		// compute the stopping condition

				while (source < end)
					{
					decompress_into(decoded, source);
					decoded++;
					}
				}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x301b7c
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x301b90
movq 0x30(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x30(%rsp)
jmp 0x301b51
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: JMMackenzie[P]binary_to_jass/compress_integer_variable_byte.cpp
// Function: JASS::compress_integer_variable_byte::encode(void*, unsigned long, unsigned int const*, unsigned long)
size_t compress_integer_variable_byte::encode(void *encoded_as_void, size_t encoded_buffer_length, const integer *source, size_t source_integers)
		{
		uint8_t *encoded = static_cast<uint8_t *>(encoded_as_void);
		size_t used = 0;						// the number of bytes of storage used so far

		const integer *end = source + source_integers;			// the end of the input sequence
		
		/*
			Iterate over each integer in the input sequence
		*/
		for (const integer *current = source; current < end; current++)
			{
			/*
				find out how much space it'll take
			*/
			size_t needed = bytes_needed_for(*current);
			
			/*
				make sure it'll fit in the output buffer
			*/
			if (used + needed > encoded_buffer_length)
				return 0;				// didn't fit so return failure state.
			
			/*
				it fits so encode and add to the size used
			*/
			compress_into(encoded, *current);
			used += needed;
			}

		return used;
		}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x301e76
movq 0x8(%rsp), %rax
movl (%rax), %edi
callq 0x301990
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
addq (%rsp), %rax
cmpq 0x38(%rsp), %rax
jbe 0x301e47
movq $0x0, 0x50(%rsp)
jmp 0x301e80
movq 0x8(%rsp), %rax
movl (%rax), %esi
leaq 0x20(%rsp), %rdi
callq 0x301e90
movq (%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x8(%rsp)
jmp 0x301e10
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: bcthomas[P]shrinksam/src/sam.h
// Function: Shrinksam::Sam::find_cigar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string Sam::find_cigar(const std::string s) {
		for(std::vector<std::string>::iterator it = other.begin(); it != other.end(); ++it) {
			if ((*it).find(s) == 0)
				return(*it);
		}
		return("");
	}

// Assembly:
subq $0x68, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
addq $0xd8, %rdi
callq 0x4fd0
movq %rax, 0x48(%rsp)
movq 0x20(%rsp), %rdi
addq $0xd8, %rdi
callq 0x5040
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5000
testb $0x1, %al
jne 0x409b
jmp 0x40e3
leaq 0x48(%rsp), %rdi
callq 0x5070
movq 0x8(%rsp), %rsi
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x34e0
cmpq $0x0, %rax
jne 0x40d5
leaq 0x48(%rsp), %rdi
callq 0x5070
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x30f0
jmp 0x412e
jmp 0x40d7
leaq 0x48(%rsp), %rdi
callq 0x5080
jmp 0x4070
leaq 0x3f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x3480
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x5478(%rip), %rsi      # 0x9579
callq 0x50a0
jmp 0x4108
leaq 0x3f(%rsp), %rdi
callq 0x32d0
jmp 0x412e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x32d0
jmp 0x4138
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x3470
nopw %cs:(%rax,%rax)
// File: bcthomas[P]shrinksam/src/process_stream.cpp
// Function: parse_read_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string parse_read_name(const string &oldname) {
	if ( (oldname.rfind("/1") == string::npos) && (oldname.rfind("/2") == string::npos) )
		return(oldname);
	else {
		std::string::size_type len = oldname.length();
		return(oldname.substr(0,len-2));
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x538e(%rip), %rsi      # 0x9504
movq $-0x1, %rdx
callq 0x3440
cmpq $-0x1, %rax
jne 0x41b6
movq 0x18(%rsp), %rdi
leaq 0x5373(%rip), %rsi      # 0x9507
movq $-0x1, %rdx
callq 0x3440
cmpq $-0x1, %rax
jne 0x41b6
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x30f0
jmp 0x41e0
movq 0x18(%rsp), %rdi
callq 0x33d0
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rcx
subq $0x2, %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x32a0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: j-faria[P]kima/src/distributions/Empirical.cpp
// Function: DNest4::Empirical::Empirical(char const*)
Empirical::Empirical(const char* filename)
{
    string value;
	ifstream file(filename);
    while(file >> value) {
        data.push_back(stod(value));
    }
	file.close();
    // std::cout << "done reading data from " << filename << std::endl;
    std::sort(data.begin(), data.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x270(%rbp)
callq 0x77a0
movq -0x270(%rbp), %rax
leaq 0x11210f(%rip), %rcx    # 0x1192e0
movq %rcx, (%rax)
movq %rax, %rdi
addq $0x8, %rdi
movq %rdi, -0x268(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
callq 0x77c0
leaq -0x30(%rbp), %rdi
callq 0x66b0
movq -0x10(%rbp), %rsi
leaq -0x238(%rbp), %rdi
movl $0x8, %edx
callq 0x68b0
jmp 0x7216
jmp 0x7218
leaq -0x238(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6610
movq %rax, -0x278(%rbp)
jmp 0x7231
movq -0x278(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6600
movb %al, -0x279(%rbp)
jmp 0x724f
movb -0x279(%rbp), %al
testb $0x1, %al
jne 0x725e
jmp 0x72e8
movq -0x270(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x290(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x7810
movsd %xmm0, -0x288(%rbp)
jmp 0x7287
movq -0x290(%rbp), %rdi
movsd -0x288(%rbp), %xmm0
movsd %xmm0, -0x250(%rbp)
leaq -0x250(%rbp), %rsi
callq 0x77e0
jmp 0x72ac
jmp 0x7218
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
jmp 0x735a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x6130
jmp 0x735a
leaq -0x238(%rbp), %rdi
callq 0x60d0
jmp 0x72f6
movq -0x270(%rbp), %rdi
addq $0x8, %rdi
movq %rdi, -0x298(%rbp)
callq 0x7890
movq -0x298(%rbp), %rdi
movq %rax, -0x258(%rbp)
callq 0x78c0
movq %rax, -0x260(%rbp)
movq -0x258(%rbp), %rdi
movq -0x260(%rbp), %rsi
callq 0x7850
jmp 0x733c
leaq -0x238(%rbp), %rdi
callq 0x6130
leaq -0x30(%rbp), %rdi
callq 0x6948
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x6948
movq -0x268(%rbp), %rdi
callq 0x78f0
movq -0x240(%rbp), %rdi
callq 0x6830
nopl (%rax,%rax)