LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: DoubleString[P]eph_converter/src/Com.cpp
// Function: cross(double*, double*, double*)
void cross(double* v1, double*v2, double* vout) {
	double tmp[3];
	tmp[0] = v1[1] * v2[2] - v1[2] * v2[1];
	tmp[1] = v1[2] * v2[0] - v1[0] * v2[2];
	tmp[2] = v1[0] * v2[1] - v1[1] * v2[0];

	vout[0] = tmp[0];
	vout[1] = tmp[1];
	vout[2] = tmp[2];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm2
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm1
movq -0x10(%rbp), %rax
mulsd 0x8(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm2
movq -0x8(%rbp), %rax
movsd (%rax), %xmm1
movq -0x10(%rbp), %rax
mulsd 0x10(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm2
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
mulsd (%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x10(%rax)
popq %rbp
retq
nop
// File: ricbit[P]dlx/cover_shortcut.cc
// Function: parse_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
vector<string> parse_line(const string& line) {
  istringstream iss(line);
  vector<string> items;
  string item;
  while (iss >> item) {
    items.push_back(item);
  }
  return items;
}

// Assembly:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq 0x1d8(%rsp), %rsi
leaq 0x58(%rsp), %rdi
movl $0x8, %edx
callq 0x21f0
movq 0x18(%rsp), %rdi
movb $0x0, 0x57(%rsp)
callq 0x26d0
leaq 0x30(%rsp), %rdi
callq 0x2190
leaq 0x58(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2160
movq %rax, 0x8(%rsp)
jmp 0x23ca
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2150
movb %al, 0x7(%rsp)
jmp 0x23e4
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x23ee
jmp 0x242f
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x26e0
jmp 0x23ff
jmp 0x23b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x20e0
movq 0x18(%rsp), %rdi
callq 0x2750
leaq 0x58(%rsp), %rdi
callq 0x20a0
jmp 0x2466
movb $0x1, 0x57(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x20e0
testb $0x1, 0x57(%rsp)
jne 0x244f
movq 0x18(%rsp), %rdi
callq 0x2750
leaq 0x58(%rsp), %rdi
callq 0x20a0
movq 0x10(%rsp), %rax
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x28(%rsp), %rdi
callq 0x2200
// File: ricbit[P]dlx/cover_shortcut.cc
// Function: main
int main() {
  string line;
  getline(cin, line);
  vector<string> items = parse_line(line);
  vector<vector<string>> options;
  while (getline(cin, line)) {
    vector<string> option = parse_line(line);
    if (!option.empty()) {
      options.push_back(option);
    }
  }
  ExactCover ec(items, options);
  //ec.print();
  //ec.write_dot();
  cout << "Number of solutions: " << ec.run() << "\n";
  return 0;
}

// Assembly:
subq $0x168, %rsp            # imm = 0x168
movl $0x0, 0x164(%rsp)
leaq 0x140(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x2190
movq 0x28(%rsp), %rsi
movq 0xeb40(%rip), %rdi      # 0x10fe0
callq 0x2030
jmp 0x24a7
leaq 0x118(%rsp), %rdi
leaq 0x140(%rsp), %rsi
callq 0x2360
jmp 0x24be
leaq 0x100(%rsp), %rdi
callq 0x27b0
movq 0xeb0e(%rip), %rdi      # 0x10fe0
leaq 0x140(%rsp), %rsi
callq 0x2030
movq %rax, 0x20(%rsp)
jmp 0x24e6
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2150
movb %al, 0x1f(%rsp)
jmp 0x2500
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x250d
jmp 0x25b8
leaq 0xe8(%rsp), %rdi
leaq 0x140(%rsp), %rsi
callq 0x2360
jmp 0x2524
leaq 0xe8(%rsp), %rdi
callq 0x27c0
testb $0x1, %al
jne 0x25a6
leaq 0x100(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x2810
jmp 0x254c
jmp 0x25a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x138(%rsp)
movl %eax, 0x134(%rsp)
jmp 0x26a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x138(%rsp)
movl %eax, 0x134(%rsp)
jmp 0x268f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x138(%rsp)
movl %eax, 0x134(%rsp)
leaq 0xe8(%rsp), %rdi
callq 0x2750
jmp 0x268f
leaq 0xe8(%rsp), %rdi
callq 0x2750
jmp 0x24cb
leaq 0x30(%rsp), %rdi
leaq 0x118(%rsp), %rsi
leaq 0x100(%rsp), %rdx
callq 0x2880
jmp 0x25d4
movq 0xe9f5(%rip), %rdi      # 0x10fd0
leaq 0x8a26(%rip), %rsi      # 0xb008
callq 0x2120
movq %rax, 0x10(%rsp)
jmp 0x25ee
leaq 0x30(%rsp), %rdi
callq 0x2a30
movq %rax, 0x8(%rsp)
jmp 0x25ff
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x2210
movq %rax, (%rsp)
jmp 0x2614
movq (%rsp), %rdi
leaq 0x89ff(%rip), %rsi      # 0xb01e
callq 0x2120
jmp 0x2626
movl $0x0, 0x164(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2a80
leaq 0x100(%rsp), %rdi
callq 0x2ae0
leaq 0x118(%rsp), %rdi
callq 0x2750
leaq 0x140(%rsp), %rdi
callq 0x20e0
movl 0x164(%rsp), %eax
addq $0x168, %rsp            # imm = 0x168
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x138(%rsp)
movl %eax, 0x134(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x2a80
leaq 0x100(%rsp), %rdi
callq 0x2ae0
leaq 0x118(%rsp), %rdi
callq 0x2750
leaq 0x140(%rsp), %rdi
callq 0x20e0
movq 0x138(%rsp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::run()
long run() {
    count = 0;
    active = header.size() - 1;
    solve(0);
    if (DEBUG) {
      for (int i = 0; i < int(hist.size()) - 1; i++) {
        if (hist[i] > 0) {
          cout << "hist "<< i << " = " << hist[i] << "\n";
        }
      }
    }
    return count;
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq $0x0, 0xb0(%rdi)
callq 0x7f40
movq 0x8(%rsp), %rdi
subq $0x1, %rax
movl %eax, 0xa8(%rdi)
xorl %esi, %esi
callq 0x7f60
movq 0x8(%rsp), %rax
movq 0xb0(%rax), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::build_header(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
vector<Header> build_header(
      const vector<string>& items) {
    vector<Header> header(items.size() + 1);
    int size = items.size();
    for (int i = 0; i <= size; i++) {
      if (i == 0) {
        header[i] = { size, 1 };
      } else {
        header[i] = { i - 1, (i + 1) % (size + 1) };
      }
    }
    return header;
  }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movb $0x0, 0x4f(%rsp)
movq 0x50(%rsp), %rdi
callq 0x3750
incq %rax
movq %rax, 0x10(%rsp)
leaq 0x4e(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3770
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x3780
jmp 0x2cbb
leaq 0x4e(%rsp), %rdi
callq 0x3800
movq 0x50(%rsp), %rdi
callq 0x3750
movl %eax, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x38(%rsp), %eax
jg 0x2d7c
cmpl $0x0, 0x34(%rsp)
jne 0x2d33
movq 0x8(%rsp), %rdi
movl 0x38(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl $0x1, 0x30(%rsp)
movslq 0x34(%rsp), %rsi
callq 0x3810
movq 0x2c(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x2d6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4e(%rsp), %rdi
callq 0x3800
jmp 0x2d9b
movq 0x8(%rsp), %rdi
movl 0x34(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x24(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl 0x38(%rsp), %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movl %edx, 0x28(%rsp)
movslq 0x34(%rsp), %rsi
callq 0x3810
movq 0x24(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x2d6c
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x2cdb
movb $0x1, 0x4f(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x2d92
movq 0x8(%rsp), %rdi
callq 0x36f0
movq (%rsp), %rax
addq $0x68, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
nop
// File: ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::count_nodes(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::vector<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>> const&)
int count_nodes(
      const vector<string>& items,
      const vector<vector<string>>& options) {
    int total_nodes = 2 + items.size();
    for (const auto& option : options) {
      total_nodes += option.size();
    }
    return total_nodes;
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3750
addq $0x2, %rax
movl %eax, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4200
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4230
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4260
testb $0x1, %al
jne 0x3fd2
jmp 0x4006
leaq 0x18(%rsp), %rdi
callq 0x42a0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x3750
movq %rax, %rcx
movslq 0x2c(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x2c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x42b0
jmp 0x3fbd
movl 0x2c(%rsp), %eax
addq $0x48, %rsp
retq
nop
// File: ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::solve(int)
void solve(int level) {
    if (header[0].rlink == 0) {
      count++;
      return;
    }
    int item = best_item();
    cover(item);
    solution[level].option = nodes[item].dlink;
    for (auto& option = solution[level].option; option != item; option = nodes[option].dlink) {
      try_option(option, solution[level]);
      if (active == 1) {
        int size = nodes[header[0].rlink].top;
        count += size;
        if (DEBUG) {
          hist[size]++;
        }
      } else {
        solve(level + 1);
      }
      rewind_option(option, solution[level]);
    }
    uncover(item);
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3810
cmpl $0x0, 0x4(%rax)
jne 0x7fa2
movq 0x20(%rsp), %rax
movq 0xb0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xb0(%rax)
jmp 0x8115
movq 0x20(%rsp), %rdi
callq 0x8120
movq 0x20(%rsp), %rdi
movl %eax, 0x38(%rsp)
movl 0x38(%rsp), %esi
callq 0x81f0
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movslq 0x38(%rsp), %rsi
callq 0x4140
movq 0x20(%rsp), %rdi
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
addq $0x38, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x82d0
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rdi
movl %ecx, (%rax)
addq $0x38, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x82d0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %eax
cmpl 0x38(%rsp), %eax
je 0x8107
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x18(%rsp)
addq $0x38, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x82d0
movl 0x18(%rsp), %esi
movq 0x20(%rsp), %rdi
movq %rax, %rdx
callq 0x82f0
movq 0x20(%rsp), %rax
cmpl $0x1, 0xa8(%rax)
jne 0x80a2
movq 0x20(%rsp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3810
movq 0x10(%rsp), %rdi
movslq 0x4(%rax), %rsi
callq 0x4140
movq %rax, %rcx
movq 0x20(%rsp), %rax
movl (%rcx), %ecx
movl %ecx, 0x2c(%rsp)
movslq 0x2c(%rsp), %rcx
addq 0xb0(%rax), %rcx
movq %rcx, 0xb0(%rax)
jmp 0x80b3
movq 0x20(%rsp), %rdi
movl 0x3c(%rsp), %esi
addl $0x1, %esi
callq 0x7f60
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
addq $0x38, %rdi
movslq 0x3c(%rsp), %rsi
callq 0x82d0
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
movq %rax, %rdx
callq 0x8340
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movq 0x30(%rsp), %rax
movslq (%rax), %rsi
callq 0x4140
movl 0x8(%rax), %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
jmp 0x8009
movq 0x20(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0x8380
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::best_item()
int best_item() {
    int best = header[0].rlink;
    int value = nodes[best].top;
    for (int p = header[best].rlink; p != 0; p = header[p].rlink) {
      if (nodes[p].top < value) {
        best = p;
        value = nodes[p].top;
        if (value == 0) {
          break;
        }
      }
    }
    return best;
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3810
movq 0x8(%rsp), %rdi
movl 0x4(%rax), %eax
movl %eax, 0x1c(%rsp)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4140
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x18(%rsp)
movslq 0x1c(%rsp), %rsi
callq 0x3810
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x81da
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movslq 0x14(%rsp), %rsi
callq 0x4140
movl (%rax), %eax
cmpl 0x18(%rsp), %eax
jge 0x81c0
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, 0x1c(%rsp)
addq $0x18, %rdi
movslq 0x14(%rsp), %rsi
callq 0x4140
movl (%rax), %eax
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x18(%rsp)
jne 0x81be
jmp 0x81da
jmp 0x81c0
jmp 0x81c2
movq 0x8(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x3810
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x8172
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::cover(int)
void cover(int i) {
    active--;
    for (auto p = nodes[i].dlink; p != i; p = nodes[p].dlink) {
      hide(p);
    }
    auto l = header[i].llink;
    auto r = header[i].rlink;
    header[l].rlink = r;
    header[r].llink = l;
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0xa8(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0xa8(%rdi)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4140
movl 0x8(%rax), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
je 0x825f
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x8460
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movslq 0x18(%rsp), %rsi
callq 0x4140
movl 0x8(%rax), %eax
movl %eax, 0x18(%rsp)
jmp 0x822b
movq 0x8(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x3810
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movslq 0x1c(%rsp), %rsi
callq 0x3810
movq 0x8(%rsp), %rdi
movl 0x4(%rax), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, (%rsp)
movslq 0x14(%rsp), %rsi
callq 0x3810
movl (%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, 0x4(%rax)
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
movslq 0x10(%rsp), %rsi
callq 0x3810
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::try_option(int, Solution&)
void try_option(int option, Solution& sol) {
    option_right_edges(option, [&](int p) {
      cover(abs(nodes[p].top));
    }, [&sol](int right) {
      sol.right = right;
    }, [&sol](int left) {
      sol.left = left;
    });
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq %rdi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x8690
addq $0x38, %rsp
retq
nopl (%rax)
// File: ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::uncover(int)
void uncover(int i) {
    active++;
    auto l = header[i].llink;
    auto r = header[i].rlink;
    header[l].rlink = i;
    header[r].llink = i;
    for (auto p = nodes[i].ulink; p != i; p = nodes[p].ulink) {
      unhide(p);
    }
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0xa8(%rdi), %eax
addl $0x1, %eax
movl %eax, 0xa8(%rdi)
movslq 0x1c(%rsp), %rsi
callq 0x3810
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x18(%rsp)
movslq 0x1c(%rsp), %rsi
callq 0x3810
movq 0x8(%rsp), %rdi
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, (%rsp)
movslq 0x18(%rsp), %rsi
callq 0x3810
movl (%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, 0x4(%rax)
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
movslq 0x14(%rsp), %rsi
callq 0x3810
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, (%rax)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4140
movl 0x4(%rax), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x1c(%rsp), %eax
je 0x8453
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x88c0
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movslq 0x10(%rsp), %rsi
callq 0x4140
movl 0x4(%rax), %eax
movl %eax, 0x10(%rsp)
jmp 0x841f
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: ricbit[P]dlx/cover_shortcut.cc
// Function: void ExactCover::option_right_edges<ExactCover::hide(int)::'lambda'(int), void ExactCover::option_right<ExactCover::hide(int)::'lambda'(int)>(int, ExactCover::hide(int)::'lambda'(int))::'lambda'(int), void ExactCover::option_right<ExactCover::hide(int)::'lambda'(int)>(int, ExactCover::hide(int)::'lambda'(int))::'lambda'(int)>(int, ExactCover::hide(int)::'lambda'(int), void ExactCover::option_right<ExactCover::hide(int)::'lambda'(int)>(int, ExactCover::hide(int)::'lambda'(int))::'lambda'(int), void ExactCover::option_right<ExactCover::hide(int)::'lambda'(int)>(int, ExactCover::hide(int)::'lambda'(int))::'lambda'(int))
void option_right_edges(int option, T action, P action_right, Q action_left) {
    auto p = option + 1;
    if (nodes[option].top > 0) {
      do {
        action(p);
      } while (nodes[p++].top > 0);
      action_right(p - 1);
    } else {
      action_right(option);
    }

    for (p = option - 1; nodes[p].top > 0; p--) {
      action(p);
    }
    action_left(p + 1);
  }

// Assembly:
subq $0x28, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
addq $0x18, %rdi
movslq 0xc(%rsp), %rsi
callq 0x4140
cmpl $0x0, (%rax)
jle 0x854e
jmp 0x850b
movl 0x8(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x85b0
movq (%rsp), %rdi
addq $0x18, %rdi
movl 0x8(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rsp)
movslq %eax, %rsi
callq 0x4140
cmpl $0x0, (%rax)
jg 0x850b
movl 0x8(%rsp), %esi
subl $0x1, %esi
leaq 0x1f(%rsp), %rdi
callq 0x8680
jmp 0x855c
movl 0xc(%rsp), %esi
leaq 0x1f(%rsp), %rdi
callq 0x8680
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x8(%rsp)
movq (%rsp), %rdi
addq $0x18, %rdi
movslq 0x8(%rsp), %rsi
callq 0x4140
cmpl $0x0, (%rax)
jle 0x8599
movl 0x8(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x85b0
movl 0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x8567
movl 0x8(%rsp), %esi
addl $0x1, %esi
leaq 0x1e(%rsp), %rdi
callq 0x8680
addq $0x28, %rsp
retq
nop
// File: ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::hide(int)::'lambda'(int)::operator()(int) const
void hide(int p) {
    option_right(p, [&](int q) {
      auto x = abs(nodes[q].top);
      auto u = nodes[q].ulink;
      auto d = nodes[q].dlink;
      nodes[u].dlink = d;
      nodes[d].ulink = u;
      nodes[x].top--;
    });
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4140
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, 0x18(%rsp)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4140
movq 0x8(%rsp), %rdi
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4140
movq 0x8(%rsp), %rdi
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, (%rsp)
addq $0x18, %rdi
movslq 0x14(%rsp), %rsi
callq 0x4140
movl (%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, 0x8(%rax)
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x18, %rdi
movslq 0x10(%rsp), %rsi
callq 0x4140
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, 0x4(%rax)
addq $0x18, %rdi
movslq 0x18(%rsp), %rsi
callq 0x4140
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: ricbit[P]dlx/cover_shortcut.cc
// Function: void ExactCover::option_left<ExactCover::rewind_option(int, Solution const&)::'lambda'(int)>(int, Solution const&, ExactCover::rewind_option(int, Solution const&)::'lambda'(int))
void option_left(int option, const Solution& sol, T action) {
    for (auto p = sol.left; p != option; p++) {
      action(p);
    }
    for (auto p = sol.right; p != option; p--) {
      action(p);
    }
  }

// Assembly:
subq $0x28, %rsp
movq %rcx, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
je 0x8848
movl 0x4(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x8880
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x8823
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, (%rsp)
movl (%rsp), %eax
cmpl 0x14(%rsp), %eax
je 0x8874
movl (%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x8880
movl (%rsp), %eax
addl $-0x1, %eax
movl %eax, (%rsp)
jmp 0x8853
addq $0x28, %rsp
retq
nopl (%rax)
// File: ricbit[P]dlx/cover_shortcut.cc
// Function: ExactCover::unhide(int)::'lambda'(int)::operator()(int) const
void unhide(int p) {
    option_right(p, [&](int q) {
      auto x = abs(nodes[q].top);
      auto u = nodes[q].ulink;
      auto d = nodes[q].dlink;
      nodes[u].dlink = q;
      nodes[d].ulink = q;
      nodes[x].top++;
    });
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq %rdi, 0x8(%rsp)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4140
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, 0x18(%rsp)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4140
movq 0x8(%rsp), %rdi
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
addq $0x18, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x4140
movq 0x8(%rsp), %rdi
movl 0x8(%rax), %eax
movl %eax, 0x10(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, (%rsp)
addq $0x18, %rdi
movslq 0x14(%rsp), %rsi
callq 0x4140
movl (%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, 0x8(%rax)
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
addq $0x18, %rdi
movslq 0x10(%rsp), %rsi
callq 0x4140
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, 0x4(%rax)
addq $0x18, %rdi
movslq 0x18(%rsp), %rsi
callq 0x4140
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: bastelfreak[P]erp-system/articlesearch.cpp
// Function: ArtikelNameSuche[abi:cxx11]()
std::string ArtikelNameSuche ()
{
  std::string ArtikelName;
	//cout<< "Bitte geben Sie den Namen des Produktes ein!" <<endl;
  std::cout << "Please enter the Article Name" << std::endl;
  std::cin >> ArtikelName;

	return ArtikelName;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x2280
movq 0x3561(%rip), %rdi      # 0x5fc8
leaq 0x167c(%rip), %rsi      # 0x40ea
callq 0x21a0
movq %rax, -0x28(%rbp)
jmp 0x2a79
movq -0x28(%rbp), %rdi
movq 0x3534(%rip), %rsi      # 0x5fb8
callq 0x21b0
jmp 0x2a8b
movq -0x38(%rbp), %rsi
movq 0x3542(%rip), %rdi      # 0x5fd8
callq 0x2250
jmp 0x2a9d
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x2ac9
jmp 0x2ac0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x20e0
jmp 0x2ad3
movq -0x38(%rbp), %rdi
callq 0x20e0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2310
nopl (%rax)
// File: bastelfreak[P]erp-system/filehandler.cpp
// Function: getFileName[abi:cxx11]()
std::string getFileName()
{
	std::string filename;
	std::cout << "Please enter in the name of the file you'd like to open: ";
	std::cin >> filename;
	return filename;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x2280
movq 0x2fe1(%rip), %rdi      # 0x5fc8
leaq 0x1163(%rip), %rsi      # 0x4151
callq 0x21a0
jmp 0x2ff5
movq -0x30(%rbp), %rsi
movq 0x2fd8(%rip), %rdi      # 0x5fd8
callq 0x2250
jmp 0x3007
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x3033
jmp 0x302a
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x20e0
jmp 0x303d
movq -0x30(%rbp), %rdi
callq 0x20e0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
// File: bastelfreak[P]erp-system/filehandler.cpp
// Function: open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::basic_fstream<char, std::char_traits<char>>&)
void open(std::string filepath, std::fstream& file)
{
	bool file_exists = checkFileExistence(filepath);
	if (!file_exists)
	{
		std::cout << "File " << filepath << " not found.\n";
		filepath = getFileName(); //Not found
		std::ofstream dummy(filepath.c_str());
		if (!dummy.is_open()) {
			std::cerr << "Could not create file.\n";
			return;
		}
		std::cout << "File created.\n";
	}
	else
	{
		file.open(filepath.c_str());
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x250(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2f10
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x31a4
movq 0x2f43(%rip), %rdi      # 0x5fc8
leaq 0x10ff(%rip), %rsi      # 0x418b
callq 0x21a0
movq -0x250(%rbp), %rsi
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
leaq 0x10e7(%rip), %rsi      # 0x4191
callq 0x21a0
leaq -0x38(%rbp), %rdi
movq %rdi, -0x268(%rbp)
callq 0x2fc0
movq -0x268(%rbp), %rsi
movq -0x250(%rbp), %rdi
callq 0x2220
movq -0x268(%rbp), %rdi
callq 0x20e0
movq -0x250(%rbp), %rdi
callq 0x20a0
movq %rax, %rsi
leaq -0x238(%rbp), %rdi
movq %rdi, -0x260(%rbp)
movl $0x10, %edx
callq 0x21e0
movq -0x260(%rbp), %rdi
callq 0x2110
movb %al, -0x251(%rbp)
jmp 0x3119
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0x3169
jmp 0x3125
movq 0x2ec4(%rip), %rdi      # 0x5ff0
leaq 0x106b(%rip), %rsi      # 0x419e
callq 0x21a0
jmp 0x313a
movl $0x1, -0x248(%rbp)
jmp 0x3188
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x22a0
jmp 0x31ef
movq 0x2e58(%rip), %rdi      # 0x5fc8
leaq 0x103f(%rip), %rsi      # 0x41b6
callq 0x21a0
jmp 0x317e
movl $0x0, -0x248(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x22a0
movl -0x248(%rbp), %eax
testl %eax, %eax
je 0x31a2
jmp 0x31a0
jmp 0x31e6
jmp 0x31e6
movq -0x250(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x278(%rbp)
callq 0x20a0
movq %rax, -0x270(%rbp)
movl $0x8, %edi
movl $0x10, %esi
callq 0x3430
movq -0x278(%rbp), %rdi
movq -0x270(%rbp), %rsi
movl %eax, %edx
callq 0x2180
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x240(%rbp), %rdi
callq 0x2310
nopl (%rax,%rax)
// File: bastelfreak[P]erp-system/filehandler.cpp
// Function: getData(std::basic_fstream<char, std::char_traits<char>>&, TArticle*)
void getData(std::fstream& file, TArticle AlleArtikel[1000])
{
	if (!file.is_open())
	{
		std::cout << "File must be open!" << std::endl;
	}
	else 
	{
		char cText[256];
		char * pch;
		int i = 0;
		int n;
		while (!file.eof()){
			file.getline(cText, sizeof(cText));
			pch = strtok(cText, ";");
			n = 1;
			while (pch != NULL)
			{
				if (n == 1)
					AlleArtikel[i].id = atoi(pch);
				else if (n == 2)
					strcpy(AlleArtikel[i].name, pch);
				else if (n == 3)
					AlleArtikel[i].price = atof(pch);
				pch = strtok(NULL, ";");
				n++;
			}
			i++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x22f0
testb $0x1, %al
jne 0x32d7
movq 0x2d11(%rip), %rdi      # 0x5fc8
leaq 0xf07(%rip), %rsi       # 0x41c5
callq 0x21a0
movq %rax, %rdi
movq 0x2ceb(%rip), %rsi      # 0x5fb8
callq 0x21b0
jmp 0x341a
movl $0x0, -0x11c(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x2340
xorb $-0x1, %al
testb $0x1, %al
jne 0x32fc
jmp 0x3418
movq -0x8(%rbp), %rdi
leaq -0x110(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x2080
leaq -0x110(%rbp), %rdi
leaq 0xeb9(%rip), %rsi       # 0x41d8
callq 0x22d0
movq %rax, -0x118(%rbp)
movl $0x1, -0x120(%rbp)
cmpq $0x0, -0x118(%rbp)
je 0x3404
cmpl $0x1, -0x120(%rbp)
jne 0x3373
movq -0x118(%rbp), %rdi
callq 0x22c0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq -0x11c(%rbp), %rdx
imulq $0x110, %rdx, %rdx      # imm = 0x110
addq %rdx, %rax
movl %ecx, (%rax)
jmp 0x33d9
cmpl $0x2, -0x120(%rbp)
jne 0x33a3
movq -0x10(%rbp), %rdi
movslq -0x11c(%rbp), %rax
imulq $0x110, %rax, %rax      # imm = 0x110
addq %rax, %rdi
addq $0x4, %rdi
movq -0x118(%rbp), %rsi
callq 0x2190
jmp 0x33d7
cmpl $0x3, -0x120(%rbp)
jne 0x33d5
movq -0x118(%rbp), %rdi
callq 0x2240
movq -0x10(%rbp), %rax
movslq -0x11c(%rbp), %rcx
imulq $0x110, %rcx, %rcx      # imm = 0x110
addq %rcx, %rax
movsd %xmm0, 0x108(%rax)
jmp 0x33d7
jmp 0x33d9
xorl %eax, %eax
movl %eax, %edi
leaq 0xdf4(%rip), %rsi       # 0x41d8
callq 0x22d0
movq %rax, -0x118(%rbp)
movl -0x120(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x120(%rbp)
jmp 0x3335
movl -0x11c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x11c(%rbp)
jmp 0x32e1
jmp 0x341a
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: bastelfreak[P]erp-system/main.cpp
// Function: main
int main (void)
{
	TArticle AlleArtikel[1000];
	std::string db_path = "database.csv";
	bool exit = false;
	char input;
	std::fstream database;
	open(db_path, database);
	getData(database, AlleArtikel);
  std::cout << "Hey, I'm your crazy ERP-System, what do you want to do?\n";
	while(!exit)
	{
		menue(AlleArtikel);
		std::cout << "Do you want to exit the Tool(y)?" << "\n";
		std::cin >> input;
		if(input == 'y' || input == 'Y' || input == 'z' || input == 'Z')
		{
			exit = true;
		}
	}
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x42910, %rsp          # imm = 0x42910
movl $0x0, -0x4(%rbp)
leaq -0x426b1(%rbp), %rdi
movq %rdi, -0x42900(%rbp)
callq 0x2320
movq -0x42900(%rbp), %rdx
leaq 0xd57(%rip), %rsi       # 0x41da
leaq -0x426b0(%rbp), %rdi
callq 0x2b30
jmp 0x3491
leaq -0x426b1(%rbp), %rdi
callq 0x21d0
movb $0x0, -0x426c5(%rbp)
leaq -0x428d8(%rbp), %rdi
callq 0x2210
jmp 0x34b2
leaq -0x428f8(%rbp), %rdi
leaq -0x426b0(%rbp), %rsi
callq 0x20b0
jmp 0x34c7
leaq -0x428f8(%rbp), %rdi
leaq -0x428d8(%rbp), %rsi
callq 0x3050
jmp 0x34dc
leaq -0x428f8(%rbp), %rdi
callq 0x20e0
leaq -0x428d8(%rbp), %rdi
leaq -0x42690(%rbp), %rsi
callq 0x3290
jmp 0x34fd
movq 0x2ac4(%rip), %rdi      # 0x5fc8
leaq 0xcdc(%rip), %rsi       # 0x41e7
callq 0x21a0
jmp 0x3512
jmp 0x3514
movb -0x426c5(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3525
jmp 0x3622
leaq -0x42690(%rbp), %rdi
callq 0x3680
jmp 0x3533
movq 0x2a8e(%rip), %rdi      # 0x5fc8
leaq 0xcdf(%rip), %rsi       # 0x4220
callq 0x21a0
movq %rax, -0x42908(%rbp)
jmp 0x354f
movq -0x42908(%rbp), %rdi
leaq 0xdb2(%rip), %rsi       # 0x430f
callq 0x21a0
jmp 0x3564
movq 0x2a6d(%rip), %rdi      # 0x5fd8
leaq -0x426c6(%rbp), %rsi
callq 0x2260
jmp 0x3579
movsbl -0x426c6(%rbp), %eax
cmpl $0x79, %eax
je 0x35a9
movsbl -0x426c6(%rbp), %eax
cmpl $0x59, %eax
je 0x35a9
movsbl -0x426c6(%rbp), %eax
cmpl $0x7a, %eax
je 0x35a9
movsbl -0x426c6(%rbp), %eax
cmpl $0x5a, %eax
jne 0x361d
movb $0x1, -0x426c5(%rbp)
jmp 0x361d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x426c0(%rbp)
movl %eax, -0x426c4(%rbp)
leaq -0x426b1(%rbp), %rdi
callq 0x21d0
jmp 0x3665
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x426c0(%rbp)
movl %eax, -0x426c4(%rbp)
jmp 0x3659
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x426c0(%rbp)
movl %eax, -0x426c4(%rbp)
jmp 0x364d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x426c0(%rbp)
movl %eax, -0x426c4(%rbp)
leaq -0x428f8(%rbp), %rdi
callq 0x20e0
jmp 0x364d
jmp 0x3514
movl $0x0, -0x4(%rbp)
leaq -0x428d8(%rbp), %rdi
callq 0x2050
leaq -0x426b0(%rbp), %rdi
callq 0x20e0
movl -0x4(%rbp), %eax
addq $0x42910, %rsp          # imm = 0x42910
popq %rbp
retq
leaq -0x428d8(%rbp), %rdi
callq 0x2050
leaq -0x426b0(%rbp), %rdi
callq 0x20e0
movq -0x426c0(%rbp), %rdi
callq 0x2310
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: bastelfreak[P]erp-system/menue.cpp
// Function: menue(TArticle*)
int menue (TArticle AlleArtikel[])
{
	char choice;

  std::cout << " Please choose one of these menue points: " << std::endl;
  std::cout << " (1) teuersterArtikel " << std::endl;
  std::cout << " (2) guenstigsterArtikel " << std::endl;
  std::cout << " (3) anzahlArtikel " << std::endl;
  std::cout << " (4) ArtikelSuche " << std::endl;

  while (true)
  {
    std::cout << " Please enter your choice: ";
    std::cin >> choice;

    switch (choice) 
    {
      case '1': teuersterArtikel(AlleArtikel); break;
      case '2': guenstigsterArtikel(AlleArtikel); break;
      case '3': anzahlArtikel(AlleArtikel); break;
      case '4': ArtikelSuche(AlleArtikel); break;
      default: std::cout << "Please choose a valid entry!\n"; return 0; break;
    }

  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x2935(%rip), %rdi      # 0x5fc8
leaq 0xbba(%rip), %rsi       # 0x4254
callq 0x21a0
movq %rax, %rdi
movq 0x290f(%rip), %rsi      # 0x5fb8
callq 0x21b0
movq 0x2913(%rip), %rdi      # 0x5fc8
leaq 0xbc3(%rip), %rsi       # 0x427f
callq 0x21a0
movq %rax, %rdi
movq 0x28ed(%rip), %rsi      # 0x5fb8
callq 0x21b0
movq 0x28f1(%rip), %rdi      # 0x5fc8
leaq 0xbb8(%rip), %rsi       # 0x4296
callq 0x21a0
movq %rax, %rdi
movq 0x28cb(%rip), %rsi      # 0x5fb8
callq 0x21b0
movq 0x28cf(%rip), %rdi      # 0x5fc8
leaq 0xbb0(%rip), %rsi       # 0x42b0
callq 0x21a0
movq %rax, %rdi
movq 0x28a9(%rip), %rsi      # 0x5fb8
callq 0x21b0
movq 0x28ad(%rip), %rdi      # 0x5fc8
leaq 0xba2(%rip), %rsi       # 0x42c4
callq 0x21a0
movq %rax, %rdi
movq 0x2887(%rip), %rsi      # 0x5fb8
callq 0x21b0
movq 0x288b(%rip), %rdi      # 0x5fc8
leaq 0xb93(%rip), %rsi       # 0x42d7
callq 0x21a0
movq 0x2888(%rip), %rdi      # 0x5fd8
leaq -0x9(%rbp), %rsi
callq 0x2260
movsbl -0x9(%rbp), %eax
addl $-0x31, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x37ab
movq -0x18(%rbp), %rax
leaq 0xace(%rip), %rcx       # 0x4244
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x37d0
jmp 0x37c6
movq -0x8(%rbp), %rdi
callq 0x3900
jmp 0x37c6
movq -0x8(%rbp), %rdi
callq 0x3a30
jmp 0x37c6
movq -0x8(%rbp), %rdi
callq 0x25b0
jmp 0x37c6
movq 0x2816(%rip), %rdi      # 0x5fc8
leaq 0xb3a(%rip), %rsi       # 0x42f3
callq 0x21a0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
jmp 0x3736
nopl (%rax,%rax)
// File: bastelfreak[P]erp-system/statistics.cpp
// Function: teuersterArtikel(TArticle*)
int teuersterArtikel(TArticle AlleArtikel[]) // Programm f�r die Statistik des teuersten Artikel im Array 
{

	TArticle tartikelZwischenspeicher; // Variable wird Initialisiert
	int hoechsterPreis = 0;

	for (int i = 1; i < 1000; i++)
	{
		if (AlleArtikel[i].price >= hoechsterPreis) //Vergleicht den Wert "Preis" aus dem Array mit Wert in int hoechsterpreis
		{
			hoechsterPreis = AlleArtikel[i].price;		//�berschreibt Wert in Variable mit h�herem Wert
			tartikelZwischenspeicher = AlleArtikel[i];	//�berschreibt Werte in tartikelZwischenspeicher
		}
	}
	//Ausgabe in Konsole
  std::cout << "Der teuerste Artikel ist: " << tartikelZwischenspeicher.id << 
	std::endl << tartikelZwischenspeicher.name << std::endl << tartikelZwischenspeicher.price;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movl $0x0, -0x11c(%rbp)
movl $0x1, -0x120(%rbp)
cmpl $0x3e8, -0x120(%rbp)    # imm = 0x3E8
jge 0x388d
movq -0x8(%rbp), %rax
movslq -0x120(%rbp), %rcx
imulq $0x110, %rcx, %rcx      # imm = 0x110
addq %rcx, %rax
movsd 0x108(%rax), %xmm0
cvtsi2sdl -0x11c(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jb 0x3877
movq -0x8(%rbp), %rax
movslq -0x120(%rbp), %rcx
imulq $0x110, %rcx, %rcx      # imm = 0x110
addq %rcx, %rax
cvttsd2si 0x108(%rax), %eax
movl %eax, -0x11c(%rbp)
movq -0x8(%rbp), %rsi
movslq -0x120(%rbp), %rax
imulq $0x110, %rax, %rax      # imm = 0x110
addq %rax, %rsi
leaq -0x118(%rbp), %rdi
movl $0x110, %edx            # imm = 0x110
callq 0x2140
jmp 0x3879
movl -0x120(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x120(%rbp)
jmp 0x37f3
movq 0x2734(%rip), %rdi      # 0x5fc8
leaq 0xa76(%rip), %rsi       # 0x4311
callq 0x21a0
movq %rax, %rdi
movl -0x118(%rbp), %esi
callq 0x2300
movq %rax, %rdi
movq 0x2700(%rip), %rsi      # 0x5fb8
callq 0x21b0
movq %rax, %rdi
leaq -0x118(%rbp), %rsi
addq $0x4, %rsi
callq 0x21a0
movq %rax, %rdi
movq 0x26de(%rip), %rsi      # 0x5fb8
callq 0x21b0
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
callq 0x2350
xorl %eax, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)
// File: bastelfreak[P]erp-system/statistics.cpp
// Function: guenstigsterArtikel(TArticle*)
int guenstigsterArtikel(TArticle AlleArtikel[])
{
	
	TArticle tartikelZwischenspeicher;
	int guenstigsterPreis = 0;

	for (int i = 1; i < 1000; i++)
	{
		if (AlleArtikel[i].price <= guenstigsterPreis)
		{
			guenstigsterPreis = AlleArtikel[i].price;
			tartikelZwischenspeicher = AlleArtikel[i];
		}
	}

  std::cout << "Der guenstigste Artikel ist: " << tartikelZwischenspeicher.id << 
	std::endl << tartikelZwischenspeicher.name << std::endl << tartikelZwischenspeicher.price;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movl $0x0, -0x11c(%rbp)
movl $0x1, -0x120(%rbp)
cmpl $0x3e8, -0x120(%rbp)    # imm = 0x3E8
jge 0x39bd
movq -0x8(%rbp), %rax
movslq -0x120(%rbp), %rcx
imulq $0x110, %rcx, %rcx      # imm = 0x110
addq %rcx, %rax
movsd 0x108(%rax), %xmm1
cvtsi2sdl -0x11c(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x39a7
movq -0x8(%rbp), %rax
movslq -0x120(%rbp), %rcx
imulq $0x110, %rcx, %rcx      # imm = 0x110
addq %rcx, %rax
cvttsd2si 0x108(%rax), %eax
movl %eax, -0x11c(%rbp)
movq -0x8(%rbp), %rsi
movslq -0x120(%rbp), %rax
imulq $0x110, %rax, %rax      # imm = 0x110
addq %rax, %rsi
leaq -0x118(%rbp), %rdi
movl $0x110, %edx            # imm = 0x110
callq 0x2140
jmp 0x39a9
movl -0x120(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x120(%rbp)
jmp 0x3923
movq 0x2604(%rip), %rdi      # 0x5fc8
leaq 0x961(%rip), %rsi       # 0x432c
callq 0x21a0
movq %rax, %rdi
movl -0x118(%rbp), %esi
callq 0x2300
movq %rax, %rdi
movq 0x25d0(%rip), %rsi      # 0x5fb8
callq 0x21b0
movq %rax, %rdi
leaq -0x118(%rbp), %rsi
addq $0x4, %rsi
callq 0x21a0
movq %rax, %rdi
movq 0x25ae(%rip), %rsi      # 0x5fb8
callq 0x21b0
movq %rax, %rdi
movsd -0x10(%rbp), %xmm0
callq 0x2350
xorl %eax, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)
// File: bastelfreak[P]erp-system/statistics.cpp
// Function: anzahlArtikel(TArticle*)
int anzahlArtikel(TArticle AlleArtikel[])
{

	int anzahl = 0;

	for (int i = 1; i < 1000; i++)
	{
		if (AlleArtikel[i].id != '\0')
		{
			 anzahl += 1;
		}
	}

  std::cout << "Die Anzahl der Artikel ist: " << anzahl << std::endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
cmpl $0x3e8, -0x10(%rbp)     # imm = 0x3E8
jge 0x3a80
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x110, %rcx, %rcx      # imm = 0x110
addq %rcx, %rax
cmpl $0x0, (%rax)
je 0x3a73
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3a75
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3a4a
movq 0x2541(%rip), %rdi      # 0x5fc8
leaq 0x8bc(%rip), %rsi       # 0x434a
callq 0x21a0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2300
movq %rax, %rdi
movq 0x2510(%rip), %rsi      # 0x5fb8
callq 0x21b0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: hariguchi[P]rtacl/unitTest.cpp
// Function: main
int
main (int argc, char *argv[])
{
    std::cout << "IPv4 Raw Test\n";
    v4rawTest();
    std::cout << "\nIPv4 sockaddr Test\n";
    v4sockTest();
    std::cout << "\nIPv6 sockaddr Test\n";
    v6sockTest();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xab682(%rip), %rdi     # 0xb0fb8
leaq 0x4a0c7(%rip), %rsi     # 0x4fa04
callq 0x5350
callq 0x5980
movq 0xab66a(%rip), %rdi     # 0xb0fb8
leaq 0x4a0be(%rip), %rsi     # 0x4fa13
callq 0x5350
callq 0x7260
movq 0xab652(%rip), %rdi     # 0xb0fb8
leaq 0x4a0bb(%rip), %rsi     # 0x4fa28
callq 0x5350
callq 0x86d0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: hariguchi[P]rtacl/unitTest.cpp
// Function: void showRTaclEnt<long, sockaddr_in>(boost::geometry::model::box<boost::geometry::model::point<long, 6ul, boost::geometry::cs::cartesian>> const&, unsigned long)
static void
showRTaclEnt (const rtacl::range<ADDR>& r, const uintptr_t index)
{
    rtacl::sockEnt<SADDR>* p =
        reinterpret_cast<rtacl::sockEnt<SADDR>*>(index);

    std::cout << (bfmt("rtree: %s\nacl:   %s\n")
                  % rtacl::range2str(r)
                  % p->str()).str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x45dec(%rip), %rsi     # 0x4fa7e
leaq -0x118(%rbp), %rdi
callq 0xa390
movq -0x8(%rbp), %rsi
leaq -0x138(%rbp), %rdi
callq 0xaa30
jmp 0x9cb0
leaq -0x118(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0xaa00
movq %rax, -0x170(%rbp)
jmp 0x9ccc
movq -0x18(%rbp), %rsi
leaq -0x168(%rbp), %rdi
callq 0x2d940
jmp 0x9cde
movq -0x170(%rbp), %rdi
leaq -0x168(%rbp), %rsi
callq 0xaa00
movq %rax, -0x178(%rbp)
jmp 0x9cfa
movq -0x178(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xa590
jmp 0x9d0c
movq 0xa72a5(%rip), %rdi     # 0xb0fb8
leaq -0x38(%rbp), %rsi
callq 0x52f0
jmp 0x9d1e
leaq -0x38(%rbp), %rdi
callq 0x51e0
leaq -0x168(%rbp), %rdi
callq 0x51e0
leaq -0x138(%rbp), %rdi
callq 0x51e0
leaq -0x118(%rbp), %rdi
callq 0xa7e0
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0x9dc3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0x9db7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
jmp 0x9dab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x140(%rbp)
movl %eax, -0x144(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x51e0
leaq -0x168(%rbp), %rdi
callq 0x51e0
leaq -0x138(%rbp), %rdi
callq 0x51e0
leaq -0x118(%rbp), %rdi
callq 0xa7e0
movq -0x140(%rbp), %rdi
callq 0x5640
nopl (%rax,%rax)
// File: hariguchi[P]rtacl/./rtacl.hpp
// Function: rtacl::db<long>::db()
inline
db<ADDR>::db ()
 {
     if (typeid(ADDR) == typeid(rtacl::ipv4a)) {
         af = AF_INET;
         ao = offsetof(sockaddr_in, sin_addr);
         po = offsetof(sockaddr_in, sin_port);
     } else {
         af = AF_INET6;
         ao = offsetof(sockaddr_in, sin_addr);
         po = offsetof(sockaddr_in, sin_port);
     }
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
leaq -0x9(%rbp), %rsi
leaq -0xa(%rbp), %rdx
leaq -0xb(%rbp), %rcx
callq 0xb340
movq 0xa6e14(%rip), %rsi     # 0xb0fe0
movq %rsi, %rdi
callq 0xb380
testb $0x1, %al
jne 0xa1da
jmp 0xa1f2
movq -0x18(%rbp), %rax
movw $0x2, 0x18(%rax)
movw $0x4, 0x1a(%rax)
movw $0x2, 0x1c(%rax)
jmp 0xa208
movq -0x18(%rbp), %rax
movw $0xa, 0x18(%rax)
movw $0x4, 0x1a(%rax)
movw $0x2, 0x1c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: hariguchi[P]rtacl/./rtacl.hpp
// Function: rtacl::db<long>::dump() const
inline result<ADDR>
db<ADDR>::dump () const
{
    /*
     * Get an entire copy of the entries
     */
    range<ADDR>  b = rtree.bounds();
    result<ADDR> r;
    rtree.query(bgi::covered_by(b), std::back_inserter(r));

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x100(%rbp)
movq %rdi, %rax
movq %rax, -0x110(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x108(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x23d60
movq -0x100(%rbp), %rdi
movb $0x0, -0x71(%rbp)
callq 0x23de0
movq -0xf8(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x23e60
jmp 0xa8a4
movq -0x100(%rbp), %rdi
callq 0x23e90
movq %rax, -0x118(%rbp)
jmp 0xa8b9
movq -0x108(%rbp), %rdi
movq -0x118(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0xf0(%rbp), %rdx
leaq -0xd8(%rbp), %rsi
callq 0x23e00
jmp 0xa8e3
movb $0x1, -0x71(%rbp)
testb $0x1, -0x71(%rbp)
jne 0xa91b
jmp 0xa90f
movq -0x100(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
callq 0xb290
jmp 0xa92b
movq -0x100(%rbp), %rdi
callq 0xb290
movq -0x110(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0xe0(%rbp), %rdi
callq 0x5640
nopw (%rax,%rax)
// File: hariguchi[P]rtacl/./rtacl.hpp
// Function: rtacl::db<long>::find(boost::geometry::model::point<long, 6ul, boost::geometry::cs::cartesian> const&)
inline result<ADDR>
db<ADDR>::find (const tuple<ADDR>& key)
{
    result<ADDR> r;
    size_t n = rtree.query(bgi::contains(key), std::back_inserter(r));
    if (n != r.size()) {
        fprintf(stderr, "n(%ld) != r.size()(%ld)\n", n, r.size());
    }
    assert(n == r.size());

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x23de0
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x27180
jmp 0xaf05
movq -0x88(%rbp), %rdi
callq 0x23e90
movq %rax, -0x90(%rbp)
jmp 0xaf1a
movq -0x78(%rbp), %rdi
movq -0x90(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdx
leaq -0x58(%rbp), %rsi
callq 0x27120
movq %rax, -0x98(%rbp)
jmp 0xaf3f
movq -0x88(%rbp), %rdi
movq -0x98(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xa0(%rbp)
callq 0xb050
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
je 0xafd3
movq -0x88(%rbp), %rdi
movq 0xa604a(%rip), %rax     # 0xb0fc8
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0xb050
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rdx
movq %rax, %rcx
leaq 0x54f99(%rip), %rsi     # 0x5ff49
movb $0x0, %al
callq 0x5540
jmp 0xafd3
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0xb290
jmp 0xb03d
movq -0x88(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0xb8(%rbp)
callq 0xb050
movq %rax, %rcx
movq -0xb8(%rbp), %rax
cmpq %rcx, %rax
jne 0xaffb
jmp 0xb01a
leaq 0x54f60(%rip), %rdi     # 0x5ff62
leaq 0x54f67(%rip), %rsi     # 0x5ff70
movl $0x23d, %edx            # imm = 0x23D
leaq 0x54f67(%rip), %rcx     # 0x5ff7c
callq 0x5220
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xb030
movq -0x88(%rbp), %rdi
callq 0xb290
movq -0x80(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x5640
nopw %cs:(%rax,%rax)