LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: acliusBackHome[P]kamaya/dist/x86.cpp
// Function: x86::Assembler::quaALLOC(std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
void Assembler::quaALLOC(const Qua &qua) {
  static int stackTop = 0;
  // (alloc,1648,4,_2@T2)
  string top = get<1>(qua);
  string sz = get<2>(qua);
  stackTop = max(stackTop, stoi(top));
  if (stackTop < stoi(top)) {
    stackTop = stoi(top);
    sub("esp", sz);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78c50
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x4190
movq -0x10(%rbp), %rdi
callq 0x78c70
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0x4190
jmp 0x7ddfa
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
movl $0xa, %edx
callq 0x812c0
movl %eax, -0xb4(%rbp)
jmp 0x7de14
movl -0xb4(%rbp), %eax
movl %eax, -0x60(%rbp)
leaq 0x496c4(%rip), %rdi     # 0xc74e8
leaq -0x60(%rbp), %rsi
callq 0x81280
movq %rax, -0xc0(%rbp)
jmp 0x7de36
movq -0xc0(%rbp), %rax
movl (%rax), %eax
movl %eax, 0x496a3(%rip)     # 0xc74e8
movl 0x4969d(%rip), %eax     # 0xc74e8
movl %eax, -0xc8(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
movl $0xa, %edx
callq 0x812c0
movl %eax, -0xc4(%rbp)
jmp 0x7de6b
movl -0xc8(%rbp), %eax
movl -0xc4(%rbp), %ecx
cmpl %ecx, %eax
jge 0x7df86
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
movl $0xa, %edx
callq 0x812c0
movl %eax, -0xcc(%rbp)
jmp 0x7de99
movl -0xcc(%rbp), %eax
movl %eax, 0x49643(%rip)     # 0xc74e8
leaq -0x81(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x45f0
movq -0xd8(%rbp), %rdx
leaq 0x13991(%rip), %rsi     # 0x91857
leaq -0x80(%rbp), %rdi
callq 0x4450
jmp 0x7ded1
leaq -0xa8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4190
jmp 0x7dee3
movq -0xb0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x80db0
jmp 0x7defc
leaq -0xa8(%rbp), %rdi
callq 0x4688
leaq -0x80(%rbp), %rdi
callq 0x4688
leaq -0x81(%rbp), %rdi
callq 0x4380
jmp 0x7df86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7dfaa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7dfa1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7df78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x7df6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x4688
leaq -0x80(%rbp), %rdi
callq 0x4688
leaq -0x81(%rbp), %rdi
callq 0x4380
jmp 0x7dfa1
leaq -0x50(%rbp), %rdi
callq 0x4688
leaq -0x30(%rbp), %rdi
callq 0x4688
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x4688
leaq -0x30(%rbp), %rdi
callq 0x4688
movq -0x58(%rbp), %rdi
callq 0x45e0
nopl (%rax)
// File: acliusBackHome[P]kamaya/dist/x86.cpp
// Function: x86::Assembler::quaJLT(std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
void Assembler::quaJLT(const Qua &qua) {
  // (j<,[esp+8],10,19)
  const string &x = get<1>(qua);
  const string &y = get<2>(qua);
  const string &jto = get<3>(qua);
  string blockName = getBlockName(jto);
  cmp(x, y);
  jlt(blockName);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78c50
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78c70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78750
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x4190
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x7ec60
jmp 0x7ef72
leaq -0x68(%rbp), %rdi
callq 0x4688
movq -0x18(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x4190
jmp 0x7ef8d
movq -0x20(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x4190
jmp 0x7ef9f
movq -0xe8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x81670
jmp 0x7efbb
leaq -0xb8(%rbp), %rdi
callq 0x4688
leaq -0x98(%rbp), %rdi
callq 0x4688
leaq -0xd8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4190
jmp 0x7efe5
movq -0xe8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x81880
jmp 0x7effa
leaq -0xd8(%rbp), %rdi
callq 0x4688
leaq -0x48(%rbp), %rdi
callq 0x4688
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4688
jmp 0x7f092
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7f089
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7f063
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x4688
leaq -0x98(%rbp), %rdi
callq 0x4688
jmp 0x7f089
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x4688
leaq -0x48(%rbp), %rdi
callq 0x4688
movq -0x70(%rbp), %rdi
callq 0x45e0
nopl (%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/x86.cpp
// Function: x86::Assembler::quaJLE(std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
void Assembler::quaJLE(const Qua &qua) {
  // (j<=,[esp+8],10,19)
  const string &x = get<1>(qua);
  const string &y = get<2>(qua);
  const string &jto = get<3>(qua);
  string blockName = getBlockName(jto);
  cmp(x, y);
  jle(blockName);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78c50
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78c70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78750
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x4190
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x7ec60
jmp 0x7f112
leaq -0x68(%rbp), %rdi
callq 0x4688
movq -0x18(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x4190
jmp 0x7f12d
movq -0x20(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x4190
jmp 0x7f13f
movq -0xe8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x81670
jmp 0x7f15b
leaq -0xb8(%rbp), %rdi
callq 0x4688
leaq -0x98(%rbp), %rdi
callq 0x4688
leaq -0xd8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4190
jmp 0x7f185
movq -0xe8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x81990
jmp 0x7f19a
leaq -0xd8(%rbp), %rdi
callq 0x4688
leaq -0x48(%rbp), %rdi
callq 0x4688
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4688
jmp 0x7f232
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7f229
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7f203
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x4688
leaq -0x98(%rbp), %rdi
callq 0x4688
jmp 0x7f229
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x4688
leaq -0x48(%rbp), %rdi
callq 0x4688
movq -0x70(%rbp), %rdi
callq 0x45e0
nopl (%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/x86.cpp
// Function: x86::Assembler::quaJGT(std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
void Assembler::quaJGT(const Qua &qua) {
  // (j>,[esp+8],10,19)
  const string &x = get<1>(qua);
  const string &y = get<2>(qua);
  const string &jto = get<3>(qua);
  string blockName = getBlockName(jto);
  cmp(x, y);
  jgt(blockName);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78c50
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78c70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78750
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x4190
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x7ec60
jmp 0x7f2b2
leaq -0x68(%rbp), %rdi
callq 0x4688
movq -0x18(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x4190
jmp 0x7f2cd
movq -0x20(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x4190
jmp 0x7f2df
movq -0xe8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x81670
jmp 0x7f2fb
leaq -0xb8(%rbp), %rdi
callq 0x4688
leaq -0x98(%rbp), %rdi
callq 0x4688
leaq -0xd8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4190
jmp 0x7f325
movq -0xe8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x81aa0
jmp 0x7f33a
leaq -0xd8(%rbp), %rdi
callq 0x4688
leaq -0x48(%rbp), %rdi
callq 0x4688
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4688
jmp 0x7f3d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7f3c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7f3a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x4688
leaq -0x98(%rbp), %rdi
callq 0x4688
jmp 0x7f3c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x4688
leaq -0x48(%rbp), %rdi
callq 0x4688
movq -0x70(%rbp), %rdi
callq 0x45e0
nopl (%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/x86.cpp
// Function: x86::Assembler::quaJGE(std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
void Assembler::quaJGE(const Qua &qua) {
  // (j>=,[esp+8],10,19)
  const string &x = get<1>(qua);
  const string &y = get<2>(qua);
  const string &jto = get<3>(qua);
  string blockName = getBlockName(jto);
  cmp(x, y);
  jge(blockName);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78c50
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78c70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78750
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x4190
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x7ec60
jmp 0x7f452
leaq -0x68(%rbp), %rdi
callq 0x4688
movq -0x18(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x4190
jmp 0x7f46d
movq -0x20(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x4190
jmp 0x7f47f
movq -0xe8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x81670
jmp 0x7f49b
leaq -0xb8(%rbp), %rdi
callq 0x4688
leaq -0x98(%rbp), %rdi
callq 0x4688
leaq -0xd8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4190
jmp 0x7f4c5
movq -0xe8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x81bb0
jmp 0x7f4da
leaq -0xd8(%rbp), %rdi
callq 0x4688
leaq -0x48(%rbp), %rdi
callq 0x4688
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4688
jmp 0x7f572
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7f569
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7f543
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x4688
leaq -0x98(%rbp), %rdi
callq 0x4688
jmp 0x7f569
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x4688
leaq -0x48(%rbp), %rdi
callq 0x4688
movq -0x70(%rbp), %rdi
callq 0x45e0
nopl (%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/x86.cpp
// Function: x86::Assembler::quaJE(std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
void Assembler::quaJE(const Qua &qua) {
  //(j==,[ebp+20],10,25)
  const string &x = get<1>(qua);
  const string &y = get<2>(qua);
  const string &jto = get<3>(qua);
  string blockName = getBlockName(jto);
  cmp(x, y);
  je(blockName);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78c50
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78c70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78750
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x4190
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x7ec60
jmp 0x7f5f2
leaq -0x68(%rbp), %rdi
callq 0x4688
movq -0x18(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x4190
jmp 0x7f60d
movq -0x20(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x4190
jmp 0x7f61f
movq -0xe8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x81670
jmp 0x7f63b
leaq -0xb8(%rbp), %rdi
callq 0x4688
leaq -0x98(%rbp), %rdi
callq 0x4688
leaq -0xd8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4190
jmp 0x7f665
movq -0xe8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x81cc0
jmp 0x7f67a
leaq -0xd8(%rbp), %rdi
callq 0x4688
leaq -0x48(%rbp), %rdi
callq 0x4688
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4688
jmp 0x7f712
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7f709
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7f6e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x4688
leaq -0x98(%rbp), %rdi
callq 0x4688
jmp 0x7f709
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x4688
leaq -0x48(%rbp), %rdi
callq 0x4688
movq -0x70(%rbp), %rdi
callq 0x45e0
nopl (%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/x86.cpp
// Function: x86::Assembler::quaJNE(std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
void Assembler::quaJNE(const Qua &qua) {
  //(j!=,[ebp+20],10,25)
  const string &x = get<1>(qua);
  const string &y = get<2>(qua);
  const string &jto = get<3>(qua);
  string blockName = getBlockName(jto);
  cmp(x, y);
  jne(blockName);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78c50
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78c70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78750
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x4190
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x7ec60
jmp 0x7f792
leaq -0x68(%rbp), %rdi
callq 0x4688
movq -0x18(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x4190
jmp 0x7f7ad
movq -0x20(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
callq 0x4190
jmp 0x7f7bf
movq -0xe8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x81670
jmp 0x7f7db
leaq -0xb8(%rbp), %rdi
callq 0x4688
leaq -0x98(%rbp), %rdi
callq 0x4688
leaq -0xd8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4190
jmp 0x7f805
movq -0xe8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x81dd0
jmp 0x7f81a
leaq -0xd8(%rbp), %rdi
callq 0x4688
leaq -0x48(%rbp), %rdi
callq 0x4688
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4688
jmp 0x7f8b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7f8a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7f883
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x4688
leaq -0x98(%rbp), %rdi
callq 0x4688
jmp 0x7f8a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x4688
leaq -0x48(%rbp), %rdi
callq 0x4688
movq -0x70(%rbp), %rdi
callq 0x45e0
nopl (%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/x86.cpp
// Function: x86::Assembler::quaDATA(std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
void Assembler::quaDATA(const Qua &qua) {
  // 0	(.data,dd,0,a)
  // 1	(.data,dd,0,b)
  const string &symbol = get<3>(qua);
  const string &init = get<2>(qua);
  const string &wide = get<1>(qua);
  sectionData.push_back(DataVar{.symbol = symbol, .init = init, .wide = wide});
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78750
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78c70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78c50
movq %rax, %rcx
movq -0xb8(%rbp), %rax
movq %rcx, -0x28(%rbp)
addq $0xa8, %rax
movq %rax, -0xb0(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
movq -0x18(%rbp), %rsi
callq 0x4190
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq -0x20(%rbp), %rsi
callq 0x4190
jmp 0x7f949
leaq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x4190
jmp 0x7f958
movq -0xb0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x81ee0
jmp 0x7f96d
leaq -0x88(%rbp), %rdi
callq 0x2a770
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x7f9b4
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
callq 0x4688
movq -0xa8(%rbp), %rdi
callq 0x4688
jmp 0x7f9e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2a770
movq -0x90(%rbp), %rdi
callq 0x45e0
nopl (%rax)
// File: acliusBackHome[P]kamaya/dist/x86.cpp
// Function: x86::Assembler::quaRET(std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
void Assembler::quaRET(const Qua &qua) {
  const string &rv = get<1>(qua);
  if (rv != "_") {
    mov("eax", rv);
  }
  pop("ebp");
  //  of << "leave" << N;
  of << "ret" << N;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78c50
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xfc13(%rip), %rsi      # 0x8f6b9
callq 0x81f10
testb $0x1, %al
jne 0x7fab4
jmp 0x7fb67
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x45f0
movq -0xa8(%rbp), %rdx
leaq 0x11d75(%rip), %rsi     # 0x91847
leaq -0x38(%rbp), %rdi
callq 0x4450
jmp 0x7fadd
movq -0x18(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x4190
jmp 0x7faec
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x80b50
jmp 0x7fb02
leaq -0x70(%rbp), %rdi
callq 0x4688
leaq -0x38(%rbp), %rdi
callq 0x4688
leaq -0x39(%rbp), %rdi
callq 0x4380
jmp 0x7fb67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7fb59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7fb50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4688
leaq -0x38(%rbp), %rdi
callq 0x4688
leaq -0x39(%rbp), %rdi
callq 0x4380
jmp 0x7fc23
leaq -0x91(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x45f0
movq -0xb0(%rbp), %rdx
leaq 0x11ce9(%rip), %rsi     # 0x91871
leaq -0x90(%rbp), %rdi
callq 0x4450
jmp 0x7fb96
movq -0xa0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x81f40
jmp 0x7fbab
leaq -0x90(%rbp), %rdi
callq 0x4688
leaq -0x91(%rbp), %rdi
callq 0x4380
movq -0xa0(%rbp), %rax
movq (%rax), %rdi
leaq 0xd2f5(%rip), %rsi      # 0x8cec9
callq 0x42f0
movq %rax, %rdi
leaq 0x478a5(%rip), %rsi     # 0xc7488
callq 0x42b0
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7fc17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4688
leaq -0x91(%rbp), %rdi
callq 0x4380
movq -0x48(%rbp), %rdi
callq 0x45e0
nopl (%rax)
// File: acliusBackHome[P]kamaya/dist/x86.cpp
// Function: x86::Assembler::quaFUNC(std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
void Assembler::quaFUNC(const Qua &qua) {
  const string &l = get<3>(qua);
  label(l);
  push("ebp");
  mov("ebp", "esp");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x78750
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x4190
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x82050
jmp 0x7fc84
leaq -0x38(%rbp), %rdi
callq 0x4688
leaq -0x69(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x45f0
movq -0xd8(%rbp), %rdx
leaq 0x11bc6(%rip), %rsi     # 0x91871
leaq -0x68(%rbp), %rdi
callq 0x4450
jmp 0x7fcb6
movq -0xd0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x820b0
jmp 0x7fcc8
leaq -0x68(%rbp), %rdi
callq 0x4688
leaq -0x69(%rbp), %rdi
callq 0x4380
leaq -0x91(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x45f0
movq -0xe0(%rbp), %rdx
leaq 0x11b76(%rip), %rsi     # 0x91871
leaq -0x90(%rbp), %rdi
callq 0x4450
jmp 0x7fd09
leaq -0xb9(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x45f0
movq -0xe8(%rbp), %rdx
leaq 0x11b2d(%rip), %rsi     # 0x91857
leaq -0xb8(%rbp), %rdi
callq 0x4450
jmp 0x7fd38
movq -0xd0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x80b50
jmp 0x7fd54
leaq -0xb8(%rbp), %rdi
callq 0x4688
leaq -0xb9(%rbp), %rdi
callq 0x4380
leaq -0x90(%rbp), %rdi
callq 0x4688
leaq -0x91(%rbp), %rdi
callq 0x4380
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4688
jmp 0x7fe2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7fdca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4688
leaq -0x69(%rbp), %rdi
callq 0x4380
jmp 0x7fe2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7fe21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7fe09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x4688
leaq -0xb9(%rbp), %rdi
callq 0x4380
leaq -0x90(%rbp), %rdi
callq 0x4688
leaq -0x91(%rbp), %rdi
callq 0x4380
movq -0x40(%rbp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/x86.hpp
// Function: x86::Assembler::cmp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline void cmp(string dist, string src) {
    static string cmpins = "cmp\tdword";
    of << T << "mov\tdword" << T << "eax" << C << dist << N;
    of << T << "mov\tdword" << T << "ebx" << C << src << N;
    of << T << cmpins << T << "eax" << C << "ebx" << N;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpb $0x0, 0x45fb5(%rip)     # 0xc7650
jne 0x81703
leaq 0x45fac(%rip), %rdi     # 0xc7650
callq 0x4600
cmpl $0x0, %eax
je 0x81703
leaq -0x19(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x45f0
movq -0x50(%rbp), %rdx
leaq 0x45f6a(%rip), %rdi     # 0xc7630
leaq 0x102c1(%rip), %rsi     # 0x9198e
callq 0x4450
jmp 0x816d4
leaq -0x19(%rbp), %rdi
callq 0x4380
movq 0x448b4(%rip), %rdi     # 0xc5f98
leaq 0x45f45(%rip), %rsi     # 0xc7630
leaq 0x44c56(%rip), %rdx     # 0xc6348
callq 0x42a0
leaq 0x45f52(%rip), %rdi     # 0xc7650
callq 0x4240
movq -0x38(%rbp), %rax
movq (%rax), %rdi
leaq 0x45d57(%rip), %rsi     # 0xc7468
callq 0x42b0
movq %rax, %rdi
leaq 0x10278(%rip), %rsi     # 0x91998
callq 0x42f0
movq %rax, %rdi
leaq 0x45d39(%rip), %rsi     # 0xc7468
callq 0x42b0
movq %rax, %rdi
leaq 0x10109(%rip), %rsi     # 0x91847
callq 0x42f0
movq %rax, %rdi
leaq 0x45d5b(%rip), %rsi     # 0xc74a8
callq 0x42b0
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x42b0
movq %rax, %rdi
leaq 0x45d20(%rip), %rsi     # 0xc7488
callq 0x42b0
movq -0x38(%rbp), %rax
movq (%rax), %rdi
leaq 0x45ced(%rip), %rsi     # 0xc7468
callq 0x42b0
movq %rax, %rdi
leaq 0x1020e(%rip), %rsi     # 0x91998
callq 0x42f0
movq %rax, %rdi
leaq 0x45ccf(%rip), %rsi     # 0xc7468
callq 0x42b0
movq %rax, %rdi
leaq 0x100a3(%rip), %rsi     # 0x9184b
callq 0x42f0
movq %rax, %rdi
leaq 0x45cf1(%rip), %rsi     # 0xc74a8
callq 0x42b0
movq -0x40(%rbp), %rsi
movq %rax, %rdi
callq 0x42b0
movq %rax, %rdi
leaq 0x45cb6(%rip), %rsi     # 0xc7488
callq 0x42b0
movq -0x38(%rbp), %rax
movq (%rax), %rdi
leaq 0x45c83(%rip), %rsi     # 0xc7468
callq 0x42b0
movq %rax, %rdi
leaq 0x45e3c(%rip), %rsi     # 0xc7630
callq 0x42b0
movq %rax, %rdi
leaq 0x45c65(%rip), %rsi     # 0xc7468
callq 0x42b0
movq %rax, %rdi
leaq 0x10035(%rip), %rsi     # 0x91847
callq 0x42f0
movq %rax, %rdi
leaq 0x45c87(%rip), %rsi     # 0xc74a8
callq 0x42b0
movq %rax, %rdi
leaq 0x1001b(%rip), %rsi     # 0x9184b
callq 0x42f0
movq %rax, %rdi
leaq 0x45c49(%rip), %rsi     # 0xc7488
callq 0x42b0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x4380
leaq 0x45dea(%rip), %rdi     # 0xc7650
callq 0x4230
movq -0x28(%rbp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
nop
// File: acliusBackHome[P]kamaya/dist/IR.cpp
// Function: IR::gen(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&, 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&, unsigned long)
void IR::gen(const string &op, const string &arg1, const string &arg2,
             const string &result, size_t node_id) {
  quas.push_back(make_tuple(op, arg1, arg2, result));
  if (node_id) {
    // 设置该节点的第一条指令编号
    set_node_begen_code(node_id, nextinstr);
  }
  nextinstr++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
addq $0x10, %rax
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x879f0
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x879c0
jmp 0x844a1
leaq -0xb0(%rbp), %rdi
callq 0x24de0
cmpq $0x0, -0x30(%rbp)
je 0x844ea
movq -0xd8(%rbp), %rax
movq -0x30(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x5c40
jmp 0x844ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x24de0
jmp 0x84506
movq -0xd8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0xe0, %rsp
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: acliusBackHome[P]kamaya/dist/IR.cpp
// Function: IR::print()
void IR::print() {
  log("IR QUAS OUTPUT");
  for (int i = 0; i < quas.size(); i++) {
    cout << to_string(i) << "\t(" << get<0>(quas[i]) << "," << get<1>(quas[i])
         << "," << get<2>(quas[i]) << "," << get<3>(quas[i]) << ")" << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x45f0
movq -0x68(%rbp), %rdx
leaq 0xd546(%rip), %rsi      # 0x91a95
leaq -0x28(%rbp), %rdi
callq 0x4450
jmp 0x8455a
leaq -0x28(%rbp), %rdi
callq 0x87a40
jmp 0x84565
leaq -0x28(%rbp), %rdi
callq 0x4688
leaq -0x29(%rbp), %rdi
callq 0x4380
movl $0x0, -0x40(%rbp)
movq -0x70(%rbp), %rdi
movslq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x10, %rdi
callq 0x786f0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x8478d
movl -0x40(%rbp), %esi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x15f20
movq -0x88(%rbp), %rsi
movq 0x419fc(%rip), %rdi     # 0xc5fc0
callq 0x42b0
movq %rax, -0x80(%rbp)
jmp 0x845cf
movq -0x80(%rbp), %rdi
leaq 0xd243(%rip), %rsi      # 0x9181d
callq 0x42f0
movq %rax, -0x90(%rbp)
jmp 0x845e8
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
movslq -0x40(%rbp), %rsi
callq 0x78b20
movq %rax, %rdi
callq 0x82260
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x42b0
movq %rax, -0x98(%rbp)
jmp 0x84619
movq -0x98(%rbp), %rdi
leaq 0xb7f4(%rip), %rsi      # 0x8fe1b
callq 0x42f0
movq %rax, -0xa0(%rbp)
jmp 0x84635
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
movslq -0x40(%rbp), %rsi
callq 0x78b20
movq %rax, %rdi
callq 0x87a80
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
callq 0x42b0
movq %rax, -0xa8(%rbp)
jmp 0x84666
movq -0xa8(%rbp), %rdi
leaq 0xb7a7(%rip), %rsi      # 0x8fe1b
callq 0x42f0
movq %rax, -0xb0(%rbp)
jmp 0x84682
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
movslq -0x40(%rbp), %rsi
callq 0x78b20
movq %rax, %rdi
callq 0x87aa0
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
callq 0x42b0
movq %rax, -0xb8(%rbp)
jmp 0x846b3
movq -0xb8(%rbp), %rdi
leaq 0xb75a(%rip), %rsi      # 0x8fe1b
callq 0x42f0
movq %rax, -0xc0(%rbp)
jmp 0x846cf
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
movslq -0x40(%rbp), %rsi
callq 0x78b20
movq %rax, %rdi
callq 0x87ac0
movq -0xc0(%rbp), %rdi
movq %rax, %rsi
callq 0x42b0
movq %rax, -0xc8(%rbp)
jmp 0x84700
movq -0xc8(%rbp), %rdi
leaq 0x8e0c(%rip), %rsi      # 0x8d51a
callq 0x42f0
movq %rax, -0xd0(%rbp)
jmp 0x8471c
movq -0xd0(%rbp), %rdi
movq 0x41866(%rip), %rsi     # 0xc5f90
callq 0x4350
jmp 0x84731
leaq -0x60(%rbp), %rdi
callq 0x4688
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x8457e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8476b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4688
leaq -0x29(%rbp), %rdi
callq 0x4380
jmp 0x84796
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4688
jmp 0x84796
addq $0xd0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x45e0
nop
// File: acliusBackHome[P]kamaya/dist/IR.cpp
// Function: IR::dataEmit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
size_t IR::dataEmit(const string &name, size_t size, const string &value,
                    size_t node_id) {
  string type = size2type(size);
  sectionData.push_back(SData{name, type, value});
  gen(".data", type, value, name, node_id);
  return -sectionData.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xf8(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x84940
movq -0xf8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0xf0(%rbp)
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
movq -0x10(%rbp), %rsi
callq 0x4190
jmp 0x85052
leaq -0x88(%rbp), %rdi
movq %rdi, -0x100(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x4190
jmp 0x8506b
leaq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4190
jmp 0x8507a
movq -0xf0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x87b80
jmp 0x8508f
leaq -0xa8(%rbp), %rdi
callq 0x24ba0
leaq -0xd9(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x45f0
movq -0x108(%rbp), %rdx
leaq 0xa2bb(%rip), %rsi      # 0x8f377
leaq -0xd8(%rbp), %rdi
callq 0x4450
jmp 0x850ca
movq -0xf8(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %r8
movq -0x28(%rbp), %r9
leaq -0xd8(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x84430
jmp 0x850ef
leaq -0xd8(%rbp), %rdi
callq 0x4688
leaq -0xd9(%rbp), %rdi
callq 0x4380
movq -0xf8(%rbp), %rdi
addq $0x28, %rdi
callq 0x184b0
movq %rax, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x110(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4688
movq -0x110(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x851f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x85188
movq -0x100(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
callq 0x4688
movq -0xe8(%rbp), %rdi
callq 0x4688
jmp 0x851f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x24ba0
jmp 0x851f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x851e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x4688
leaq -0xd9(%rbp), %rdi
callq 0x4380
leaq -0x48(%rbp), %rdi
callq 0x4688
movq -0xb0(%rbp), %rdi
callq 0x45e0
nopl (%rax)
// File: toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_depth() const
int HierarchicalBlockSparseMatrix<Treal>::get_depth() const  {

			if(empty()) return 0;

			if(!children_exist()) return 0;

			int depths[4];
			if(children[0] != NULL) depths[0] = children[0]->get_depth();
			else depths[0] = 0;

			if(children[1] != NULL) depths[1] = children[1]->get_depth();
			else depths[1] = 0;

			if(children[2] != NULL) depths[2] = children[2]->get_depth();
			else depths[2] = 0;

			if(children[3] != NULL) depths[3] = children[3]->get_depth();
			else depths[3] = 0;

			return  1 + *std::max_element(depths,depths+4);


		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x230a0
testb $0x1, %al
jne 0x10f5f
jmp 0x10f6b
movl $0x0, -0x4(%rbp)
jmp 0x11095
movq -0x28(%rbp), %rdi
callq 0x23140
testb $0x1, %al
jne 0x10f84
movl $0x0, -0x4(%rbp)
jmp 0x11095
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x232b0
testb $0x1, %al
jne 0x10f9b
jmp 0x10fb5
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x23570
movq %rax, %rdi
callq 0x10f40
movl %eax, -0x20(%rbp)
jmp 0x10fbc
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x232b0
testb $0x1, %al
jne 0x10fd7
jmp 0x10ff5
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
addq $0x10, %rdi
callq 0x23570
movq %rax, %rdi
callq 0x10f40
movl %eax, -0x1c(%rbp)
jmp 0x10ffc
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x232b0
testb $0x1, %al
jne 0x11017
jmp 0x11035
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
addq $0x20, %rdi
callq 0x23570
movq %rax, %rdi
callq 0x10f40
movl %eax, -0x18(%rbp)
jmp 0x1103c
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x232b0
testb $0x1, %al
jne 0x11057
jmp 0x11075
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
addq $0x30, %rdi
callq 0x23570
movq %rax, %rdi
callq 0x10f40
movl %eax, -0x14(%rbp)
jmp 0x1107c
movl $0x0, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x20(%rbp), %rsi
addq $0x10, %rsi
callq 0x294d0
movl (%rax), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::print() const
void print() const{
				std::vector<int> rows, cols;
				std::vector<Treal> vals;
				get_all_values(rows, cols, vals);
				for(int i = 0; i < rows.size(); ++i){
					std::cout << rows[i] << " " << cols[i] << " " << vals[i] << std::endl;
				}
			}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x10e60
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x10e60
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x10e80
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
callq 0x257e0
jmp 0x110f5
movl $0x0, -0x60(%rbp)
movslq -0x60(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x26700
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x11217
movslq -0x60(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x26720
movl (%rax), %esi
movq 0x2fe97(%rip), %rdi     # 0x40fd0
callq 0x2330
movq %rax, -0x90(%rbp)
jmp 0x11147
movq -0x90(%rbp), %rdi
leaq 0x253c8(%rip), %rsi     # 0x3651d
callq 0x21e0
movq %rax, -0x98(%rbp)
jmp 0x11163
movslq -0x60(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x26720
movq -0x98(%rbp), %rdi
movl (%rax), %esi
callq 0x2330
movq %rax, -0xa0(%rbp)
jmp 0x11187
movq -0xa0(%rbp), %rdi
leaq 0x25388(%rip), %rsi     # 0x3651d
callq 0x21e0
movq %rax, -0xa8(%rbp)
jmp 0x111a3
movslq -0x60(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x22b60
movq -0xa8(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x2370
movq %rax, -0xb0(%rbp)
jmp 0x111c9
movq -0xb0(%rbp), %rdi
movq 0x2fdd9(%rip), %rsi     # 0x40fb0
callq 0x2210
jmp 0x111de
jmp 0x111e0
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x110fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x112e0
leaq -0x38(%rbp), %rdi
callq 0x11340
leaq -0x20(%rbp), %rdi
callq 0x11340
jmp 0x1123b
leaq -0x50(%rbp), %rdi
callq 0x112e0
leaq -0x38(%rbp), %rdi
callq 0x11340
leaq -0x20(%rbp), %rdi
callq 0x11340
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2340
nopw %cs:(%rax,%rax)
nop
// File: toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_trace() const
Treal HierarchicalBlockSparseMatrix<Treal>::get_trace() const{

            if(lowest_level()){

                Treal trace = 0.0;

                for(int i = 0; i < blocksize; ++i){
                    trace += submatrix[i * blocksize + i];
                }

                return trace;
            }

            Treal trace = 0.0;

            if(children[0] != NULL) trace += children[0]->get_trace();
            if(children[3] != NULL) trace += children[3]->get_trace();

            return trace;

        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x23500
testb $0x1, %al
jne 0x13bbf
jmp 0x13c1f
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x13c10
movq -0x30(%rbp), %rcx
movq %rcx, %rdi
addq $0x70, %rdi
movl -0x1c(%rbp), %eax
imull 0x10(%rcx), %eax
addl -0x1c(%rbp), %eax
movslq %eax, %rsi
callq 0x245a0
movsd (%rax), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13bce
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x13ca5
movq -0x30(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x232b0
testb $0x1, %al
jne 0x13c3e
jmp 0x13c5d
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
callq 0x23570
movq %rax, %rdi
callq 0x13ba0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x232b0
testb $0x1, %al
jne 0x13c78
jmp 0x13c9b
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
addq $0x30, %rdi
callq 0x23570
movq %rax, %rdi
callq 0x13ba0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_nnz_diag_lowest_level() const
size_t HierarchicalBlockSparseMatrix<Treal>::get_nnz_diag_lowest_level()const{

            if(lowest_level()){

							size_t n = nRows;

              return n*n;
            }

            size_t nnz = 0;

            if(children[0] != NULL) nnz += children[0]->get_nnz_diag_lowest_level();
            if(children[3] != NULL) nnz += children[3]->get_nnz_diag_lowest_level();

            return nnz;

        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x23500
testb $0x1, %al
jne 0x13f0f
jmp 0x13f2c
movq -0x28(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x13fac
movq -0x28(%rbp), %rdi
movq $0x0, -0x20(%rbp)
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x232b0
testb $0x1, %al
jne 0x13f4b
jmp 0x13f68
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x23570
movq %rax, %rdi
callq 0x13ef0
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x232b0
testb $0x1, %al
jne 0x13f83
jmp 0x13fa4
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
addq $0x30, %rdi
callq 0x23570
movq %rax, %rdi
callq 0x13ef0
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::get_level() const
int HierarchicalBlockSparseMatrix<Treal>::get_level() const  {

			if(parent == NULL)
				return 0;
			else{

				HierarchicalBlockSparseMatrix<Treal> *tmp = parent;
				int counter = 0;
				while(tmp != NULL){
					tmp = tmp->parent;
					counter++;
				}
				return counter;
			}

		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x68(%rax)
jne 0x27530
movl $0x0, -0x4(%rbp)
jmp 0x27567
movq -0x28(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x27561
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x27543
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: toxaart[P]hierarchical_block_sparse_lib/source/HierarchicalBlockSparseMatrix.h
// Function: hbsm::HierarchicalBlockSparseMatrix<double>::adjust_sizes(hbsm::HierarchicalBlockSparseMatrix<double>&, int, int)
void HierarchicalBlockSparseMatrix<Treal>::adjust_sizes(HierarchicalBlockSparseMatrix<Treal> & A, const int nRows_other, const int nCols_other){


			std::vector<int> rows, cols;
			std::vector<Treal> vals;

			A.get_all_values(rows, cols, vals);

			//save original sizes
			int n_rows_orig = A.get_n_rows();
			int n_cols_orig = A.get_n_cols();

			A.clear(); // params are preserved

			A.resize(nRows_other, nCols_other);

			// original sizes are to be restored manually!
			if(A.parent == NULL){ // only top level!
				A.nRows_orig = n_rows_orig;
				A.nCols_orig = n_cols_orig;
			}

			A.assign_from_vectors(rows,cols,vals);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x10e60
leaq -0x40(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x10e60
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x10e80
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rcx
movq -0x8(%rbp), %rdi
callq 0x257e0
jmp 0x2bbf9
movq -0x8(%rbp), %rdi
callq 0x24470
movl %eax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24540
movl %eax, -0x6c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x23300
jmp 0x2bc1c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x8600
jmp 0x2bc31
movq -0x8(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x2bc7b
movl -0x68(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x6c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x2bc7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x112e0
leaq -0x40(%rbp), %rdi
callq 0x11340
leaq -0x28(%rbp), %rdi
callq 0x11340
jmp 0x2bcb6
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x58(%rbp), %rcx
callq 0x10f00
jmp 0x2bc92
leaq -0x58(%rbp), %rdi
callq 0x112e0
leaq -0x40(%rbp), %rdi
callq 0x11340
leaq -0x28(%rbp), %rdi
callq 0x11340
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x2340
nop